@norman-else/dsh-claude 0.1.0

package/lib/index.mjs

@@ -0,0 +1,2272 @@
+import { a as latestClaudeTasks, b as isClaudePresetId, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_CODE_PRESET_ID, g as CLAUDE_PROJECTION_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, y as TASK_TOOL_NAMES } from "./events-qlmU1KrH.mjs";
+import { a as ClaudeCommandBridge, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-DbfG-9KQ.mjs";
+import { a as runClaudeDoctor, i as resolveClaudeExecutable, t as ensureManagedPreset } from "./preset-installer-DUVN1J6P.mjs";
+import z from "@deepseek-ai/schemastery";
+import { CallId, LlmAdapter, ReasoningEffortId, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { EventEmitter } from "node:events";
+import { DSH_ENV_PREFIX, SENSITIVE_ENV_PATTERN } from "@deepseek-ai/dsh-subprocess";
+//#region src/sidecar.ts
+const SIDECAR_SCHEMA_VERSION = 1;
+const MAX_ACTIVITIES = 1e4;
+function emptyProjection() {
+	return {
+		schemaVersion: SIDECAR_SCHEMA_VERSION,
+		revision: 0,
+		activities: []
+	};
+}
+function record$1(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) {
+	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;
+	return {
+		claudeSessionId: input.claudeSessionId,
+		sdkVersion: input.sdkVersion,
+		cwd: input.cwd,
+		...input.cliVersion === void 0 ? {} : { cliVersion: input.cliVersion }
+	};
+}
+const ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+	"status",
+	"thinking",
+	"tool-call",
+	"tool-result",
+	"permission",
+	"subagent",
+	"usage",
+	"warning",
+	"error"
+]);
+const ACTIVITY_PHASES = /* @__PURE__ */ new Set([
+	"started",
+	"updated",
+	"completed",
+	"denied",
+	"failed"
+]);
+function activity(value) {
+	const input = record$1(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);
+	if (input === void 0 || !Array.isArray(input.categories)) return void 0;
+	return normalizeContextUsage(input);
+}
+function tasks(value) {
+	const input = record$1(value);
+	if (input === void 0 || !Array.isArray(input.tasks)) return void 0;
+	return normalizeTasksEvent(input.tasks);
+}
+function parseClaudeSidecar(value) {
+	const input = record$1(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");
+	const parsedBinding = input.binding === void 0 ? void 0 : binding(input.binding);
+	const parsedUsage = input.contextUsage === void 0 ? void 0 : contextUsage(input.contextUsage);
+	const parsedTasks = input.tasks === void 0 ? void 0 : tasks(input.tasks);
+	if (input.binding !== void 0 && parsedBinding === void 0 || input.contextUsage !== void 0 && parsedUsage === void 0 || input.tasks !== void 0 && parsedTasks === void 0) throw new Error("dsh-claude: invalid sidecar projection");
+	return {
+		schemaVersion: SIDECAR_SCHEMA_VERSION,
+		revision: input.revision,
+		activities,
+		...parsedBinding === void 0 ? {} : { binding: parsedBinding },
+		...parsedUsage === void 0 ? {} : { contextUsage: parsedUsage },
+		...parsedTasks === void 0 ? {} : { tasks: parsedTasks }
+	};
+}
+function compareActivity(left, right) {
+	return left.turn - right.turn || left.step - right.step || left.ordinal - right.ordinal;
+}
+function activityKey(value) {
+	return `${value.turn}:${value.step}:${value.ordinal}`;
+}
+function mergeActivities(existing, additions) {
+	const merged = new Map(existing.map((item) => [activityKey(item), item]));
+	for (const item of additions) merged.set(activityKey(item), item);
+	return [...merged.values()].sort(compareActivity).slice(-1e4);
+}
+function normalizeBinding(input) {
+	return {
+		claudeSessionId: redactText(input.claudeSessionId, 512),
+		sdkVersion: redactText(input.sdkVersion ?? "0.3.233", 128),
+		cwd: redactText(input.cwd, 4096),
+		...input.cliVersion === void 0 ? {} : { cliVersion: redactText(input.cliVersion, 128) }
+	};
+}
+var ClaudeSidecarRepository = class {
+	root;
+	legacyRoot;
+	#pending = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.root = options.root ?? dshHomePath("plugins", "dsh-claude", "sessions");
+		this.legacyRoot = options.legacyRoot ?? (options.root === void 0 ? dshHomePath("plugins", "dsh-claude-code", "sessions") : void 0);
+	}
+	async read(sessionId) {
+		await this.#pending.get(sessionId)?.catch(() => void 0);
+		return this.#readNow(sessionId);
+	}
+	writeBinding(sessionId, value) {
+		const normalized = normalizeBinding(value);
+		return this.#update(sessionId, (current) => ({
+			...current,
+			binding: normalized
+		}));
+	}
+	appendActivity(sessionId, value) {
+		const normalized = normalizeActivity(value);
+		return this.#update(sessionId, (current) => ({
+			...current,
+			activities: mergeActivities(current.activities, [normalized])
+		}));
+	}
+	writeContextUsage(sessionId, value) {
+		const normalized = normalizeContextUsage(value);
+		return this.#update(sessionId, (current) => ({
+			...current,
+			contextUsage: normalized
+		}));
+	}
+	writeTasks(sessionId, value) {
+		const normalized = normalizeTasksEvent(value);
+		return this.#update(sessionId, (current) => ({
+			...current,
+			tasks: normalized
+		}));
+	}
+	importLegacy(sessionId, events) {
+		const importedActivities = events.filter((event) => event.type === CLAUDE_ACTIVITY_EVENT).map((event) => activity(event.data)).filter((item) => item !== void 0);
+		const importedBinding = latestClaudeSessionBinding(events);
+		const importedUsage = latestClaudeContextUsage(events);
+		const importedTasks = latestClaudeTasks(events);
+		return this.#update(sessionId, (current) => ({
+			...current,
+			activities: mergeActivities(importedActivities, current.activities),
+			...current.binding !== void 0 || importedBinding === void 0 ? {} : { binding: normalizeBinding(importedBinding) },
+			...current.contextUsage !== void 0 || importedUsage === void 0 ? {} : { contextUsage: normalizeContextUsage(importedUsage) },
+			...current.tasks !== void 0 || importedTasks === void 0 ? {} : { tasks: normalizeTasksEvent(importedTasks.tasks) }
+		}), true);
+	}
+	#path(sessionId, root = this.root) {
+		if (sessionId.length === 0 || sessionId.length > 1024) throw new Error("dsh-claude: invalid session id");
+		return join(root, `${Buffer.from(sessionId).toString("base64url")}.json`);
+	}
+	#update(sessionId, change, skipUnchanged = false) {
+		const operation = (this.#pending.get(sessionId) ?? Promise.resolve()).catch(() => void 0).then(async () => {
+			const current = await this.#readNow(sessionId);
+			const changed = parseClaudeSidecar({
+				...change(current),
+				schemaVersion: SIDECAR_SCHEMA_VERSION,
+				revision: current.revision
+			});
+			if (skipUnchanged && JSON.stringify(changed) === JSON.stringify(current)) return current;
+			const next = {
+				...changed,
+				revision: current.revision + 1
+			};
+			await this.#writeNow(sessionId, next);
+			return next;
+		});
+		this.#pending.set(sessionId, operation);
+		operation.finally(() => {
+			if (this.#pending.get(sessionId) === operation) this.#pending.delete(sessionId);
+		}).catch(() => void 0);
+		return operation;
+	}
+	async #readNow(sessionId) {
+		try {
+			return parseClaudeSidecar(JSON.parse(await readFile(this.#path(sessionId), "utf8")));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		if (this.legacyRoot === void 0) return emptyProjection();
+		try {
+			return parseClaudeSidecar(JSON.parse(await readFile(this.#path(sessionId, this.legacyRoot), "utf8")));
+		} catch (error) {
+			if (error.code === "ENOENT") return emptyProjection();
+			throw error;
+		}
+	}
+	async #writeNow(sessionId, projection) {
+		await mkdir(this.root, {
+			recursive: true,
+			mode: 448
+		});
+		await chmod(this.root, 448);
+		const target = this.#path(sessionId);
+		const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+		try {
+			await writeFile(temporary, `${JSON.stringify(projection)}\n`, {
+				mode: 384,
+				flag: "wx"
+			});
+			await chmod(temporary, 384);
+			await rename(temporary, target);
+			await chmod(target, 384);
+		} finally {
+			await rm(temporary, { force: true }).catch(() => void 0);
+		}
+	}
+};
+//#endregion
+//#region src/async-queue.ts
+var AsyncQueueClosedError = class extends Error {
+	constructor() {
+		super("Async queue is closed");
+		this.name = "AsyncQueueClosedError";
+	}
+};
+var AsyncQueue = class {
+	#values = [];
+	#pending = [];
+	#closed = false;
+	#failure;
+	get closed() {
+		return this.#closed;
+	}
+	push(value) {
+		if (this.#closed) throw new AsyncQueueClosedError();
+		const waiter = this.#pending.shift();
+		if (waiter !== void 0) waiter.resolve({
+			value,
+			done: false
+		});
+		else this.#values.push(value);
+	}
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const waiter of this.#pending.splice(0)) waiter.resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	fail(error) {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#failure = error;
+		for (const waiter of this.#pending.splice(0)) waiter.reject(error);
+	}
+	discard(error) {
+		this.#values.splice(0);
+		if (this.#closed) return;
+		this.#closed = true;
+		if (error === void 0) {
+			for (const waiter of this.#pending.splice(0)) waiter.resolve({
+				value: void 0,
+				done: true
+			});
+			return;
+		}
+		this.#failure = error;
+		for (const waiter of this.#pending.splice(0)) waiter.resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	next() {
+		const value = this.#values.shift();
+		if (value !== void 0) return Promise.resolve({
+			value,
+			done: false
+		});
+		if (this.#closed) return this.#failure === void 0 ? Promise.resolve({
+			value: void 0,
+			done: true
+		}) : Promise.reject(this.#failure);
+		return new Promise((resolve, reject) => {
+			this.#pending.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	return() {
+		this.close();
+		return Promise.resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+};
+//#endregion
+//#region src/permission.ts
+function denialMessage(outcome) {
+	switch (outcome) {
+		case "rejected": return "The user rejected this action in DeepSeek Harness.";
+		case "cancelled": return "The permission request was cancelled in DeepSeek Harness.";
+		case "unavailable": return "No DeepSeek Harness approval surface was available; the action was denied.";
+		case "allowed-once": return "";
+	}
+}
+function permissionReason(toolName, input, options) {
+	const prompt = options.title ?? options.description ?? options.decisionReason ?? `Claude Code wants to use ${toolName}.`;
+	const detail = safeDetail(input);
+	return boundText(detail === void 0 ? prompt : `${prompt}\nInput: ${detail}`, 1200);
+}
+function mapApprovalOutcome(outcome, input, toolUseID) {
+	if (outcome === "allowed-once") return {
+		behavior: "allow",
+		updatedInput: input,
+		toolUseID,
+		decisionClassification: "user_temporary"
+	};
+	return {
+		behavior: "deny",
+		message: denialMessage(outcome),
+		toolUseID,
+		decisionClassification: "user_reject"
+	};
+}
+function createPermissionBridge(approval, activeContext) {
+	return async (toolName, input, options) => {
+		const active = activeContext();
+		if (active === void 0) return {
+			behavior: "deny",
+			message: "No active DeepSeek Harness turn owns this Claude Code action.",
+			toolUseID: options.toolUseID,
+			decisionClassification: "user_reject"
+		};
+		active.markActivity?.();
+		const reason = permissionReason(toolName, input, options);
+		try {
+			await active.appendActivity({
+				kind: "permission",
+				phase: "started",
+				toolUseId: options.toolUseID,
+				toolName,
+				title: options.displayName ?? toolName,
+				summary: options.title ?? options.description ?? reason,
+				detail: input
+			});
+			const outcome = await approval.request({
+				agent: active.agent,
+				toolName,
+				reason,
+				signal: options.signal
+			});
+			const result = mapApprovalOutcome(outcome, input, options.toolUseID);
+			if (result.behavior === "deny") active.recordDenial?.(options.toolUseID);
+			await active.appendActivity({
+				kind: "permission",
+				phase: outcome === "allowed-once" ? "completed" : "denied",
+				toolUseId: options.toolUseID,
+				toolName,
+				title: options.displayName ?? toolName,
+				summary: outcome === "allowed-once" ? "Allowed once in DeepSeek Harness" : denialMessage(outcome)
+			});
+			return result;
+		} catch (error) {
+			const message = options.signal.aborted ? "The permission request was cancelled in DeepSeek Harness." : "DeepSeek Harness could not record or answer the permission request; the action was denied.";
+			try {
+				await active.appendActivity({
+					kind: "permission",
+					phase: "failed",
+					toolUseId: options.toolUseID,
+					toolName,
+					title: options.displayName ?? toolName,
+					summary: message,
+					isError: true,
+					detail: error
+				});
+			} catch {}
+			return {
+				behavior: "deny",
+				message,
+				toolUseID: options.toolUseID,
+				decisionClassification: "user_reject"
+			};
+		}
+	};
+}
+//#endregion
+//#region src/sdk-messages.ts
+function record(value) {
+	return value !== null && typeof value === "object" ? value : void 0;
+}
+function string(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function taskUsageOf(usage) {
+	if (usage === void 0) return void 0;
+	const normalized = {};
+	if (typeof usage.total_tokens === "number") normalized.totalTokens = usage.total_tokens;
+	if (typeof usage.tool_uses === "number") normalized.toolUses = usage.tool_uses;
+	if (typeof usage.duration_ms === "number") normalized.durationMs = usage.duration_ms;
+	return Object.keys(normalized).length === 0 ? void 0 : normalized;
+}
+function resultUsage(message) {
+	const usage = record(message.usage);
+	const normalized = {};
+	if (usage !== void 0) {
+		if (typeof usage.input_tokens === "number") normalized.inputTokens = usage.input_tokens;
+		if (typeof usage.output_tokens === "number") normalized.outputTokens = usage.output_tokens;
+		if (typeof usage.cache_read_input_tokens === "number") normalized.cacheReadTokens = usage.cache_read_input_tokens;
+		if (typeof usage.cache_creation_input_tokens === "number") normalized.cacheCreationTokens = usage.cache_creation_input_tokens;
+	}
+	if (typeof message.total_cost_usd === "number") normalized.cumulativeCostUsd = message.total_cost_usd;
+	return normalized;
+}
+function normalizeAssistant(message) {
+	const content = record(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 normalized = [];
+	for (const item of content) {
+		const block = record(item);
+		if (block === void 0) continue;
+		if (block.type === "text") {
+			const text = string(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);
+			if (text !== void 0 && text.length > 0) normalized.push({
+				kind: "thinking",
+				text,
+				phase: "completed",
+				...parentToolUseId === void 0 ? {} : { parentToolUseId }
+			});
+		} else if (block.type === "tool_use") {
+			const toolUseId = string(block.id);
+			const toolName = string(block.name);
+			if (toolUseId !== void 0 && toolName !== void 0) normalized.push({
+				kind: "tool-call",
+				toolUseId,
+				toolName,
+				input: block.input,
+				...parentToolUseId === void 0 ? {} : { parentToolUseId }
+			});
+		}
+	}
+	return normalized;
+}
+function normalizeUser(message) {
+	const content = record(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 normalized = [];
+	for (const item of content) {
+		const block = record(item);
+		if (block?.type !== "tool_result") continue;
+		const toolUseId = string(block.tool_use_id);
+		if (toolUseId === void 0) continue;
+		normalized.push({
+			kind: "tool-result",
+			toolUseId,
+			output: message.tool_use_result ?? block.content,
+			isError: block.is_error === true,
+			...parentToolUseId === void 0 ? {} : { parentToolUseId }
+		});
+	}
+	return normalized;
+}
+function normalizeSystem(message) {
+	const subtype = string(message.subtype);
+	if (subtype === "init") {
+		const sessionId = string(message.session_id);
+		const cliVersion = string(message.claude_code_version);
+		const cwd = string(message.cwd);
+		return sessionId !== void 0 && cliVersion !== void 0 && cwd !== void 0 ? [{
+			kind: "init",
+			sessionId,
+			cliVersion,
+			cwd
+		}] : [{
+			kind: "protocol-error",
+			title: "Malformed Claude initialization message",
+			detail: message
+		}];
+	}
+	if (subtype === "status") {
+		const status = message.status;
+		if (status === null) return [{
+			kind: "status",
+			title: "Claude Code is ready"
+		}];
+		return [{
+			kind: "status",
+			title: `Claude Code ${String(status)}`,
+			detail: message
+		}];
+	}
+	if (subtype === "session_state_changed") return [{
+		kind: "status",
+		title: `Claude session ${String(message.state)}`
+	}];
+	if (subtype === "permission_denied") {
+		const toolUseId = string(message.tool_use_id);
+		const toolName = string(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"
+		}];
+	}
+	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);
+		return [{
+			kind: "subagent",
+			title: description ?? taskId ?? "Claude subagent started",
+			phase: "started",
+			detail: message,
+			...taskId === void 0 ? {} : { taskId },
+			taskStatus: "running",
+			...description === void 0 ? {} : { description },
+			...subagentType === void 0 ? {} : { subagentType },
+			...taskType === void 0 ? {} : { taskType },
+			...message.skip_transcript === true ? { skipTranscript: true } : {}
+		}];
+	}
+	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));
+		return [{
+			kind: "subagent",
+			title: summary ?? description ?? "Claude subagent update",
+			phase: "updated",
+			detail: message,
+			...taskId === void 0 ? {} : { taskId },
+			taskStatus: "running",
+			...description === void 0 ? {} : { description },
+			...subagentType === void 0 ? {} : { subagentType },
+			...lastToolName === void 0 ? {} : { lastToolName },
+			...summary === void 0 ? {} : { summary },
+			...usage === void 0 ? {} : { usage }
+		}];
+	}
+	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 taskStatus = status === void 0 ? void 0 : status === "killed" ? "killed" : status === "completed" ? "completed" : status === "failed" ? "failed" : "running";
+		return [{
+			kind: "subagent",
+			title: description ?? "Claude subagent update",
+			phase: status === "failed" || status === "killed" ? "failed" : status === "completed" ? "completed" : "updated",
+			detail: message,
+			...taskId === void 0 ? {} : { taskId },
+			...taskStatus === void 0 ? {} : { taskStatus },
+			...description === void 0 ? {} : { description },
+			...error === void 0 ? {} : { summary: error }
+		}];
+	}
+	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 taskStatus = failed ? "failed" : stopped ? "stopped" : "completed";
+		const usage = taskUsageOf(record(message.usage));
+		return [{
+			kind: "subagent",
+			title: summary ?? taskId ?? "Claude subagent finished",
+			phase: failed || stopped ? "failed" : "completed",
+			detail: message,
+			...taskId === void 0 ? {} : { taskId },
+			taskStatus,
+			...summary === void 0 ? {} : { summary },
+			...usage === void 0 ? {} : { usage }
+		}];
+	}
+	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);
+			if (taskId === void 0 || description === void 0) return [];
+			return [{
+				taskId,
+				description,
+				...taskType === void 0 ? {} : { taskType }
+			}];
+		})
+	}];
+	if (subtype === "api_retry") return [{
+		kind: "warning",
+		title: "Claude API retry",
+		detail: 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",
+		detail: message
+	}];
+	if (subtype?.startsWith("hook_") === true || subtype === "plugin_install") return [{
+		kind: "status",
+		title: `Claude Code ${subtype.replaceAll("_", " ")}`,
+		detail: message
+	}];
+	if (subtype !== void 0) return [{
+		kind: "status",
+		title: `Claude Code ${subtype.replaceAll("_", " ")}`,
+		detail: message
+	}];
+	return [];
+}
+const RESULT_ERROR_SUBTYPES = /* @__PURE__ */ new Set([
+	"error_during_execution",
+	"error_max_turns",
+	"error_max_budget_usd",
+	"error_max_structured_output_retries"
+]);
+function normalizeSdkMessage(message) {
+	const value = message;
+	if (value.type === "stream_event") {
+		const event = record(value.event);
+		const parentToolUseId = string(value.parent_tool_use_id);
+		if (event?.type === "content_block_delta") {
+			const delta = record(event.delta);
+			if (delta?.type === "text_delta") {
+				const text = string(delta.text);
+				return text === void 0 ? [] : [{
+					kind: "text-delta",
+					text,
+					...parentToolUseId === void 0 ? {} : { parentToolUseId }
+				}];
+			}
+			if (delta?.type === "thinking_delta") {
+				const text = string(delta.thinking);
+				return text === void 0 ? [] : [{
+					kind: "thinking",
+					text,
+					phase: "updated",
+					...parentToolUseId === void 0 ? {} : { parentToolUseId }
+				}];
+			}
+		}
+		return [];
+	}
+	if (value.type === "assistant") return normalizeAssistant(value);
+	if (value.type === "user") return normalizeUser(value);
+	if (value.type === "system") return normalizeSystem(value);
+	if (value.type === "result") {
+		const sessionId = string(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",
+			detail: value
+		}];
+		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);
+			return toolName === void 0 || toolUseId === void 0 ? void 0 : {
+				toolName,
+				toolUseId
+			};
+		}).filter((item) => item !== void 0).slice(0, 40) : void 0;
+		return [{
+			kind: "result",
+			success,
+			...success && typeof value.result === "string" ? { text: value.result } : {},
+			...errors === void 0 ? {} : { errors },
+			...terminalReason === void 0 ? {} : { terminalReason },
+			...permissionDenials === void 0 || permissionDenials.length === 0 ? {} : { permissionDenials },
+			usage: resultUsage(value),
+			sessionId,
+			...userMessageUuid === void 0 ? {} : { userMessageUuid }
+		}];
+	}
+	if (value.type === "auth_status") return [{
+		kind: value.error === void 0 ? "status" : "warning",
+		title: value.error === void 0 ? "Claude authentication status changed" : "Claude authentication failed",
+		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";
+		return [{
+			kind: blocking ? "warning" : "status",
+			title: blocking ? "Claude rate limit is blocking requests" : "Claude rate limit status changed",
+			detail: value.rate_limit_info
+		}];
+	}
+	return [{
+		kind: "unknown",
+		title: `Unknown Claude SDK message: ${String(value.type)}`,
+		detail: value
+	}];
+}
+//#endregion
+//#region src/spawn.ts
+const CLAUDE_PROCESS_GRACE_MS = 2e3;
+const CLAUDE_STDERR_TAIL_BYTES = 32768;
+const ADDITIONAL_SENSITIVE_ENV_PATTERN = /(?:authorization|cookie|credential|database[_-]?url|private[_-]?key|netrc)/iu;
+function scrubClaudeSpawnEnv(env) {
+	const safe = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (value === void 0) continue;
+		if (key.toUpperCase().startsWith(DSH_ENV_PREFIX)) continue;
+		if (SENSITIVE_ENV_PATTERN.test(key)) continue;
+		if (ADDITIONAL_SENSITIVE_ENV_PATTERN.test(key)) continue;
+		safe[key] = value;
+	}
+	return safe;
+}
+var ManagedClaudeProcess = class extends EventEmitter {
+	stdin;
+	stdout;
+	handle;
+	#killed = false;
+	#exitCode = null;
+	#signalCode = null;
+	constructor(handle) {
+		super();
+		if (handle.stdin === void 0 || handle.stdout === void 0) throw new Error("dsh-claude: managed Claude process requires piped stdin/stdout");
+		this.handle = handle;
+		this.stdin = handle.stdin;
+		this.stdout = handle.stdout;
+		handle.done.then((outcome) => {
+			this.#exitCode = outcome.exitCode;
+			this.#signalCode = outcome.signal;
+			this.emit("exit", outcome.exitCode, outcome.signal);
+		}, (error) => {
+			this.emit("error", error instanceof Error ? error : new Error(String(error)));
+		});
+	}
+	get killed() {
+		return this.#killed;
+	}
+	get exitCode() {
+		return this.#exitCode;
+	}
+	get signalCode() {
+		return this.#signalCode;
+	}
+	kill(signal) {
+		if (this.#exitCode !== null || this.#signalCode !== null) return false;
+		this.#killed = true;
+		this.handle.terminate();
+		return true;
+	}
+	stderrTail() {
+		return this.handle.collected.stderr?.readFrom(0).text ?? "";
+	}
+};
+function createManagedClaudeSpawner(runtime, executablePath, observe) {
+	return (options) => {
+		if (options.command !== executablePath) throw new Error(`dsh-claude: SDK requested unexpected executable ${JSON.stringify(options.command)}`);
+		const managed = new ManagedClaudeProcess(runtime.spawn({
+			argv: [executablePath, ...options.args],
+			cwd: options.cwd ?? process.cwd(),
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: { maxBytes: CLAUDE_STDERR_TAIL_BYTES }
+			},
+			graceMs: CLAUDE_PROCESS_GRACE_MS,
+			signal: options.signal,
+			env: scrubClaudeSpawnEnv(options.env)
+		}));
+		observe?.(managed, options);
+		return managed;
+	};
+}
+//#endregion
+//#region src/supervisor.ts
+const CLAUDE_INITIALIZATION_TIMEOUT_MS = 3e4;
+/** Control requests must settle; a wedged one must not clog the metadata chain. */
+const CLAUDE_METADATA_TIMEOUT_MS = 15e3;
+const CLAUDE_MODE_BY_SANDBOX = {
+	"read-only": "plan",
+	"workspace-write": "acceptEdits",
+	"danger-full-access": "bypassPermissions"
+};
+/** Fold DSH's native access selector into Claude Code's closest permission mode. */
+function claudePermissionMode(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event?.type !== "sandbox/mode") continue;
+		const mode = event.data.mode;
+		return typeof mode === "string" && mode in CLAUDE_MODE_BY_SANDBOX ? CLAUDE_MODE_BY_SANDBOX[mode] : "plan";
+	}
+	return "plan";
+}
+var ClaudeTurnBusyError = class extends Error {
+	constructor(sessionId) {
+		super(`Claude Code session ${sessionId} already has an active or interrupting turn`);
+		this.name = "ClaudeTurnBusyError";
+	}
+};
+var ClaudeOutcomeUnknownError = class extends Error {
+	constructor(message = "Claude Code exited after activity; side-effect outcome is unknown and the prompt was not replayed") {
+		super(message);
+		this.name = "ClaudeOutcomeUnknownError";
+	}
+};
+var ClaudeProtocolError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ClaudeProtocolError";
+	}
+};
+var ClaudeProcessLimitError = class extends Error {
+	constructor(maxProcesses) {
+		super(`Claude Code process limit reached (${maxProcesses}) and no idle session can be evicted`);
+		this.name = "ClaudeProcessLimitError";
+	}
+};
+function abortFailure() {
+	const error = /* @__PURE__ */ new Error("Claude Code turn aborted");
+	error.name = "AbortError";
+	return error;
+}
+function signalAborted(signal) {
+	return signal?.aborted === true;
+}
+async function withTimeout(operation, timeoutMs, label) {
+	let timer;
+	try {
+		return await Promise.race([operation, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+			timer.unref?.();
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function sdkUserMessage(prompt, uuid) {
+	return {
+		type: "user",
+		message: {
+			role: "user",
+			content: prompt
+		},
+		parent_tool_use_id: null,
+		uuid
+	};
+}
+/** CLI ≥ 2.1.235 emits system/init only after its first stdin input, while
+*  the supervisor must see init before submitting any real turn. A local
+*  slash command nudges startup without costing a model call; its lifecycle
+*  messages are ignored because no DSH turn is active while they arrive. */
+const CLAUDE_HANDSHAKE_PROMPT = "/status";
+function usageSummary(usage) {
+	return `${usage.inputTokens ?? 0} input / ${usage.outputTokens ?? 0} output tokens${usage.cumulativeCostUsd === void 0 ? "" : ` · $${usage.cumulativeCostUsd.toFixed(4)} cumulative`}`;
+}
+function errorSummary(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Root-call activity summary; subagent dispatches lead with Claude's own task description. */
+function rootCallSummary(toolName, input) {
+	if (TASK_TOOL_NAMES.has(toolName)) {
+		const description = input !== null && typeof input === "object" ? input.description : void 0;
+		if (typeof description === "string" && description.length > 0) return description;
+		return "Claude dispatched a subagent";
+	}
+	return `Claude called ${toolName}`;
+}
+var ClaudeSupervisor = class {
+	#entries = /* @__PURE__ */ new Map();
+	#runtime;
+	#approval;
+	#config;
+	#queryFactory;
+	#runDetached;
+	#sidecar;
+	#dynamicPresenterNames = /* @__PURE__ */ new WeakMap();
+	#contextWindows = /* @__PURE__ */ new Map();
+	#disposed = false;
+	#admissionGate = Promise.resolve();
+	constructor(dependencies) {
+		this.#runtime = dependencies.runtime;
+		this.#approval = dependencies.approval;
+		this.#config = dependencies.config;
+		this.#queryFactory = dependencies.queryFactory ?? ((params) => query(params));
+		this.#runDetached = dependencies.runDetached ?? ((operation) => operation());
+		this.#sidecar = dependencies.sidecar ?? new ClaudeSidecarRepository();
+	}
+	snapshots() {
+		return [...this.#entries.values()].map((entry) => ({
+			sessionId: entry.sessionId,
+			...entry.claudeSessionId === void 0 ? {} : { claudeSessionId: entry.claudeSessionId },
+			state: entry.state,
+			cwd: entry.cwd,
+			model: entry.model,
+			...entry.thinkingMode === void 0 ? {} : { thinkingMode: entry.thinkingMode },
+			lastUsedAt: entry.lastUsedAt,
+			...entry.process === void 0 ? {} : { pid: entry.process.handle.pid }
+		}));
+	}
+	supportedCommands(agent, model = this.#config.defaultModel) {
+		return this.#runMetadata(agent, model, (query) => query.supportedCommands());
+	}
+	async contextUsage(agent, model = this.#config.defaultModel) {
+		const usage = await this.#runMetadata(agent, model, (query) => query.getContextUsage());
+		const contextWindow = usage.rawMaxTokens > 0 ? usage.rawMaxTokens : usage.maxTokens;
+		if (contextWindow > 0) {
+			this.#contextWindows.set(model, contextWindow);
+			this.#contextWindows.set(usage.model, contextWindow);
+		}
+		return usage;
+	}
+	contextWindow(model) {
+		return this.#contextWindows.get(model);
+	}
+	runTurn(request) {
+		const operation = this.#admissionGate.then(() => this.#runTurnAdmitted(request));
+		this.#admissionGate = operation.then(() => void 0, () => void 0);
+		return operation;
+	}
+	async #runTurnAdmitted(request) {
+		if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
+		if (signalAborted(request.signal)) throw abortFailure();
+		const sessionId = request.agent.id;
+		let entry = this.#entries.get(sessionId);
+		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
+			this.#entries.delete(sessionId);
+			await this.#disposeEntry(entry);
+			entry = void 0;
+		}
+		if (entry === void 0) {
+			await this.#makeRoom();
+			entry = await this.#createEntry(request.agent, request.model ?? this.#config.defaultModel, request.thinkingMode);
+			this.#entries.set(sessionId, entry);
+			this.#armInitializationTimer(entry);
+		}
+		if (entry.ownerAgent !== request.agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
+		if (entry.active !== void 0 || entry.state === "interrupting") throw new ClaudeTurnBusyError(sessionId);
+		if (entry.idleTimer !== void 0) {
+			clearTimeout(entry.idleTimer);
+			entry.idleTimer = void 0;
+		}
+		const model = request.model ?? this.#config.defaultModel;
+		if (request.thinkingMode !== entry.thinkingMode) {
+			this.#entries.delete(sessionId);
+			await this.#disposeEntry(entry);
+			entry = await this.#createEntry(request.agent, model, request.thinkingMode);
+			this.#entries.set(sessionId, entry);
+			this.#armInitializationTimer(entry);
+		} else {
+			await this.#syncPermissionMode(entry);
+			if (model !== entry.model) {
+				await entry.query.setModel(model);
+				entry.model = model;
+			}
+		}
+		const promptUuid = randomUUID();
+		const cursor = currentClaudeActivityCursor(request.agent.session.events);
+		cursor.nextOrdinal = (await this.#sidecar.read(sessionId)).activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
+		const active = {
+			agent: request.agent,
+			cursor,
+			output: new AsyncQueue(),
+			promptUuid,
+			sawActivity: false,
+			sawTextDelta: false,
+			text: "",
+			thinking: "",
+			aborted: false,
+			deniedToolUseIds: /* @__PURE__ */ new Set(),
+			callNames: /* @__PURE__ */ new Map(),
+			...request.signal === void 0 ? {} : { signal: request.signal }
+		};
+		entry.active = active;
+		entry.state = "running";
+		entry.lastUsedAt = Date.now();
+		try {
+			await this.#appendActivity(active, {
+				kind: "status",
+				phase: "started",
+				title: "Claude Code turn started"
+			});
+		} catch (error) {
+			active.output.fail(error);
+			entry.active = void 0;
+			if (this.#entries.get(sessionId) === entry) this.#entries.delete(sessionId);
+			await this.#disposeEntry(entry);
+			throw error;
+		}
+		if (signalAborted(request.signal)) {
+			active.aborted = true;
+			active.output.fail(abortFailure());
+			await this.#appendActivity(active, {
+				kind: "status",
+				phase: "failed",
+				title: "Claude Code turn cancelled before submission"
+			});
+			entry.active = void 0;
+			entry.state = "idle";
+			entry.lastUsedAt = Date.now();
+			this.#armIdleTimer(entry);
+			return active.output;
+		}
+		if (request.signal !== void 0) {
+			const abortListener = () => {
+				this.#interrupt(entry);
+			};
+			active.abortListener = abortListener;
+			request.signal.addEventListener("abort", abortListener, { once: true });
+		}
+		entry.input.push(sdkUserMessage(request.prompt, promptUuid));
+		return active.output;
+	}
+	#runMetadata(agent, model, operation) {
+		const admitted = this.#admissionGate.then(async () => {
+			if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
+			const entry = await this.#metadataEntry(agent, model);
+			try {
+				await withTimeout(this.#whenInitialized(entry), CLAUDE_INITIALIZATION_TIMEOUT_MS, "Claude metadata initialization");
+				return await withTimeout(operation(entry.query, entry), CLAUDE_METADATA_TIMEOUT_MS, "Claude metadata request");
+			} finally {
+				entry.lastUsedAt = Date.now();
+				if (entry.active === void 0 && entry.state === "idle") this.#armIdleTimer(entry);
+			}
+		});
+		this.#admissionGate = admitted.then(() => void 0, () => void 0);
+		return admitted;
+	}
+	#whenInitialized(entry) {
+		if (entry.initialized) return Promise.resolve();
+		if (entry.state === "disposed" || entry.state === "disconnected" || entry.state === "outcome-unknown") return Promise.reject(/* @__PURE__ */ new Error(`dsh-claude: session ${entry.sessionId} is ${entry.state}`));
+		return new Promise((resolve, reject) => {
+			entry.initWaiters.push((error) => error === void 0 ? resolve() : reject(error instanceof Error ? error : new Error(String(error))));
+		});
+	}
+	async #metadataEntry(agent, model) {
+		const sessionId = agent.id;
+		let entry = this.#entries.get(sessionId);
+		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
+			this.#entries.delete(sessionId);
+			await this.#disposeEntry(entry);
+			entry = void 0;
+		}
+		if (entry === void 0) {
+			await this.#makeRoom();
+			entry = await this.#createEntry(agent, model);
+			this.#entries.set(sessionId, entry);
+			this.#armInitializationTimer(entry);
+		}
+		if (entry.ownerAgent !== agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
+		if (entry.active !== void 0 || entry.state === "interrupting") throw new ClaudeTurnBusyError(sessionId);
+		if (entry.idleTimer !== void 0) {
+			clearTimeout(entry.idleTimer);
+			entry.idleTimer = void 0;
+		}
+		await this.#syncPermissionMode(entry);
+		if (model !== entry.model) {
+			await entry.query.setModel(model);
+			entry.model = model;
+		}
+		return entry;
+	}
+	async #syncPermissionMode(entry) {
+		const mode = claudePermissionMode(entry.ownerAgent.session.events);
+		if (mode === entry.permissionMode) return;
+		await entry.query.setPermissionMode(mode);
+		entry.permissionMode = mode;
+	}
+	async disposeSession(sessionId) {
+		const entry = this.#entries.get(sessionId);
+		if (entry === void 0) return;
+		this.#entries.delete(sessionId);
+		await this.#disposeEntry(entry);
+	}
+	async dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		const entries = [...this.#entries.values()];
+		this.#entries.clear();
+		await Promise.allSettled(entries.map((entry) => this.#disposeEntry(entry)));
+	}
+	async #makeRoom() {
+		if (this.#entries.size < this.#config.maxProcesses) return;
+		const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+		if (idle === void 0) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
+		this.#entries.delete(idle.sessionId);
+		await this.#disposeEntry(idle);
+	}
+	async #createEntry(agent, model, thinkingMode) {
+		const sessionId = agent.id;
+		const cwd = agent.session.header.cwd ?? process.cwd();
+		const input = new AsyncQueue();
+		const lifetime = new AbortController();
+		const binding = (await this.#sidecar.importLegacy(sessionId, agent.session.events)).binding;
+		const permissionMode = claudePermissionMode(agent.session.events);
+		const entry = {
+			sessionId,
+			ownerAgent: agent,
+			cwd,
+			model,
+			thinkingMode,
+			permissionMode,
+			state: "starting",
+			lastUsedAt: Date.now(),
+			input,
+			lifetime,
+			claudeSessionId: binding?.claudeSessionId,
+			expectedResume: binding?.claudeSessionId,
+			handshakeUuid: randomUUID(),
+			handshakePending: true,
+			initialized: false,
+			initWaiters: [],
+			initTimer: void 0,
+			idleTimer: void 0,
+			tasks: /* @__PURE__ */ new Map(),
+			taskSnapshotAt: 0,
+			taskSnapshotTimer: void 0
+		};
+		const canUseTool = createPermissionBridge(this.#approval, () => {
+			const active = entry.active;
+			return active === void 0 ? void 0 : {
+				agent: active.agent,
+				cursor: active.cursor,
+				markActivity: () => {
+					active.sawActivity = true;
+				},
+				recordDenial: (toolUseId) => {
+					active.deniedToolUseIds.add(toolUseId);
+				},
+				appendActivity: (activity) => this.#appendActivity(active, activity)
+			};
+		});
+		const options = {
+			pathToClaudeCodeExecutable: this.#config.executablePath,
+			cwd,
+			settingSources: [
+				"user",
+				"project",
+				"local"
+			],
+			systemPrompt: {
+				type: "preset",
+				preset: "claude_code"
+			},
+			tools: {
+				type: "preset",
+				preset: "claude_code"
+			},
+			includePartialMessages: true,
+			permissionMode,
+			allowDangerouslySkipPermissions: true,
+			canUseTool,
+			abortController: lifetime,
+			spawnClaudeCodeProcess: createManagedClaudeSpawner(this.#runtime, this.#config.executablePath, (process) => {
+				entry.process = process;
+			}),
+			...binding === void 0 ? {} : { resume: binding.claudeSessionId },
+			model,
+			...thinkingMode === void 0 ? {} : thinkingMode === "off" ? { thinking: { type: "disabled" } } : thinkingMode === "ultracode" ? { settings: { ultracode: true } } : { effort: thinkingMode }
+		};
+		entry.query = this.#queryFactory({
+			prompt: input,
+			options
+		});
+		entry.input.push(sdkUserMessage(CLAUDE_HANDSHAKE_PROMPT, entry.handshakeUuid));
+		entry.pump = this.#runDetached(() => this.#pump(entry));
+		return entry;
+	}
+	async #pump(entry) {
+		try {
+			for await (const sdkMessage of entry.query) for (const message of normalizeSdkMessage(sdkMessage)) await this.#handleMessage(entry, message);
+			if (entry.state !== "disposed") await this.#handleDisconnect(entry, /* @__PURE__ */ new Error("Claude Code stream ended"));
+		} catch (error) {
+			if (entry.state !== "disposed") await this.#handleDisconnect(entry, error);
+		}
+	}
+	async #handleMessage(entry, message) {
+		if (message.kind === "init") {
+			if (entry.expectedResume !== void 0 && message.sessionId !== entry.expectedResume) throw new ClaudeProtocolError(`Claude Code resumed unexpected session ${message.sessionId}; expected ${entry.expectedResume}`);
+			if (message.cwd !== entry.cwd) throw new ClaudeProtocolError(`Claude Code initialized in unexpected cwd ${message.cwd}; expected ${entry.cwd}`);
+			if (entry.initTimer !== void 0) {
+				clearTimeout(entry.initTimer);
+				entry.initTimer = void 0;
+			}
+			entry.initialized = true;
+			entry.claudeSessionId = message.sessionId;
+			entry.state = entry.active === void 0 ? "idle" : "running";
+			for (const waiter of entry.initWaiters.splice(0)) waiter(void 0);
+			if (entry.tasks.size > 0) {
+				entry.tasks.clear();
+				await this.#flushTasksSnapshot(entry);
+			}
+			await this.#sidecar.writeBinding(entry.sessionId, {
+				claudeSessionId: message.sessionId,
+				cliVersion: message.cliVersion,
+				cwd: message.cwd
+			});
+			return;
+		}
+		const taskId = message.kind === "subagent" ? message.taskId : void 0;
+		if (message.kind === "subagent" && taskId !== void 0) await this.#trackTask(entry, message, taskId, entry.active?.cursor.turn);
+		else if (message.kind === "background-tasks") this.#trackBackgroundLevel(entry, message.tasks, entry.active?.cursor.turn);
+		if (entry.handshakePending) {
+			if (message.kind === "protocol-error") throw new ClaudeProtocolError(`${message.title}: ${JSON.stringify(message.detail).slice(0, 1e3)}`);
+			if (message.kind === "result") entry.handshakePending = false;
+			return;
+		}
+		const active = entry.active;
+		if (active === void 0) return;
+		if (message.kind === "result") {
+			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}`);
+			await this.#completeTurn(entry, active, message);
+			return;
+		}
+		if (message.kind === "protocol-error") throw new ClaudeProtocolError(`${message.title}: ${JSON.stringify(message.detail).slice(0, 1e3)}`);
+		active.sawActivity = true;
+		switch (message.kind) {
+			case "text-delta":
+				if (message.parentToolUseId !== void 0) return;
+				active.sawTextDelta = true;
+				active.text += message.text;
+				active.output.push({
+					type: "text-delta",
+					text: message.text
+				});
+				return;
+			case "assistant-text":
+				if (message.parentToolUseId !== void 0) return;
+				if (!active.sawTextDelta) {
+					active.sawTextDelta = true;
+					active.text += message.text;
+					active.output.push({
+						type: "text-delta",
+						text: message.text
+					});
+				}
+				return;
+			case "thinking":
+				if (message.parentToolUseId !== void 0) return;
+				if (message.phase === "updated") {
+					active.thinking += message.text;
+					return;
+				}
+				active.thinking = message.text;
+				await this.#appendActivity(active, {
+					kind: "thinking",
+					phase: "completed",
+					title: "Claude thinking",
+					summary: message.text
+				});
+				return;
+			case "tool-call":
+				await this.#appendActivity(active, {
+					kind: message.parentToolUseId === void 0 ? "tool-call" : "subagent",
+					phase: "started",
+					toolUseId: message.toolUseId,
+					...message.parentToolUseId === void 0 ? {} : { parentToolUseId: message.parentToolUseId },
+					toolName: message.toolName,
+					title: message.toolName,
+					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);
+				}
+				return;
+			case "tool-result":
+				await this.#appendActivity(active, {
+					kind: message.parentToolUseId === void 0 ? "tool-result" : "subagent",
+					phase: message.isError ? "failed" : "completed",
+					toolUseId: message.toolUseId,
+					...message.parentToolUseId === void 0 ? {} : { parentToolUseId: message.parentToolUseId },
+					title: message.isError ? "Tool failed" : "Tool completed",
+					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, {
+					kind: "subagent",
+					phase: message.phase,
+					...message.taskId === void 0 ? {} : { taskId: message.taskId },
+					title: message.title,
+					summary: message.summary,
+					detail: message.detail,
+					isError: message.phase === "failed"
+				});
+				return;
+			case "status":
+			case "warning":
+			case "unknown":
+				await this.#appendActivity(active, {
+					kind: message.kind === "status" ? "status" : "warning",
+					phase: "updated",
+					title: message.title,
+					..."summary" in message ? { summary: message.summary } : {},
+					..."detail" in message ? { detail: message.detail } : {}
+				});
+				return;
+			case "permission-denied":
+				await this.#appendActivity(active, {
+					kind: "permission",
+					phase: "denied",
+					toolUseId: message.toolUseId,
+					toolName: message.toolName,
+					title: message.toolName,
+					summary: message.summary
+				});
+				return;
+		}
+	}
+	/** Merge one task lifecycle message into the session's task board. */
+	async #trackTask(entry, message, taskId, originTurn) {
+		const previous = entry.tasks.get(taskId);
+		const next = {
+			taskId,
+			description: message.description ?? previous?.description ?? message.title,
+			status: message.taskStatus ?? previous?.status ?? "running"
+		};
+		const resolvedOriginTurn = previous?.originTurn ?? originTurn;
+		if (resolvedOriginTurn !== void 0) next.originTurn = resolvedOriginTurn;
+		const subagentType = message.subagentType ?? previous?.subagentType;
+		if (subagentType !== void 0) next.subagentType = subagentType;
+		const taskType = message.taskType ?? previous?.taskType;
+		if (taskType !== void 0) next.taskType = taskType;
+		const lastToolName = message.lastToolName ?? previous?.lastToolName;
+		if (lastToolName !== void 0) next.lastToolName = lastToolName;
+		const summary = message.summary ?? previous?.summary;
+		if (summary !== void 0) next.summary = summary;
+		const usage = message.usage ?? previous?.usage;
+		if (usage !== void 0) next.usage = usage;
+		if (previous?.backgrounded === true) next.backgrounded = true;
+		entry.tasks.set(taskId, next);
+		const settled = next.status !== "running";
+		await this.#scheduleTasksSnapshot(entry, settled);
+	}
+	/** Fold the background-task level signal into the board (REPLACE semantics
+	*  for the backgrounded flag: only the listed tasks are detached). */
+	#trackBackgroundLevel(entry, tasks, originTurn) {
+		const live = new Set(tasks.map((task) => task.taskId));
+		let changed = false;
+		for (const task of tasks) {
+			const existing = entry.tasks.get(task.taskId);
+			if (existing === void 0) {
+				entry.tasks.set(task.taskId, {
+					taskId: task.taskId,
+					description: task.description,
+					status: "running",
+					...originTurn === void 0 ? {} : { originTurn },
+					...task.taskType === void 0 ? {} : { taskType: task.taskType },
+					backgrounded: true
+				});
+				changed = true;
+			} else if (existing.backgrounded !== true || existing.status !== "running") {
+				entry.tasks.set(task.taskId, {
+					...existing,
+					status: "running",
+					backgrounded: true
+				});
+				changed = true;
+			}
+		}
+		for (const task of entry.tasks.values()) if (task.backgrounded === true && task.status === "running" && !live.has(task.taskId)) {
+			entry.tasks.set(task.taskId, {
+				...task,
+				status: "completed"
+			});
+			changed = true;
+		}
+		if (changed) this.#scheduleTasksSnapshot(entry, true);
+	}
+	/** Persist the task board. Settled transitions flush immediately; progress
+	*  ticks throttle to one snapshot per second to bound log volume. */
+	async #scheduleTasksSnapshot(entry, immediate) {
+		const THROTTLE_MS = 1e3;
+		const elapsed = Date.now() - entry.taskSnapshotAt;
+		if (!immediate && elapsed < THROTTLE_MS) {
+			if (entry.taskSnapshotTimer === void 0) {
+				entry.taskSnapshotTimer = setTimeout(() => {
+					entry.taskSnapshotTimer = void 0;
+					this.#flushTasksSnapshot(entry);
+				}, THROTTLE_MS - elapsed);
+				entry.taskSnapshotTimer.unref?.();
+			}
+			return;
+		}
+		await this.#flushTasksSnapshot(entry);
+	}
+	async #flushTasksSnapshot(entry) {
+		if (entry.taskSnapshotTimer !== void 0) {
+			clearTimeout(entry.taskSnapshotTimer);
+			entry.taskSnapshotTimer = void 0;
+		}
+		entry.taskSnapshotAt = Date.now();
+		await this.#sidecar.writeTasks(entry.sessionId, [...entry.tasks.values()]).catch(() => void 0);
+	}
+	async #completeTurn(entry, active, result) {
+		if (entry.active !== active) return;
+		if (active.signal !== void 0 && active.abortListener !== void 0) active.signal.removeEventListener("abort", active.abortListener);
+		if (active.aborted) {
+			await this.#appendSafely(active, {
+				kind: "status",
+				phase: "failed",
+				title: "Claude Code turn cancelled"
+			});
+			entry.active = void 0;
+			entry.state = "idle";
+			entry.lastUsedAt = Date.now();
+			this.#armIdleTimer(entry);
+			return;
+		}
+		if (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
+			});
+		}
+		const unmatchedDenials = (result.permissionDenials ?? []).filter((denial) => !active.deniedToolUseIds.has(denial.toolUseId));
+		if (unmatchedDenials.length > 0) await this.#appendSafely(active, {
+			kind: "permission",
+			phase: "denied",
+			title: "Claude Code auto-denied tool calls",
+			summary: unmatchedDenials.map((denial) => denial.toolName).join(", ")
+		});
+		if (!result.success) {
+			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",
+				phase: "failed",
+				title: "Claude Code turn failed",
+				summary: message,
+				isError: true
+			});
+			active.output.fail(new Error(message));
+		} else {
+			if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
+				active.text = result.text;
+				active.output.push({
+					type: "text-delta",
+					text: result.text
+				});
+			}
+			await this.#appendSafely(active, {
+				kind: "status",
+				phase: "completed",
+				title: "Claude Code turn completed"
+			});
+			active.output.push({
+				type: "complete",
+				text: active.text
+			});
+			active.output.close();
+		}
+		entry.active = void 0;
+		entry.state = "idle";
+		entry.lastUsedAt = Date.now();
+		this.#armIdleTimer(entry);
+	}
+	async #appendActivity(active, activity) {
+		const ordinal = active.cursor.nextOrdinal++;
+		await this.#sidecar.appendActivity(active.agent.id, {
+			...activity,
+			turn: active.cursor.turn,
+			step: active.cursor.step,
+			ordinal
+		});
+	}
+	/** Persist durable activity without letting a storage failure unsettle the
+	* in-memory turn or leak process ownership. Audit failure is best-effort. */
+	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 {}
+	}
+	async #interrupt(entry) {
+		const active = entry.active;
+		if (active === void 0 || entry.state === "interrupting") return;
+		entry.state = "interrupting";
+		active.aborted = true;
+		active.output.fail(abortFailure());
+		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`);
+		} catch (error) {
+			interruptError = error;
+		}
+		try {
+			await this.#appendActivity(active, {
+				kind: "status",
+				phase: "failed",
+				title: interruptError === void 0 ? "Claude Code turn cancelled" : "Claude Code cancelled; process entry reset",
+				...interruptError === void 0 ? {} : { summary: errorSummary(interruptError) }
+			});
+		} catch {}
+		if (this.#entries.get(entry.sessionId) === entry) this.#entries.delete(entry.sessionId);
+		await this.#disposeEntry(entry);
+	}
+	async #handleDisconnect(entry, error) {
+		const active = entry.active;
+		const stderr = entry.process?.stderrTail();
+		if (active !== void 0) {
+			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";
+			const failure = unknown ? new ClaudeOutcomeUnknownError(stderr === void 0 || stderr.length === 0 ? void 0 : `Claude Code exited after activity; outcome unknown. ${stderr}`) : new Error(stderr === void 0 || stderr.length === 0 ? errorSummary(error) : stderr);
+			await this.#appendSafely(active, {
+				kind: "error",
+				phase: "failed",
+				title: unknown ? "Claude Code outcome unknown" : "Claude Code disconnected",
+				summary: failure.message,
+				isError: true,
+				detail: error
+			});
+			active.output.fail(failure);
+			entry.active = void 0;
+		} else entry.state = "disconnected";
+		const waiters = entry.initWaiters.splice(0);
+		const waiterError = error instanceof Error ? error : new Error(String(error));
+		for (const waiter of waiters) waiter(waiterError);
+		this.#entries.delete(entry.sessionId);
+		await this.#disposeEntry(entry);
+	}
+	#armInitializationTimer(entry) {
+		const timer = setTimeout(() => {
+			if (entry.state !== "starting" || entry.initialized) return;
+			this.#handleDisconnect(entry, /* @__PURE__ */ new Error("Claude Code initialization timed out"));
+		}, CLAUDE_INITIALIZATION_TIMEOUT_MS);
+		timer.unref?.();
+		entry.initTimer = timer;
+	}
+	#armIdleTimer(entry) {
+		if (this.#config.idleTimeoutMs <= 0) return;
+		const timer = setTimeout(() => {
+			if (entry.active !== void 0 || entry.state !== "idle") return;
+			this.#entries.delete(entry.sessionId);
+			this.#disposeEntry(entry);
+		}, this.#config.idleTimeoutMs);
+		timer.unref?.();
+		entry.idleTimer = timer;
+	}
+	async #disposeEntry(entry) {
+		if (entry.state === "disposed") return;
+		if (entry.idleTimer !== void 0) clearTimeout(entry.idleTimer);
+		if (entry.initTimer !== void 0) clearTimeout(entry.initTimer);
+		entry.state = "disposed";
+		entry.input.discard(abortFailure());
+		entry.query.close();
+		entry.lifetime.abort();
+		if (entry.active !== void 0) entry.active.output.fail(abortFailure());
+		entry.process?.kill("SIGTERM");
+		if (entry.process !== void 0) try {
+			await entry.process.handle.waitForExit(AbortSignal.timeout(5e3));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/adapter.ts
+const MODELS = [
+	{
+		id: "default",
+		name: "Default (recommended)",
+		description: "Use Claude Code’s recommended default model."
+	},
+	{
+		id: "opus[1m]",
+		name: "Opus (1M context)",
+		description: "Use Opus with a 1M-token context window.",
+		contextWindow: 1e6
+	},
+	{
+		id: "fable",
+		name: "Fable",
+		description: "Use Fable, Claude Code’s most capable coding model."
+	},
+	{
+		id: "sonnet",
+		name: "Sonnet",
+		description: "Use Sonnet for efficient routine coding work."
+	},
+	{
+		id: "haiku",
+		name: "Haiku",
+		description: "Use Haiku for fast, lightweight tasks."
+	}
+];
+const THINKING_MODES = [
+	{
+		id: "off",
+		name: "Off",
+		description: "No extended thinking."
+	},
+	{
+		id: "low",
+		name: "Low",
+		description: "Minimal thinking, fastest responses."
+	},
+	{
+		id: "medium",
+		name: "Medium",
+		description: "Moderate thinking."
+	},
+	{
+		id: "high",
+		name: "High",
+		description: "Deep reasoning (Claude Code default)."
+	},
+	{
+		id: "xhigh",
+		name: "Extra High",
+		description: "Deeper than high; unsupported models silently downgrade to high."
+	},
+	{
+		id: "max",
+		name: "Max",
+		description: "Maximum effort; unsupported models silently downgrade."
+	},
+	{
+		id: "ultracode",
+		name: "Ultracode",
+		description: "Extra-high effort plus standing dynamic-workflow orchestration; requires an xhigh-capable model."
+	}
+];
+function thinkingModeFor(effort) {
+	if (effort === void 0) return void 0;
+	if (THINKING_MODES.some((mode) => mode.id === effort)) return effort;
+	throw new Error(`dsh-claude: unsupported reasoning effort ${JSON.stringify(effort)}`);
+}
+const NO_RETRY_POLICY = Object.freeze({
+	mode: "normal",
+	maxRetries: 0,
+	retryableCodes: Object.freeze([]),
+	initialDelayMs: 500,
+	maxDelayMs: 1e4,
+	jitterRatio: .1
+});
+function extractDirectUserText(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role !== "user" || message.source.kind !== "user") continue;
+		const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+		if (text.length > 0) return text;
+		if (message.content.some((block) => block.type === "image")) throw new Error("dsh-claude: image-only prompts are not supported in v0.1; include a text prompt");
+	}
+	throw new Error("dsh-claude: no direct human text was present in this model step");
+}
+function tokenUsage(usage) {
+	const normalized = {
+		inputTokens: usage.inputTokens ?? 0,
+		outputTokens: usage.outputTokens ?? 0
+	};
+	if (usage.cacheReadTokens !== void 0) normalized.cacheReadTokens = usage.cacheReadTokens;
+	if (usage.cacheCreationTokens !== void 0) normalized.cacheWriteTokens = usage.cacheCreationTokens;
+	return normalized;
+}
+function resolveAgent(agents, options) {
+	const initiator = agents.currentInitiator();
+	if (initiator !== void 0) return initiator;
+	if (options.sessionId !== void 0) {
+		const agent = agents.get(options.sessionId);
+		if (agent !== void 0) return agent;
+	}
+	throw new Error("dsh-claude: the model request has no live owning DSH agent");
+}
+var ClaudeCodeAdapter = class extends LlmAdapter {
+	#supervisor;
+	#agents;
+	#presetIdFor;
+	constructor(supervisor, agents, presetIdFor) {
+		super();
+		this.#supervisor = supervisor;
+		this.#agents = agents;
+		this.#presetIdFor = presetIdFor;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "Claude Code"
+		};
+	}
+	providerRetryPolicy() {
+		return NO_RETRY_POLICY;
+	}
+	async listModels() {
+		return MODELS.map((model) => ({
+			provider: CLAUDE_CODE_PROVIDER,
+			id: model.id,
+			name: model.name,
+			description: model.description,
+			inputModalities: ["text"]
+		}));
+	}
+	async resolveModel(provider, model) {
+		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 {
+			provider,
+			id: model,
+			name: known?.name ?? `Claude Code ${model}`,
+			...known === void 0 ? {} : { description: known.description },
+			...contextWindow === void 0 ? {} : { context: { contextWindow } },
+			inputModalities: ["text"],
+			reasoning: { efforts: THINKING_MODES.map((mode) => ({
+				id: ReasoningEffortId(mode.id),
+				name: mode.name,
+				description: mode.description
+			})) }
+		};
+	}
+	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);
+		if (!isClaudePresetId(this.#presetIdFor(agent))) throw new Error(`dsh-claude: provider ${CLAUDE_CODE_PROVIDER} is available only to the ${CLAUDE_CODE_PRESET_ID} preset`);
+		const thinkingMode = thinkingModeFor(options.reasoningEffort);
+		const prompt = extractDirectUserText(options.messages);
+		const events = await this.#supervisor.runTurn({
+			agent,
+			prompt,
+			model: options.model,
+			...thinkingMode === void 0 ? {} : { thinkingMode },
+			...options.signal === void 0 ? {} : { signal: options.signal }
+		});
+		let text = "";
+		let pendingUsage;
+		let completed = false;
+		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 {
+				completed = true;
+				if (text.length > 0) {
+					yield {
+						type: "block-start",
+						index: 0,
+						blockType: "text"
+					};
+					yield {
+						type: "text-delta",
+						index: 0,
+						text
+					};
+					yield {
+						type: "block-end",
+						index: 0,
+						block: {
+							type: "text",
+							text
+						}
+					};
+				}
+				if (pendingUsage !== void 0) yield {
+					type: "usage",
+					usage: pendingUsage
+				};
+				yield {
+					type: "finish",
+					reason: { kind: "stop" }
+				};
+			}
+		} catch (error) {
+			if (error.name === "AbortError") {
+				completed = true;
+				if (text.length > 0) {
+					yield {
+						type: "block-start",
+						index: 0,
+						blockType: "text"
+					};
+					yield {
+						type: "text-delta",
+						index: 0,
+						text
+					};
+					yield {
+						type: "block-end",
+						index: 0,
+						block: {
+							type: "text",
+							text
+						}
+					};
+				}
+				yield {
+					type: "finish",
+					reason: {
+						kind: "aborted",
+						failure: {
+							code: "aborted",
+							message: error instanceof Error ? error.message : "Claude Code turn aborted"
+						}
+					}
+				};
+				return;
+			}
+			throw error;
+		}
+		if (!completed) throw new Error("dsh-claude: Claude turn stream ended without a result");
+	}
+};
+function createClaudeCodeAdapter(supervisor, agents, presetIdFor) {
+	return new ClaudeCodeAdapter(supervisor, agents, presetIdFor);
+}
+//#endregion
+//#region src/http.ts
+/** Accept only loopback, same-origin browser requests to plugin-private routes. */
+function trustedRequest(req) {
+	const remote = req.socket.remoteAddress;
+	if (remote !== "127.0.0.1" && remote !== "::1" && remote !== "::ffff:127.0.0.1") return false;
+	if (req.headers["sec-fetch-site"] === "cross-site") return false;
+	const host = req.headers.host;
+	if (host === void 0) return false;
+	const authority = /^(?:127\.0\.0\.1|\[?::1\]?|localhost)(?::\d+)?$/i;
+	if (!authority.test(host)) return false;
+	const origin = req.headers.origin;
+	if (origin === void 0) return true;
+	try {
+		const originUrl = new URL(origin);
+		return originUrl.host === host && authority.test(originUrl.host);
+	} catch {
+		return false;
+	}
+}
+/** Send a non-cacheable JSON response with MIME sniffing disabled. */
+function json(res, status, value) {
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store",
+		"x-content-type-options": "nosniff"
+	});
+	res.end(JSON.stringify(value));
+}
+//#endregion
+//#region src/doctor-routes.ts
+const CLAUDE_DOCTOR_PROBE_TIMEOUT_MS = 15e3;
+const claudeBridgeDiagnostics = /* @__PURE__ */ new WeakMap();
+function safeMessage(error) {
+	return redactText(error instanceof Error ? error.message : String(error), 1e3);
+}
+/** Live command-bridge diagnostics: which agents exist, their presets, and how
+*  many slash commands each agent's registry layer resolves. */
+function commandDiagnostics(ctx) {
+	try {
+		const agents = ctx.agents.list();
+		return {
+			total: agents.length,
+			agents: agents.map((agent) => {
+				const info = { id: String(agent.id) };
+				try {
+					const preset = ctx.agentPresets.composedPreset(agent.ctx);
+					if (preset !== void 0) info.preset = preset;
+				} catch (error) {
+					info.error = safeMessage(error);
+				}
+				try {
+					const list = ctx.commands.list(agent);
+					info.commandCount = list.length;
+					info.sample = list.slice(0, 10).map((command) => command.name);
+				} catch (error) {
+					info.error = info.error === void 0 ? safeMessage(error) : `${info.error}; ${safeMessage(error)}`;
+				}
+				const bridge = claudeBridgeDiagnostics.get(agent);
+				if (bridge !== void 0) info.bridge = bridge;
+				return info;
+			})
+		};
+	} catch (error) {
+		return { error: safeMessage(error) };
+	}
+}
+function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolutionError) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: CLAUDE_DOCTOR_PATH,
+		handler: async (req, res) => {
+			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			try {
+				if (resolutionError !== void 0) return json(res, 200, {
+					executable: {
+						status: "missing",
+						searched: config.executablePath.length > 0 ? [config.executablePath] : [
+							"claude",
+							"~/.local/bin/claude",
+							"/opt/homebrew/bin/claude",
+							"/usr/local/bin/claude"
+						]
+					},
+					version: { status: "not-run" },
+					authentication: { status: "not-run" },
+					handshake: "not-run",
+					message: safeMessage(resolutionError),
+					limits: {
+						idleTimeoutMs: config.idleTimeoutMs,
+						maxProcesses: config.maxProcesses
+					},
+					processes: {
+						count: 0,
+						active: 0
+					}
+				});
+				const report = await runClaudeDoctor(runtime, {
+					configuredPath: config.executablePath,
+					cwd: process.cwd(),
+					signal: AbortSignal.timeout(CLAUDE_DOCTOR_PROBE_TIMEOUT_MS)
+				});
+				const processes = supervisor.snapshots();
+				if (processes.some((process) => process.claudeSessionId !== void 0)) report.handshake = "ok";
+				json(res, 200, {
+					...report,
+					limits: {
+						idleTimeoutMs: config.idleTimeoutMs,
+						maxProcesses: config.maxProcesses
+					},
+					processes: {
+						count: processes.length,
+						active: processes.filter((process) => process.state === "running" || process.state === "starting").length
+					},
+					commandBridge: commandDiagnostics(ctx)
+				});
+			} catch (error) {
+				json(res, 500, { error: safeMessage(error) });
+			}
+		}
+	}), "dsh-claude: Doctor route");
+}
+//#endregion
+//#region src/projection-routes.ts
+const MAX_SESSION_ID_CHARS = 1024;
+function sessionIdFromUrl(rawUrl) {
+	try {
+		const pathname = new URL(rawUrl ?? "/", "http://localhost").pathname;
+		const prefix = `${CLAUDE_PROJECTION_PATH}/`;
+		if (!pathname.startsWith(prefix)) return void 0;
+		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;
+		return sessionId;
+	} catch {
+		return;
+	}
+}
+/** Register the browser-readable, credential-free sidecar projection endpoint. */
+function registerClaudeProjectionRoute(ctx, sidecar, ownsSession) {
+	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);
+			if (sessionId === void 0) return json(res, 400, { error: "invalid session id" });
+			try {
+				const projection = await sidecar.read(sessionId);
+				return json(res, 200, {
+					schemaVersion: projection.schemaVersion,
+					revision: projection.revision,
+					owned: ownsSession(sessionId),
+					activities: projection.activities,
+					...projection.contextUsage === void 0 ? {} : { contextUsage: projection.contextUsage },
+					...projection.tasks === void 0 ? {} : { tasks: projection.tasks }
+				});
+			} catch {
+				return json(res, 500, { error: "projection unavailable" });
+			}
+		}
+	}), "dsh-claude: sidecar projection route");
+}
+//#endregion
+//#region src/index.ts
+const name = "llm-claude";
+const inject = [
+	"llm",
+	"agents",
+	"agentPresets",
+	"commands",
+	"subprocess",
+	"approval"
+];
+const Config = z.object({
+	executablePath: z.string().default(""),
+	model: z.string().default("default"),
+	idleTimeoutMs: z.number().min(1e3).max(2147483647).default(18e5),
+	maxProcesses: z.number().step(1).min(1).default(4)
+});
+const CLAUDE_SCOPE_UNAVAILABLE_MESSAGE = "agent command scope unavailable (preset route not mounted?)";
+const CATALOG_RETRY_MS = 5e3;
+const SCOPE_RETRY_MS = 500;
+const MAX_CATALOG_RETRIES = 3;
+const MAX_SCOPE_RETRIES = 24;
+function mountClaudeMetadata(ctx, supervisor, agent, model, sidecar, resolveCommands = () => ctx.agentPresets.serviceFor(agent, CLAUDE_COMMANDS_SERVICE)) {
+	if (!isClaudePresetId(ctx.agentPresets.composedPreset(agent.ctx))) return void 0;
+	let stopped = false;
+	let pending = Promise.resolve();
+	let commandScope;
+	const scopedCommands = () => {
+		const scoped = commandScope ?? resolveCommands();
+		if (scoped === void 0) throw new Error(CLAUDE_SCOPE_UNAVAILABLE_MESSAGE);
+		commandScope = scoped;
+		return scoped;
+	};
+	const bridge = new ClaudeCommandBridge({
+		list: () => scopedCommands().list(agent),
+		register: (definition) => scopedCommands().register(definition),
+		forward: (line) => {
+			agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text: line
+				}],
+				source: { kind: "user" }
+			}));
+		}
+	});
+	const warn = (area, error) => {
+		ctx.logger.warn(`dsh-claude: ${area} refresh failed for ${String(agent.id)}: ${error instanceof Error ? error.message : String(error)}`);
+	};
+	const isScopeUnavailable = (error) => {
+		if (error instanceof Error) return error.message === CLAUDE_SCOPE_UNAVAILABLE_MESSAGE;
+		return String(error) === CLAUDE_SCOPE_UNAVAILABLE_MESSAGE;
+	};
+	const diagnostic = claudeBridgeDiagnostics.get(agent) ?? { attempts: 0 };
+	claudeBridgeDiagnostics.set(agent, diagnostic);
+	let catalogRetries = 0;
+	let scopeRetries = 0;
+	let retryTimer;
+	const scheduleRetry = (area, attempt) => {
+		if (retryTimer !== void 0) clearTimeout(retryTimer);
+		const delay = area === "command catalog" ? CATALOG_RETRY_MS * attempt : Math.min(SCOPE_RETRY_MS * 2 ** attempt, 5e3);
+		retryTimer = setTimeout(() => {
+			if (!stopped) refresh();
+		}, delay);
+		retryTimer.unref?.();
+	};
+	const refresh = () => {
+		pending = pending.then(async () => {
+			if (stopped) return;
+			diagnostic.attempts += 1;
+			let catalog;
+			try {
+				catalog = await supervisor.supportedCommands(agent, model);
+				catalogRetries = 0;
+				scopeRetries = 0;
+				diagnostic.lastCatalog = catalog.length;
+				delete diagnostic.lastError;
+			} catch (error) {
+				diagnostic.lastError = error instanceof Error ? error.message : String(error);
+				warn("command catalog", error);
+				if (!stopped && catalogRetries < MAX_CATALOG_RETRIES) {
+					catalogRetries += 1;
+					scheduleRetry("command catalog", catalogRetries);
+				}
+			}
+			if (stopped || catalog === void 0) return;
+			try {
+				diagnostic.registered = bridge.refresh(catalog).map((view) => view.publicName);
+				if (!stopped) scopeRetries = 0;
+			} catch (error) {
+				diagnostic.lastError = error instanceof Error ? error.message : String(error);
+				warn("command catalog", error);
+				if (!stopped && isScopeUnavailable(error) && scopeRetries < MAX_SCOPE_RETRIES) {
+					scopeRetries += 1;
+					scheduleRetry("command scope", scopeRetries);
+				}
+			}
+			if (stopped) return;
+			try {
+				const usage = await supervisor.contextUsage(agent, model);
+				if (!stopped) await sidecar.writeContextUsage(agent.id, usage);
+			} catch (error) {
+				warn("context usage", error);
+			}
+		});
+	};
+	return agent.ctx.effect(() => {
+		const stopStatus = agent.ctx.on("agent/status", ({ status }) => {
+			if (status === "idle") refresh();
+		});
+		refresh();
+		return async () => {
+			stopped = true;
+			if (retryTimer !== void 0) clearTimeout(retryTimer);
+			stopStatus();
+			await pending;
+			bridge.dispose();
+		};
+	}, "dsh-claude: agent metadata bridge");
+}
+async function apply(ctx, config) {
+	await ensureManagedPreset();
+	const supervisorConfig = {
+		executablePath: "",
+		defaultModel: config.model ?? "default",
+		idleTimeoutMs: config.idleTimeoutMs ?? 18e5,
+		maxProcesses: config.maxProcesses ?? 4
+	};
+	const sidecar = new ClaudeSidecarRepository();
+	const supervisor = new ClaudeSupervisor({
+		runtime: ctx.subprocess,
+		approval: ctx.approval,
+		config: supervisorConfig,
+		runDetached: (operation) => ctx.agents.withoutInitiator(operation),
+		sidecar
+	});
+	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, (agent) => ctx.agentPresets.composedPreset(agent.ctx)));
+		ctx.effect(() => {
+			const mounted = /* @__PURE__ */ new Map();
+			const pending = /* @__PURE__ */ new Set();
+			const MOUNT_RETRY_MS = 200;
+			const MOUNT_RETRY_LIMIT = 50;
+			const mount = (agent) => {
+				if (mounted.has(agent)) return;
+				const dispose = mountClaudeMetadata(ctx, supervisor, agent, supervisorConfig.defaultModel, sidecar);
+				if (dispose !== void 0) mounted.set(agent, dispose);
+				pending.delete(agent);
+			};
+			const mountWhenPresetSettles = (agent) => {
+				if (mounted.has(agent) || pending.has(agent)) return;
+				if (ctx.agentPresets.composedPreset(agent.ctx) !== void 0) {
+					mount(agent);
+					return;
+				}
+				pending.add(agent);
+				let attempts = 0;
+				const retry = () => {
+					if (mounted.has(agent) || !pending.has(agent)) return;
+					if (ctx.agentPresets.composedPreset(agent.ctx) !== void 0) {
+						mount(agent);
+						return;
+					}
+					attempts += 1;
+					if (attempts >= MOUNT_RETRY_LIMIT) {
+						pending.delete(agent);
+						return;
+					}
+					setTimeout(retry, MOUNT_RETRY_MS).unref?.();
+				};
+				setTimeout(retry, MOUNT_RETRY_MS).unref?.();
+			};
+			const stopCreated = ctx.on("agent/created", ({ agent }) => {
+				mountWhenPresetSettles(agent);
+			});
+			const onPresetSelected = ctx.on;
+			const stopSelected = onPresetSelected("agent-preset/selected", (sessionId, preset) => {
+				if (!isClaudePresetId(preset)) return;
+				const agent = ctx.agents.get(sessionId);
+				if (agent !== void 0) mountWhenPresetSettles(agent);
+			});
+			for (const agent of ctx.agents.list()) mountWhenPresetSettles(agent);
+			return async () => {
+				stopCreated();
+				stopSelected();
+				pending.clear();
+				await Promise.allSettled([...mounted.values()].map((dispose) => dispose()));
+				mounted.clear();
+			};
+		}, "dsh-claude: metadata bridges");
+	} catch (error) {
+		resolutionError = error;
+	}
+	ctx.on("agent/disposed", async ({ agent }) => {
+		await supervisor.disposeSession(agent.id);
+	});
+	ctx.effect(() => () => supervisor.dispose(), "dsh-claude: process supervisor");
+	ctx.inject(["webServer"], (webCtx) => {
+		registerClaudeDoctorRoutes(webCtx, webCtx.subprocess, supervisor, supervisorConfig, resolutionError);
+		registerClaudeProjectionRoute(webCtx, sidecar, (sessionId) => {
+			const agent = webCtx.agents.get(sessionId);
+			return agent !== void 0 && isClaudePresetId(webCtx.agentPresets.composedPreset(agent.ctx));
+		});
+	});
+}
+//#endregion
+export { Config, apply, inject, mountClaudeMetadata, name };
+
+//# sourceMappingURL=index.mjs.map