@blade-hq/agent-kit 0.4.1 → 0.4.4

package/dist/react/components/plan/index.js

@@ -0,0 +1,3490 @@
+// src/react/components/plan/debug-log.ts
+var events = [];
+var verbose = typeof window !== "undefined" && (window.location?.hostname === "localhost" || window.location?.hostname === "127.0.0.1");
+function exportPlanLog() {
+  return [...events];
+}
+function downloadPlanLog() {
+  const blob = new Blob([JSON.stringify(events, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = `plan-timeline-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}.json`;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+// src/react/components/plan/extract-plan-messages.ts
+function parseModeChange(message) {
+  if (message.kind !== "mode_change" || typeof message.content !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(message.content);
+    if (typeof parsed.from === "string" && typeof parsed.to === "string") {
+      return { from: parsed.from, to: parsed.to };
+    }
+  } catch {
+  }
+  return null;
+}
+function isPlanningEnter(message) {
+  if (message.kind === "planning_enter") {
+    return true;
+  }
+  const modeChange = parseModeChange(message);
+  return modeChange?.to === "planning";
+}
+function isPlanningExit(message) {
+  if (message.kind === "planning_exit") {
+    return true;
+  }
+  const modeChange = parseModeChange(message);
+  return modeChange?.from === "planning";
+}
+function extractLatestPlanMessages(messages) {
+  const safeMessages = Array.isArray(messages) ? messages : [];
+  let enterIndex = -1;
+  let exitIndex = -1;
+  for (let i = safeMessages.length - 1; i >= 0; i -= 1) {
+    const message = safeMessages[i];
+    if (isPlanningExit(message) && exitIndex === -1) {
+      exitIndex = i;
+      continue;
+    }
+    if (isPlanningEnter(message)) {
+      enterIndex = i;
+      break;
+    }
+  }
+  if (enterIndex === -1) {
+    return [];
+  }
+  return safeMessages.slice(enterIndex + 1).filter((message, offset) => {
+    const absoluteIndex = enterIndex + 1 + offset;
+    if (isPlanningEnter(message) || isPlanningExit(message)) {
+      return false;
+    }
+    if (exitIndex !== -1 && absoluteIndex > exitIndex) {
+      return message.kind === "plan_status";
+    }
+    return true;
+  });
+}
+
+// src/react/components/plan/PlanSummaryCard.tsx
+import { CheckCircle2, ChevronRight, PencilLine, Play, Sparkles } from "lucide-react";
+import { useMemo as useMemo4, useState as useState4 } from "react";
+
+// src/react/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+async function copyToClipboard(text) {
+  if (navigator.clipboard) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  textarea.select();
+  try {
+    return document.execCommand("copy");
+  } finally {
+    document.body.removeChild(textarea);
+  }
+}
+
+// src/react/stores/ui-store.ts
+import { create } from "zustand";
+
+// src/react/stores/client-aware.ts
+function createClientActions(set) {
+  return {
+    _client: null,
+    setClient: (client) => set({ _client: client })
+  };
+}
+
+// src/react/stores/ui-store.ts
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+function resolveEffectiveTheme(theme) {
+  if (theme !== "system") return theme;
+  return isBrowser && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function applyTheme(theme) {
+  if (!isBrowser) return;
+  const effective = resolveEffectiveTheme(theme);
+  document.documentElement.setAttribute("data-theme", effective);
+}
+var storedTheme = isBrowser ? localStorage.getItem("blade-theme") ?? "light" : "light";
+applyTheme(storedTheme);
+if (isBrowser) {
+  window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
+    const current = useUiStore?.getState?.()?.theme;
+    if (current === "system") applyTheme("system");
+  });
+}
+function removeArtifactAtIndex(state, index) {
+  const next = state.artifacts.filter((_, i) => i !== index);
+  let nextActive = state.activeArtifactIndex;
+  if (next.length === 0) {
+    return { artifacts: [], activeArtifactIndex: -1, rightPanelCollapsed: true };
+  }
+  if (index < nextActive) {
+    nextActive -= 1;
+  } else if (index === nextActive) {
+    nextActive = Math.min(index, next.length - 1);
+  }
+  return { artifacts: next, activeArtifactIndex: nextActive };
+}
+function upsertArtifactState(state, target, options) {
+  const reveal = options?.reveal ?? true;
+  const activate = options?.activate ?? true;
+  const targetKey = target.key ?? target.title;
+  const applyUiState = (partial) => ({
+    ...partial,
+    ...reveal ? { rightPanelCollapsed: false, activeRightTab: "preview" } : {}
+  });
+  const existing = state.artifacts.findIndex((artifact) => targetKey && (artifact.key ?? artifact.title) === targetKey);
+  if (existing >= 0) {
+    const updated = [...state.artifacts];
+    updated[existing] = target;
+    return applyUiState({
+      artifacts: updated,
+      activeArtifactIndex: activate ? existing : state.activeArtifactIndex
+    });
+  }
+  const next = [...state.artifacts, target];
+  return applyUiState({
+    artifacts: next,
+    activeArtifactIndex: activate ? next.length - 1 : state.activeArtifactIndex >= 0 ? state.activeArtifactIndex : 0
+  });
+}
+var useUiStore = create()((set) => ({
+  ...createClientActions(set),
+  leftPanelSize: 20,
+  rightPanelSize: 25,
+  leftPanelCollapsed: false,
+  rightPanelCollapsed: false,
+  activeRightTab: "situation",
+  artifacts: [],
+  activeArtifactIndex: -1,
+  theme: storedTheme,
+  setLeftPanelSize: (size) => set({ leftPanelSize: size }),
+  setRightPanelSize: (size) => set({ rightPanelSize: size }),
+  setLeftPanelCollapsed: (collapsed) => set({ leftPanelCollapsed: collapsed }),
+  setRightPanelCollapsed: (collapsed) => set({ rightPanelCollapsed: collapsed }),
+  toggleLeftPanel: () => set((s) => ({ leftPanelCollapsed: !s.leftPanelCollapsed })),
+  toggleRightPanel: () => set((s) => ({ rightPanelCollapsed: !s.rightPanelCollapsed })),
+  setActiveRightTab: (tab) => set({ activeRightTab: tab }),
+  pushArtifact: (target) => set((state) => upsertArtifactState(state, target)),
+  upsertArtifact: (target, options) => set((state) => upsertArtifactState(state, target, options)),
+  setActiveArtifact: (index) => set({ activeArtifactIndex: index }),
+  closeArtifact: (index) => set((state) => removeArtifactAtIndex(state, index)),
+  removeArtifactByKey: (key) => set((state) => {
+    const index = state.artifacts.findIndex((artifact) => (artifact.key ?? artifact.title) === key);
+    if (index < 0) return state;
+    return removeArtifactAtIndex(state, index);
+  }),
+  clearArtifacts: () => set({ artifacts: [], activeArtifactIndex: -1 }),
+  setPreviewTarget: (target) => set(() => {
+    if (target === null) {
+      return { artifacts: [], activeArtifactIndex: -1 };
+    }
+    return {
+      artifacts: [target],
+      activeArtifactIndex: 0,
+      rightPanelCollapsed: false,
+      activeRightTab: "preview"
+    };
+  }),
+  setTheme: (theme) => {
+    localStorage.setItem("blade-theme", theme);
+    applyTheme(theme);
+    set({ theme });
+  }
+}));
+
+// src/react/components/chat/AskUserQuestionBlock.tsx
+import { Check as Check2, Loader2, MessageSquareMore } from "lucide-react";
+import { useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+
+// src/react/components/markdown/MarkdownContent.tsx
+import { mermaid } from "@streamdown/mermaid";
+import { Check, Copy, Download } from "lucide-react";
+import {
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState2
+} from "react";
+import { Streamdown } from "streamdown";
+
+// src/client/resources/models.ts
+import { type } from "arktype";
+var ModelOption = type({
+  id: "string",
+  label: "string"
+});
+var ModelsConfig = type({
+  default: "string",
+  models: ModelOption.array()
+});
+
+// src/client/socket.ts
+import { io } from "socket.io-client";
+
+// src/react/schemas/partner-skill.ts
+import { type as type2 } from "arktype";
+var PartnerSkillName = type2("/^[a-z0-9-]+\\/[a-z0-9-]+$/");
+var PartnerSkillFile = type2({
+  path: "string > 0",
+  content: "string"
+});
+var PartnerSkillInstallPayload = type2({
+  name: PartnerSkillName,
+  files: PartnerSkillFile.array().atLeastLength(1)
+});
+var PartnerSkillInstallResult = type2({
+  name: PartnerSkillName,
+  skill_dir: "string",
+  file_count: "number.integer >= 0",
+  overwritten: "boolean"
+});
+
+// src/react/stores/ui-bridge-store.ts
+import { create as create2 } from "zustand";
+function buildSignalId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `bridge-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function clearSignalRecord(record, sessionId) {
+  if (!(sessionId in record)) {
+    return record;
+  }
+  const next = { ...record };
+  delete next[sessionId];
+  return next;
+}
+var useUiBridgeStore = create2()((set, get) => ({
+  ...createClientActions(set),
+  pendingContexts: {},
+  draftAppends: {},
+  sendRequests: {},
+  addPendingContext: (sessionId, context) => set((state) => ({
+    pendingContexts: {
+      ...state.pendingContexts,
+      [sessionId]: [
+        ...state.pendingContexts[sessionId] ?? [],
+        {
+          id: buildSignalId(),
+          label: context.label,
+          content: context.content
+        }
+      ]
+    }
+  })),
+  removePendingContext: (sessionId, contextId) => set((state) => {
+    const contexts = state.pendingContexts[sessionId];
+    if (!contexts?.length) {
+      return state;
+    }
+    const nextContexts = contexts.filter((context) => context.id !== contextId);
+    if (nextContexts.length === contexts.length) {
+      return state;
+    }
+    return {
+      pendingContexts: nextContexts.length > 0 ? {
+        ...state.pendingContexts,
+        [sessionId]: nextContexts
+      } : clearSignalRecord(state.pendingContexts, sessionId)
+    };
+  }),
+  consumePendingContexts: (sessionId) => {
+    const signals = get().pendingContexts[sessionId] ?? [];
+    if (signals.length === 0) return [];
+    set((state) => ({
+      pendingContexts: clearSignalRecord(state.pendingContexts, sessionId)
+    }));
+    return signals;
+  },
+  clearPendingContexts: (sessionId) => set((state) => ({
+    pendingContexts: clearSignalRecord(state.pendingContexts, sessionId)
+  })),
+  addDraftAppend: (sessionId, text) => set((state) => ({
+    draftAppends: {
+      ...state.draftAppends,
+      [sessionId]: [
+        ...state.draftAppends[sessionId] ?? [],
+        {
+          id: buildSignalId(),
+          text
+        }
+      ]
+    }
+  })),
+  consumeDraftAppends: (sessionId) => {
+    const signals = get().draftAppends[sessionId] ?? [];
+    if (signals.length === 0) return [];
+    set((state) => ({
+      draftAppends: clearSignalRecord(state.draftAppends, sessionId)
+    }));
+    return signals;
+  },
+  clearDraftAppends: (sessionId) => set((state) => ({
+    draftAppends: clearSignalRecord(state.draftAppends, sessionId)
+  })),
+  addSendRequest: (sessionId) => set((state) => ({
+    sendRequests: {
+      ...state.sendRequests,
+      [sessionId]: [
+        ...state.sendRequests[sessionId] ?? [],
+        {
+          id: buildSignalId()
+        }
+      ]
+    }
+  })),
+  consumeSendRequests: (sessionId) => {
+    const signals = get().sendRequests[sessionId] ?? [];
+    if (signals.length === 0) return [];
+    set((state) => ({
+      sendRequests: clearSignalRecord(state.sendRequests, sessionId)
+    }));
+    return signals;
+  },
+  clearSendRequests: (sessionId) => set((state) => ({
+    sendRequests: clearSignalRecord(state.sendRequests, sessionId)
+  })),
+  clearSession: (sessionId) => set((state) => ({
+    pendingContexts: clearSignalRecord(state.pendingContexts, sessionId),
+    draftAppends: clearSignalRecord(state.draftAppends, sessionId),
+    sendRequests: clearSignalRecord(state.sendRequests, sessionId)
+  }))
+}));
+
+// src/react/lib/chat.ts
+function normalizeMessageContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content;
+  return String(content ?? "");
+}
+
+// src/react/stores/auth-store.ts
+import { create as create6 } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+// src/react/api/auth.ts
+var r = () => getClient().auth;
+var getMe = (...args) => r().getMe(...args);
+var logout = (...args) => r().logout(...args);
+
+// src/react/sockets/socket-state.ts
+var agentSocket = null;
+
+// src/react/stores/session-store.ts
+import { create as create5 } from "zustand";
+
+// src/react/api/sessions.ts
+var r2 = () => getClient().sessions;
+var listSessions = (...args) => r2().listSessions(...args);
+var createSession = (...args) => r2().createSession(...args);
+var getSession = (...args) => r2().getSession(...args);
+var pinSession = (...args) => r2().pinSession(...args);
+var updateSharing = (...args) => r2().updateSharing(...args);
+var getSessionTasks = (...args) => r2().getSessionTasks(...args);
+var getSessionTurns = (...args) => r2().getSessionTurns(...args);
+var deleteSession = (...args) => r2().deleteSession(...args);
+
+// src/react/stores/chat-store.ts
+import { create as create3 } from "zustand";
+
+// src/react/components/chat/display-utils.ts
+var TOOL_NAME_ALIASES = {
+  agent: "Agent",
+  ask_user_question: "AskUserQuestion",
+  bash: "Bash",
+  bg_bash: "BgBash",
+  edit: "Edit",
+  exit_plan_mode: "ExitPlanMode",
+  file_edit: "Edit",
+  file_read: "Read",
+  file_write: "Write",
+  finish_task: "FinishTask",
+  get_skill_content: "GetSkillContent",
+  glob: "Glob",
+  grep: "Grep",
+  list_skill_tools: "ListSkillTools",
+  load_skill_tools: "LoadSkillTools",
+  ls: "Ls",
+  read: "Read",
+  run_skill_tool: "RunSkillTool",
+  search_skills: "SearchSkills",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  write: "Write"
+};
+var TOOL_DISPLAY_LABELS = {
+  Bash: "\u6267\u884C\u547D\u4EE4",
+  BgBash: "\u540E\u53F0\u6267\u884C\u547D\u4EE4",
+  Read: "\u8BFB\u53D6\u6587\u4EF6",
+  Write: "\u5199\u5165\u6587\u4EF6",
+  Edit: "\u7F16\u8F91\u6587\u4EF6",
+  Ls: "\u5217\u51FA\u76EE\u5F55",
+  Glob: "\u5339\u914D\u6587\u4EF6",
+  Grep: "\u641C\u7D22\u6587\u672C",
+  WebSearch: "\u641C\u7D22\u7F51\u9875",
+  WebFetch: "\u6574\u7406\u7F51\u9875\u5185\u5BB9",
+  Agent: "\u6D3E\u751F\u5B50\u667A\u80FD\u4F53",
+  AskUserQuestion: "\u5411\u7528\u6237\u63D0\u95EE",
+  SearchSkills: "\u641C\u7D22\u6280\u80FD",
+  GetSkillContent: "\u8BFB\u53D6\u6280\u80FD",
+  ListSkillTools: "\u67E5\u770B\u5DE5\u5177\u5217\u8868",
+  LoadSkillTools: "\u52A0\u8F7D\u6280\u80FD",
+  RunSkillTool: "\u6267\u884C\u6280\u80FD\u5DE5\u5177",
+  FinishTask: "\u4EFB\u52A1\u5B8C\u6210",
+  ExitPlanMode: "\u63D0\u4EA4\u8BA1\u5212",
+  ListSessions: "\u5217\u51FA\u5386\u53F2\u4F1A\u8BDD",
+  GetSessionHistory: "\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2"
+};
+var GENERIC_DISPLAY_NAMES = new Set(Object.values(TOOL_DISPLAY_LABELS));
+function formatToolName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) return name;
+  const stripped = trimmed.split(":").pop()?.split("/").pop()?.split(".").pop()?.trim() || trimmed;
+  const normalized = stripped.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  return TOOL_NAME_ALIASES[normalized] ?? stripped;
+}
+
+// src/react/stores/chat-store.ts
+var _getActiveSessionId = null;
+function setChatStoreSessionAccessor(fn) {
+  _getActiveSessionId = fn;
+}
+function parseAgentDescription(argumentsJson) {
+  try {
+    return JSON.parse(argumentsJson)?.description ?? "\u5B50\u667A\u80FD\u4F53";
+  } catch {
+    return "\u5B50\u667A\u80FD\u4F53";
+  }
+}
+function inferLoopStatusFromMessages(messages) {
+  const toolCalls = messages.flatMap((message) => message.tool_calls ?? []);
+  if (messages.some((message) => message.status === "streaming")) return "running";
+  if (toolCalls.some((toolCall) => toolCall.status === "awaiting_answer")) return "awaiting_answer";
+  if (toolCalls.some((toolCall) => toolCall.status === "error")) return "error";
+  if (toolCalls.some((toolCall) => toolCall.status === "cancelled")) return "cancelled";
+  if (toolCalls.some((toolCall) => toolCall.status === "pending")) return "running";
+  return "done";
+}
+function inferLoopStatusFromTurns(turns, messages) {
+  const latestAgentNotification = [...turns].reverse().flatMap((turn) => turn.blocks).find((block) => {
+    if (block.type !== "system_notification" || !isRecord(block.content)) return false;
+    return block.content.notification_type === "agent:start" || block.content.notification_type === "agent:end";
+  });
+  if (latestAgentNotification?.type === "system_notification" && isRecord(latestAgentNotification.content)) {
+    const notificationType = latestAgentNotification.content.notification_type;
+    const status = latestAgentNotification.content.status;
+    if (notificationType === "agent:start" || status === "running") return "running";
+    if (status === "error") return "error";
+    if (status === "cancelled") return "cancelled";
+  }
+  return inferLoopStatusFromMessages(messages);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parentForkToolCallIdFromTurn(turn) {
+  if (typeof turn.parent_fork_tool_call_id === "string" && turn.parent_fork_tool_call_id.length > 0) {
+    return turn.parent_fork_tool_call_id;
+  }
+  for (const block of turn.blocks) {
+    if (block.type !== "system_notification" || !isRecord(block.content)) continue;
+    const metadata = block.content.metadata;
+    if (!isRecord(metadata)) continue;
+    const parentId = metadata.parent_fork_tool_call_id;
+    if (typeof parentId === "string" && parentId.length > 0) return parentId;
+  }
+  return null;
+}
+function buildMessageContent(turn) {
+  const textBlocks = turn.blocks.filter((block) => block.type === "text");
+  if (textBlocks.length === 0) return "";
+  if (textBlocks.length === 1) return normalizeMessageContent(textBlocks[0].content);
+  return textBlocks.map((block) => {
+    if (typeof block.content === "string") return block.content;
+    return JSON.stringify(block.content);
+  }).join("");
+}
+function buildReasoning(turn) {
+  const thinking = turn.blocks.filter((block) => block.type === "thinking").map((block) => typeof block.content === "string" ? block.content : JSON.stringify(block.content)).filter(Boolean);
+  if (thinking.length === 0) return void 0;
+  return thinking.join("\n\n");
+}
+function isModeChangeContent(value) {
+  return typeof value === "object" && value !== null && typeof value.from === "string" && typeof value.to === "string";
+}
+function extractModeFromBlocks(blocks) {
+  const modeBlock = blocks.find((block) => block.type === "mode_change");
+  if (modeBlock && isModeChangeContent(modeBlock.content)) {
+    return modeBlock.content.to === "planning" || modeBlock.content.to === "executing" ? modeBlock.content.to : null;
+  }
+  if (blocks.some((block) => block.type === "planning_enter")) return "planning";
+  if (blocks.some((block) => block.type === "planning_exit")) return "executing";
+  return null;
+}
+function projectionToMessage(turn) {
+  if (turn.kind === "compaction" && turn.compaction_id) {
+    return {
+      role: "assistant",
+      content: turn.summary_preview ?? "",
+      kind: "compaction",
+      loop_name: turn.loop_id,
+      entry_id: turn.turn_id,
+      status: turn.status,
+      compaction: {
+        compaction_id: turn.compaction_id,
+        summary_preview: turn.summary_preview,
+        summary_full: turn.summary_full,
+        archived_count: turn.archived_count,
+        archived_files: turn.archived_files,
+        archived_tool_calls: turn.archived_tool_calls,
+        tokens_before: turn.tokens_before,
+        tokens_after: turn.tokens_after,
+        saved_ratio: turn.saved_ratio,
+        trigger: turn.trigger,
+        failure_reason: turn.failure_reason,
+        fallback_applied: turn.fallback_applied
+      }
+    };
+  }
+  const planningBlock = turn.blocks.find(
+    (block) => block.type === "mode_change" || block.type === "planning_enter" || block.type === "planning_exit" || block.type === "plan_status"
+  );
+  if (planningBlock) {
+    if (planningBlock.type === "plan_status") {
+      return {
+        role: "tool",
+        content: typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}, null, 2),
+        kind: "plan_status",
+        loop_name: turn.loop_id,
+        entry_id: turn.turn_id,
+        status: turn.status
+      };
+    }
+    return {
+      role: "assistant",
+      content: planningBlock.type === "mode_change" ? typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}) : "",
+      kind: planningBlock.type,
+      loop_name: turn.loop_id,
+      entry_id: turn.turn_id,
+      status: turn.status
+    };
+  }
+  if (turn.blocks.some((block) => block.type === "ask_user_answer")) {
+    return null;
+  }
+  const content = buildMessageContent(turn);
+  const reasoning = buildReasoning(turn);
+  const toolCalls = turn.tool_calls.length > 0 ? turn.tool_calls.map((toolCall) => ({
+    id: toolCall.id,
+    name: toolCall.tool_name,
+    display_name: toolCall.display_name,
+    arguments: toolCall.arguments,
+    result: toolCall.result ?? void 0,
+    pending_question_ref: toolCall.pending_question_ref ?? void 0,
+    status: toolCall.status === "pending" || toolCall.status === "awaiting_answer" || toolCall.status === "done" || toolCall.status === "error" || toolCall.status === "cancelled" ? toolCall.status : "pending",
+    ...typeof toolCall.duration_ms === "number" ? { duration_ms: toolCall.duration_ms } : {}
+  })) : void 0;
+  if (turn.role === "system" && !content && !toolCalls?.length) {
+    return null;
+  }
+  return {
+    role: turn.role === "system" ? "assistant" : turn.role,
+    content,
+    blocks: turn.blocks,
+    ...reasoning ? { reasoning } : {},
+    ...toolCalls ? { tool_calls: toolCalls } : {},
+    loop_name: turn.loop_id,
+    entry_id: turn.turn_id,
+    status: turn.status,
+    ...typeof turn.duration_ms === "number" ? { duration_ms: turn.duration_ms } : {},
+    ...turn.started_at ? { timestamp: turn.started_at } : {},
+    ...turn.memory_refs?.length ? { memory_refs: turn.memory_refs } : {}
+  };
+}
+function rebuildAgentLoops(turns) {
+  const messages = turns.map(projectionToMessage).filter(Boolean);
+  const childLoopNames = [...new Set(turns.map((turn) => turn.loop_id).filter((name) => name !== "root"))];
+  if (childLoopNames.length === 0) return {};
+  const agentToolCalls = messages.filter((message) => message.role === "assistant" && (message.loop_name ?? "root") === "root").flatMap((message) => message.tool_calls ?? []).filter((toolCall) => formatToolName(toolCall.name) === "Agent");
+  const loops = {};
+  const agentToolCallsById = new Map(agentToolCalls.map((toolCall) => [toolCall.id, toolCall]));
+  const explicitParentToolCallIds = new Set(
+    turns.map(parentForkToolCallIdFromTurn).filter((id) => id !== null)
+  );
+  const usedToolCallIds = /* @__PURE__ */ new Set();
+  for (const loopName of childLoopNames) {
+    const loopMessages = messages.filter((message) => (message.loop_name ?? "root") === loopName);
+    const loopTurns = turns.filter((turn) => turn.loop_id === loopName);
+    const parentToolCallId = loopTurns.map(parentForkToolCallIdFromTurn).find(Boolean);
+    const explicitToolCall = parentToolCallId && !usedToolCallIds.has(parentToolCallId) ? agentToolCallsById.get(parentToolCallId) ?? null : null;
+    const fallbackToolCall = explicitToolCall === null ? agentToolCalls.find(
+      (toolCall2) => !usedToolCallIds.has(toolCall2.id) && !explicitParentToolCallIds.has(toolCall2.id)
+    ) : null;
+    const toolCall = explicitToolCall ?? fallbackToolCall;
+    if (!toolCall) continue;
+    usedToolCallIds.add(toolCall.id);
+    loops[loopName] = {
+      toolCallId: toolCall.id,
+      description: parseAgentDescription(toolCall.arguments),
+      status: inferLoopStatusFromTurns(loopTurns, loopMessages)
+    };
+  }
+  return loops;
+}
+function applyPlanningSideEffects(sessionId, turns) {
+  const latestMode = [...turns].reverse().map((turn) => extractModeFromBlocks(turn.blocks)).find((mode) => mode !== null);
+  if (latestMode !== "planning") return;
+  if (_getActiveSessionId?.() !== sessionId) return;
+  const ui = useUiStore.getState();
+  ui.setActiveRightTab("situation");
+  if (ui.rightPanelCollapsed) {
+    ui.toggleRightPanel();
+  }
+}
+function materialize(turns) {
+  const messages = turns.map(projectionToMessage).filter((message) => message !== null);
+  const activeCompaction = [...turns].reverse().find(
+    (turn) => turn.kind === "compaction" && turn.status === "streaming" && typeof turn.compaction_id === "string"
+  );
+  return {
+    messages,
+    agentLoops: rebuildAgentLoops(turns),
+    activeCompaction: activeCompaction ? {
+      turn_id: activeCompaction.turn_id,
+      status: activeCompaction.status,
+      compaction_id: activeCompaction.compaction_id,
+      summary_preview: activeCompaction.summary_preview,
+      summary_full: activeCompaction.summary_full,
+      archived_count: activeCompaction.archived_count,
+      archived_files: activeCompaction.archived_files,
+      archived_tool_calls: activeCompaction.archived_tool_calls,
+      tokens_before: activeCompaction.tokens_before,
+      tokens_after: activeCompaction.tokens_after,
+      saved_ratio: activeCompaction.saved_ratio,
+      trigger: activeCompaction.trigger,
+      failure_reason: activeCompaction.failure_reason,
+      fallback_applied: activeCompaction.fallback_applied
+    } : null
+  };
+}
+var ERROR_ANCHOR_PREFIX = "error-anchor:";
+function updateSessionState(state, sessionId, turns) {
+  const orderedTurns = [...turns].sort((left, right) => left.sequence - right.sequence);
+  const { messages, agentLoops, activeCompaction } = materialize(orderedTurns);
+  applyPlanningSideEffects(sessionId, orderedTurns);
+  const lastTurnId = orderedTurns[orderedTurns.length - 1]?.turn_id ?? null;
+  const preservedErrors = lastTurnId ? (state.messages[sessionId] ?? []).filter(
+    (m) => m.role === "error" && typeof m.entry_id === "string" && m.entry_id.startsWith(`${ERROR_ANCHOR_PREFIX}${lastTurnId}:`)
+  ) : [];
+  const mergedMessages = preservedErrors.length > 0 ? [...messages, ...preservedErrors] : messages;
+  return {
+    turns: { ...state.turns, [sessionId]: orderedTurns },
+    messages: { ...state.messages, [sessionId]: mergedMessages },
+    agentLoops: { ...state.agentLoops, [sessionId]: agentLoops },
+    activeCompactions: { ...state.activeCompactions, [sessionId]: activeCompaction }
+  };
+}
+var useChatStore = create3()((set) => ({
+  ...createClientActions(set),
+  turns: {},
+  messages: {},
+  askAnswers: {},
+  isStreaming: {},
+  agentLoops: {},
+  activeCompactions: {},
+  addUserMessage: (sessionId, content) => {
+    set((state) => {
+      const existing = state.turns[sessionId] ?? [];
+      const turnId = `local-user-${Date.now()}`;
+      const optimisticTurn = {
+        id: turnId,
+        sequence: Math.max(0, ...existing.map((turn) => turn.sequence)) + 1,
+        turn_id: turnId,
+        loop_id: "root",
+        role: "user",
+        status: "completed",
+        blocks: [{ type: "text", content }],
+        tool_calls: [],
+        model: null,
+        usage: null,
+        duration_ms: 0
+      };
+      return updateSessionState(state, sessionId, [...existing, optimisticTurn]);
+    });
+  },
+  setTurns: (sessionId, turns) => {
+    set((state) => updateSessionState(state, sessionId, [...turns]));
+  },
+  upsertTurn: (sessionId, turn) => {
+    set((state) => {
+      const existing = [...state.turns[sessionId] ?? []];
+      const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
+      if (index >= 0) {
+        existing[index] = turn;
+      } else {
+        existing.push(turn);
+      }
+      return {
+        ...updateSessionState(state, sessionId, existing)
+      };
+    });
+  },
+  applyTurnPatch: (sessionId, patch) => {
+    set((state) => {
+      const turn = patch.data.turn;
+      if (!turn) return state;
+      const existing = [...state.turns[sessionId] ?? []];
+      const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
+      const lastSequence = index >= 0 ? existing[index].sequence : null;
+      if (lastSequence !== null && patch.sequence <= lastSequence) {
+        return state;
+      }
+      const nextTurn = {
+        ...turn,
+        sequence: patch.sequence
+      };
+      if (index >= 0) {
+        existing[index] = nextTurn;
+      } else {
+        existing.push(nextTurn);
+      }
+      return {
+        ...updateSessionState(state, sessionId, existing)
+      };
+    });
+  },
+  addErrorMessage: (sessionId, content) => {
+    set((state) => {
+      const turns = state.turns[sessionId] ?? [];
+      const anchorTurnId = turns[turns.length - 1]?.turn_id ?? null;
+      const entry_id = anchorTurnId ? `${ERROR_ANCHOR_PREFIX}${anchorTurnId}:${Date.now()}` : void 0;
+      return {
+        messages: {
+          ...state.messages,
+          [sessionId]: [
+            ...state.messages[sessionId] ?? [],
+            { role: "error", content, loop_name: "root", entry_id }
+          ]
+        }
+      };
+    });
+  },
+  markInterrupted: (sessionId) => {
+    set((state) => {
+      const turns = (state.turns[sessionId] ?? []).map((turn) => {
+        if (turn.status !== "streaming") return turn;
+        return {
+          ...turn,
+          status: "interrupted",
+          tool_calls: turn.tool_calls.map(
+            (toolCall) => toolCall.status === "pending" || toolCall.status === "awaiting_answer" ? { ...toolCall, status: "cancelled" } : toolCall
+          )
+        };
+      });
+      return {
+        ...updateSessionState(state, sessionId, turns)
+      };
+    });
+  },
+  markFailed: (sessionId) => {
+    set((state) => {
+      const turns = (state.turns[sessionId] ?? []).map((turn) => {
+        if (turn.status !== "streaming") return turn;
+        return {
+          ...turn,
+          status: "failed",
+          tool_calls: turn.tool_calls.map(
+            (toolCall) => toolCall.status === "pending" || toolCall.status === "awaiting_answer" ? { ...toolCall, status: "error" } : toolCall
+          )
+        };
+      });
+      return {
+        ...updateSessionState(state, sessionId, turns)
+      };
+    });
+  },
+  setStreaming: (sessionId, streaming) => {
+    set((state) => ({
+      isStreaming: { ...state.isStreaming, [sessionId]: streaming }
+    }));
+  },
+  setAskAnswers: (sessionId, answers) => {
+    set((state) => ({
+      askAnswers: {
+        ...state.askAnswers,
+        [sessionId]: answers
+      }
+    }));
+  },
+  clearMessages: (sessionId) => {
+    set((state) => {
+      const { [sessionId]: _turns, ...restTurns } = state.turns;
+      const { [sessionId]: _messages, ...restMessages } = state.messages;
+      const { [sessionId]: _answers, ...restAnswers } = state.askAnswers;
+      const { [sessionId]: _loops, ...restLoops } = state.agentLoops;
+      const { [sessionId]: _compaction, ...restCompactions } = state.activeCompactions;
+      return {
+        turns: restTurns,
+        messages: restMessages,
+        askAnswers: restAnswers,
+        agentLoops: restLoops,
+        activeCompactions: restCompactions
+      };
+    });
+  }
+}));
+
+// src/react/stores/task-store.ts
+import { create as create4 } from "zustand";
+var EMPTY_TASKS = [];
+var useTaskStore = create4()((set, get) => ({
+  ...createClientActions(set),
+  tasks: {},
+  setTasks: (sessionId, tasks) => {
+    set((state) => ({
+      tasks: { ...state.tasks, [sessionId]: tasks }
+    }));
+  },
+  getTasks: (sessionId) => {
+    return get().tasks[sessionId] ?? EMPTY_TASKS;
+  }
+}));
+
+// src/react/stores/session-store.ts
+var DEFAULT_SESSION_MODE = "executing";
+var onSessionChange = null;
+function invalidateHomeSidebarSessions() {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["sessions", "home-sidebar"] });
+}
+function isSessionAccessRevoked(error) {
+  if (error instanceof Error) {
+    const msg = error.message;
+    return msg.includes("API 403") || msg.includes("API 404");
+  }
+  return false;
+}
+function removeSessionArtifacts(sessionId) {
+  useChatStore.getState().clearMessages(sessionId);
+  useTaskStore.getState().setTasks(sessionId, []);
+}
+function pruneSessionState(state, sessionId) {
+  const nextFresh = new Set(state._freshSessions);
+  nextFresh.delete(sessionId);
+  const { [sessionId]: _mode, ...modes } = state.modes;
+  const { [sessionId]: _rewindDraft, ...rewindDrafts } = state.rewindDrafts;
+  return {
+    sessions: state.sessions.filter((session) => session.id !== sessionId),
+    activeSessionId: state.activeSessionId === sessionId ? null : state.activeSessionId,
+    modes,
+    rewindDrafts,
+    _freshSessions: nextFresh
+  };
+}
+function navigateAwayFromSession(sessionId) {
+  if (typeof window === "undefined") return;
+  if (window.location.pathname !== `/chat/${sessionId}`) return;
+  window.history.replaceState(window.history.state, "", "/chat");
+  window.dispatchEvent(new PopStateEvent("popstate"));
+}
+function handleUnreadableSession(set, get, sessionId) {
+  const wasActive = get().activeSessionId === sessionId;
+  removeSessionArtifacts(sessionId);
+  set((state) => pruneSessionState(state, sessionId));
+  if (wasActive) {
+    onSessionChange?.(null);
+    navigateAwayFromSession(sessionId);
+  }
+  invalidateHomeSidebarSessions();
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractModeFromBlocks2(blocks) {
+  const modeBlock = blocks.find((block) => block.type === "mode_change");
+  if (modeBlock && isPlainRecord(modeBlock.content) && (modeBlock.content.to === "planning" || modeBlock.content.to === "executing")) {
+    return modeBlock.content.to;
+  }
+  if (blocks.some((block) => block.type === "planning_enter")) return "planning";
+  if (blocks.some((block) => block.type === "planning_exit")) return "executing";
+  return null;
+}
+function toSelectionMap(value) {
+  if (!isPlainRecord(value)) return {};
+  const entries = Object.entries(value).map(([questionKey, optionIndexes]) => {
+    if (!Array.isArray(optionIndexes)) return null;
+    const parsedIndexes = optionIndexes.map((item) => typeof item === "number" ? item : Number(item)).filter((item) => Number.isInteger(item));
+    return [Number(questionKey), parsedIndexes];
+  }).filter((entry) => entry !== null);
+  return Object.fromEntries(entries);
+}
+function toCustomMap(value) {
+  if (!isPlainRecord(value)) return {};
+  const entries = Object.entries(value).filter(([, text]) => typeof text === "string").map(([questionKey, text]) => [Number(questionKey), text]);
+  return Object.fromEntries(entries);
+}
+function extractAskAnswers(turns) {
+  const answers = {};
+  for (const turn of turns) {
+    for (const block of turn.blocks) {
+      if (block.type !== "ask_user_answer" || typeof block.tool_call_id !== "string") continue;
+      answers[block.tool_call_id] = {
+        selections: toSelectionMap(isPlainRecord(block.content) ? block.content.selections : void 0),
+        custom: toCustomMap(isPlainRecord(block.content) ? block.content.custom : void 0)
+      };
+    }
+  }
+  return answers;
+}
+function registerCreatedSessionState(set, session, mode = DEFAULT_SESSION_MODE) {
+  useChatStore.getState().setTurns(session.id, []);
+  useTaskStore.getState().setTasks(session.id, []);
+  set((state) => ({
+    sessions: [session, ...state.sessions.filter((item) => item.id !== session.id)],
+    modes: { ...state.modes, [session.id]: state.modes[session.id] ?? mode },
+    _freshSessions: new Set(state._freshSessions).add(session.id)
+  }));
+}
+async function revalidateViewerSessions(existingSessions) {
+  const viewerSessions = existingSessions.filter((session) => session.viewer_role === "viewer");
+  if (viewerSessions.length === 0) {
+    return [];
+  }
+  const refreshed = await Promise.all(
+    viewerSessions.map(async (session) => {
+      try {
+        return await getSession(session.id);
+      } catch (error) {
+        if (isSessionAccessRevoked(error)) {
+          return null;
+        }
+        return session;
+      }
+    })
+  );
+  return refreshed.filter((session) => session !== null);
+}
+var useSessionStore = create5()((set, get) => ({
+  ...createClientActions(set),
+  sessions: [],
+  activeSessionId: null,
+  loading: false,
+  modes: {},
+  rewindDrafts: {},
+  _freshSessions: /* @__PURE__ */ new Set(),
+  fetchSessions: async () => {
+    set({ loading: true });
+    try {
+      const currentState = get();
+      const [sessions, viewerSessions] = await Promise.all([
+        listSessions(),
+        revalidateViewerSessions(currentState.sessions)
+      ]);
+      const knownSessionIds = new Set(sessions.map((session) => session.id));
+      const mergedSessions = [
+        ...sessions,
+        ...viewerSessions.filter((session) => !knownSessionIds.has(session.id))
+      ];
+      const removedSessionIds = currentState.sessions.filter(
+        (session) => session.viewer_role === "viewer" && !mergedSessions.some((candidate) => candidate.id === session.id)
+      ).map((session) => session.id);
+      const activeSessionId = currentState.activeSessionId;
+      for (const sessionId of removedSessionIds) {
+        removeSessionArtifacts(sessionId);
+      }
+      let nextState = {
+        sessions: mergedSessions,
+        activeSessionId: currentState.activeSessionId,
+        loading: false,
+        modes: currentState.modes,
+        rewindDrafts: currentState.rewindDrafts,
+        _freshSessions: currentState._freshSessions
+      };
+      for (const sessionId of removedSessionIds) {
+        nextState = {
+          ...nextState,
+          ...pruneSessionState(
+            {
+              ...currentState,
+              sessions: nextState.sessions ?? currentState.sessions,
+              activeSessionId: nextState.activeSessionId ?? currentState.activeSessionId,
+              loading: nextState.loading ?? currentState.loading,
+              modes: nextState.modes ?? currentState.modes,
+              rewindDrafts: nextState.rewindDrafts ?? currentState.rewindDrafts,
+              _freshSessions: nextState._freshSessions ?? currentState._freshSessions
+            },
+            sessionId
+          )
+        };
+      }
+      set(nextState);
+      if (activeSessionId && removedSessionIds.includes(activeSessionId)) {
+        onSessionChange?.(null);
+        navigateAwayFromSession(activeSessionId);
+      }
+      invalidateHomeSidebarSessions();
+    } catch (error) {
+      set({ loading: false });
+      throw error;
+    }
+  },
+  createSession: async (intent) => {
+    const { session_id } = await createSession(intent);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    get().registerCreatedSession({
+      id: session_id,
+      intent: intent ?? "",
+      status: "created",
+      created_at: now,
+      updated_at: now
+    });
+    get().setActiveSession(session_id);
+    invalidateHomeSidebarSessions();
+    get().fetchSessions().catch(() => {
+    });
+    return session_id;
+  },
+  registerCreatedSession: (session, mode = DEFAULT_SESSION_MODE) => {
+    registerCreatedSessionState(set, session, mode);
+  },
+  upsertSession: (session) => {
+    set((state) => ({
+      sessions: state.sessions.some((item) => item.id === session.id) ? state.sessions.map((item) => item.id === session.id ? { ...item, ...session } : item) : [session, ...state.sessions]
+    }));
+  },
+  isFreshSession: (sessionId) => get()._freshSessions.has(sessionId),
+  setActiveSession: (id) => {
+    set({ activeSessionId: id });
+    onSessionChange?.(id);
+    getSession(id).then((detail) => {
+      set((state) => ({
+        sessions: state.sessions.some((s) => s.id === id) ? state.sessions.map(
+          (s) => s.id === id ? { ...s, status: detail.status, updated_at: detail.updated_at } : s
+        ) : [detail, ...state.sessions]
+      }));
+    }).catch(() => {
+    });
+    const tasksPromise = getSessionTasks(id).catch(() => null);
+    Promise.all([getSessionTurns(id), tasksPromise]).then(([turns, tasks]) => {
+      if (tasks) useTaskStore.getState().setTasks(id, tasks);
+      useChatStore.getState().setAskAnswers(id, extractAskAnswers(turns));
+      let inferredMode = DEFAULT_SESSION_MODE;
+      for (const turn of turns) {
+        const nextMode = extractModeFromBlocks2(turn.blocks);
+        if (nextMode) {
+          inferredMode = nextMode;
+        }
+      }
+      set((state) => {
+        if (state.modes[id] == null) {
+          return { modes: { ...state.modes, [id]: inferredMode } };
+        }
+        return state;
+      });
+      const isFresh = get()._freshSessions.has(id);
+      if (isFresh) {
+        set((state) => {
+          const next = new Set(state._freshSessions);
+          next.delete(id);
+          return { _freshSessions: next };
+        });
+        if (turns.length > 0) {
+          useChatStore.getState().setTurns(id, turns);
+        }
+      } else {
+        useChatStore.getState().setTurns(id, turns);
+      }
+    }).catch((error) => {
+      if (isSessionAccessRevoked(error)) {
+        handleUnreadableSession(set, get, id);
+        return;
+      }
+      console.error("Failed to load session data", error);
+    });
+  },
+  clearActiveSession: () => {
+    set({ activeSessionId: null });
+    onSessionChange?.(null);
+  },
+  deleteSession: async (id) => {
+    await deleteSession(id);
+    invalidateHomeSidebarSessions();
+    const wasActive = get().activeSessionId === id;
+    await get().fetchSessions();
+    if (!wasActive) {
+      return;
+    }
+    const nextId = get().sessions[0]?.id ?? null;
+    if (nextId) {
+      get().setActiveSession(nextId);
+      return;
+    }
+    get().clearActiveSession();
+  },
+  updateSessionStatus: (sessionId, status) => {
+    set((state) => ({
+      sessions: state.sessions.map((s) => s.id === sessionId ? { ...s, status } : s)
+    }));
+    if (status === "failed" || status === "interrupted") {
+      useChatStore.getState().setStreaming(sessionId, false);
+      if (status === "interrupted") {
+        useChatStore.getState().markInterrupted(sessionId);
+      } else {
+        useChatStore.getState().markFailed(sessionId);
+      }
+    }
+  },
+  updateSessionIntent: (sessionId, intent) => {
+    set((state) => ({
+      sessions: state.sessions.map((s) => s.id === sessionId ? { ...s, intent } : s)
+    }));
+  },
+  patchSession: (sessionId, patch) => {
+    set((state) => ({
+      sessions: state.sessions.map(
+        (s) => s.id === sessionId ? { ...s, ...patch } : s
+      )
+    }));
+  },
+  pinSession: async (sessionId, pinned) => {
+    const updated = await pinSession(sessionId, pinned);
+    set((state) => ({
+      sessions: state.sessions.map(
+        (s) => s.id === sessionId ? { ...s, is_pinned: updated.is_pinned, pinned_at: updated.pinned_at } : s
+      )
+    }));
+    invalidateHomeSidebarSessions();
+  },
+  setRewindDraft: (sessionId, text) => {
+    set((state) => {
+      if (text == null) {
+        const { [sessionId]: _, ...rest } = state.rewindDrafts;
+        return { rewindDrafts: rest };
+      }
+      return {
+        rewindDrafts: {
+          ...state.rewindDrafts,
+          [sessionId]: text
+        }
+      };
+    });
+  },
+  setMode: (sessionId, mode) => {
+    set((state) => ({ modes: { ...state.modes, [sessionId]: mode } }));
+  },
+  togglePlanningMode: (sessionId) => {
+    const current = get().modes[sessionId] ?? DEFAULT_SESSION_MODE;
+    const next = current === "executing" ? "planning" : "executing";
+    set((state) => ({ modes: { ...state.modes, [sessionId]: next } }));
+  },
+  toggleSharing: async (sessionId) => {
+    const session = get().sessions.find((s) => s.id === sessionId);
+    if (!session) return;
+    const newShared = !session.shared;
+    const result = await updateSharing(sessionId, newShared);
+    set((state) => ({
+      sessions: state.sessions.map(
+        (s) => s.id === sessionId ? { ...s, shared: result.shared } : s
+      )
+    }));
+  },
+  reset: () => {
+    set({
+      sessions: [],
+      activeSessionId: null,
+      loading: false,
+      modes: {},
+      rewindDrafts: {},
+      _freshSessions: /* @__PURE__ */ new Set()
+    });
+    invalidateHomeSidebarSessions();
+  }
+}));
+setChatStoreSessionAccessor(() => useSessionStore.getState().activeSessionId);
+
+// src/react/stores/auth-store.ts
+var noopStorage = {
+  getItem: () => null,
+  setItem: () => {
+  },
+  removeItem: () => {
+  }
+};
+function shouldClearPersistedAuthState(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed.state?.token == null && parsed.state?.user == null;
+  } catch {
+    return false;
+  }
+}
+var authStorage = createJSONStorage(() => {
+  if (typeof localStorage === "undefined") {
+    return noopStorage;
+  }
+  return {
+    getItem: (name) => localStorage.getItem(name),
+    setItem: (name, value) => {
+      if (shouldClearPersistedAuthState(value)) {
+        localStorage.removeItem(name);
+        return;
+      }
+      localStorage.setItem(name, value);
+    },
+    removeItem: (name) => localStorage.removeItem(name)
+  };
+});
+function finishAuth(set, payload) {
+  set({
+    token: payload.token,
+    socketAuthToken: null,
+    user: payload.user,
+    loading: false,
+    error: null
+  });
+  agentSocket?.reconnect();
+  useSessionStore.getState().fetchSessions().catch(() => {
+  });
+}
+function finishCookieHydration(set, payload) {
+  set({
+    token: null,
+    socketAuthToken: payload.token,
+    user: payload.user,
+    loading: false,
+    error: null
+  });
+  agentSocket?.reconnect();
+  useSessionStore.getState().fetchSessions().catch(() => {
+  });
+}
+function toUser(info) {
+  return {
+    id: info.id,
+    username: info.username,
+    display_name: info.display_name,
+    avatar_url: info.avatar_url,
+    is_admin: info.is_admin
+  };
+}
+var useAuthStore = create6()(
+  persist(
+    (set, get) => ({
+      ...createClientActions(set),
+      token: null,
+      socketAuthToken: null,
+      user: null,
+      loading: false,
+      error: null,
+      logout: () => {
+        void logout().catch(() => {
+        });
+        set({ token: null, socketAuthToken: null, user: null, error: null });
+        agentSocket?.disconnect();
+        useSessionStore.getState().reset();
+      },
+      checkAuth: async () => {
+        const token = get().token;
+        if (!token) return;
+        try {
+          const auth = await getMe();
+          finishAuth(set, { token: auth.token, user: toUser(auth) });
+        } catch {
+          set({ token: null, socketAuthToken: null, user: null, error: null });
+          useSessionStore.getState().reset();
+        }
+      },
+      hydrateFromCookie: async () => {
+        set({ loading: true, error: null });
+        const previousToken = get().token;
+        if (previousToken) {
+          try {
+            const auth = await getMe();
+            finishAuth(set, { token: auth.token, user: toUser(auth) });
+            return;
+          } catch {
+            set({ token: null, socketAuthToken: null, user: null, error: null });
+            useSessionStore.getState().reset();
+          }
+        }
+        try {
+          const auth = await getMe();
+          finishCookieHydration(set, { token: auth.token, user: toUser(auth) });
+        } catch {
+          set({
+            token: null,
+            socketAuthToken: null,
+            user: null,
+            loading: false,
+            error: null
+          });
+          useSessionStore.getState().reset();
+        }
+      }
+    }),
+    {
+      name: "agent-auth",
+      storage: authStorage,
+      partialize: (state) => {
+        if (state.socketAuthToken) {
+          return { token: null, user: null };
+        }
+        return { token: state.token, user: state.user };
+      }
+    }
+  )
+);
+
+// src/react/stores/background-store.ts
+import { create as create7 } from "zustand";
+var useBackgroundStore = create7()((set) => ({
+  ...createClientActions(set),
+  tasks: {},
+  selectedTaskId: {},
+  setTasks: (sessionId, tasks) => set((state) => ({
+    tasks: { ...state.tasks, [sessionId]: tasks },
+    selectedTaskId: {
+      ...state.selectedTaskId,
+      [sessionId]: state.selectedTaskId[sessionId] ?? tasks[0]?.id ?? null
+    }
+  })),
+  upsertTask: (sessionId, task) => set((state) => {
+    const existing = state.tasks[sessionId] ?? [];
+    const index = existing.findIndex((item) => item.id === task.id);
+    const next = [...existing];
+    if (index >= 0) {
+      next[index] = { ...next[index], ...task };
+    } else {
+      next.unshift(task);
+    }
+    return {
+      tasks: { ...state.tasks, [sessionId]: next },
+      selectedTaskId: {
+        ...state.selectedTaskId,
+        [sessionId]: state.selectedTaskId[sessionId] ?? task.id
+      }
+    };
+  }),
+  selectTask: (sessionId, taskId) => set((state) => ({
+    selectedTaskId: { ...state.selectedTaskId, [sessionId]: taskId }
+  }))
+}));
+
+// src/react/stores/card-state-store.ts
+import { create as create8 } from "zustand";
+var useCardStateStore = create8((set, get) => ({
+  ...createClientActions(set),
+  states: {},
+  getCardState: (cardId) => {
+    return get().states[cardId];
+  },
+  setCardState: (cardId, state) => {
+    set((prev) => ({
+      states: { ...prev.states, [cardId]: state }
+    }));
+  },
+  removeCardState: (cardId) => {
+    set((prev) => {
+      const { [cardId]: _, ...rest } = prev.states;
+      return { states: rest };
+    });
+  },
+  clearAllStates: () => {
+    set({ states: {} });
+  }
+}));
+
+// src/react/stores/connection-store.ts
+import { create as create9 } from "zustand";
+var initialConnectionState = {
+  status: "disconnected",
+  reconnectAttempt: 0,
+  lastConnectedAt: null,
+  lastDisconnectedAt: null,
+  hasEverConnected: false
+};
+var useConnectionStore = create9()((set) => ({
+  ...createClientActions(set),
+  ...initialConnectionState,
+  markConnecting: (attempt = 0) => set({
+    status: "connecting",
+    reconnectAttempt: attempt
+  }),
+  markConnected: () => set({
+    status: "connected",
+    reconnectAttempt: 0,
+    lastConnectedAt: Date.now(),
+    hasEverConnected: true
+  }),
+  markDisconnected: () => set({
+    status: "disconnected",
+    reconnectAttempt: 0,
+    lastDisconnectedAt: Date.now()
+  }),
+  reset: () => set(initialConnectionState)
+}));
+
+// src/react/stores/runtime-store.ts
+import { create as create10 } from "zustand";
+var useRuntimeStore = create10()((set) => ({
+  ...createClientActions(set),
+  events: {},
+  addEvent: (sessionId, event) => set((state) => {
+    const current = state.events[sessionId] ?? [];
+    const nextEvent = {
+      ...event,
+      id: `${Date.now()}-${current.length}`,
+      sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return {
+      events: {
+        ...state.events,
+        [sessionId]: [...current.slice(-59), nextEvent]
+      }
+    };
+  }),
+  clearSession: (sessionId) => set((state) => ({
+    events: { ...state.events, [sessionId]: [] }
+  }))
+}));
+
+// src/react/stores/gis-store.ts
+import { create as create11 } from "zustand";
+var EMPTY_GOALS = [];
+var EMPTY_RESOURCES = [];
+var EMPTY_TARGETS = [];
+var EMPTY_COMMANDS = [];
+function newCommandId() {
+  if (typeof globalThis !== "undefined" && "crypto" in globalThis) {
+    return globalThis.crypto?.randomUUID?.() ?? `gis-map-${Date.now()}-${Math.random()}`;
+  }
+  return `gis-map-${Date.now()}-${Math.random()}`;
+}
+var useGisStore = create11()((set, get) => ({
+  ...createClientActions(set),
+  goalsBySession: {},
+  resourcesBySession: {},
+  targetsBySession: {},
+  pendingMapCommandsBySession: {},
+  setGoals: (sessionId, goals) => {
+    set((state) => ({
+      goalsBySession: { ...state.goalsBySession, [sessionId]: goals }
+    }));
+  },
+  setResources: (sessionId, resources) => {
+    set((state) => ({
+      resourcesBySession: { ...state.resourcesBySession, [sessionId]: resources }
+    }));
+  },
+  setTargets: (sessionId, targets) => {
+    set((state) => ({
+      targetsBySession: { ...state.targetsBySession, [sessionId]: targets }
+    }));
+  },
+  pushMapCommand: (sessionId, command) => {
+    set((state) => ({
+      pendingMapCommandsBySession: {
+        ...state.pendingMapCommandsBySession,
+        [sessionId]: [
+          ...state.pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS,
+          {
+            ...command,
+            id: newCommandId(),
+            createdAt: Date.now()
+          }
+        ]
+      }
+    }));
+  },
+  consumeMapCommand: (sessionId, commandId) => {
+    set((state) => ({
+      pendingMapCommandsBySession: {
+        ...state.pendingMapCommandsBySession,
+        [sessionId]: (state.pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS).filter(
+          (command) => command.id !== commandId
+        )
+      }
+    }));
+  },
+  getGoals: (sessionId) => get().goalsBySession[sessionId] ?? EMPTY_GOALS,
+  getResources: (sessionId) => get().resourcesBySession[sessionId] ?? EMPTY_RESOURCES,
+  getTargets: (sessionId) => get().targetsBySession[sessionId] ?? EMPTY_TARGETS,
+  getPendingMapCommands: (sessionId) => get().pendingMapCommandsBySession[sessionId] ?? EMPTY_COMMANDS
+}));
+
+// src/react/stores/answer-callback-store.ts
+import { create as create12 } from "zustand";
+var useAnswerCallbackStore = create12()((set) => ({
+  ...createClientActions(set),
+  callbacks: {},
+  setAnswerCallback: (sessionId, callback) => {
+    set((state) => ({
+      callbacks: {
+        ...state.callbacks,
+        [sessionId]: callback
+      }
+    }));
+  }
+}));
+
+// src/react/stores/runtime-features-store.ts
+import { create as create13 } from "zustand";
+var useRuntimeFeaturesStore = create13((set) => ({
+  ...createClientActions(set),
+  asrEnabled: false,
+  asrProvider: "volcengine",
+  publicSharingEnabled: false,
+  memoryEnabled: false,
+  setFeatures: (features) => set((prev) => ({
+    asrEnabled: features.asrEnabled ?? prev.asrEnabled,
+    asrProvider: features.asrProvider ?? prev.asrProvider,
+    publicSharingEnabled: features.publicSharingEnabled ?? prev.publicSharingEnabled,
+    memoryEnabled: features.memoryEnabled ?? prev.memoryEnabled
+  }))
+}));
+
+// src/react/bootstrap.ts
+var bootstrappedClient = null;
+function getBootstrappedClient() {
+  if (!bootstrappedClient) {
+    throw new Error("bootstrapBladeClient() must be called before any SDK usage");
+  }
+  return bootstrappedClient;
+}
+
+// src/react/api/client.ts
+function getAuthedUrl(path) {
+  return getClient().buildAuthedUrl(path);
+}
+function getClient() {
+  return getBootstrappedClient();
+}
+
+// src/react/components/card/CardCodeBlock.tsx
+import { useIsCodeFenceIncomplete } from "streamdown";
+
+// src/react/lib/card-registry.ts
+var CardComponentRegistry = class {
+  components;
+  constructor(initial) {
+    if (initial instanceof Map) {
+      this.components = new Map(initial);
+    } else if (initial) {
+      this.components = new Map(Object.entries(initial));
+    } else {
+      this.components = /* @__PURE__ */ new Map();
+    }
+  }
+  register(type3, component) {
+    this.components.set(type3, component);
+  }
+  get(type3) {
+    return this.components.get(type3);
+  }
+  has(type3) {
+    return this.components.has(type3);
+  }
+  keys() {
+    return Array.from(this.components.keys());
+  }
+  clear() {
+    this.components.clear();
+  }
+  get size() {
+    return this.components.size;
+  }
+};
+var cardRegistry = new CardComponentRegistry();
+var CardJSON = {
+  safeParseJSON(text) {
+    try {
+      const value = JSON.parse(text);
+      return { ok: true, value };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "Unknown parsing error"
+      };
+    }
+  },
+  toCardArray(value) {
+    if (value && typeof value === "object" && "type" in value && typeof value.type === "string") {
+      return [value];
+    }
+    if (Array.isArray(value)) {
+      const cards = value.filter(
+        (item) => item && typeof item === "object" && "type" in item && typeof item.type === "string"
+      );
+      return cards.length > 0 ? cards : null;
+    }
+    return null;
+  },
+  isCardsLanguage(lang) {
+    return lang === "card+json";
+  }
+};
+
+// src/react/lib/code-highlight.ts
+import { useEffect, useMemo, useState } from "react";
+var DARK_THEME = "github-dark-default";
+var LIGHT_THEME = "github-light-default";
+var LANGUAGE_ALIASES = {
+  bash: "bash",
+  css: "css",
+  go: "go",
+  golang: "go",
+  htm: "html",
+  html: "html",
+  javascript: "javascript",
+  js: "javascript",
+  json: "json",
+  jsonc: "json",
+  jsx: "jsx",
+  markdown: "markdown",
+  md: "markdown",
+  py: "python",
+  python: "python",
+  rs: "rust",
+  rust: "rust",
+  scss: "css",
+  sh: "bash",
+  shell: "bash",
+  ts: "typescript",
+  tsx: "tsx",
+  typescript: "typescript",
+  yaml: "yaml",
+  yml: "yaml",
+  zsh: "bash"
+};
+var highlighterPromise = null;
+var CACHE_MAX_SIZE = 200;
+var highlightCache = /* @__PURE__ */ new Map();
+function normalizeCodeLanguage(language) {
+  if (!language) return null;
+  return LANGUAGE_ALIASES[language.trim().toLowerCase()] ?? null;
+}
+function useHighlightedCodeHtml(code, language) {
+  const normalizedLanguage = useMemo(() => normalizeCodeLanguage(language), [language]);
+  const [highlightedHtml, setHighlightedHtml] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    setHighlightedHtml(null);
+    if (!normalizedLanguage) {
+      return () => {
+        cancelled = true;
+      };
+    }
+    void highlightCodeToInnerHtml(code, normalizedLanguage).then((result) => {
+      if (!cancelled) {
+        setHighlightedHtml(result);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [code, normalizedLanguage]);
+  return { highlightedHtml, language: normalizedLanguage };
+}
+async function highlightCodeToInnerHtml(code, language) {
+  const cacheKey = `${language}\0${code}`;
+  const cached = highlightCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const request = loadCodeHighlighter().then((highlighter) => {
+    const html = highlighter.codeToHtml(code, {
+      lang: language,
+      themes: { light: LIGHT_THEME, dark: DARK_THEME },
+      defaultColor: false
+    });
+    return extractInnerCodeHtml(html);
+  }).catch(() => {
+    highlightCache.delete(cacheKey);
+    return null;
+  });
+  if (highlightCache.size >= CACHE_MAX_SIZE) {
+    const oldest = highlightCache.keys().next().value;
+    if (oldest !== void 0) highlightCache.delete(oldest);
+  }
+  highlightCache.set(cacheKey, request);
+  return request;
+}
+async function loadCodeHighlighter() {
+  if (!highlighterPromise) {
+    highlighterPromise = Promise.all([
+      import("shiki/core"),
+      import("shiki/engine/javascript"),
+      import("@shikijs/langs/bash"),
+      import("@shikijs/langs/css"),
+      import("@shikijs/langs/go"),
+      import("@shikijs/langs/html"),
+      import("@shikijs/langs/javascript"),
+      import("@shikijs/langs/json"),
+      import("@shikijs/langs/jsx"),
+      import("@shikijs/langs/markdown"),
+      import("@shikijs/langs/python"),
+      import("@shikijs/langs/rust"),
+      import("@shikijs/langs/tsx"),
+      import("@shikijs/langs/typescript"),
+      import("@shikijs/langs/yaml"),
+      import("@shikijs/themes/github-dark-default"),
+      import("@shikijs/themes/github-light-default")
+    ]).then(
+      ([
+        core,
+        engine,
+        bash,
+        css,
+        go,
+        html,
+        javascript,
+        json,
+        jsx13,
+        markdown,
+        python,
+        rust,
+        tsx,
+        typescript,
+        yaml,
+        darkTheme,
+        lightTheme
+      ]) => core.createHighlighterCore({
+        engine: engine.createJavaScriptRegexEngine(),
+        langs: [
+          bash.default,
+          css.default,
+          go.default,
+          html.default,
+          javascript.default,
+          json.default,
+          jsx13.default,
+          markdown.default,
+          python.default,
+          rust.default,
+          tsx.default,
+          typescript.default,
+          yaml.default
+        ],
+        themes: [darkTheme.default, lightTheme.default]
+      })
+    ).catch((err) => {
+      highlighterPromise = null;
+      throw err;
+    });
+  }
+  return highlighterPromise;
+}
+function extractInnerCodeHtml(html) {
+  const match = html.match(/<code[^>]*>([\s\S]*)<\/code><\/pre>\s*$/);
+  return match?.[1] ?? null;
+}
+
+// src/react/components/card/CardRenderer.tsx
+import { Component } from "react";
+
+// src/react/components/card/CardContext.tsx
+import { createContext, useContext } from "react";
+var CardContext = createContext({});
+var useCardContext = () => useContext(CardContext);
+
+// src/react/components/card/CardStates.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function CardLoadingState({ content }) {
+  return /* @__PURE__ */ jsxs("div", { className: "my-4 rounded-md border border-[hsl(var(--primary)/0.2)] bg-[hsl(var(--primary)/0.05)] p-4", children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-2 flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("div", { className: "h-4 w-4 animate-spin rounded-full border-2 border-[hsl(var(--primary))] border-t-transparent" }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-[hsl(var(--primary))]", children: "\u6B63\u5728\u52A0\u8F7D\u5361\u7247\u6570\u636E..." })
+    ] }),
+    /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-xs text-[hsl(var(--primary)/0.7)]", children: "\u67E5\u770B\u63A5\u6536\u4E2D\u7684\u6570\u636E" }),
+      /* @__PURE__ */ jsx("pre", { className: "mt-1 whitespace-pre-wrap rounded bg-[hsl(var(--primary)/0.1)] p-2 font-mono text-xs text-[hsl(var(--primary)/0.8)]", children: content })
+    ] })
+  ] });
+}
+function CardErrorState({ content, message }) {
+  return /* @__PURE__ */ jsxs("div", { className: "my-4 rounded-md border border-red-500/20 bg-red-500/5 p-4", children: [
+    /* @__PURE__ */ jsx("p", { className: "mb-2 text-sm text-red-400", children: message || "\u5361\u7247\u6570\u636E\u89E3\u6790\u5931\u8D25" }),
+    /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-xs text-red-400/70 hover:underline", children: "\u67E5\u770B\u539F\u59CB\u4EE3\u7801\u5757" }),
+      /* @__PURE__ */ jsx("pre", { className: "mt-2 overflow-x-auto whitespace-pre-wrap rounded bg-red-500/10 p-3 font-mono text-xs text-red-400/80", children: content })
+    ] })
+  ] });
+}
+function CardWarningState({ content, message }) {
+  return /* @__PURE__ */ jsxs("div", { className: "my-4 rounded-md border border-yellow-500/20 bg-yellow-500/5 p-4", children: [
+    /* @__PURE__ */ jsx("p", { className: "mb-2 text-sm text-yellow-400", children: message || "\u6570\u636E\u683C\u5F0F\u4E0D\u7B26\u5408\u5361\u7247\u8981\u6C42" }),
+    /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-xs text-yellow-400/70", children: "\u67E5\u770B\u539F\u59CB\u6570\u636E" }),
+      /* @__PURE__ */ jsx("pre", { className: "mt-1 whitespace-pre-wrap rounded bg-yellow-500/10 p-2 font-mono text-xs text-yellow-400/80", children: content })
+    ] })
+  ] });
+}
+
+// src/react/components/card/CardRenderer.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function looksIncomplete(text) {
+  const t = text.trim();
+  if (!t) return true;
+  const openBraces = (t.match(/{/g) || []).length;
+  const closeBraces = (t.match(/}/g) || []).length;
+  const openBrackets = (t.match(/\[/g) || []).length;
+  const closeBrackets = (t.match(/]/g) || []).length;
+  const quotes = (t.match(/"/g) || []).length;
+  return !t.endsWith("}") && !t.endsWith("]") || openBraces !== closeBraces || openBrackets !== closeBrackets || t.endsWith(",") || t.endsWith(":") || quotes % 2 !== 0;
+}
+var CardErrorBoundary = class extends Component {
+  state = { hasError: false };
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error, info) {
+    console.error("Card render error:", error, info);
+  }
+  render() {
+    if (this.state.hasError) return this.props.fallback;
+    return this.props.children;
+  }
+};
+function OpenInPreviewButton({ card }) {
+  const pushArtifact = useUiStore((s) => s.pushArtifact);
+  return /* @__PURE__ */ jsx2(
+    "button",
+    {
+      type: "button",
+      onClick: () => pushArtifact({
+        type: "card",
+        content: JSON.stringify(card, null, 2),
+        title: card.title || card.type,
+        key: `card-${card.id}`
+      }),
+      className: "absolute right-2 top-2 rounded bg-[hsl(var(--accent))] px-1.5 py-0.5 text-[10px] text-[hsl(var(--muted-foreground))] opacity-0 transition-opacity group-hover/card:opacity-100 hover:text-[hsl(var(--foreground))]",
+      children: "\u9884\u89C8"
+    }
+  );
+}
+function CardRenderer({ raw, blockPosition, isCodeFenceIncomplete }) {
+  const { sessionId, messageId, sendMessage } = useCardContext();
+  const trimmed = raw.trim();
+  if (!trimmed) return /* @__PURE__ */ jsx2(CardLoadingState, { content: "" });
+  if (isCodeFenceIncomplete) {
+    return /* @__PURE__ */ jsx2(CardLoadingState, { content: trimmed });
+  }
+  const parsed = CardJSON.safeParseJSON(trimmed);
+  if (!parsed.ok) {
+    if (looksIncomplete(trimmed)) {
+      return /* @__PURE__ */ jsx2(CardLoadingState, { content: trimmed });
+    }
+    return /* @__PURE__ */ jsx2(CardErrorState, { content: trimmed, message: parsed.error });
+  }
+  const cards = CardJSON.toCardArray(parsed.value);
+  if (!cards) {
+    return /* @__PURE__ */ jsx2(CardWarningState, { content: trimmed, message: "JSON \u683C\u5F0F\u6B63\u786E\u4F46\u4E0D\u7B26\u5408\u5361\u7247\u7ED3\u6784" });
+  }
+  const cardsWithIds = cards.map((c, i) => {
+    if (c.id) return c;
+    return {
+      ...c,
+      id: `${messageId || "msg"}-block-${blockPosition ?? 0}-card-${i}`
+    };
+  });
+  return /* @__PURE__ */ jsx2(Fragment, { children: cardsWithIds.map((card) => {
+    const CardComponent = cardRegistry.get(card.type);
+    if (!CardComponent) {
+      return /* @__PURE__ */ jsx2(
+        CardWarningState,
+        {
+          content: JSON.stringify(card, null, 2),
+          message: `\u672A\u77E5\u7684\u5361\u7247\u7C7B\u578B: ${card.type}`
+        },
+        card.id
+      );
+    }
+    return /* @__PURE__ */ jsx2("div", { className: "group/card relative my-4", children: /* @__PURE__ */ jsxs2(
+      CardErrorBoundary,
+      {
+        fallback: /* @__PURE__ */ jsx2(
+          CardErrorState,
+          {
+            content: JSON.stringify(card, null, 2),
+            message: "\u5361\u7247\u6E32\u67D3\u51FA\u9519"
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx2(CardComponent, { card, sendMessage, sessionId }),
+          /* @__PURE__ */ jsx2(OpenInPreviewButton, { card })
+        ]
+      }
+    ) }, card.id);
+  }) });
+}
+
+// src/react/components/card/CardCodeBlock.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CardCodeBlock({ className, children, node, ...props }) {
+  const isIncomplete = useIsCodeFenceIncomplete();
+  const match = /language-(\S+)/.exec(className || "");
+  const lang = match?.[1];
+  const isInline = !className;
+  const raw = String(children ?? "");
+  const normalizedLang = normalizeCodeLanguage(lang);
+  const { highlightedHtml } = useHighlightedCodeHtml(raw, normalizedLang);
+  if (!isInline && CardJSON.isCardsLanguage(lang)) {
+    return /* @__PURE__ */ jsx3(
+      CardRenderer,
+      {
+        raw,
+        blockPosition: node?.position?.start?.line,
+        isCodeFenceIncomplete: isIncomplete
+      }
+    );
+  }
+  if (!isInline && highlightedHtml) {
+    return /* @__PURE__ */ jsx3(
+      "code",
+      {
+        className,
+        ...props,
+        dangerouslySetInnerHTML: { __html: highlightedHtml }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3("code", { className, ...props, children });
+}
+
+// src/react/components/markdown/MarkdownContent.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var STREAMDOWN_PLUGINS = { mermaid };
+var SYSTEM_REMINDER_TAG = "system-reminder";
+var HIDDEN_SYSTEM_REMINDER_TAGS = {
+  [SYSTEM_REMINDER_TAG]: []
+};
+var HIDDEN_SYSTEM_REMINDER_COMPONENTS = {
+  [SYSTEM_REMINDER_TAG]: () => null
+};
+function CodeBlockPre({ children, node: _node, ...props }) {
+  const preRef = useRef(null);
+  const [copied, setCopied] = useState2(false);
+  const [hasCodeNode, setHasCodeNode] = useState2(false);
+  useEffect2(() => {
+    setHasCodeNode(!!preRef.current?.querySelector("code"));
+  }, []);
+  const getRawCode = () => preRef.current?.querySelector("code")?.textContent ?? "";
+  const handleCopy = async () => {
+    const ok = await copyToClipboard(getRawCode());
+    if (ok) {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    }
+  };
+  const handleDownload = () => {
+    const codeEl = preRef.current?.querySelector("code");
+    const text = codeEl?.textContent ?? "";
+    const ext = codeEl?.className.match(/language-(\S+)/)?.[1] ?? "txt";
+    const blob = new Blob([text], { type: "text/plain" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `code.${ext}`;
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: "relative group", children: [
+    /* @__PURE__ */ jsx4("pre", { ref: preRef, ...props, children }),
+    hasCodeNode && /* @__PURE__ */ jsxs3("div", { className: "absolute top-2 right-2 flex gap-1 opacity-0 group-hover:opacity-100 transition-opacity", children: [
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          type: "button",
+          onClick: handleCopy,
+          className: cn(
+            "flex items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] transition-colors",
+            copied ? "text-[hsl(var(--primary))]" : "text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))] hover:bg-[hsl(var(--accent))]"
+          ),
+          children: [
+            copied ? /* @__PURE__ */ jsx4(Check, { size: 12 }) : /* @__PURE__ */ jsx4(Copy, { size: 12 }),
+            /* @__PURE__ */ jsx4("span", { children: copied ? "\u5DF2\u590D\u5236" : "\u590D\u5236" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          type: "button",
+          onClick: handleDownload,
+          className: "flex items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] transition-colors text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))] hover:bg-[hsl(var(--accent))]",
+          children: [
+            /* @__PURE__ */ jsx4(Download, { size: 12 }),
+            /* @__PURE__ */ jsx4("span", { children: "\u4E0B\u8F7D" })
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+function isExternalImageSrc(src) {
+  if (!src) return false;
+  if (src.startsWith("data:") || src.startsWith("blob:")) return true;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(src)) return true;
+  if (src.startsWith("/")) return true;
+  return false;
+}
+function decodeMarkdownPath(src) {
+  try {
+    return decodeURIComponent(src);
+  } catch {
+    return src;
+  }
+}
+var MARKDOWN_IMAGE_PATTERN = /!\[((?:\\.|[^\]\\])*)\]\(\s*(?:<([^>\n]+)>|([^\s)]+))(\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\s*\)/g;
+function resolveSessionImageMarkdown(children, sessionId) {
+  return children.replace(
+    MARKDOWN_IMAGE_PATTERN,
+    (match, alt, angleSrc, plainSrc, title = "") => {
+      const src = angleSrc ?? plainSrc;
+      if (!src || isExternalImageSrc(src)) {
+        return match;
+      }
+      const resolved = getAuthedUrl(
+        `/api/sessions/${encodeURIComponent(sessionId)}/files/${encodeURIComponent(decodeMarkdownPath(src))}`
+      );
+      return `![${alt}](<${resolved}>${title})`;
+    }
+  );
+}
+function MarkdownContent({
+  allowedTags,
+  children,
+  components,
+  mode,
+  plugins,
+  sessionId,
+  ...props
+}) {
+  const resolvedChildren = useMemo2(
+    () => sessionId && typeof children === "string" ? resolveSessionImageMarkdown(children, sessionId) : children,
+    [children, sessionId]
+  );
+  return /* @__PURE__ */ jsx4(
+    Streamdown,
+    {
+      ...props,
+      mode: mode ?? "static",
+      allowedTags: {
+        ...allowedTags ?? {},
+        ...HIDDEN_SYSTEM_REMINDER_TAGS
+      },
+      components: {
+        code: CardCodeBlock,
+        pre: CodeBlockPre,
+        ...components ?? {},
+        ...HIDDEN_SYSTEM_REMINDER_COMPONENTS
+      },
+      plugins: {
+        ...STREAMDOWN_PLUGINS,
+        ...plugins ?? {}
+      },
+      children: resolvedChildren
+    }
+  );
+}
+
+// src/react/components/chat/AskUserQuestionBlock.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function AskUserQuestionBlock({
+  data,
+  answered,
+  toolCallId,
+  sessionStatus,
+  answerData,
+  onAnswer
+}) {
+  const [selections, setSelections] = useState3(/* @__PURE__ */ new Map());
+  const [customTexts, setCustomTexts] = useState3(/* @__PURE__ */ new Map());
+  const [usingCustom, setUsingCustom] = useState3(/* @__PURE__ */ new Set());
+  const [submitted, setSubmitted] = useState3(false);
+  useEffect3(() => {
+    if (sessionStatus === "failed" || sessionStatus === "interrupted") {
+      setSubmitted(false);
+    }
+  }, [sessionStatus]);
+  const displayAnswerState = useMemo3(() => {
+    if (!(answered && answerData)) {
+      return {
+        selections,
+        customTexts,
+        usingCustom
+      };
+    }
+    const nextSelections = /* @__PURE__ */ new Map();
+    const nextCustomTexts = /* @__PURE__ */ new Map();
+    const nextUsingCustom = /* @__PURE__ */ new Set();
+    for (const [questionKey, optionIndexes] of Object.entries(answerData.selections)) {
+      nextSelections.set(Number(questionKey), new Set(optionIndexes));
+    }
+    for (const [questionKey, text] of Object.entries(answerData.custom)) {
+      const qIdx = Number(questionKey);
+      nextCustomTexts.set(qIdx, text);
+      nextUsingCustom.add(qIdx);
+    }
+    return {
+      selections: nextSelections,
+      customTexts: nextCustomTexts,
+      usingCustom: nextUsingCustom
+    };
+  }, [answerData, answered, customTexts, selections, usingCustom]);
+  const displaySelections = displayAnswerState.selections;
+  const displayCustomTexts = displayAnswerState.customTexts;
+  const displayUsingCustom = displayAnswerState.usingCustom;
+  const toggleOption = (qIdx, optIdx, multi) => {
+    if (answered || submitted) return;
+    setSelections((prev) => {
+      const next = new Map(prev);
+      const current = new Set(next.get(qIdx) ?? []);
+      if (multi) {
+        if (current.has(optIdx)) current.delete(optIdx);
+        else current.add(optIdx);
+      } else {
+        current.clear();
+        current.add(optIdx);
+      }
+      next.set(qIdx, current);
+      return next;
+    });
+    setUsingCustom((prev) => {
+      const next = new Set(prev);
+      next.delete(qIdx);
+      return next;
+    });
+  };
+  const handleCustomFocus = (qIdx) => {
+    if (answered || submitted) return;
+    setSelections((prev) => {
+      const next = new Map(prev);
+      next.delete(qIdx);
+      return next;
+    });
+    setUsingCustom((prev) => new Set(prev).add(qIdx));
+  };
+  const setCustomText = (qIdx, text) => {
+    if (answered || submitted) return;
+    setCustomTexts((prev) => new Map(prev).set(qIdx, text));
+  };
+  const getAnswer = (qIdx) => {
+    const q = data.questions[qIdx];
+    if (usingCustom.has(qIdx)) {
+      const text = (customTexts.get(qIdx) ?? "").trim();
+      return text || null;
+    }
+    const sel = selections.get(qIdx);
+    if (!sel || sel.size === 0) return null;
+    return [...sel].sort().map((i) => q.options[i].label).join(", ");
+  };
+  const allAnswered = data.questions.every((_, i) => getAnswer(i) !== null);
+  const handleSubmit = () => {
+    if (answered || submitted || !allAnswered || !onAnswer) return;
+    const nextAnswerData = {
+      selections: Object.fromEntries(
+        Array.from(selections.entries()).map(([qIdx, optionIndexes]) => [
+          qIdx,
+          Array.from(optionIndexes).sort((a, b) => a - b)
+        ])
+      ),
+      custom: Object.fromEntries(
+        Array.from(usingCustom).map((qIdx) => [qIdx, (customTexts.get(qIdx) ?? "").trim()]).filter(([, text2]) => text2.length > 0)
+      )
+    };
+    const parts = data.questions.map((q, i) => `- ${q.question} -> ${getAnswer(i)}`);
+    const text = `\u5173\u4E8E\u9700\u8981\u786E\u8BA4\u7684\u95EE\u9898\uFF0C\u7528\u6237\u7684\u56DE\u7B54\u5982\u4E0B\uFF1A
+${parts.join("\n")}`;
+    setSubmitted(true);
+    onAnswer(text, toolCallId, nextAnswerData);
+  };
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      className: cn(
+        "ml-4 rounded-xl border border-[hsl(var(--border))] bg-[hsl(var(--card))]",
+        answered ? "max-w-2xl space-y-3 p-3 text-xs text-[hsl(var(--muted-foreground))] opacity-80" : "max-w-lg space-y-5 p-4 text-sm"
+      ),
+      children: [
+        data.source_loop?.description && /* @__PURE__ */ jsxs4("div", { className: "rounded-lg bg-[hsl(var(--muted)/0.35)] px-3 py-2 text-xs text-[hsl(var(--muted-foreground))]", children: [
+          "\u5B50\u667A\u80FD\u4F53\u300C",
+          data.source_loop.description,
+          "\u300D\u5728\u7B49\u5F85\u4F60\u7684\u56DE\u7B54"
+        ] }),
+        data.questions.map((q, qIdx) => /* @__PURE__ */ jsx5(
+          QuestionCard,
+          {
+            question: q,
+            qIdx,
+            answered,
+            selected: displaySelections.get(qIdx) ?? /* @__PURE__ */ new Set(),
+            isCustom: displayUsingCustom.has(qIdx),
+            customText: displayCustomTexts.get(qIdx) ?? "",
+            onToggle: toggleOption,
+            onCustomFocus: handleCustomFocus,
+            onCustomChange: setCustomText
+          },
+          q.question
+        )),
+        !answered && !submitted && onAnswer && /* @__PURE__ */ jsx5(
+          "button",
+          {
+            type: "button",
+            onClick: handleSubmit,
+            disabled: !allAnswered,
+            className: "w-full rounded-lg bg-[hsl(var(--primary))] px-4 py-2 text-xs font-semibold text-[hsl(var(--primary-foreground))] transition-opacity hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-60",
+            children: allAnswered ? "\u786E\u8BA4" : "\u8BF7\u5148\u9009\u62E9\u4E00\u4E2A\u9009\u9879"
+          }
+        ),
+        submitted && !answered && /* @__PURE__ */ jsxs4(
+          "button",
+          {
+            type: "button",
+            disabled: true,
+            className: "flex w-full items-center justify-center gap-2 rounded-lg bg-[hsl(var(--primary))] px-4 py-2 text-xs font-semibold text-[hsl(var(--primary-foreground))] opacity-80",
+            children: [
+              /* @__PURE__ */ jsx5(Loader2, { size: 14, className: "animate-spin" }),
+              "\u786E\u8BA4\u4E2D"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function QuestionCard({
+  question,
+  qIdx,
+  answered,
+  selected,
+  isCustom,
+  customText,
+  onToggle,
+  onCustomFocus,
+  onCustomChange
+}) {
+  const multi = question.multiSelect ?? false;
+  return /* @__PURE__ */ jsxs4("div", { children: [
+    /* @__PURE__ */ jsxs4("div", { className: cn("flex items-start gap-2", answered ? "mb-2" : "mb-3"), children: [
+      /* @__PURE__ */ jsx5(
+        MessageSquareMore,
+        {
+          size: answered ? 12 : 13,
+          className: "mt-0.5 shrink-0 text-[hsl(var(--primary))]"
+        }
+      ),
+      /* @__PURE__ */ jsx5(
+        "div",
+        {
+          className: cn(
+            "min-w-0 flex-1 font-medium text-[hsl(var(--foreground))]",
+            answered ? "text-xs" : "text-sm"
+          ),
+          children: /* @__PURE__ */ jsx5(
+            MarkdownContent,
+            {
+              className: cn(
+                "prose prose-sm prose-invert max-w-none [&_li>p]:inline [&_ol]:my-1 [&_p]:my-1 [&_p:first-child]:mt-0 [&_p:last-child]:mb-0 [&_ul]:my-1",
+                answered ? "text-xs" : "text-sm"
+              ),
+              controls: { code: true },
+              children: question.question
+            }
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs4("div", { className: cn("flex flex-col pl-5", answered ? "gap-1" : "gap-1.5"), children: [
+      question.options.map((opt, optIdx) => {
+        const isSel = selected.has(optIdx);
+        return /* @__PURE__ */ jsxs4(
+          "button",
+          {
+            type: "button",
+            disabled: answered,
+            onClick: () => onToggle(qIdx, optIdx, multi),
+            className: cn(
+              "flex items-start gap-2.5 rounded-lg border text-left transition-all",
+              answered ? "px-2.5 py-1.5" : "px-3 py-2.5",
+              isSel && !answered ? "border-[hsl(var(--primary)/0.8)] bg-[hsl(var(--primary))] text-[hsl(var(--primary-foreground))]" : isSel ? "border-[hsl(var(--primary)/0.45)] bg-[hsl(var(--primary)/0.08)] text-[hsl(var(--foreground))]" : "border-[hsl(var(--border))] bg-[hsl(var(--muted)/0.2)]",
+              !answered && !isSel && "hover:border-[hsl(var(--ring)/0.4)] hover:bg-[hsl(var(--accent))]",
+              answered && "cursor-default opacity-70"
+            ),
+            children: [
+              multi && /* @__PURE__ */ jsx5(
+                "div",
+                {
+                  className: cn(
+                    "mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded border transition-colors",
+                    isSel && !answered ? "border-[hsl(var(--primary-foreground)/0.6)] bg-[hsl(var(--primary-foreground)/0.2)]" : isSel ? "border-[hsl(var(--primary)/0.45)] bg-[hsl(var(--primary)/0.12)]" : "border-[hsl(var(--border))]"
+                  ),
+                  children: isSel && /* @__PURE__ */ jsx5(
+                    Check2,
+                    {
+                      size: 9,
+                      className: answered ? "text-[hsl(var(--primary))]" : "text-[hsl(var(--primary-foreground))]"
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsxs4("div", { className: "min-w-0", children: [
+                /* @__PURE__ */ jsx5("div", { className: cn("font-medium", answered ? "text-xs" : "text-[13px]"), children: opt.label }),
+                opt.description && /* @__PURE__ */ jsx5(
+                  "div",
+                  {
+                    className: cn(
+                      "mt-0.5",
+                      answered ? "text-[11px]" : "text-xs",
+                      isSel && !answered ? "opacity-75" : "text-[hsl(var(--muted-foreground))]"
+                    ),
+                    children: opt.description
+                  }
+                )
+              ] })
+            ]
+          },
+          opt.label
+        );
+      }),
+      answered && !isCustom ? null : /* @__PURE__ */ jsxs4(
+        "div",
+        {
+          className: cn(
+            "flex items-center gap-2 rounded-lg border transition-all",
+            answered ? "px-2.5 py-1.5" : "px-3 py-2.5",
+            isCustom ? "border-[hsl(var(--ring)/0.6)] bg-[hsl(var(--accent))]" : "border-[hsl(var(--border))] hover:border-[hsl(var(--ring)/0.3)] hover:bg-[hsl(var(--accent))]",
+            answered && "cursor-default opacity-70"
+          ),
+          children: [
+            /* @__PURE__ */ jsx5("span", { className: "shrink-0 text-xs text-[hsl(var(--muted-foreground))]", children: "\u5176\u4ED6\uFF1A" }),
+            /* @__PURE__ */ jsx5(
+              "input",
+              {
+                type: "text",
+                value: customText,
+                disabled: answered,
+                onChange: (e) => onCustomChange(qIdx, e.target.value),
+                onFocus: () => onCustomFocus(qIdx),
+                "aria-label": "\u81EA\u5B9A\u4E49\u56DE\u7B54",
+                placeholder: "\u8F93\u5165\u4F60\u7684\u7B54\u6848...",
+                className: cn(
+                  "min-w-0 flex-1 bg-transparent text-[hsl(var(--foreground))] outline-none placeholder:text-[hsl(var(--muted-foreground)/0.5)]",
+                  answered ? "text-xs" : "text-sm"
+                )
+              }
+            )
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+function parseAskUserQuestion(toolResult) {
+  if (!toolResult) return null;
+  try {
+    const parsed = JSON.parse(toolResult);
+    let questions = parsed?.questions;
+    if (typeof questions === "string") {
+      try {
+        questions = JSON.parse(questions);
+      } catch {
+        return null;
+      }
+    }
+    if (Array.isArray(questions) && questions.every(isQuestionItem)) {
+      return { ...parsed, questions };
+    }
+  } catch {
+  }
+  return null;
+}
+function isQuestionItem(value) {
+  if (!value || typeof value !== "object") return false;
+  const question = value.question;
+  const options = value.options;
+  return typeof question === "string" && Array.isArray(options) && options.every(isOptionItem);
+}
+function isOptionItem(value) {
+  if (!value || typeof value !== "object") return false;
+  const option = value;
+  return typeof option.label === "string" && typeof option.description === "string";
+}
+
+// src/react/components/plan/parse-plan-tree.ts
+import { load } from "js-yaml";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPlanStep(value) {
+  if (!value || typeof value !== "object") return false;
+  const step = value;
+  if (!isNonEmptyString(step.label)) return false;
+  if ("skill" in step && step.skill !== void 0 && !isNonEmptyString(step.skill)) return false;
+  if ("children" in step && !Array.isArray(step.children)) return false;
+  const children = Array.isArray(step.children) ? step.children : [];
+  if (children.length > 0 && !isNonEmptyString(step.skill)) return false;
+  return children.every((child) => isPlanStep(child));
+}
+function isPlanDocument(value) {
+  if (!value || typeof value !== "object") return false;
+  const doc = value;
+  if (!isNonEmptyString(doc.title) || !isNonEmptyString(doc.objective)) return false;
+  if (!Array.isArray(doc.steps) || doc.steps.length === 0) return false;
+  if (!doc.steps.every((step) => isPlanStep(step))) return false;
+  if ("notes" in doc) {
+    if (!Array.isArray(doc.notes)) return false;
+    if (!doc.notes.every((note) => isNonEmptyString(note))) return false;
+  }
+  return true;
+}
+function getPlanDocumentError(value) {
+  if (!value || typeof value !== "object") return "PLAN.yaml \u9876\u5C42\u7ED3\u6784\u5FC5\u987B\u662F\u5BF9\u8C61";
+  const doc = value;
+  if (!isNonEmptyString(doc.title)) return "PLAN.yaml \u7F3A\u5C11\u975E\u7A7A title";
+  if (!isNonEmptyString(doc.objective)) return "PLAN.yaml \u7F3A\u5C11\u975E\u7A7A objective";
+  if (!Array.isArray(doc.steps) || doc.steps.length === 0) return "PLAN.yaml \u7F3A\u5C11\u975E\u7A7A steps";
+  if (!doc.steps.every((step) => isPlanStep(step))) {
+    return "PLAN.yaml \u6B65\u9AA4\u7ED3\u6784\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5 label / skill / children";
+  }
+  if ("notes" in doc) {
+    if (!Array.isArray(doc.notes) || !doc.notes.every((note) => isNonEmptyString(note))) {
+      return "PLAN.yaml notes \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u5217\u8868";
+    }
+  }
+  return "PLAN.yaml \u7ED3\u6784\u65E0\u6548";
+}
+function toPlanStatus(value) {
+  if (!isNonEmptyString(value)) return "pending";
+  const normalized = value.trim().toLowerCase();
+  return normalized === "pending" || normalized === "running" || normalized === "done" || normalized === "failed" ? normalized : "pending";
+}
+function applyPlanStatusesById(root, statuses) {
+  const nextStatus = statuses[root.id] ?? root.status;
+  const children = Array.isArray(root.children) ? root.children : [];
+  return {
+    ...root,
+    status: nextStatus,
+    children: children.map((child) => applyPlanStatusesById(child, statuses))
+  };
+}
+function parsePlanTreeResult(content) {
+  if (!content.trim()) {
+    return { plan: null, error: null };
+  }
+  let parsed;
+  try {
+    parsed = load(content);
+  } catch (error) {
+    return {
+      plan: null,
+      error: error instanceof Error ? `PLAN.yaml YAML \u8BED\u6CD5\u9519\u8BEF\uFF1A${error.message}` : "PLAN.yaml YAML \u8BED\u6CD5\u9519\u8BEF"
+    };
+  }
+  if (!isPlanDocument(parsed)) {
+    return { plan: null, error: getPlanDocumentError(parsed) };
+  }
+  const createNode = (step, depth, fallbackId) => {
+    const children = Array.isArray(step.children) ? step.children : [];
+    return {
+      id: isNonEmptyString(step.id) ? step.id.trim() : fallbackId,
+      label: step.label.trim(),
+      skillRef: isNonEmptyString(step.skill) ? step.skill.trim() : null,
+      status: toPlanStatus(step.status),
+      children: children.map((child, index) => createNode(child, depth + 1, `${fallbackId}.${index + 1}`)),
+      depth
+    };
+  };
+  const root = {
+    id: "plan-root",
+    label: parsed.title.trim(),
+    skillRef: null,
+    status: "pending",
+    children: parsed.steps.map((step, index) => createNode(step, 1, `${index + 1}`)),
+    depth: 0
+  };
+  const notes = [parsed.objective.trim(), ...(parsed.notes ?? []).map((note) => note.trim())];
+  return { plan: { root, notes }, error: null };
+}
+
+// src/react/components/plan/parse-plan-messages.ts
+function resultAsString(result) {
+  if (typeof result === "string") return result;
+  return null;
+}
+var PAUSE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+var READ_FILE_TOOLS = /* @__PURE__ */ new Set(["Read"]);
+var PLAN_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write"]);
+var PLAN_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit"]);
+function getSkillId(payload) {
+  if (!payload) {
+    return "";
+  }
+  if (typeof payload.skill_id === "string" && payload.skill_id) {
+    return payload.skill_id;
+  }
+  if (typeof payload.name === "string" && payload.name) {
+    return payload.name;
+  }
+  return "";
+}
+function getSkillDisplayName(payload) {
+  if (!payload || typeof payload.display_name !== "string") {
+    return void 0;
+  }
+  const displayName = payload.display_name.trim();
+  if (!displayName) {
+    return void 0;
+  }
+  const skillId = getSkillId(payload);
+  return displayName === skillId ? void 0 : displayName;
+}
+function parseModeChange2(message) {
+  if (message.kind !== "mode_change" || typeof message.content !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(message.content);
+    if (typeof parsed.from === "string" && typeof parsed.to === "string") {
+      return { from: parsed.from, to: parsed.to };
+    }
+  } catch {
+  }
+  return null;
+}
+function isPlanningBoundaryMessage(message) {
+  if (message.kind === "planning_enter" || message.kind === "planning_exit") {
+    return true;
+  }
+  const modeChange = parseModeChange2(message);
+  if (!modeChange) {
+    return false;
+  }
+  return modeChange.to === "planning" || modeChange.from === "planning";
+}
+function parsePlanMessages(allMessages) {
+  const messages = Array.isArray(allMessages) ? allMessages : [];
+  let intent = "";
+  for (const msg of messages) {
+    if (!msg.tool_calls) continue;
+    const searchTc = msg.tool_calls.find(
+      (tc) => tc.name === "search_skills" || tc.name === "SearchSkills"
+    );
+    if (searchTc) {
+      try {
+        intent = JSON.parse(searchTc.arguments).query ?? "";
+      } catch {
+      }
+      if (intent) break;
+    }
+  }
+  const plannerMsgs = messages.filter(
+    (message) => !isPlanningBoundaryMessage(message)
+  );
+  const searchResults = [];
+  const searchMap = /* @__PURE__ */ new Map();
+  const selectedSkills = [];
+  const selectedSet = /* @__PURE__ */ new Set();
+  const askQuestions = [];
+  const readFiles = [];
+  let lastPauseTool = null;
+  let planContent = "";
+  let planContentPriority = 0;
+  let latestStatuses = {};
+  const setPlanContent = (nextContent, priority) => {
+    if (typeof nextContent !== "string" || !nextContent.trim()) {
+      return;
+    }
+    if (priority < planContentPriority) {
+      return;
+    }
+    planContent = nextContent;
+    planContentPriority = priority;
+  };
+  const applyPlanEdit = (args) => {
+    const oldString = typeof args.old_string === "string" ? args.old_string : "";
+    const newString = typeof args.new_string === "string" ? args.new_string : "";
+    if (!planContent || !oldString || !planContent.includes(oldString)) {
+      return;
+    }
+    planContent = planContent.replace(oldString, newString);
+  };
+  const maybeParsePlanStatus = (msg) => {
+    if (msg.kind !== "plan_status") return;
+    if (typeof msg.content !== "string" || !msg.content.trim()) return;
+    try {
+      const data = JSON.parse(msg.content);
+      setPlanContent(data.plan_yaml, 3);
+      if (data.statuses && typeof data.statuses === "object" && !Array.isArray(data.statuses)) {
+        latestStatuses = Object.fromEntries(
+          Object.entries(data.statuses).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string").map(([stepId, status]) => [stepId, normalizePlanStatus(status)])
+        );
+      }
+    } catch {
+    }
+  };
+  for (const msg of plannerMsgs) {
+    maybeParsePlanStatus(msg);
+    if (!msg.tool_calls) continue;
+    for (const tc of msg.tool_calls) {
+      if ((tc.name === "search_skills" || tc.name === "SearchSkills") && resultAsString(tc.result)) {
+        try {
+          const parsed = JSON.parse(resultAsString(tc.result));
+          const results = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.results) ? parsed.results : [];
+          for (const r3 of results) {
+            const skillId = getSkillId(r3);
+            if (!skillId || searchMap.has(skillId)) continue;
+            const skill = {
+              skillId,
+              displayName: getSkillDisplayName(r3),
+              description: r3.description ?? ""
+            };
+            searchMap.set(skillId, skill);
+            searchResults.push(skill);
+          }
+        } catch {
+        }
+      }
+      if ((tc.name === "get_skill_content" || tc.name === "GetSkillContent") && resultAsString(tc.result)) {
+        try {
+          const data = JSON.parse(resultAsString(tc.result));
+          const skillId = getSkillId(data);
+          if (!skillId || selectedSet.has(skillId)) continue;
+          let existing = searchMap.get(skillId);
+          if (!existing) {
+            existing = {
+              skillId,
+              displayName: getSkillDisplayName(data),
+              description: data.description ?? ""
+            };
+            searchMap.set(skillId, existing);
+            searchResults.push(existing);
+          }
+          existing.displayName ??= getSkillDisplayName(data);
+          existing.content = data.content;
+          existing.references = extractRefs(data.content ?? "");
+          selectedSkills.push(existing);
+          selectedSet.add(skillId);
+        } catch {
+        }
+      }
+      if (tc.name === "AskUserQuestion" && resultAsString(tc.result)) {
+        const data = parseAskUserQuestion(resultAsString(tc.result));
+        if (data) {
+          askQuestions.push({ toolCallId: tc.id, data });
+        }
+      }
+      if (READ_FILE_TOOLS.has(tc.name) && tc.arguments) {
+        try {
+          const args = JSON.parse(tc.arguments);
+          if (typeof args.file_path === "string" && args.file_path) {
+            readFiles.push({ path: args.file_path, status: tc.status ?? "done" });
+          }
+        } catch {
+        }
+      }
+      if (PLAN_WRITE_TOOLS.has(tc.name) && tc.arguments && tc.status === "done" && !(typeof tc.result === "string" && tc.result.startsWith("\u9519\u8BEF"))) {
+        try {
+          const args = JSON.parse(tc.arguments);
+          if (typeof args.file_path === "string" && (args.file_path === "PLAN.yaml" || args.file_path.endsWith("/PLAN.yaml")) && typeof args.content === "string") {
+            setPlanContent(args.content, 1);
+          }
+        } catch {
+        }
+      }
+      if (PLAN_EDIT_TOOLS.has(tc.name) && tc.arguments && tc.status === "done" && !(typeof tc.result === "string" && tc.result.startsWith("\u9519\u8BEF"))) {
+        try {
+          const args = JSON.parse(tc.arguments);
+          if (typeof args.file_path === "string" && (args.file_path === "PLAN.yaml" || args.file_path.endsWith("/PLAN.yaml"))) {
+            applyPlanEdit(args);
+          }
+        } catch {
+        }
+      }
+      if (PAUSE_TOOLS.has(tc.name) && tc.status === "done") {
+        lastPauseTool = tc.name;
+      }
+      if (tc.name === "ExitPlanMode" && resultAsString(tc.result)) {
+        try {
+          const data = JSON.parse(resultAsString(tc.result));
+          setPlanContent(data.plan, 2);
+        } catch {
+        }
+      }
+    }
+  }
+  const { plan: parsedPlan, error: parseError } = parsePlanTreeResult(planContent);
+  const plan = parsedPlan == null ? null : {
+    ...parsedPlan,
+    root: applyPlanStatusesById(parsedPlan.root, latestStatuses)
+  };
+  return {
+    intent,
+    searchResults,
+    selectedSkills,
+    plan,
+    hasPlanContent: planContent.trim().length > 0,
+    parseError,
+    askQuestions,
+    readFiles,
+    lastPauseTool
+  };
+}
+function normalizePlanStatus(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "running" || normalized === "done" || normalized === "failed" ? normalized : "pending";
+}
+function extractRefs(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const m of content.matchAll(/\[\[([^\]]+)\]\]/g)) {
+    const ref = m[1].trim();
+    if (ref && !seen.has(ref)) {
+      seen.add(ref);
+      refs.push(ref);
+    }
+  }
+  return refs;
+}
+
+// src/react/components/plan/PlanSummaryCard.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function PlanSummaryCard({
+  messages,
+  sessionStatus,
+  onConfirmPlan
+}) {
+  const data = useMemo4(() => parsePlanMessages(messages), [messages]);
+  const rightPanelCollapsed = useUiStore((state) => state.rightPanelCollapsed);
+  const toggleRightPanel = useUiStore((state) => state.toggleRightPanel);
+  const setActiveRightTab = useUiStore((state) => state.setActiveRightTab);
+  const summaryState = useMemo4(() => getSummaryState(data, sessionStatus), [data, sessionStatus]);
+  const stepCount = useMemo4(() => countPlanSteps(data.plan), [data.plan]);
+  const isWaitingForInput = sessionStatus === "waiting_for_input";
+  const canConfirm = Boolean(onConfirmPlan) && isWaitingForInput && data.lastPauseTool === "ExitPlanMode";
+  const openPlanPanel = () => {
+    if (rightPanelCollapsed) {
+      toggleRightPanel();
+    }
+    setActiveRightTab("situation");
+  };
+  return /* @__PURE__ */ jsxs5("div", { className: "flex w-full flex-col gap-4 rounded-2xl border border-[hsl(var(--border))] bg-[hsl(var(--card)/0.55)] p-4", children: [
+    /* @__PURE__ */ jsxs5(
+      "button",
+      {
+        type: "button",
+        onClick: openPlanPanel,
+        className: "flex w-full flex-col gap-4 text-left transition-colors hover:text-[hsl(var(--foreground))]",
+        children: [
+          /* @__PURE__ */ jsxs5("div", { className: "flex items-start justify-between gap-3", children: [
+            /* @__PURE__ */ jsxs5("div", { className: "min-w-0 space-y-2", children: [
+              /* @__PURE__ */ jsxs5("div", { className: "flex items-center gap-2 text-xs text-[hsl(var(--muted-foreground))]", children: [
+                /* @__PURE__ */ jsx6(Sparkles, { size: 12 }),
+                /* @__PURE__ */ jsx6("span", { children: "\u89C4\u5212\u6458\u8981" })
+              ] }),
+              /* @__PURE__ */ jsx6("div", { className: "truncate text-base font-medium text-[hsl(var(--foreground))]", children: data.intent || "\u5F53\u524D\u89C4\u5212" }),
+              /* @__PURE__ */ jsx6("div", { className: "flex flex-wrap items-center gap-2 text-xs", children: summaryState.kind === "progress" ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+                /* @__PURE__ */ jsx6("span", { className: "rounded-full bg-[hsl(var(--accent))] px-2.5 py-1 text-[hsl(var(--foreground))]", children: summaryState.label }),
+                /* @__PURE__ */ jsx6("span", { className: "font-mono tracking-[0.25em] text-[hsl(var(--muted-foreground))]", children: summaryState.dots })
+              ] }) : /* @__PURE__ */ jsx6(
+                "span",
+                {
+                  className: cn(
+                    "rounded-full px-2.5 py-1",
+                    summaryState.kind === "complete" && "bg-[hsl(var(--primary)/0.12)] text-[hsl(var(--primary))]",
+                    summaryState.kind === "failed" && "bg-[hsl(var(--destructive)/0.12)] text-[hsl(var(--destructive))]",
+                    summaryState.kind === "interrupted" && "bg-orange-500/12 text-orange-300"
+                  ),
+                  children: summaryState.label
+                }
+              ) })
+            ] }),
+            /* @__PURE__ */ jsx6(
+              ChevronRight,
+              {
+                size: 16,
+                className: "mt-1 shrink-0 text-[hsl(var(--muted-foreground))]",
+                "aria-hidden": "true"
+              }
+            )
+          ] }),
+          summaryState.kind === "complete" && /* @__PURE__ */ jsxs5("div", { className: "flex flex-wrap items-center gap-2 text-xs text-[hsl(var(--muted-foreground))]", children: [
+            /* @__PURE__ */ jsxs5("span", { className: "rounded-full border border-[hsl(var(--border))] px-2.5 py-1", children: [
+              data.selectedSkills.length,
+              " \u4E2A\u6280\u80FD"
+            ] }),
+            /* @__PURE__ */ jsxs5("span", { className: "rounded-full border border-[hsl(var(--border))] px-2.5 py-1", children: [
+              stepCount,
+              " \u4E2A\u6B65\u9AA4"
+            ] }),
+            /* @__PURE__ */ jsxs5("span", { className: "inline-flex items-center gap-1 text-[hsl(var(--muted-foreground))]", children: [
+              /* @__PURE__ */ jsx6(CheckCircle2, { size: 12 }),
+              "\u53F3\u4FA7\u67E5\u770B\u8BE6\u60C5"
+            ] })
+          ] })
+        ]
+      }
+    ),
+    canConfirm && /* @__PURE__ */ jsx6(PlanConfirmationPanel, { onConfirmPlan })
+  ] });
+}
+function PlanConfirmationPanel({
+  onConfirmPlan
+}) {
+  const [isEditing, setIsEditing] = useState4(false);
+  const [revisionText, setRevisionText] = useState4("");
+  const submitRevision = () => {
+    const trimmed = revisionText.trim();
+    if (!trimmed) return;
+    onConfirmPlan?.("revise", trimmed);
+    setRevisionText("");
+    setIsEditing(false);
+  };
+  return /* @__PURE__ */ jsxs5("div", { className: "space-y-3 rounded-xl border border-[hsl(var(--border))] bg-[hsl(var(--background)/0.45)] p-3", children: [
+    /* @__PURE__ */ jsxs5("div", { className: "flex flex-wrap gap-2", children: [
+      /* @__PURE__ */ jsxs5(
+        "button",
+        {
+          type: "button",
+          onClick: () => onConfirmPlan?.("execute"),
+          className: "inline-flex items-center gap-1.5 rounded-lg bg-[hsl(var(--primary))] px-3 py-2 text-sm font-medium text-[hsl(var(--primary-foreground))] transition-opacity hover:opacity-90",
+          children: [
+            /* @__PURE__ */ jsx6(Play, { size: 14 }),
+            "\u5F00\u59CB\u6267\u884C"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs5(
+        "button",
+        {
+          type: "button",
+          onClick: () => setIsEditing((value) => !value),
+          className: "inline-flex items-center gap-1.5 rounded-lg border border-[hsl(var(--border))] px-3 py-2 text-sm text-[hsl(var(--foreground))] transition-colors hover:bg-[hsl(var(--accent))]",
+          children: [
+            /* @__PURE__ */ jsx6(PencilLine, { size: 14 }),
+            "\u4FEE\u6539"
+          ]
+        }
+      )
+    ] }),
+    isEditing && /* @__PURE__ */ jsxs5("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx6(
+        "textarea",
+        {
+          value: revisionText,
+          onChange: (event) => setRevisionText(event.target.value),
+          placeholder: "\u8F93\u5165\u4FEE\u6539\u5EFA\u8BAE...",
+          className: "min-h-24 w-full resize-y rounded-lg border border-[hsl(var(--border))] bg-transparent px-3 py-2 text-sm text-[hsl(var(--foreground))] outline-none placeholder:text-[hsl(var(--muted-foreground))]"
+        }
+      ),
+      /* @__PURE__ */ jsx6("div", { className: "flex justify-end", children: /* @__PURE__ */ jsx6(
+        "button",
+        {
+          type: "button",
+          disabled: !revisionText.trim(),
+          onClick: submitRevision,
+          className: "rounded-lg bg-[hsl(var(--primary))] px-3 py-1.5 text-xs font-medium text-[hsl(var(--primary-foreground))] transition-opacity hover:opacity-90 disabled:opacity-30",
+          children: "\u63D0\u4EA4\u4FEE\u6539\u610F\u89C1"
+        }
+      ) })
+    ] })
+  ] });
+}
+function getSummaryState(data, sessionStatus) {
+  if (sessionStatus === "failed") {
+    return { kind: "failed", label: "\u51FA\u9519" };
+  }
+  if (sessionStatus === "interrupted") {
+    return { kind: "interrupted", label: "\u5DF2\u4E2D\u65AD" };
+  }
+  if (data.parseError) {
+    return { kind: "failed", label: "\u89E3\u6790\u5931\u8D25" };
+  }
+  if (data.hasPlanContent || data.plan != null) {
+    return { kind: "complete", label: "\u5DF2\u751F\u6210" };
+  }
+  if (data.selectedSkills.length > 0) {
+    return { kind: "progress", label: "\u6280\u80FD\u5206\u6790\u4E2D", dots: "\u25CF\u25CF\u25CB" };
+  }
+  if (data.searchResults.length > 0) {
+    return { kind: "progress", label: "\u6280\u80FD\u53D1\u73B0\u4E2D", dots: "\u25CF\u25CB\u25CB" };
+  }
+  return { kind: "progress", label: "\u89C4\u5212\u51C6\u5907\u4E2D", dots: "\u25CB\u25CB\u25CB" };
+}
+function countPlanSteps(plan) {
+  if (!plan) return 0;
+  const countNode = (node) => {
+    const children = Array.isArray(node.children) ? node.children : [];
+    return 1 + children.reduce((total, child) => total + countNode(child), 0);
+  };
+  if (plan.root.id === "plan-root") {
+    const children = Array.isArray(plan.root.children) ? plan.root.children : [];
+    return children.reduce((total, child) => total + countNode(child), 0);
+  }
+  return countNode(plan.root);
+}
+
+// src/react/components/plan/PlanVisualization.tsx
+import { BookOpen as BookOpen2, GitBranch as GitBranch2, Search as Search2 } from "lucide-react";
+import { useMemo as useMemo7, useRef as useRef2, useState as useState6 } from "react";
+
+// src/react/components/plan/phases/PlanTree.tsx
+import {
+  CheckSquare,
+  ChevronRight as ChevronRight3,
+  GitBranch,
+  List,
+  Workflow as Workflow2
+} from "lucide-react";
+import { useCallback, useMemo as useMemo5, useState as useState5 } from "react";
+
+// src/react/components/plan/phases/PlanMindMap.tsx
+import { ChevronRight as ChevronRight2, Workflow } from "lucide-react";
+
+// src/react/components/plan/phases/PlanStatusIcon.tsx
+import { CheckCircle2 as CheckCircle22, Circle, Loader2 as Loader22, XCircle } from "lucide-react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function PlanStatusIcon({
+  status,
+  size = 16
+}) {
+  if (status === "pending") {
+    return /* @__PURE__ */ jsx7(
+      Circle,
+      {
+        size,
+        className: "shrink-0 text-[hsl(var(--muted-foreground))] transition-transform duration-300"
+      }
+    );
+  }
+  if (status === "running") {
+    return /* @__PURE__ */ jsx7(
+      Loader22,
+      {
+        size,
+        className: "shrink-0 animate-spin text-[hsl(var(--primary))] transition-transform duration-300"
+      }
+    );
+  }
+  if (status === "done") {
+    return /* @__PURE__ */ jsx7(
+      CheckCircle22,
+      {
+        size,
+        className: "shrink-0 scale-105 text-green-500 transition-transform duration-300"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx7(
+    XCircle,
+    {
+      size,
+      className: "shrink-0 text-destructive transition-transform duration-300"
+    }
+  );
+}
+
+// src/react/components/plan/phases/PlanMindMap.tsx
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function PlanMindMap({ root, expandedIds, onToggle }) {
+  return /* @__PURE__ */ jsx8("div", { className: "overflow-x-auto py-2", children: /* @__PURE__ */ jsx8(MindMapSubtree, { node: root, expandedIds, onToggle, isRoot: true }) });
+}
+function MindMapSubtree({
+  node,
+  expandedIds,
+  onToggle,
+  isRoot = false
+}) {
+  const children = node.children ?? [];
+  const hasChildren = children.length > 0;
+  const isExpanded = expandedIds.has(node.id);
+  const visibleChildren = hasChildren && isExpanded ? children : [];
+  return /* @__PURE__ */ jsxs6("div", { className: "flex items-center", children: [
+    /* @__PURE__ */ jsx8(
+      "div",
+      {
+        role: hasChildren ? "button" : void 0,
+        tabIndex: hasChildren ? 0 : void 0,
+        "aria-expanded": hasChildren ? isExpanded : void 0,
+        onClick: hasChildren ? () => onToggle(node.id) : void 0,
+        onKeyDown: hasChildren ? (e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            e.preventDefault();
+            onToggle(node.id);
+          }
+        } : void 0,
+        className: cn(
+          "relative z-10 shrink-0 rounded-lg border px-3 py-1.5 text-sm font-medium whitespace-nowrap select-none",
+          hasChildren && "cursor-pointer",
+          isRoot ? "border-[hsl(var(--primary))] bg-[hsl(var(--primary)/0.15)] text-[hsl(var(--primary))]" : node.skillRef ? "border-[hsl(var(--primary)/0.4)] bg-[hsl(var(--primary)/0.08)] text-[hsl(var(--foreground))]" : "border-[hsl(var(--border))] bg-[hsl(var(--card))] text-[hsl(var(--foreground))]"
+        ),
+        children: /* @__PURE__ */ jsxs6("span", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx8(PlanStatusIcon, { status: node.status, size: 14 }),
+          node.skillRef && /* @__PURE__ */ jsx8(Workflow, { size: 12, className: "text-[hsl(var(--primary))]" }),
+          node.label,
+          hasChildren && /* @__PURE__ */ jsx8(
+            ChevronRight2,
+            {
+              size: 14,
+              className: cn(
+                "text-[hsl(var(--muted-foreground))] transition-transform duration-150",
+                isExpanded && "rotate-90"
+              )
+            }
+          ),
+          hasChildren && !isExpanded && /* @__PURE__ */ jsxs6("span", { className: "ml-0.5 rounded-full bg-[hsl(var(--muted))] px-1.5 py-px text-[10px] text-[hsl(var(--muted-foreground))]", children: [
+            "+",
+            children.length
+          ] })
+        ] })
+      }
+    ),
+    visibleChildren.length > 0 && /* @__PURE__ */ jsxs6(Fragment3, { children: [
+      /* @__PURE__ */ jsx8("div", { className: "h-px w-6 shrink-0 bg-[hsl(var(--border))]" }),
+      /* @__PURE__ */ jsx8(VerticalRail, { count: visibleChildren.length, children: visibleChildren.map((child) => /* @__PURE__ */ jsxs6("div", { className: "flex items-center", children: [
+        /* @__PURE__ */ jsx8("div", { className: "h-px w-4 shrink-0 bg-[hsl(var(--border))]" }),
+        /* @__PURE__ */ jsx8(MindMapSubtree, { node: child, expandedIds, onToggle })
+      ] }, child.id)) })
+    ] })
+  ] });
+}
+function VerticalRail({ count, children }) {
+  if (count <= 1) {
+    return /* @__PURE__ */ jsx8("div", { className: "flex flex-col", children });
+  }
+  return /* @__PURE__ */ jsx8("div", { className: "flex flex-col", children: children.map((child, i) => /* @__PURE__ */ jsxs6("div", { className: cn("relative", i > 0 && "pt-1.5"), children: [
+    /* @__PURE__ */ jsx8(
+      "div",
+      {
+        className: "absolute left-0 w-px bg-[hsl(var(--border))]",
+        style: {
+          top: i === 0 ? "50%" : 0,
+          bottom: i === count - 1 ? "50%" : 0
+        }
+      }
+    ),
+    child
+  ] }, i)) });
+}
+
+// src/react/components/plan/phases/PlanTree.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function collectIdsToDepth(node, maxDepth, out) {
+  if (node.depth > maxDepth) return;
+  out.add(node.id);
+  for (const child of node.children ?? []) collectIdsToDepth(child, maxDepth, out);
+}
+function treeFinger(node) {
+  const children = node.children ?? [];
+  if (children.length === 0) return node.label;
+  return `${node.label}[${children.map(treeFinger).join(",")}]`;
+}
+function PlanTree({ root, notes, active }) {
+  return /* @__PURE__ */ jsx9(PlanTreeContent, { root, notes: notes ?? [], active }, treeFinger(root));
+}
+function PlanTreeContent({ root, notes, active }) {
+  const [viewMode, setViewMode] = useState5("mindmap");
+  const defaultExpanded = useMemo5(() => {
+    const ids = /* @__PURE__ */ new Set();
+    collectIdsToDepth(root, 1, ids);
+    return ids;
+  }, [root]);
+  const [expandedIds, setExpandedIds] = useState5(defaultExpanded);
+  const toggle = useCallback((id) => {
+    setExpandedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+  return /* @__PURE__ */ jsx9("div", { className: cn(!active && "pointer-events-none opacity-0"), children: /* @__PURE__ */ jsxs7("div", { className: "flex flex-col gap-3", children: [
+    /* @__PURE__ */ jsx9("div", { className: "flex items-center justify-end", children: /* @__PURE__ */ jsxs7("div", { className: "flex items-center gap-0.5 rounded-lg border border-[hsl(var(--border))] p-0.5", children: [
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          onClick: () => setViewMode("mindmap"),
+          className: cn(
+            "rounded-md p-1.5 transition-colors",
+            viewMode === "mindmap" ? "bg-[hsl(var(--accent))] text-[hsl(var(--foreground))]" : "text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))]"
+          ),
+          title: "\u601D\u7EF4\u5BFC\u56FE",
+          children: /* @__PURE__ */ jsx9(GitBranch, { size: 14 })
+        }
+      ),
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          onClick: () => setViewMode("tree"),
+          className: cn(
+            "rounded-md p-1.5 transition-colors",
+            viewMode === "tree" ? "bg-[hsl(var(--accent))] text-[hsl(var(--foreground))]" : "text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))]"
+          ),
+          title: "\u5217\u8868\u89C6\u56FE",
+          children: /* @__PURE__ */ jsx9(List, { size: 14 })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx9("div", { className: "rounded-xl border border-[hsl(var(--border))] bg-[hsl(var(--card)/0.5)] px-3 py-3", children: viewMode === "mindmap" ? /* @__PURE__ */ jsx9(PlanMindMap, { root, expandedIds, onToggle: toggle }) : /* @__PURE__ */ jsx9(TreeNode, { node: root }) }),
+    notes.length > 0 && /* @__PURE__ */ jsx9("div", { className: "rounded-xl border border-[hsl(var(--border)/0.5)] bg-[hsl(var(--card)/0.5)] px-4 py-3 text-sm text-[hsl(var(--muted-foreground))]", children: notes.map((note, i) => /* @__PURE__ */ jsxs7("p", { className: "py-0.5", children: [
+      /* @__PURE__ */ jsxs7("span", { className: "mr-1.5 text-[hsl(var(--primary)/0.6)]", children: [
+        i + 1,
+        "."
+      ] }),
+      note
+    ] }, i)) })
+  ] }) });
+}
+function TreeNode({ node }) {
+  const children = node.children ?? [];
+  const hasChildren = children.length > 0;
+  return /* @__PURE__ */ jsxs7("div", { children: [
+    /* @__PURE__ */ jsxs7(
+      "div",
+      {
+        className: "group flex min-w-0 items-center gap-2 rounded-md px-2 py-2 hover:bg-[hsl(var(--accent)/0.5)]",
+        style: { paddingLeft: `${node.depth * 24 + 10}px` },
+        children: [
+          hasChildren ? /* @__PURE__ */ jsx9(
+            ChevronRight3,
+            {
+              size: 16,
+              className: "shrink-0 rotate-90 text-[hsl(var(--muted-foreground)/0.6)]"
+            }
+          ) : /* @__PURE__ */ jsx9("span", { className: "w-4 shrink-0" }),
+          /* @__PURE__ */ jsx9(PlanStatusIcon, { status: node.status }),
+          node.skillRef ? /* @__PURE__ */ jsx9(Workflow2, { size: 15, className: "shrink-0 text-[hsl(var(--primary))]" }) : /* @__PURE__ */ jsx9(CheckSquare, { size: 15, className: "shrink-0 text-[hsl(var(--muted-foreground))]" }),
+          /* @__PURE__ */ jsx9("span", { className: "min-w-0 flex-1 truncate text-[15px] font-medium text-[hsl(var(--foreground))]", children: node.label }),
+          node.skillRef && /* @__PURE__ */ jsx9("span", { className: "ml-auto max-w-[160px] shrink-0 truncate rounded bg-[hsl(var(--primary)/0.1)] px-2 py-0.5 text-sm font-medium text-[hsl(var(--primary)/0.8)]", children: node.skillRef })
+        ]
+      }
+    ),
+    hasChildren && /* @__PURE__ */ jsxs7("div", { className: "relative", children: [
+      /* @__PURE__ */ jsx9(
+        "div",
+        {
+          className: "absolute bottom-1 top-0 w-px bg-[hsl(var(--border)/0.4)]",
+          style: { left: `${node.depth * 24 + 18}px` }
+        }
+      ),
+      children.map((child) => /* @__PURE__ */ jsx9(TreeNode, { node: child }, child.id))
+    ] })
+  ] });
+}
+
+// src/react/components/plan/phases/SkillAnalysis.tsx
+import { BookOpen, Link2 } from "lucide-react";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function planSkillDisplayName(skill) {
+  return skill.displayName?.trim() || skill.skillId;
+}
+function extractSteps(content) {
+  return content.split("\n").filter((line) => /^\d+\.\s/.test(line.trim())).map((line) => line.trim().replace(/^\d+\.\s*/, "")).slice(0, 5);
+}
+function SkillAnalysis({ skills: rawSkills, active }) {
+  const skills = Array.isArray(rawSkills) ? rawSkills : [];
+  return /* @__PURE__ */ jsx10(
+    "div",
+    {
+      className: cn(
+        "transition-opacity duration-500",
+        active ? "opacity-100" : "pointer-events-none opacity-0"
+      ),
+      children: /* @__PURE__ */ jsx10("div", { className: "columns-2 gap-4", children: skills.map((skill) => {
+        const steps = skill.content ? extractSteps(skill.content) : [];
+        return /* @__PURE__ */ jsxs8(
+          "div",
+          {
+            className: "mb-4 break-inside-avoid overflow-hidden rounded-xl border border-[hsl(var(--primary)/0.4)] bg-[hsl(var(--card))] shadow-lg shadow-[hsl(var(--primary)/0.05)] transition-all duration-500",
+            children: [
+              /* @__PURE__ */ jsxs8("div", { className: "flex items-center gap-2 px-4 py-3", children: [
+                /* @__PURE__ */ jsx10(BookOpen, { size: 15, className: "shrink-0 text-[hsl(var(--primary))]" }),
+                /* @__PURE__ */ jsx10("span", { className: "min-w-0 truncate text-[15px] font-semibold text-[hsl(var(--foreground))]", children: planSkillDisplayName(skill) })
+              ] }),
+              /* @__PURE__ */ jsx10("div", { className: "border-t border-[hsl(var(--border)/0.5)] px-4 py-2.5", children: /* @__PURE__ */ jsx10("p", { className: "text-sm leading-relaxed text-[hsl(var(--muted-foreground))]", children: skill.description }) }),
+              /* @__PURE__ */ jsxs8("div", { className: "border-t border-[hsl(var(--border)/0.5)] px-4 py-2.5", children: [
+                skill.references && skill.references.length > 0 && /* @__PURE__ */ jsx10("div", { className: "mb-2 flex flex-wrap gap-1.5", children: skill.references.map((ref, refIdx) => /* @__PURE__ */ jsxs8(
+                  "span",
+                  {
+                    className: "inline-flex items-center gap-1 rounded-md bg-[hsl(var(--primary)/0.1)] px-2 py-0.5 text-xs text-[hsl(var(--primary))]",
+                    children: [
+                      /* @__PURE__ */ jsx10(Link2, { size: 10 }),
+                      ref
+                    ]
+                  },
+                  `${refIdx}-${ref}`
+                )) }),
+                steps.length > 0 && /* @__PURE__ */ jsx10("ol", { className: "list-inside list-decimal space-y-0.5 text-sm leading-relaxed text-[hsl(var(--muted-foreground)/0.8)]", children: steps.map((step, idx) => /* @__PURE__ */ jsx10("li", { children: step }, idx)) })
+              ] })
+            ]
+          },
+          skill.skillId
+        );
+      }) })
+    }
+  );
+}
+
+// src/react/components/plan/phases/SkillDiscovery.tsx
+import { CheckCircle2 as CheckCircle23, Search, Sparkles as Sparkles2 } from "lucide-react";
+import { useMemo as useMemo6 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function sizeClass(name) {
+  const hash = name.split("").reduce((acc, c) => acc + c.charCodeAt(0), 0);
+  const sizes = ["text-xs", "text-sm", "text-[15px]"];
+  return sizes[hash % sizes.length];
+}
+function planSkillDisplayName2(skill) {
+  return skill.displayName?.trim() || skill.skillId;
+}
+function SkillDiscovery({
+  intent,
+  searchResults: rawSearchResults,
+  selectedSkills: rawSelectedSkills,
+  allSkillNames: rawAllSkillNames,
+  active
+}) {
+  const searchResults = Array.isArray(rawSearchResults) ? rawSearchResults : [];
+  const selectedSkills = Array.isArray(rawSelectedSkills) ? rawSelectedSkills : [];
+  const allSkillNames = Array.isArray(rawAllSkillNames) ? rawAllSkillNames : [];
+  const searchNames = useMemo6(() => new Set(searchResults.map((s) => s.skillId)), [searchResults]);
+  const selectedNames = useMemo6(
+    () => new Set(selectedSkills.map((s) => s.skillId)),
+    [selectedSkills]
+  );
+  const cloudItems = useMemo6(() => {
+    const bgItems = allSkillNames.filter((skill) => !searchNames.has(skill.skillId)).map((skill) => ({
+      name: planSkillDisplayName2(skill),
+      key: `bg:${skill.skillId}`,
+      isSearch: false,
+      isSelected: false
+    }));
+    const searchItems = searchResults.map((s) => ({
+      name: planSkillDisplayName2(s),
+      key: `search:${s.skillId}`,
+      isSearch: true,
+      isSelected: selectedNames.has(s.skillId)
+    }));
+    const result = [...bgItems];
+    for (let i = 0; i < searchItems.length; i++) {
+      const insertAt = Math.round((i + 1) / (searchItems.length + 1) * result.length);
+      result.splice(insertAt, 0, searchItems[i]);
+    }
+    return result;
+  }, [allSkillNames, searchNames, searchResults, selectedNames]);
+  return /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      className: cn(
+        "flex h-full flex-col gap-6 transition-opacity duration-500",
+        active ? "opacity-100" : "pointer-events-none opacity-0"
+      ),
+      children: [
+        /* @__PURE__ */ jsxs9("div", { className: "flex shrink-0 max-w-md self-center flex-col items-center gap-2.5 rounded-2xl border border-[hsl(var(--primary)/0.4)] bg-[hsl(var(--primary)/0.08)] px-6 py-5 text-center shadow-lg shadow-[hsl(var(--primary)/0.1)]", children: [
+          /* @__PURE__ */ jsx11(Sparkles2, { size: 20, className: "text-[hsl(var(--primary))]" }),
+          /* @__PURE__ */ jsx11("p", { className: "break-words text-[15px] leading-relaxed text-[hsl(var(--foreground))]", children: intent })
+        ] }),
+        /* @__PURE__ */ jsx11("div", { className: "flex min-h-0 flex-1 flex-wrap content-start items-start justify-center gap-x-4 gap-y-3 overflow-y-auto px-6 pb-6", children: cloudItems.map((item) => {
+          if (item.isSearch && item.isSelected) {
+            return /* @__PURE__ */ jsxs9(
+              "span",
+              {
+                className: "inline-flex items-center gap-1.5 rounded-lg border border-[hsl(var(--primary)/0.5)] bg-[hsl(var(--primary)/0.12)] px-3 py-1.5 text-[15px] font-medium text-[hsl(var(--primary))] shadow-md shadow-[hsl(var(--primary)/0.15)] transition-all duration-500",
+                children: [
+                  /* @__PURE__ */ jsx11(CheckCircle23, { size: 14, className: "shrink-0" }),
+                  item.name
+                ]
+              },
+              item.key
+            );
+          }
+          if (item.isSearch) {
+            return /* @__PURE__ */ jsxs9(
+              "span",
+              {
+                className: "inline-flex items-center gap-1.5 rounded-lg border border-[hsl(var(--foreground)/0.3)] bg-[hsl(var(--foreground)/0.08)] px-3 py-1.5 text-[15px] font-medium text-[hsl(var(--foreground))] transition-all duration-500",
+                children: [
+                  /* @__PURE__ */ jsx11(Search, { size: 14, className: "shrink-0" }),
+                  item.name
+                ]
+              },
+              item.key
+            );
+          }
+          return /* @__PURE__ */ jsx11(
+            "span",
+            {
+              className: cn(
+                "select-none font-medium text-[hsl(var(--foreground)/0.45)] transition-all duration-500",
+                sizeClass(item.name)
+              ),
+              children: item.name
+            },
+            item.key
+          );
+        }) })
+      ]
+    }
+  );
+}
+
+// src/react/components/plan/PlanVisualization.tsx
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+var PHASE_LABELS = [
+  { key: "discovering", label: "\u6280\u80FD\u53D1\u73B0", icon: Search2 },
+  { key: "analyzing", label: "\u6280\u80FD\u5206\u6790", icon: BookOpen2 },
+  { key: "generating", label: "\u8BA1\u5212\u751F\u6210", icon: GitBranch2 }
+];
+function getLatestPhaseIndex(data) {
+  if (data.plan != null || data.hasPlanContent) return 2;
+  if (data.selectedSkills.length > 0) return 1;
+  if (data.searchResults.length > 0) return 0;
+  return -1;
+}
+function PlanVisualization({
+  messages: rawMessages,
+  allSkillNames: rawAllSkillNames = [],
+  onAnswer,
+  sessionStatus,
+  isStreaming = false
+}) {
+  const messages = Array.isArray(rawMessages) ? rawMessages : [];
+  const allSkillNames = Array.isArray(rawAllSkillNames) ? rawAllSkillNames : [];
+  const data = useMemo7(() => parsePlanMessages(messages), [messages]);
+  const latestIdx = getLatestPhaseIndex(data);
+  const isWaitingForInput = sessionStatus === "waiting_for_input";
+  const hasError = sessionStatus === "failed";
+  const isInterrupted = sessionStatus === "interrupted";
+  const isSessionActive = isStreaming || sessionStatus === "created" || sessionStatus === "running" || sessionStatus === "waiting_for_input";
+  const activeStatusIdx = latestIdx >= 0 ? latestIdx : 0;
+  const latestAskQuestion = data.askQuestions[data.askQuestions.length - 1];
+  const hasPhaseData = latestIdx >= 0;
+  const showAskQuestion = latestAskQuestion && isWaitingForInput && data.lastPauseTool === "AskUserQuestion" && onAnswer;
+  const [selectedTab, setSelectedTab] = useState6(null);
+  const prevLatestRef = useRef2(latestIdx);
+  if (latestIdx < prevLatestRef.current) {
+    setSelectedTab(null);
+  }
+  prevLatestRef.current = latestIdx;
+  const activeSelectedTab = selectedTab != null && selectedTab <= latestIdx ? selectedTab : null;
+  const viewIdx = activeSelectedTab ?? latestIdx;
+  return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col gap-4 rounded-2xl border border-[hsl(var(--border))] bg-[hsl(var(--card)/0.4)] p-5", children: [
+    hasPhaseData && /* @__PURE__ */ jsxs10(Fragment4, { children: [
+      /* @__PURE__ */ jsxs10("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsx12("div", { className: "flex items-center gap-1", children: PHASE_LABELS.map((p, i) => {
+          const Icon = p.icon;
+          const isViewing = viewIdx === i;
+          const isDone = latestIdx > i;
+          const isStatusPhase = i === activeStatusIdx && (hasError || isInterrupted);
+          const tabHasData = i === 0 && data.searchResults.length > 0 || i === 1 && data.selectedSkills.length > 0 || i === 2 && (data.plan != null || data.hasPlanContent);
+          const isReachable = i <= latestIdx || tabHasData;
+          return /* @__PURE__ */ jsxs10("div", { className: "flex items-center", children: [
+            i > 0 && /* @__PURE__ */ jsx12(
+              "div",
+              {
+                className: cn(
+                  "mx-1.5 h-px w-6 transition-colors duration-300",
+                  isDone && !isStatusPhase ? "bg-[hsl(var(--primary))]" : "bg-[hsl(var(--border))]"
+                )
+              }
+            ),
+            /* @__PURE__ */ jsxs10(
+              "button",
+              {
+                type: "button",
+                disabled: !isReachable,
+                onClick: () => isReachable && setSelectedTab(i === latestIdx ? null : i),
+                className: cn(
+                  "flex items-center gap-2 rounded-full px-3.5 py-2 text-sm font-medium transition-all duration-300",
+                  isViewing && "bg-[hsl(var(--primary)/0.15)] text-[hsl(var(--primary))]",
+                  !isViewing && isDone && "text-[hsl(var(--primary)/0.6)] hover:bg-[hsl(var(--primary)/0.08)]",
+                  !isReachable && "cursor-default text-[hsl(var(--muted-foreground))]",
+                  isReachable && !isViewing && !isDone && tabHasData && "text-[hsl(var(--primary)/0.5)] hover:bg-[hsl(var(--primary)/0.08)]",
+                  isReachable && !isViewing && !isDone && !tabHasData && "text-[hsl(var(--muted-foreground))]"
+                ),
+                children: [
+                  /* @__PURE__ */ jsx12(Icon, { size: 12 }),
+                  p.label,
+                  latestIdx === i && isSessionActive && activeSelectedTab === null && /* @__PURE__ */ jsx12(
+                    "span",
+                    {
+                      className: cn(
+                        "h-1.5 w-1.5 animate-pulse rounded-full",
+                        hasError ? "bg-[hsl(var(--destructive))]" : isInterrupted ? "bg-orange-400" : "bg-[hsl(var(--primary))]"
+                      )
+                    }
+                  ),
+                  isStatusPhase && latestIdx !== i && /* @__PURE__ */ jsx12(
+                    "span",
+                    {
+                      className: cn(
+                        "h-1.5 w-1.5 rounded-full",
+                        hasError ? "bg-[hsl(var(--destructive))]" : "bg-orange-400"
+                      )
+                    }
+                  )
+                ]
+              }
+            )
+          ] }, p.key);
+        }) }),
+        /* @__PURE__ */ jsxs10("div", { className: "flex items-center gap-1", children: [
+          hasError && /* @__PURE__ */ jsx12("span", { className: "rounded-full bg-[hsl(var(--destructive)/0.12)] px-2.5 py-1 text-xs font-medium text-[hsl(var(--destructive))]", children: "\u51FA\u9519" }),
+          isInterrupted && /* @__PURE__ */ jsx12("span", { className: "rounded-full bg-orange-500/10 px-2.5 py-1 text-xs font-medium text-orange-300", children: "\u5DF2\u4E2D\u65AD" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { className: "min-h-0", children: [
+        viewIdx === 0 && /* @__PURE__ */ jsx12(
+          SkillDiscovery,
+          {
+            intent: data.intent,
+            searchResults: data.searchResults,
+            selectedSkills: data.selectedSkills,
+            allSkillNames,
+            active: true
+          }
+        ),
+        viewIdx === 1 && /* @__PURE__ */ jsx12(SkillAnalysis, { skills: data.selectedSkills, active: true }),
+        viewIdx === 2 && (data.plan != null ? /* @__PURE__ */ jsx12(PlanTree, { root: data.plan.root, notes: data.plan.notes, active: true }) : data.parseError ? /* @__PURE__ */ jsx12("div", { className: "flex min-h-[240px] items-center justify-center rounded-xl border border-[hsl(var(--destructive)/0.35)] bg-[hsl(var(--destructive)/0.08)] px-6 text-sm text-[hsl(var(--destructive))]", children: data.parseError }) : data.hasPlanContent ? /* @__PURE__ */ jsx12("div", { className: "flex min-h-[240px] items-center justify-center rounded-xl border border-dashed border-[hsl(var(--border))] bg-[hsl(var(--card)/0.3)] px-6 text-sm text-[hsl(var(--muted-foreground))]", children: "\u8BA1\u5212\u89E3\u6790\u4E2D..." }) : null)
+      ] })
+    ] }),
+    !hasPhaseData && showAskQuestion && /* @__PURE__ */ jsx12(AskUserQuestionBlock, { data: latestAskQuestion.data, answered: false, toolCallId: latestAskQuestion.toolCallId, sessionStatus: sessionStatus ?? "", onAnswer }),
+    hasPhaseData && showAskQuestion && /* @__PURE__ */ jsx12(AskUserQuestionBlock, { data: latestAskQuestion.data, answered: false, toolCallId: latestAskQuestion.toolCallId, sessionStatus: sessionStatus ?? "", onAnswer })
+  ] });
+}
+export {
+  PlanSummaryCard,
+  PlanVisualization,
+  downloadPlanLog,
+  exportPlanLog,
+  extractLatestPlanMessages,
+  parsePlanMessages
+};
+//# sourceMappingURL=index.js.map