@norman-else/dsh-claude 0.1.0

package/lib/client.js

@@ -0,0 +1,1417 @@
+window.__ModuleLoader__.load({
+	id: "dsh-claude",
+	factory: (require) => {
+		var module = { exports: {} };
+		module.exports;
+		var { useCallback, useEffect, useMemo, useState, useSyncExternalStore } = require("react");
+		var { Fragment, jsx, jsxs } = require("react/jsx-runtime");
+		var { DisclosureRow, IconApiOutline14, IconThinkOutline14, StateDot } = require("@deepseek-ai/dsh-client-ui-primitives");
+		function isClaudeProvider(value) {
+			return value === "claude" || value === "claude-code-cli";
+		}
+		/** Claude's subagent dispatch tools; rendered as plugin-owned group cards
+		*  gathering subagent activity instead of native tool cards. */
+		const TASK_TOOL_NAMES = /* @__PURE__ */ new Set(["Task", "Agent"]);
+		const CLAUDE_DOCTOR_PATH = "/plugins/dsh-claude/doctor";
+		const CLAUDE_PROJECTION_PATH = "/plugins/dsh-claude/projection";
+		//#endregion
+		//#region src/client/conversation-sidecar.ts
+		function isTaskActivity(value) {
+			return (value.kind === "tool-call" || value.kind === "tool-result") && value.toolName !== void 0 && TASK_TOOL_NAMES.has(value.toolName);
+		}
+		function presentable(activity) {
+			if (isTaskActivity(activity)) return true;
+			if (activity.kind === "tool-call" || activity.kind === "tool-result") return false;
+			if (activity.isError === true) return true;
+			if (activity.title?.startsWith("Unknown Claude SDK message") === true) return false;
+			switch (activity.kind) {
+				case "subagent":
+				case "permission":
+				case "warning":
+				case "error": return true;
+				case "thinking": return activity.summary !== void 0 && activity.summary.length > 0;
+				default: return false;
+			}
+		}
+		function running(activity) {
+			return activity.phase === "started" || activity.phase === "updated";
+		}
+		function subcallOf(value) {
+			if (value.kind !== "subagent" || value.toolUseId === void 0) return void 0;
+			return {
+				toolUseId: value.toolUseId,
+				...value.toolName === void 0 ? {} : { toolName: value.toolName },
+				...value.phase === void 0 ? {} : { phase: value.phase },
+				...value.summary === void 0 ? {} : { summary: value.summary },
+				...value.isError === void 0 ? {} : { isError: value.isError }
+			};
+		}
+		/** Fold raw sidecar activity into the same lifecycle cards the old event projection rendered. */
+		function activityRows(activities, accepts, tasks = []) {
+			const rows = [];
+			const byId = /* @__PURE__ */ new Map();
+			for (const value of activities) {
+				if (!accepts(value)) continue;
+				const existingTaskId = value.toolUseId === void 0 ? void 0 : `task-${value.toolUseId}`;
+				const updatesExistingTask = value.kind === "tool-result" && existingTaskId !== void 0 && byId.has(existingTaskId);
+				if (!presentable(value) && !updatesExistingTask) continue;
+				let id;
+				if ((isTaskActivity(value) || updatesExistingTask) && existingTaskId !== void 0) id = existingTaskId;
+				else if (value.kind === "subagent" && value.parentToolUseId !== void 0) id = `task-${value.parentToolUseId}`;
+				else if (value.kind === "subagent" && value.toolUseId !== void 0) id = `call-${value.toolUseId}`;
+				else id = `act-${value.turn}-${value.step}-${value.ordinal}`;
+				const index = byId.get(id);
+				if (index === void 0) {
+					byId.set(id, rows.length);
+					rows.push({
+						activity: value,
+						running: running(value),
+						subcalls: []
+					});
+					continue;
+				}
+				const previous = rows[index];
+				if (previous === void 0) continue;
+				if (value.kind === "subagent" && value.parentToolUseId !== void 0) {
+					const nested = subcallOf(value);
+					if (nested === void 0) continue;
+					const nestedIndex = previous.subcalls.findIndex((item) => item.toolUseId === nested.toolUseId);
+					const subcalls = nestedIndex === -1 ? [...previous.subcalls, nested] : previous.subcalls.map((item, position) => position === nestedIndex ? {
+						...item,
+						...nested
+					} : item);
+					rows[index] = {
+						...previous,
+						subcalls
+					};
+					continue;
+				}
+				rows[index] = {
+					activity: {
+						...value,
+						...value.toolName === void 0 && previous.activity.toolName !== void 0 ? { toolName: previous.activity.toolName } : {}
+					},
+					running: running(value),
+					subcalls: previous.subcalls
+				};
+			}
+			const taskStatus = new Map(tasks.map((task) => [task.taskId, task.status]));
+			return rows.map((row) => {
+				const taskId = row.activity.taskId;
+				const status = taskId === void 0 ? void 0 : taskStatus.get(taskId);
+				if (status === void 0 || status === "running") return row;
+				const failed = status === "failed" || status === "stopped" || status === "killed";
+				const settledTitle = row.activity.title?.replace(/^Running\s+/u, "");
+				return {
+					...row,
+					running: false,
+					activity: {
+						...row.activity,
+						phase: failed ? "failed" : "completed",
+						...settledTitle === void 0 ? {} : { title: settledTitle },
+						...failed ? { isError: true } : {}
+					}
+				};
+			});
+		}
+		function activityRowsForStep(activities, turn, step, tasks = []) {
+			return activityRows(activities, (activity) => activity.turn === turn && activity.step === step, tasks);
+		}
+		/** Anchor one sidecar-backed activity group immediately before its Claude assistant step. */
+		const claudeActivityStepDefinition = {
+			kind: "claude-activity-step",
+			target: "chat",
+			match(event) {
+				if (event.type === "step/start") return {
+					id: `${event.data.turn}:${event.data.step}`,
+					role: "start"
+				};
+				if (event.type !== "assistant/message" || !isClaudeProvider(event.data.message.source.provider)) return null;
+				return {
+					id: `${event.data.turn}:${event.data.step}`,
+					role: "update"
+				};
+			},
+			start(_context, match) {
+				if (match.event.type !== "step/start") throw new Error("Claude activity step requires step/start");
+				return {
+					turn: match.event.data.turn,
+					step: match.event.data.step
+				};
+			},
+			update(context, match) {
+				if (match.event.type !== "assistant/message") throw new Error("Claude activity step update requires assistant/message");
+				return {
+					...context.state,
+					assistantSeq: match.event.seq
+				};
+			},
+			buildViewNode(context) {
+				const state = context.state;
+				if (state?.assistantSeq === void 0) return null;
+				return {
+					key: context.key,
+					kind: "claude-activity-step",
+					id: context.id,
+					target: "chat",
+					anchorSeq: state.assistantSeq - .1,
+					location: context.start?.location ?? { kind: "unresolved" },
+					visibility: "visible",
+					data: {
+						turn: state.turn,
+						step: state.step
+					}
+				};
+			}
+		};
+		/** Publish a marker for turns containing standard assistant output from the Claude adapter. */
+		const claudeTurnDefinition = {
+			kind: "claudeCode",
+			match(event) {
+				if (event.type === "turn/start") return {
+					id: String(event.data.turn),
+					role: "start"
+				};
+				if (event.type !== "assistant/message" || !isClaudeProvider(event.data.message.source.provider)) return null;
+				return {
+					id: String(event.data.turn),
+					role: "update"
+				};
+			},
+			start(_context, match) {
+				if (match.event.type !== "turn/start") throw new Error("Claude turn marker requires turn/start");
+				return {
+					turn: match.event.data.turn,
+					claude: false
+				};
+			},
+			update(context, match) {
+				if (match.event.type !== "assistant/message") throw new Error("Claude turn marker update requires assistant/message");
+				return context.state.claude ? context.state : {
+					turn: context.state.turn,
+					claude: true
+				};
+			},
+			buildLocationData(context, scope) {
+				if (scope !== "turn" || context.state?.claude !== true) return null;
+				const value = { turn: context.state.turn };
+				return {
+					kind: "turn",
+					turn: context.state.turn,
+					key: "claudeCode",
+					value
+				};
+			}
+		};
+		/** Pure chain selector: only Claude-produced turns mount the sidecar-backed tail. */
+		function selectClaudeTurn(owner) {
+			return owner.turn.data.get("claudeCode") ?? null;
+		}
+		//#endregion
+		//#region src/client/styles.ts
+		const iconChipRunning = { color: "var(--dsw-static-blue-450)" };
+		const iconChipError = { color: "var(--dsw-alias-state-error-primary)" };
+		const chevron = {
+			flex: "none",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: "20px",
+			transition: "transform 120ms ease",
+			userSelect: "none"
+		};
+		const chevronOpen = { transform: "rotate(90deg)" };
+		const detailCode = {
+			maxHeight: 220,
+			overflow: "auto",
+			margin: "5px 0 0",
+			padding: "8px 10px",
+			borderRadius: 6,
+			background: "var(--dsw-alias-bg-layer-2)",
+			color: "var(--dsw-alias-label-secondary)",
+			fontSize: 11,
+			lineHeight: "17px",
+			whiteSpace: "pre-wrap",
+			overflowWrap: "anywhere"
+		};
+		const settingsPage = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 18,
+			maxWidth: 760
+		};
+		const settingsHeading = {
+			margin: 0,
+			color: "var(--dsw-alias-label-primary)",
+			fontSize: 20,
+			lineHeight: "28px",
+			fontWeight: 650
+		};
+		const settingsBody = {
+			margin: 0,
+			color: "var(--dsw-alias-label-secondary)",
+			fontSize: 14,
+			lineHeight: "22px"
+		};
+		const diagnosticGrid = {
+			display: "grid",
+			gridTemplateColumns: "minmax(130px, 0.4fr) minmax(0, 1fr)",
+			gap: "9px 18px",
+			padding: "16px 0",
+			borderTop: "1px solid var(--dsw-alias-border-l2)",
+			borderBottom: "1px solid var(--dsw-alias-border-l2)",
+			fontSize: 13
+		};
+		const diagnosticLabel = { color: "var(--dsw-alias-label-tertiary)" };
+		const diagnosticValue = {
+			color: "var(--dsw-alias-label-primary)",
+			overflowWrap: "anywhere"
+		};
+		const button = {
+			alignSelf: "flex-start",
+			minHeight: 34,
+			padding: "6px 14px",
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: 18,
+			background: "var(--dsw-alias-bg-layer-1)",
+			color: "var(--dsw-alias-label-primary)",
+			font: "inherit",
+			fontSize: 13,
+			cursor: "pointer"
+		};
+		const tasksPanel = {
+			display: "flex",
+			flexDirection: "column",
+			height: "100%",
+			minWidth: 0,
+			background: "var(--dsw-alias-bg-base)"
+		};
+		const tasksHeader = {
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "space-between",
+			gap: 8,
+			padding: "12px 14px",
+			borderBottom: "1px solid var(--dsw-alias-border-l2)"
+		};
+		const tasksHeading = {
+			color: "var(--dsw-alias-label-primary)",
+			fontSize: 14,
+			lineHeight: "20px",
+			fontWeight: 600
+		};
+		const tasksClose = {
+			width: 26,
+			height: 26,
+			display: "grid",
+			placeItems: "center",
+			border: "none",
+			borderRadius: 7,
+			background: "transparent",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 15,
+			lineHeight: "1",
+			cursor: "pointer"
+		};
+		const tasksBody = {
+			flex: 1,
+			minHeight: 0,
+			overflowY: "auto",
+			padding: "10px 12px 20px"
+		};
+		const tasksGroupHeading = {
+			minHeight: 30,
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "space-between",
+			gap: 8
+		};
+		const tasksGroupTitle = {
+			display: "inline-flex",
+			alignItems: "center",
+			gap: 6,
+			color: "var(--dsw-alias-label-secondary)",
+			fontSize: 12,
+			lineHeight: "20px",
+			fontWeight: 600
+		};
+		const tasksGroupToggle = {
+			display: "inline-flex",
+			alignItems: "center",
+			gap: 5,
+			padding: 0,
+			border: "none",
+			background: "transparent",
+			color: "var(--dsw-alias-label-secondary)",
+			font: "inherit",
+			fontSize: 12,
+			lineHeight: "20px",
+			fontWeight: 600,
+			cursor: "pointer"
+		};
+		const tasksGroupCount = {
+			minWidth: 18,
+			padding: "0 5px",
+			borderRadius: 999,
+			background: "var(--dsw-alias-bg-layer-2)",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 10,
+			lineHeight: "17px",
+			textAlign: "center",
+			fontVariantNumeric: "tabular-nums"
+		};
+		const tasksGroupEmpty = {
+			margin: "5px 4px 2px",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 12,
+			lineHeight: "18px"
+		};
+		const tasksFinishedSection = {
+			marginTop: 12,
+			paddingTop: 8,
+			borderTop: "1px solid var(--dsw-alias-border-l2)"
+		};
+		const taskCardList = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 8,
+			marginTop: 4
+		};
+		const taskCard = {
+			padding: "10px 11px",
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: 10,
+			background: "var(--dsw-alias-bg-layer-1)"
+		};
+		const taskCardRunning = { borderColor: "var(--dsw-alias-border-l3)" };
+		const taskCardTop = {
+			display: "flex",
+			alignItems: "flex-start",
+			gap: 9
+		};
+		const taskCardGlyph = {
+			width: 18,
+			height: 18,
+			flex: "none",
+			display: "grid",
+			placeItems: "center",
+			marginTop: 1,
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: 1
+		};
+		const taskCardBody = {
+			flex: 1,
+			minWidth: 0
+		};
+		const taskTitle = {
+			margin: 0,
+			color: "var(--dsw-alias-label-primary)",
+			fontSize: 13,
+			lineHeight: "19px",
+			fontWeight: 550,
+			overflowWrap: "anywhere"
+		};
+		const taskStatusLine = {
+			margin: "1px 0 0",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: "17px"
+		};
+		const taskMeta$1 = {
+			margin: "7px 0 0 27px",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: "17px",
+			overflowWrap: "anywhere"
+		};
+		const taskSummary = {
+			margin: "6px 0 0 27px",
+			color: "var(--dsw-alias-label-secondary)",
+			fontSize: 12,
+			lineHeight: "18px",
+			whiteSpace: "pre-wrap",
+			overflowWrap: "anywhere"
+		};
+		const taskTextButton = {
+			padding: 0,
+			border: "none",
+			background: "transparent",
+			color: "var(--dsw-static-blue-450)",
+			font: "inherit",
+			fontSize: 11,
+			lineHeight: "18px",
+			cursor: "pointer"
+		};
+		const taskActivitySection = { margin: "7px 0 0 27px" };
+		const taskActivityList = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 7,
+			margin: "7px 0 0",
+			padding: "8px 9px",
+			borderRadius: 8,
+			background: "var(--dsw-alias-bg-layer-2)",
+			listStyle: "none"
+		};
+		const taskActivityItem = {
+			display: "flex",
+			alignItems: "flex-start",
+			gap: 6
+		};
+		const taskActivityGlyph = {
+			flex: "none",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: "17px"
+		};
+		const taskActivityBody = {
+			flex: 1,
+			minWidth: 0
+		};
+		const taskActivityTitle = {
+			margin: 0,
+			color: "var(--dsw-alias-label-secondary)",
+			fontSize: 11,
+			lineHeight: "17px",
+			fontWeight: 500,
+			overflowWrap: "anywhere"
+		};
+		const taskActivitySummary = {
+			margin: "1px 0 0",
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 11,
+			lineHeight: "17px",
+			whiteSpace: "pre-wrap",
+			overflowWrap: "anywhere"
+		};
+		const taskActivityDetail = { marginTop: 3 };
+		const taskActivityDetailSummary = {
+			color: "var(--dsw-alias-label-tertiary)",
+			fontSize: 10,
+			lineHeight: "16px",
+			cursor: "pointer"
+		};
+		const tasksTurnLauncher = {
+			display: "inline-flex",
+			alignItems: "center",
+			gap: 7,
+			margin: "6px 0 2px",
+			padding: "5px 8px",
+			border: "none",
+			borderRadius: 8,
+			background: "transparent",
+			color: "var(--dsw-alias-label-secondary)",
+			font: "inherit",
+			fontSize: 12,
+			lineHeight: "18px",
+			cursor: "pointer"
+		};
+		const tasksTurnLauncherDot = {
+			color: "var(--dsw-static-blue-450)",
+			fontSize: 9
+		};
+		const tasksTriggerHoverCss = [
+			".dsh-claude-tasks-trigger:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover)}",
+			".dsh-claude-tasks-trigger:focus:not(:focus-visible){outline:none;border-color:var(--dsw-alias-border-l2)}",
+			".dsh-claude-tasks-trigger[aria-pressed=\"true\"]:focus:not(:focus-visible){border-color:var(--dsw-alias-border-l3)}",
+			".dsh-claude-tasks-trigger>span,.dsh-claude-tasks-trigger>svg{flex:none}"
+		].join("");
+		const tasksHeaderButton = {
+			minWidth: 111,
+			height: 32,
+			display: "inline-flex",
+			alignItems: "center",
+			justifyContent: "center",
+			gap: 4,
+			padding: "6px 12px",
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: 18,
+			color: "var(--dsw-alias-label-primary)",
+			fontFamily: "var(--dsw-font-family)",
+			fontSize: 13,
+			fontWeight: 400,
+			lineHeight: "20px",
+			whiteSpace: "nowrap",
+			cursor: "pointer"
+		};
+		const tasksHeaderButtonActive = {
+			borderColor: "var(--dsw-alias-border-l3)",
+			background: "var(--dsw-alias-interactive-bg-hover)"
+		};
+		const tasksBadgeInline = {
+			minWidth: 14,
+			height: 14,
+			display: "grid",
+			placeItems: "center",
+			padding: "0 3px",
+			borderRadius: 999,
+			background: "var(--dsw-static-blue-450)",
+			color: "var(--dsw-alias-label-on-accent, #fff)",
+			fontSize: 9,
+			lineHeight: "1",
+			fontWeight: 600
+		};
+		//#endregion
+		//#region src/client/token-format.ts
+		function formatTokenCount(tokens) {
+			if (tokens >= 1e6) return `${Number((tokens / 1e6).toFixed(tokens >= 1e7 ? 0 : 1))}M`;
+			if (tokens >= 1e3) return `${Number((tokens / 1e3).toFixed(tokens >= 1e5 ? 0 : 1))}K`;
+			return String(tokens);
+		}
+		//#endregion
+		//#region src/client/ClaudeTasksPanel.tsx
+		const STATUS_LABEL = {
+			running: "tasksRunning",
+			completed: "tasksCompleted",
+			failed: "tasksFailed",
+			stopped: "tasksStopped",
+			killed: "tasksKilled"
+		};
+		function visibleTaskGroups(tasks, dismissedSettledIds) {
+			return {
+				running: tasks.filter((task) => task.status === "running"),
+				finished: tasks.filter((task) => task.status !== "running" && !dismissedSettledIds.has(task.taskId))
+			};
+		}
+		function activitiesForTask(activities, taskId) {
+			return activities.filter((activity) => activity.taskId === taskId);
+		}
+		function runningTasksForTurn(tasks, turn) {
+			return tasks.filter((task) => task.status === "running" && task.originTurn === turn);
+		}
+		function statusGlyph(status) {
+			if (status === "running") return "●";
+			if (status === "completed") return "✓";
+			if (status === "stopped") return "–";
+			return "×";
+		}
+		function formatDuration(ms) {
+			if (ms < 1e3) return String(Math.max(1, Math.round(ms))) + "ms";
+			const seconds = Math.round(ms / 1e3);
+			if (seconds < 60) return String(seconds) + "s";
+			const minutes = Math.floor(seconds / 60);
+			return String(minutes) + "m " + String(seconds % 60) + "s";
+		}
+		function taskMeta(task, t) {
+			const parts = [];
+			if (task.subagentType !== void 0) parts.push(task.subagentType);
+			else if (task.taskType !== void 0) parts.push(task.taskType);
+			if (task.usage?.durationMs !== void 0) parts.push(formatDuration(task.usage.durationMs));
+			if (task.usage?.totalTokens !== void 0) parts.push(t("tokens", { count: formatTokenCount(task.usage.totalTokens) }));
+			if (task.usage?.toolUses !== void 0) parts.push(t("tasksToolUses", { count: task.usage.toolUses }));
+			if (task.lastToolName !== void 0) parts.push(t("tasksLastTool", { tool: task.lastToolName }));
+			return parts;
+		}
+		function TaskActivity({ activity, t }) {
+			return /* @__PURE__ */ jsxs("li", {
+				style: taskActivityItem,
+				children: [/* @__PURE__ */ jsx("span", {
+					style: taskActivityGlyph,
+					"aria-hidden": "true",
+					children: activity.isError === true ? "×" : "›"
+				}), /* @__PURE__ */ jsxs("div", {
+					style: taskActivityBody,
+					children: [
+						/* @__PURE__ */ jsx("p", {
+							style: taskActivityTitle,
+							children: activity.title ?? activity.kind
+						}),
+						activity.summary === void 0 ? null : /* @__PURE__ */ jsx("p", {
+							style: taskActivitySummary,
+							children: activity.summary
+						}),
+						activity.detail === void 0 ? null : /* @__PURE__ */ jsxs("details", {
+							style: taskActivityDetail,
+							children: [/* @__PURE__ */ jsx("summary", {
+								style: taskActivityDetailSummary,
+								children: t("detail")
+							}), /* @__PURE__ */ jsx("pre", {
+								style: detailCode,
+								children: activity.detail
+							})]
+						})
+					]
+				})]
+			});
+		}
+		function TaskCard(props) {
+			const { task, activities, t } = props;
+			const [activityOpen, setActivityOpen] = useState(false);
+			const running = task.status === "running";
+			const failed = task.status === "failed" || task.status === "killed";
+			const meta = taskMeta(task, t);
+			return /* @__PURE__ */ jsxs("article", {
+				style: {
+					...taskCard,
+					...running ? taskCardRunning : {}
+				},
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						style: taskCardTop,
+						children: [/* @__PURE__ */ jsx("span", {
+							className: running ? "dsh-claude-act-running" : void 0,
+							style: {
+								...taskCardGlyph,
+								...running ? iconChipRunning : {},
+								...failed ? iconChipError : {}
+							},
+							"aria-hidden": "true",
+							children: statusGlyph(task.status)
+						}), /* @__PURE__ */ jsxs("div", {
+							style: taskCardBody,
+							children: [/* @__PURE__ */ jsx("p", {
+								style: {
+									...taskTitle,
+									...failed ? { color: "var(--dsw-alias-state-error-primary)" } : {}
+								},
+								children: task.description
+							}), /* @__PURE__ */ jsxs("p", {
+								style: taskStatusLine,
+								children: [/* @__PURE__ */ jsx("span", { children: t(STATUS_LABEL[task.status] ?? "tasksRunning") }), task.backgrounded === true ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+									"aria-hidden": "true",
+									children: " · "
+								}), /* @__PURE__ */ jsx("span", { children: t("tasksBackground") })] }) : null]
+							})]
+						})]
+					}),
+					meta.length === 0 ? null : /* @__PURE__ */ jsx("p", {
+						style: taskMeta$1,
+						children: meta.join(" · ")
+					}),
+					task.summary === void 0 || running ? null : /* @__PURE__ */ jsx("p", {
+						style: taskSummary,
+						children: task.summary
+					}),
+					activities.length === 0 ? null : /* @__PURE__ */ jsxs("div", {
+						style: taskActivitySection,
+						children: [/* @__PURE__ */ jsx("button", {
+							type: "button",
+							style: taskTextButton,
+							"aria-expanded": activityOpen,
+							onClick: () => setActivityOpen((value) => !value),
+							children: activityOpen ? t("tasksHideActivity") : t("tasksViewActivity")
+						}), activityOpen ? /* @__PURE__ */ jsx("ul", {
+							style: taskActivityList,
+							children: activities.map((activity) => /* @__PURE__ */ jsx(TaskActivity, {
+								activity,
+								t
+							}, `${activity.turn}:${activity.step}:${activity.ordinal}`))
+						}) : null]
+					})
+				]
+			});
+		}
+		function GroupHeading(props) {
+			const { label, count, collapsed, onToggle, action } = props;
+			const content = /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", { children: label }), /* @__PURE__ */ jsx("span", {
+				style: tasksGroupCount,
+				children: count
+			})] });
+			return /* @__PURE__ */ jsxs("div", {
+				style: tasksGroupHeading,
+				children: [onToggle === void 0 ? /* @__PURE__ */ jsx("div", {
+					style: tasksGroupTitle,
+					children: content
+				}) : /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					style: tasksGroupToggle,
+					"aria-expanded": !collapsed,
+					onClick: onToggle,
+					children: [/* @__PURE__ */ jsx("span", {
+						style: {
+							...chevron,
+							...collapsed === true ? {} : chevronOpen
+						},
+						children: "›"
+					}), content]
+				}), action === void 0 ? null : /* @__PURE__ */ jsx("button", {
+					type: "button",
+					style: taskTextButton,
+					onClick: action.onClick,
+					children: action.label
+				})]
+			});
+		}
+		function ClaudeTasksPanel({ useClaudeProjection, t, closeDetails }) {
+			const projection = useClaudeProjection((value) => value);
+			useEffect(() => {
+				if (!projection.owned) closeDetails();
+			}, [closeDetails, projection.owned]);
+			const tasks = projection.tasks?.tasks ?? [];
+			const [finishedCollapsed, setFinishedCollapsed] = useState(false);
+			const [dismissedSettledIds, setDismissedSettledIds] = useState(() => /* @__PURE__ */ new Set());
+			const groups = useMemo(() => visibleTaskGroups(tasks, dismissedSettledIds), [tasks, dismissedSettledIds]);
+			const taskActivities = useMemo(() => new Map(tasks.map((task) => [task.taskId, activitiesForTask(projection.activities, task.taskId)])), [projection.activities, tasks]);
+			const clearFinished = () => setDismissedSettledIds((previous) => /* @__PURE__ */ new Set([...previous, ...tasks.filter((task) => task.status !== "running").map((task) => task.taskId)]));
+			if (!projection.owned) return null;
+			return /* @__PURE__ */ jsxs("div", {
+				style: tasksPanel,
+				children: [/* @__PURE__ */ jsxs("div", {
+					style: tasksHeader,
+					children: [/* @__PURE__ */ jsx("span", {
+						style: tasksHeading,
+						children: t("tasksPanel")
+					}), /* @__PURE__ */ jsx("button", {
+						type: "button",
+						style: tasksClose,
+						"aria-label": t("tasksClose"),
+						onClick: closeDetails,
+						children: "×"
+					})]
+				}), /* @__PURE__ */ jsxs("div", {
+					style: tasksBody,
+					children: [/* @__PURE__ */ jsxs("section", {
+						"aria-label": t("tasksRunning"),
+						children: [/* @__PURE__ */ jsx(GroupHeading, {
+							label: t("tasksRunning"),
+							count: groups.running.length
+						}), groups.running.length === 0 ? /* @__PURE__ */ jsx("p", {
+							style: tasksGroupEmpty,
+							children: t("tasksNoneRunning")
+						}) : /* @__PURE__ */ jsx("div", {
+							style: taskCardList,
+							children: groups.running.map((task) => /* @__PURE__ */ jsx(TaskCard, {
+								task,
+								activities: taskActivities.get(task.taskId) ?? [],
+								t
+							}, task.taskId))
+						})]
+					}), /* @__PURE__ */ jsxs("section", {
+						"aria-label": t("tasksSettled"),
+						style: tasksFinishedSection,
+						children: [/* @__PURE__ */ jsx(GroupHeading, {
+							label: t("tasksSettled"),
+							count: groups.finished.length,
+							collapsed: finishedCollapsed,
+							onToggle: () => setFinishedCollapsed((value) => !value),
+							...groups.finished.length === 0 ? {} : { action: {
+								label: t("tasksClear"),
+								onClick: clearFinished
+							} }
+						}), finishedCollapsed || groups.finished.length === 0 ? null : /* @__PURE__ */ jsx("div", {
+							style: taskCardList,
+							children: groups.finished.map((task) => /* @__PURE__ */ jsx(TaskCard, {
+								task,
+								activities: taskActivities.get(task.taskId) ?? [],
+								t
+							}, task.taskId))
+						})]
+					})]
+				})]
+			});
+		}
+		function ClaudeTasksHeaderButton({ useClaudeProjection, t, isOpen, toggle, subscribe }) {
+			const open = useSyncExternalStore(subscribe, isOpen, isOpen);
+			const projection = useClaudeProjection((value) => value);
+			if (!projection.owned) return null;
+			const runningCount = projection.tasks?.tasks.filter((task) => task.status === "running").length ?? 0;
+			return /* @__PURE__ */ jsxs("button", {
+				type: "button",
+				className: "dsh-claude-tasks-trigger",
+				style: {
+					...tasksHeaderButton,
+					...open ? tasksHeaderButtonActive : {}
+				},
+				"aria-label": t("tasksOpen"),
+				"aria-pressed": open,
+				onClick: (event) => {
+					toggle();
+					event.currentTarget.blur();
+				},
+				children: [
+					/* @__PURE__ */ jsx("style", { children: tasksTriggerHoverCss }),
+					/* @__PURE__ */ jsxs("svg", {
+						width: "14",
+						height: "14",
+						viewBox: "0 0 24 24",
+						fill: "none",
+						stroke: "currentColor",
+						strokeWidth: "2",
+						strokeLinecap: "round",
+						strokeLinejoin: "round",
+						"aria-hidden": "true",
+						children: [
+							/* @__PURE__ */ jsx("path", { d: "m3 17 2 2 4-4" }),
+							/* @__PURE__ */ jsx("path", { d: "m3 7 2 2 4-4" }),
+							/* @__PURE__ */ jsx("path", { d: "M13 6h8" }),
+							/* @__PURE__ */ jsx("path", { d: "M13 12h8" }),
+							/* @__PURE__ */ jsx("path", { d: "M13 18h8" })
+						]
+					}),
+					/* @__PURE__ */ jsx("span", { children: t("tasks") }),
+					runningCount === 0 ? null : /* @__PURE__ */ jsx("span", {
+						className: "dsh-claude-act-running",
+						style: tasksBadgeInline,
+						"aria-hidden": "true",
+						children: runningCount
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/ClaudeActivityTail.tsx
+		function ClaudeActivityTail({ matched, useClaudeProjection, t, openTasks }) {
+			const projection = useClaudeProjection((value) => value);
+			const runningTasks = useMemo(() => runningTasksForTurn(projection.tasks?.tasks ?? [], matched.turn), [projection.tasks, matched.turn]);
+			if (runningTasks.length === 0) return null;
+			return /* @__PURE__ */ jsx("div", {
+				"data-claude-activity-tail": matched.turn,
+				children: runningTasks.length === 0 ? null : /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					style: tasksTurnLauncher,
+					onClick: openTasks,
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "dsh-claude-act-running",
+							style: tasksTurnLauncherDot,
+							"aria-hidden": "true",
+							children: "●"
+						}),
+						/* @__PURE__ */ jsx("span", { children: t("tasksRunningCount", { count: runningTasks.length }) }),
+						/* @__PURE__ */ jsx("span", {
+							"aria-hidden": "true",
+							children: "›"
+						})
+					]
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/ClaudeActivityNode.tsx
+		const EMPTY_TASKS = [];
+		const ACTIVITY_CSS = [
+			".dsh-claude-flow{display:flex;flex-direction:column;gap:4px}",
+			".dsh-claude-flow-row{position:relative;overflow:hidden}",
+			".dsh-claude-flow-leading{flex-shrink:0}",
+			".dsh-claude-flow-title{font-weight:400}",
+			".dsh-claude-flow-chevron{color:var(--dsw-alias-label-secondary)}",
+			".dsh-claude-flow-separator{width:2px;height:2px;margin:0 8px;border-radius:1px;background:var(--dsw-alias-label-caption);flex:none}",
+			".dsh-claude-flow-summary{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-tertiary);font-size:14px;line-height:24px;flex:auto}",
+			".dsh-claude-flow-summary[data-error]{color:var(--dsw-alias-state-error-primary)}",
+			".dsh-claude-flow-body{margin:4px 0 4px 22px;color:var(--dsw-alias-label-tertiary);font-size:14px;line-height:24px;white-space:pre-wrap;overflow-wrap:anywhere}",
+			".dsh-claude-flow-detail{max-height:260px;overflow:auto;margin:4px 0 4px 4px;padding:12px 16px;border:1px solid var(--dsw-alias-border-l1);border-radius:12px;background:var(--dsw-alias-markdown-code-block);color:var(--dsw-alias-label-primary);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap}",
+			".dsh-claude-flow-subcalls{display:flex;flex-direction:column;gap:2px;margin:4px 0 4px 22px;color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:22px}",
+			".dsh-claude-act-running{animation:dsh-claude-act-pulse 1.2s ease-in-out infinite}",
+			"@keyframes dsh-claude-act-pulse{0%,100%{opacity:1}50%{opacity:.3}}"
+		].join("");
+		let cssInjected = false;
+		function ensureCss() {
+			if (cssInjected || typeof document === "undefined") return;
+			cssInjected = true;
+			const element = document.createElement("style");
+			element.dataset.dshClaudeActivity = "";
+			element.textContent = ACTIVITY_CSS;
+			document.head.appendChild(element);
+		}
+		function subcallGlyph(subcall) {
+			if (subcall.isError === true || subcall.phase === "failed") return "×";
+			if (subcall.phase === "started" || subcall.phase === "updated") return "●";
+			return "✓";
+		}
+		function title(activity) {
+			return activity.toolName ?? activity.title ?? activity.kind.replaceAll("-", " ");
+		}
+		function activityState(activity, running) {
+			if (activity.isError === true || activity.kind === "error" || activity.phase === "denied" || activity.phase === "failed") return "error";
+			if (running) return "ongoing";
+			if (activity.kind === "warning") return "warning";
+			return "done";
+		}
+		function ActivityRow({ row, t }) {
+			const { activity, running, subcalls } = row;
+			const [open, setOpen] = useState(false);
+			const state = activityState(activity, running);
+			const detail = activity.detail;
+			const expandable = detail !== void 0 || subcalls.length > 0 || activity.kind === "thinking";
+			const summary = activity.summary ?? (running ? t("running") : state === "error" ? t("failed") : t("done"));
+			const body = activity.kind === "thinking" ? activity.summary : detail;
+			return /* @__PURE__ */ jsxs(DisclosureRow, {
+				rowClassName: "dsh-claude-flow-row",
+				leadingClassName: "dsh-claude-flow-leading",
+				titleClassName: "dsh-claude-flow-title",
+				chevronClassName: "dsh-claude-flow-chevron",
+				icon: activity.kind === "thinking" ? /* @__PURE__ */ jsx(IconThinkOutline14, { size: 14 }) : state === "done" ? /* @__PURE__ */ jsx(IconApiOutline14, { size: 14 }) : /* @__PURE__ */ jsx(StateDot, { state }),
+				title: activity.kind === "thinking" ? t("thinking") : title(activity),
+				open,
+				expandable,
+				expandOnRowClick: true,
+				keepContentWhenOpen: true,
+				onToggle: () => setOpen((value) => !value),
+				collapsedContent: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+					className: "dsh-claude-flow-separator",
+					"aria-hidden": "true"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "dsh-claude-flow-summary",
+					"data-error": state === "error" || void 0,
+					children: summary
+				})] }),
+				children: [subcalls.length === 0 ? null : /* @__PURE__ */ jsx("div", {
+					className: "dsh-claude-flow-subcalls",
+					children: subcalls.map((subcall) => /* @__PURE__ */ jsxs("div", { children: [
+						subcallGlyph(subcall),
+						" ",
+						subcall.toolName ?? t("subagent"),
+						subcall.summary === void 0 ? "" : ` · ${subcall.summary}`
+					] }, subcall.toolUseId))
+				}), body === void 0 ? null : activity.kind === "thinking" ? /* @__PURE__ */ jsx("div", {
+					className: "dsh-claude-flow-body",
+					children: body
+				}) : /* @__PURE__ */ jsx("pre", {
+					className: "dsh-claude-flow-detail",
+					children: body
+				})]
+			});
+		}
+		function ClaudeActivityNode({ node, useClaudeProjection, t }) {
+			ensureCss();
+			const marker = node.data;
+			const activities = useClaudeProjection((value) => value.activities);
+			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? EMPTY_TASKS);
+			const rows = useMemo(() => activityRowsForStep(activities, marker.turn, marker.step, tasks), [
+				activities,
+				marker.step,
+				marker.turn,
+				tasks
+			]);
+			if (rows.length === 0) return null;
+			return /* @__PURE__ */ jsx("div", {
+				className: "dsh-claude-flow",
+				children: rows.map((row, index) => /* @__PURE__ */ jsx(ActivityRow, {
+					row,
+					t
+				}, `${row.activity.ordinal}:${index}`))
+			});
+		}
+		//#endregion
+		//#region src/client/ClaudeCodeSettings.tsx
+		function value(status, detail) {
+			return detail === void 0 ? status : `${status} · ${detail}`;
+		}
+		function ClaudeCodeSettings({ t }) {
+			const [report, setReport] = useState();
+			const [error, setError] = useState();
+			const [busy, setBusy] = useState(false);
+			const refresh = useCallback(async () => {
+				setBusy(true);
+				setError(void 0);
+				setReport(void 0);
+				try {
+					const response = await fetch(CLAUDE_DOCTOR_PATH, {
+						credentials: "same-origin",
+						headers: { accept: "application/json" }
+					});
+					const payload = await response.json();
+					if (!response.ok) throw new Error("error" in payload ? payload.error : `HTTP ${response.status}`);
+					setReport(payload);
+				} catch (cause) {
+					setError(cause instanceof Error ? cause.message : String(cause));
+				} finally {
+					setBusy(false);
+				}
+			}, []);
+			useEffect(() => {
+				refresh();
+			}, [refresh]);
+			const rows = report === void 0 ? [] : [
+				[t("executable"), report.executable.status === "found" ? report.executable.path ?? t("unknown") : `${t("missing")} · ${report.executable.searched.join(", ")}`],
+				[t("version"), value(report.version.status, report.version.value ?? report.version.message)],
+				[t("authentication"), value(report.authentication.status, [report.authentication.method, report.authentication.subscription].filter(Boolean).join(" · ") || report.authentication.message)],
+				[t("handshake"), report.handshake],
+				[t("processes"), t("processSummary", {
+					total: report.processes.count,
+					active: report.processes.active
+				})],
+				[t("limits"), t("limitSummary", {
+					max: report.limits.maxProcesses,
+					minutes: Math.round(report.limits.idleTimeoutMs / 6e4)
+				})]
+			];
+			return /* @__PURE__ */ jsxs("div", {
+				style: settingsPage,
+				children: [
+					/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h2", {
+						style: settingsHeading,
+						children: t("title")
+					}), /* @__PURE__ */ jsx("p", {
+						style: settingsBody,
+						children: t("description")
+					})] }),
+					rows.length === 0 ? null : /* @__PURE__ */ jsx("div", {
+						style: diagnosticGrid,
+						children: rows.flatMap(([label, rowValue]) => [/* @__PURE__ */ jsx("span", {
+							style: diagnosticLabel,
+							children: label
+						}, `${label}-label`), /* @__PURE__ */ jsx("span", {
+							style: diagnosticValue,
+							children: rowValue
+						}, `${label}-value`)])
+					}),
+					error === void 0 ? null : /* @__PURE__ */ jsxs("p", {
+						style: {
+							...settingsBody,
+							color: "var(--dsw-alias-state-error-primary)"
+						},
+						children: [
+							t("error"),
+							": ",
+							error
+						]
+					}),
+					/* @__PURE__ */ jsx("button", {
+						type: "button",
+						style: button,
+						onClick: () => {
+							refresh();
+						},
+						disabled: busy,
+						children: busy ? t("refreshing") : t("doctor")
+					}),
+					/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h3", {
+						style: {
+							...settingsHeading,
+							fontSize: 15,
+							lineHeight: "22px"
+						},
+						children: t("security")
+					}), /* @__PURE__ */ jsx("p", {
+						style: settingsBody,
+						children: t("securityBody")
+					})] })
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/projection.ts
+		const EMPTY_CLAUDE_PROJECTION = {
+			schemaVersion: 1,
+			revision: 0,
+			owned: false,
+			activities: []
+		};
+		const POLL_INTERVAL_MS = 2e3;
+		const MAX_ACTIVITIES = 1e4;
+		function record(value) {
+			return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+		}
+		function nonNegativeInteger(value) {
+			return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+		}
+		/** Validate the public route envelope before publishing it to UI components. */
+		function parseClaudeClientProjection(value) {
+			const input = record(value);
+			if (input === void 0 || input.schemaVersion !== 1 || !nonNegativeInteger(input.revision) || typeof input.owned !== "boolean" || !Array.isArray(input.activities) || input.activities.length > MAX_ACTIVITIES) throw new Error("invalid Claude sidecar projection");
+			for (const item of input.activities) {
+				const activity = record(item);
+				if (activity === void 0 || !nonNegativeInteger(activity.turn) || !nonNegativeInteger(activity.step) || !nonNegativeInteger(activity.ordinal) || typeof activity.kind !== "string") throw new Error("invalid Claude sidecar activity");
+			}
+			if (input.contextUsage !== void 0 && record(input.contextUsage) === void 0) throw new Error("invalid Claude context projection");
+			const tasks = input.tasks === void 0 ? void 0 : record(input.tasks);
+			if (tasks !== void 0 && !Array.isArray(tasks.tasks)) throw new Error("invalid Claude tasks projection");
+			return input;
+		}
+		/** Create one lazy source: active subscribers trigger an immediate load and bounded polling. */
+		function createClaudeProjectionSource(sessionId, fetchProjection = fetch, pollIntervalMs = POLL_INTERVAL_MS) {
+			let snapshot = EMPTY_CLAUDE_PROJECTION;
+			let timer;
+			let controller;
+			let disposed = false;
+			const listeners = /* @__PURE__ */ new Set();
+			const schedule = () => {
+				if (disposed || listeners.size === 0) return;
+				timer = setTimeout(() => {
+					refresh();
+				}, pollIntervalMs);
+			};
+			const refresh = async () => {
+				if (disposed || listeners.size === 0) return;
+				controller?.abort();
+				controller = new AbortController();
+				try {
+					const response = await fetchProjection(`${CLAUDE_PROJECTION_PATH}/${encodeURIComponent(sessionId)}`, {
+						headers: { accept: "application/json" },
+						signal: controller.signal
+					});
+					if (!response.ok) throw new Error(`Claude projection request failed (${response.status})`);
+					const next = parseClaudeClientProjection(await response.json());
+					if (next.revision !== snapshot.revision || next.owned !== snapshot.owned) {
+						snapshot = next;
+						for (const listener of [...listeners]) listener();
+					}
+				} catch (error) {
+					if (!(error instanceof DOMException && error.name === "AbortError") && snapshot !== EMPTY_CLAUDE_PROJECTION) {
+						snapshot = EMPTY_CLAUDE_PROJECTION;
+						for (const listener of [...listeners]) listener();
+					}
+				} finally {
+					controller = void 0;
+					schedule();
+				}
+			};
+			return {
+				getSnapshot: () => snapshot,
+				subscribe(listener) {
+					if (disposed) return () => {};
+					const wasIdle = listeners.size === 0;
+					listeners.add(listener);
+					if (wasIdle) refresh();
+					return () => {
+						listeners.delete(listener);
+						if (listeners.size !== 0) return;
+						if (timer !== void 0) clearTimeout(timer);
+						timer = void 0;
+						controller?.abort();
+						controller = void 0;
+					};
+				},
+				dispose() {
+					disposed = true;
+					listeners.clear();
+					if (timer !== void 0) clearTimeout(timer);
+					timer = void 0;
+					controller?.abort();
+					controller = void 0;
+				}
+			};
+		}
+		var ClaudeProjectionStore = class {
+			#sources = /* @__PURE__ */ new Map();
+			source(sessionId) {
+				let source = this.#sources.get(sessionId);
+				if (source === void 0) {
+					source = createClaudeProjectionSource(sessionId);
+					this.#sources.set(sessionId, source);
+				}
+				return source;
+			}
+			dispose() {
+				for (const source of this.#sources.values()) source.dispose();
+				this.#sources.clear();
+			}
+		};
+		//#endregion
+		//#region src/client/locales.ts
+		const zh = {
+			nav: "Claude Code",
+			title: "Claude Code",
+			description: "DSH 使用本机 Claude Code，并保留其 Agent Loop、工具、CLAUDE.md、Skills、Hooks 与 MCP 配置。",
+			activity: "Claude Code 活动",
+			detail: "查看已脱敏详情",
+			thinking: "思考",
+			running: "运行中",
+			failed: "失败",
+			done: "完成",
+			subagent: "子代理",
+			tokens: "{count} 个 token",
+			doctor: "运行诊断",
+			refreshing: "诊断中…",
+			executable: "可执行文件",
+			version: "版本",
+			authentication: "登录状态",
+			handshake: "协议握手",
+			processes: "活动进程",
+			limits: "进程限制",
+			processSummary: "共 {total} 个 · {active} 个活动中",
+			limitSummary: "最多 {max} 个 · 空闲 {minutes} 分钟后回收",
+			missing: "未找到",
+			unknown: "未知",
+			error: "诊断失败",
+			security: "权限边界",
+			securityBody: "Claude 工具权限通过 DSH 审批界面决定；当前版本不宣称对 ~/.claude 与工作区之外路径提供内核级写入隔离。",
+			tasks: "任务",
+			tasksPanel: "后台任务",
+			tasksEmpty: "当前没有子代理或后台任务",
+			tasksOpen: "查看后台任务",
+			tasksClose: "关闭任务面板",
+			tasksRunning: "运行中",
+			tasksNoneRunning: "当前没有运行中的任务",
+			tasksSettled: "已结束",
+			tasksClear: "清除",
+			tasksViewActivity: "查看活动",
+			tasksHideActivity: "收起活动",
+			tasksRunningCount: "{count} 个运行中任务",
+			tasksToolUses: "{count} 次工具调用",
+			tasksCompleted: "已完成",
+			tasksFailed: "失败",
+			tasksStopped: "已停止",
+			tasksKilled: "已终止",
+			tasksBackground: "后台",
+			tasksLastTool: "最近工具 {tool}"
+		};
+		const en = {
+			nav: "Claude Code",
+			title: "Claude Code",
+			description: "DSH uses the local Claude Code and preserves its agent loop, tools, CLAUDE.md, Skills, Hooks, and MCP configuration.",
+			activity: "Claude Code activity",
+			detail: "Show redacted detail",
+			thinking: "Think",
+			running: "Running",
+			failed: "Failed",
+			done: "Done",
+			subagent: "Subagent",
+			tokens: "{count} tokens",
+			doctor: "Run Doctor",
+			refreshing: "Running Doctor…",
+			executable: "Executable",
+			version: "Version",
+			authentication: "Authentication",
+			handshake: "Protocol handshake",
+			processes: "Live processes",
+			limits: "Process limits",
+			processSummary: "{total} total · {active} active",
+			limitSummary: "{max} max · {minutes} min idle",
+			missing: "Not found",
+			unknown: "Unknown",
+			error: "Doctor failed",
+			security: "Permission boundary",
+			securityBody: "Claude tool permissions are decided through the DSH approval UI. This version does not claim kernel-level write isolation for ~/.claude or paths outside the workspace.",
+			tasks: "Tasks",
+			tasksPanel: "Background tasks",
+			tasksEmpty: "No subagents or background tasks",
+			tasksOpen: "Show background tasks",
+			tasksClose: "Close tasks panel",
+			tasksRunning: "Running",
+			tasksNoneRunning: "No tasks are running",
+			tasksSettled: "Finished",
+			tasksClear: "Clear",
+			tasksViewActivity: "View activity",
+			tasksHideActivity: "Hide activity",
+			tasksRunningCount: "{count} running task(s)",
+			tasksToolUses: "{count} tool use(s)",
+			tasksCompleted: "Completed",
+			tasksFailed: "Failed",
+			tasksStopped: "Stopped",
+			tasksKilled: "Killed",
+			tasksBackground: "Background",
+			tasksLastTool: "Last tool {tool}"
+		};
+		//#endregion
+		//#region src/client/index.tsx
+		const name = "dsh-claude-client";
+		const inject = [
+			"slots",
+			"locale",
+			"conversationEvents",
+			"sessions"
+		];
+		function apply(ctx) {
+			const namespace = "settings.claude-code";
+			ctx.effect(() => ctx.locale.register(namespace, {
+				zh,
+				en
+			}), "dsh-claude: client copy");
+			const t = ctx.locale.bind(namespace);
+			const projections = new ClaudeProjectionStore();
+			const sessions = ctx.get("sessions");
+			if (sessions !== void 0) ctx.effect(() => sessions.provide({
+				hooks: ["claudeProjection"],
+				resolve: (binding) => ({ hooks: { claudeProjection: projections.source(binding.sessionId) } })
+			}), "dsh-claude: sidecar projection provider");
+			ctx.effect(() => () => projections.dispose(), "dsh-claude: sidecar projection lifecycle");
+			ctx.effect(() => ctx.conversationEvents.register(claudeTurnDefinition), "dsh-claude: Claude turn marker");
+			ctx.effect(() => ctx.conversationEvents.register(claudeActivityStepDefinition), "dsh-claude: Claude activity flow node");
+			ctx.slots.inject("conversation.chat.node", () => ctx.slots.register({
+				name: "conversation.chat.node",
+				key: "claude-activity-step",
+				locale: namespace
+			}, ClaudeActivityNode));
+			const layout = ctx.get("layout");
+			const tasksPanelListeners = /* @__PURE__ */ new Set();
+			let disposeTasksDetails;
+			let tasksPanelSession;
+			const notifyTasksPanel = () => {
+				for (const fn of [...tasksPanelListeners]) fn();
+			};
+			const closeTasksPanel = () => {
+				if (disposeTasksDetails === void 0) return;
+				disposeTasksDetails();
+				disposeTasksDetails = void 0;
+				tasksPanelSession = void 0;
+				layout?.closeDetails();
+				notifyTasksPanel();
+			};
+			const openTasksPanel = (sessionId) => {
+				closeTasksPanel();
+				try {
+					disposeTasksDetails = ctx.slots.register({
+						name: "details",
+						priority: -10,
+						locale: namespace,
+						inject: () => ({
+							t,
+							closeDetails: closeTasksPanel
+						})
+					}, ClaudeTasksPanel);
+				} catch {
+					return;
+				}
+				tasksPanelSession = sessionId;
+				layout?.openDetails();
+				notifyTasksPanel();
+			};
+			const toggleTasksPanel = (sessionId) => {
+				if (tasksPanelSession === sessionId) closeTasksPanel();
+				else openTasksPanel(sessionId);
+			};
+			ctx.effect(() => {
+				if (typeof document === "undefined" || typeof MutationObserver === "undefined") return () => closeTasksPanel();
+				const observer = new MutationObserver(() => {
+					if (tasksPanelSession !== void 0 && document.querySelector("[data-details-collapsed]") !== null) closeTasksPanel();
+				});
+				observer.observe(document.body, {
+					attributes: true,
+					attributeFilter: ["data-details-collapsed"],
+					subtree: true
+				});
+				return () => {
+					observer.disconnect();
+					closeTasksPanel();
+				};
+			}, "dsh-claude: tasks panel lifecycle");
+			const tasksLauncher = (sessionId) => ({
+				isOpen: () => tasksPanelSession === sessionId,
+				toggle: () => toggleTasksPanel(sessionId),
+				subscribe: (fn) => {
+					tasksPanelListeners.add(fn);
+					return () => {
+						tasksPanelListeners.delete(fn);
+					};
+				}
+			});
+			ctx.slots.inject("conversation.chat.turnTail", () => ctx.slots.register({
+				name: "conversation.chat.turnTail",
+				select: selectClaudeTurn,
+				inject: (sessionId) => ({
+					t,
+					openTasks: () => openTasksPanel(sessionId)
+				})
+			}, ClaudeActivityTail));
+			if (sessions !== void 0) ctx.effect(() => sessions.list.subscribe(() => {
+				if (tasksPanelSession !== void 0 && sessions.list.getSnapshot().current !== tasksPanelSession) closeTasksPanel();
+			}), "dsh-claude: tasks panel session tracking");
+			ctx.slots.inject("conversation.session.header.utilities", () => ctx.slots.register({
+				name: "conversation.session.header.utilities",
+				id: "claude-tasks",
+				order: -10,
+				label: () => t("tasksOpen"),
+				inject: (sessionId) => ({
+					t,
+					...tasksLauncher(sessionId)
+				})
+			}, ClaudeTasksHeaderButton));
+			ctx.slots.inject("settings.section", () => ctx.slots.register({
+				name: "settings.section",
+				id: "claude-code",
+				order: 16,
+				label: () => t("nav"),
+				inject: () => ({ t })
+			}, ClaudeCodeSettings));
+		}
+		//#endregion
+		module.exports.apply = apply;
+		module.exports.inject = inject;
+		module.exports.name = name;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map