@blade-hq/agent-kit 0.4.5 → 0.4.6

package/dist/chunk-4VWLTG5L.js

@@ -0,0 +1,2984 @@
+import {
+  tapBridgeEvent
+} from "./chunk-J3XVFPOV.js";
+import {
+  BladeClient
+} from "./chunk-OKQWPNE3.js";
+import {
+  createClientActions,
+  useCardStateStore
+} from "./chunk-JCJFFJ42.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/react/api/partner-skill.ts
+var partner_skill_exports = {};
+__export(partner_skill_exports, {
+  installPartnerSkill: () => installPartnerSkill
+});
+
+// src/react/api/skills.ts
+var skills_exports = {};
+__export(skills_exports, {
+  getGlobalSkillStats: () => getGlobalSkillStats,
+  getSkill: () => getSkill,
+  getSkillStats: () => getSkillStats,
+  installPartnerSkill: () => installPartnerSkill,
+  listSessionSkills: () => listSessionSkills,
+  listSkills: () => listSkills,
+  resyncSkills: () => resyncSkills,
+  searchSkills: () => searchSkills
+});
+var r = () => getClient().skills;
+var listSkills = (...args) => r().listSkills(...args);
+var listSessionSkills = (...args) => r().listSessionSkills(...args);
+var resyncSkills = (...args) => r().resyncSkills(...args);
+var searchSkills = (...args) => r().searchSkills(...args);
+var getSkillStats = (...args) => r().getSkillStats(...args);
+var getGlobalSkillStats = (...args) => r().getGlobalSkillStats(...args);
+var getSkill = (...args) => r().getSkill(...args);
+var installPartnerSkill = (...args) => r().installPartnerSkill(...args);
+
+// src/react/schemas/partner-skill.ts
+import { type } from "arktype";
+var PartnerSkillName = type("/^[a-z0-9-]+\\/[a-z0-9-]+$/");
+var PartnerSkillFile = type({
+  path: "string > 0",
+  content: "string"
+});
+var PartnerSkillInstallPayload = type({
+  name: PartnerSkillName,
+  files: PartnerSkillFile.array().atLeastLength(1)
+});
+var PartnerSkillInstallResult = type({
+  name: PartnerSkillName,
+  skill_dir: "string",
+  file_count: "number.integer >= 0",
+  overwritten: "boolean"
+});
+function parsePartnerSkillInstallPayload(payload) {
+  const parsed = PartnerSkillInstallPayload.assert(payload);
+  if (!parsed.files.some((file) => file.path === "SKILL.md")) {
+    throw new Error("installSkill payload must include SKILL.md");
+  }
+  return parsed;
+}
+
+// src/react/stores/ui-bridge-store.ts
+import { create } 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 = create()((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/resource-bridge.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function hasUserActivation() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  return navigator.userActivation?.isActive === true;
+}
+var BRIDGE_ACTIONS = ["addContext", "appendInput", "sendMessage"];
+function isBridgeAction(action) {
+  return BRIDGE_ACTIONS.includes(action);
+}
+function resourceBridgeDispatch({
+  sessionId,
+  activeSessionId,
+  isStreaming,
+  action,
+  payload
+}) {
+  if (!sessionId || !activeSessionId || sessionId !== activeSessionId) {
+    return false;
+  }
+  if (!isBridgeAction(action)) {
+    return false;
+  }
+  const bridgeStore = useUiBridgeStore.getState();
+  if (action === "addContext") {
+    if (!isRecord(payload)) return false;
+    const content = getNonEmptyString(payload.content);
+    const label = getNonEmptyString(payload.label);
+    if (!content || !label) return false;
+    bridgeStore.addPendingContext(sessionId, { content, label });
+    return true;
+  }
+  if (action === "appendInput") {
+    if (!isRecord(payload)) return false;
+    const text = getNonEmptyString(payload.text);
+    if (!text) return false;
+    bridgeStore.addDraftAppend(sessionId, text);
+    return true;
+  }
+  if (isStreaming || !hasUserActivation()) {
+    return false;
+  }
+  bridgeStore.addSendRequest(sessionId);
+  return true;
+}
+
+// src/react/lib/parent-bridge.ts
+function invalidateSkillStats(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["skill-stats", sessionId] });
+}
+var HOST_BRIDGE_ACTIONS = ["addContext", "appendInput", "sendMessage"];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAllowedBridgeAction(action) {
+  return HOST_BRIDGE_ACTIONS.includes(action);
+}
+function isBladeBridgeEnvelope(value) {
+  return isRecord2(value) && value.__bladeBridge === true && typeof value.action === "string" && (value.direction === "agent-to-host" || value.direction === "host-to-agent");
+}
+function isLegacyResourceBridgeEnvelope(value) {
+  return isRecord2(value) && value.__resourceBridge === true && typeof value.action === "string";
+}
+function toBridgeActionEnvelope(value) {
+  if (isBladeBridgeEnvelope(value)) {
+    return {
+      action: value.action,
+      payload: value.payload,
+      direction: value.direction,
+      canonical: true
+    };
+  }
+  if (isLegacyResourceBridgeEnvelope(value)) {
+    return { action: value.action, payload: value.payload, canonical: false };
+  }
+  return null;
+}
+function isInsideIframe() {
+  return typeof window !== "undefined" && window.parent !== window;
+}
+function postToParent(envelope) {
+  if (!isInsideIframe()) {
+    return;
+  }
+  tapBridgeEvent({
+    side: "agent",
+    direction: "agent-to-host",
+    action: envelope.action,
+    payload: envelope.payload,
+    meta: envelope.meta
+  });
+  try {
+    window.parent.postMessage(envelope, "*");
+  } catch (error) {
+    console.debug("[parent-bridge] failed to post message to parent", error);
+  }
+}
+function attachHostBridgeListener(getState) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const listener = (event) => {
+    const envelope = toBridgeActionEnvelope(event.data);
+    if (!envelope) {
+      return;
+    }
+    const { sessionId, activeSessionId, isStreaming } = getState();
+    const tap = (note, rejected) => {
+      tapBridgeEvent({
+        side: "agent",
+        direction: envelope.direction ?? "host-to-agent",
+        action: envelope.action,
+        payload: envelope.payload,
+        meta: { canonical: envelope.canonical, sessionId: sessionId ?? null },
+        note,
+        rejected
+      });
+    };
+    if (!sessionId) {
+      tap("ignored: no active session", true);
+      return;
+    }
+    switch (envelope.action) {
+      case "installSkill":
+        if (!envelope.canonical || envelope.direction !== "host-to-agent") {
+          tap(
+            "installSkill rejected: requires __bladeBridge envelope with direction=host-to-agent",
+            true
+          );
+          console.warn(
+            "[parent-bridge] installSkill rejected: requires __bladeBridge envelope with direction=host-to-agent"
+          );
+          return;
+        }
+        tap(void 0, false);
+        try {
+          const payload = parsePartnerSkillInstallPayload(envelope.payload);
+          void installPartnerSkill(sessionId, payload).then(() => {
+            invalidateSkillStats(sessionId);
+          }).catch((error) => {
+            console.warn("[parent-bridge] installSkill request failed", error);
+          });
+        } catch (error) {
+          console.warn("[parent-bridge] invalid installSkill payload", error);
+        }
+        return;
+      default:
+        if (!isAllowedBridgeAction(envelope.action)) {
+          tap(`rejected: action not in allowlist [${HOST_BRIDGE_ACTIONS.join(", ")}]`, true);
+          return;
+        }
+        tap(void 0, false);
+    }
+    resourceBridgeDispatch({
+      sessionId,
+      activeSessionId,
+      isStreaming,
+      action: envelope.action,
+      payload: envelope.payload
+    });
+  };
+  window.addEventListener("message", listener);
+  return () => {
+    window.removeEventListener("message", listener);
+  };
+}
+
+// src/react/lib/chat.ts
+var SYSTEM_REMINDER_PATTERN = /^<system-reminder>\s*[\s\S]*?\s*<\/system-reminder>$/i;
+var LEGACY_FORK_CONTEXT_MARKERS = [
+  "\u7236\u667A\u80FD\u4F53\u5728\u6D3E\u751F\u4F60\u4E4B\u524D\u5DF2\u7ECF\u5B8C\u6210\u4E86\u4E00\u4E9B\u64CD\u4F5C\u3002",
+  "\u53EF\u901A\u8FC7 `read_file` \u8BFB\u53D6\u3002",
+  "# \u4F60\u7684\u4EFB\u52A1"
+];
+function normalizeMessageContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content;
+  return String(content ?? "");
+}
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function isSystemReminderText(text) {
+  return SYSTEM_REMINDER_PATTERN.test(text.trim());
+}
+function isLegacyForkContextText(text) {
+  const normalized = text.trim();
+  return LEGACY_FORK_CONTEXT_MARKERS.every((marker) => normalized.includes(marker));
+}
+function isHiddenInternalMessage(message) {
+  if (message.role !== "user") return false;
+  const text = getTextContent(normalizeMessageContent(message.content));
+  return isSystemReminderText(text) || isLegacyForkContextText(text);
+}
+function buildMessageContent(text, attachments) {
+  if (attachments.length === 0) return text;
+  const textSegments = [];
+  if (text.trim()) {
+    textSegments.push(text);
+  }
+  for (const attachment of attachments) {
+    let fileText;
+    if (attachment.uploadedPath) {
+      const displayName = attachment.uploadedPath.split("/").pop() || attachment.name;
+      fileText = `[\u9644\u4EF6: ${displayName}] \u5DF2\u4E0A\u4F20\u5230\u5DE5\u4F5C\u533A\u8DEF\u5F84: ${attachment.uploadedPath}`;
+    } else if (attachment.textContent) {
+      const MAX_TEXT_CHARS = 1e5;
+      const content = attachment.textContent.length > MAX_TEXT_CHARS ? `${attachment.textContent.slice(0, MAX_TEXT_CHARS)}
+
+[\u5185\u5BB9\u5DF2\u622A\u65AD\uFF0C\u539F\u59CB\u5171 ${attachment.textContent.length} \u5B57\u7B26]` : attachment.textContent;
+      fileText = `[\u9644\u4EF6: ${attachment.name}]
+${content}`;
+    } else {
+      fileText = `[\u9644\u4EF6: ${attachment.name}]`;
+    }
+    textSegments.push(fileText);
+  }
+  return textSegments.join("\n\n");
+}
+function contentPreview(content, maxLen = 80) {
+  const text = getTextContent(content).trim();
+  return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+}
+function transformSlashCommand(skillName, rawInput) {
+  const prompt = rawInput.replace(`<skill>${skillName}</skill>`, "").trim();
+  return prompt ? `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1
+${prompt}` : `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1`;
+}
+var ATTACHMENT_TAG_RE = /\[附件:\s*([^\]]+)\](?:[ \t]*已上传到工作区路径:[ \t]*([^\r\n]+))?/g;
+var CONTEXT_PART_RE = /^\[上下文:\s*([^\]]+)\]\n([\s\S]*)$/;
+function extractTextAttachments(content) {
+  if (typeof content === "string") {
+    const attachments2 = [];
+    const contexts2 = [];
+    const ctxMatch = CONTEXT_PART_RE.exec(content);
+    let working = content;
+    if (ctxMatch) {
+      contexts2.push({ label: ctxMatch[1].trim(), content: ctxMatch[2].trim() });
+      working = "";
+    }
+    for (const match of working.matchAll(ATTACHMENT_TAG_RE)) {
+      attachments2.push({
+        name: match[1].trim(),
+        uploadedPath: match[2]?.trim() || void 0
+      });
+    }
+    return {
+      cleanText: working.replace(ATTACHMENT_TAG_RE, "").trim(),
+      attachments: attachments2,
+      contexts: contexts2
+    };
+  }
+  const attachments = [];
+  const contexts = [];
+  const cleanParts = [];
+  for (const part of content) {
+    if (part.type !== "text") continue;
+    const ctxMatch = CONTEXT_PART_RE.exec(part.text);
+    if (ctxMatch) {
+      contexts.push({ label: ctxMatch[1].trim(), content: ctxMatch[2].trim() });
+      continue;
+    }
+    let hasAttachment = false;
+    for (const match of part.text.matchAll(ATTACHMENT_TAG_RE)) {
+      attachments.push({
+        name: match[1].trim(),
+        uploadedPath: match[2]?.trim() || void 0
+      });
+      hasAttachment = true;
+    }
+    if (hasAttachment) {
+      const remaining = part.text.replace(ATTACHMENT_TAG_RE, "").trim();
+      if (remaining) cleanParts.push(remaining);
+    } else {
+      cleanParts.push(part.text);
+    }
+  }
+  return { cleanText: cleanParts.join("\n").trim(), attachments, contexts };
+}
+function getImageParts(content) {
+  if (typeof content === "string") return [];
+  return content.filter((part) => part.type === "image_url");
+}
+function getFileParts(content) {
+  if (typeof content === "string") return [];
+  return content.filter((part) => part.type === "file");
+}
+function groupMessagesByLoop(messages) {
+  const groups = [];
+  let currentGroup = null;
+  for (const msg of messages) {
+    const loop = msg.loop_name ?? "root";
+    if (loop === "root") {
+      currentGroup = { root: msg, childLoops: [] };
+      groups.push(currentGroup);
+    } else {
+      if (!currentGroup) {
+        currentGroup = { root: null, childLoops: [] };
+        groups.push(currentGroup);
+      }
+      const existingLoop = currentGroup.childLoops.find((l) => l.loopName === loop);
+      if (existingLoop) {
+        existingLoop.messages.push(msg);
+      } else {
+        currentGroup.childLoops.push({ loopName: loop, messages: [msg] });
+      }
+    }
+  }
+  return groups;
+}
+
+// src/react/lib/analytics.ts
+var analyticsClient = null;
+function setAnalyticsClient(client) {
+  analyticsClient = client;
+}
+function trackEvent(name, props = {}) {
+  analyticsClient?.capture(name, props);
+}
+
+// src/react/lib/tool-preview.ts
+function buildToolPreviewKey(content, type2, toolCallId) {
+  if (type2 === "resource-uri") {
+    return `tool-preview-uri:${content}`;
+  }
+  return `tool-preview:${toolCallId}`;
+}
+
+// src/react/lib/ui-meta.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isUiMeta(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const raw = value;
+  if (raw.target !== "inline" && raw.target !== "preview") {
+    return false;
+  }
+  if (!isPositiveNumber(raw.height)) {
+    return false;
+  }
+  if (!isNonEmptyString(raw.resourceHTML) && !isNonEmptyString(raw.resourceUri) && !isNonEmptyString(raw.resourceURI)) {
+    return false;
+  }
+  if (raw.title != null && !isNonEmptyString(raw.title)) {
+    return false;
+  }
+  return true;
+}
+
+// src/react/stores/auth-store.ts
+import { create as create6 } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+// src/react/api/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getMe: () => getMe,
+  getProviders: () => getProviders,
+  logout: () => logout
+});
+var r2 = () => getClient().auth;
+var getProviders = (...args) => r2().getProviders(...args);
+var getMe = (...args) => r2().getMe(...args);
+var logout = (...args) => r2().logout(...args);
+
+// src/react/sockets/socket-state.ts
+var agentSocket = null;
+function setAgentSocket(nextSocket) {
+  agentSocket = nextSocket;
+}
+function getSocket() {
+  if (!agentSocket) throw new Error("Socket not initialized. Call bootstrapBladeClient() first.");
+  return agentSocket;
+}
+
+// src/react/stores/session-store.ts
+import { create as create5 } from "zustand";
+
+// src/react/api/sessions.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  checkoutSession: () => checkoutSession,
+  copyFile: () => copyFile,
+  createSession: () => createSession,
+  createSessionWithRequest: () => createSessionWithRequest,
+  createShare: () => createShare,
+  deleteFile: () => deleteFile,
+  deleteSession: () => deleteSession,
+  exportSession: () => exportSession,
+  getBackgroundTask: () => getBackgroundTask,
+  getDownloadDirUrl: () => getDownloadDirUrl,
+  getSession: () => getSession,
+  getSessionCheckpoints: () => getSessionCheckpoints,
+  getSessionContextStats: () => getSessionContextStats,
+  getSessionHistory: () => getSessionHistory,
+  getSessionTasks: () => getSessionTasks,
+  getSessionTurns: () => getSessionTurns,
+  getSharedSession: () => getSharedSession,
+  importSession: () => importSession,
+  listBackgroundTasks: () => listBackgroundTasks,
+  listDir: () => listDir,
+  listSessions: () => listSessions,
+  listSessionsPaginated: () => listSessionsPaginated,
+  listSessionsWithSkillData: () => listSessionsWithSkillData,
+  pinSession: () => pinSession,
+  previewImport: () => previewImport,
+  renameFile: () => renameFile,
+  revokeShare: () => revokeShare,
+  rewindSession: () => rewindSession,
+  shareFile: () => shareFile,
+  startReplaySession: () => startReplaySession,
+  stopBackgroundTask: () => stopBackgroundTask,
+  switchBranch: () => switchBranch,
+  tokenizeMessages: () => tokenizeMessages,
+  tokenizePrompt: () => tokenizePrompt,
+  updateReplaySession: () => updateReplaySession,
+  updateSession: () => updateSession,
+  updateSessionMemory: () => updateSessionMemory,
+  updateSharing: () => updateSharing,
+  uploadFiles: () => uploadFiles,
+  writeFile: () => writeFile
+});
+var r3 = () => getClient().sessions;
+var listSessions = (...args) => r3().listSessions(...args);
+var listSessionsPaginated = (...args) => r3().listSessionsPaginated(...args);
+var listSessionsWithSkillData = (...args) => r3().listSessionsWithSkillData(...args);
+var createSession = (...args) => r3().createSession(...args);
+var createSessionWithRequest = (...args) => r3().createSessionWithRequest(...args);
+var getSession = (...args) => r3().getSession(...args);
+var updateSession = (...args) => r3().updateSession(...args);
+var pinSession = (...args) => r3().pinSession(...args);
+var startReplaySession = (...args) => r3().startReplaySession(...args);
+var updateReplaySession = (...args) => r3().updateReplaySession(...args);
+var updateSharing = (...args) => r3().updateSharing(...args);
+var updateSessionMemory = (...args) => r3().updateSessionMemory(...args);
+var createShare = (...args) => r3().createShare(...args);
+var revokeShare = (...args) => r3().revokeShare(...args);
+var getSharedSession = (...args) => r3().getSharedSession(...args);
+var getSessionTasks = (...args) => r3().getSessionTasks(...args);
+var getSessionTurns = (...args) => r3().getSessionTurns(...args);
+var getSessionContextStats = (...args) => r3().getSessionContextStats(...args);
+var getSessionHistory = (...args) => r3().getSessionHistory(...args);
+var tokenizePrompt = (...args) => r3().tokenizePrompt(...args);
+var tokenizeMessages = (...args) => r3().tokenizeMessages(...args);
+var getSessionCheckpoints = (...args) => r3().getSessionCheckpoints(...args);
+var checkoutSession = (...args) => r3().checkoutSession(...args);
+var rewindSession = (...args) => r3().rewindSession(...args);
+var switchBranch = (...args) => r3().switchBranch(...args);
+var deleteSession = (...args) => r3().deleteSession(...args);
+var listBackgroundTasks = (...args) => r3().listBackgroundTasks(...args);
+var getBackgroundTask = (...args) => r3().getBackgroundTask(...args);
+var stopBackgroundTask = (...args) => r3().stopBackgroundTask(...args);
+var listDir = (...args) => r3().listDir(...args);
+var uploadFiles = (...args) => r3().uploadFiles(...args);
+var deleteFile = (...args) => r3().deleteFile(...args);
+var writeFile = (...args) => r3().writeFile(...args);
+var renameFile = (...args) => r3().renameFile(...args);
+var copyFile = (...args) => r3().copyFile(...args);
+var shareFile = (...args) => r3().shareFile(...args);
+var getDownloadDirUrl = (...args) => r3().getDownloadDirUrl(...args);
+var exportSession = (...args) => r3().exportSession(...args);
+var previewImport = (...args) => r3().previewImport(...args);
+var importSession = (...args) => r3().importSession(...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 OUTPUT_TOOL_ICONS = {
+  Write: "\u{1F4C4}",
+  Edit: "\u{1F4DD}"
+};
+var PRIORITY_FILE_KEYS = [
+  "file_path",
+  "output_file",
+  "output_path",
+  "path",
+  "filepath",
+  "target_file",
+  "destination",
+  "filename"
+];
+var FILE_PATH_PATTERN = /(?:^|[\s"'`：:])([^\s"'`,;:)\]}，。；、]+?\.[a-z0-9]{1,8})(?=$|[\s"'`,.;:)\]}，。；、])/i;
+function safeParseJson(value) {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getStringArgValue(args, key) {
+  const value = args?.[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+var GENERIC_DISPLAY_NAMES = new Set(Object.values(TOOL_DISPLAY_LABELS));
+function getRunSkillDisplayName(toolCall, args) {
+  const argDisplayName = getStringArgValue(args, "display_name");
+  if (argDisplayName) return argDisplayName;
+  const displayName = toolCall.display_name?.trim() ?? "";
+  if (displayName && (displayName === "\u5199\u5165\u6587\u4EF6" || !GENERIC_DISPLAY_NAMES.has(displayName))) {
+    return displayName;
+  }
+  const argToolName = getStringArgValue(args, "tool_name");
+  if (argToolName) return argToolName;
+  return "";
+}
+function getCommandDescription(args) {
+  return getStringArgValue(args, "description");
+}
+function findFileLikeValue(value, depth = 0, allowPlainString = false) {
+  if (depth > 3) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (allowPlainString || trimmed.includes("/") || /\.[a-z0-9]{1,8}$/i.test(trimmed)) {
+      return trimmed;
+    }
+    return null;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findFileLikeValue(item, depth + 1, allowPlainString);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (isPlainObject(value)) {
+    for (const key of PRIORITY_FILE_KEYS) {
+      const direct = findFileLikeValue(value[key], depth + 1, true);
+      if (direct) return direct;
+    }
+    for (const nested of Object.values(value)) {
+      const found = findFileLikeValue(nested, depth + 1, allowPlainString);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function extractFilePathFromText(text) {
+  return text.match(FILE_PATH_PATTERN)?.[1] ?? null;
+}
+function extractFilePathFromResult(result) {
+  if (typeof result === "string") {
+    const parsed = safeParseJson(result);
+    if (parsed != null && parsed !== result) {
+      const found = extractFilePathFromResult(parsed);
+      if (found) return found;
+    }
+    return extractFilePathFromText(result);
+  }
+  if (Array.isArray(result)) {
+    for (const item of result) {
+      const found = extractFilePathFromResult(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (isPlainObject(result)) {
+    for (const key of PRIORITY_FILE_KEYS) {
+      const direct = findFileLikeValue(result[key], 0, true);
+      if (direct) return direct;
+    }
+    for (const nested of Object.values(result)) {
+      const found = extractFilePathFromResult(nested);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function isWriteLikeRunSkillTool(label, args) {
+  const normalizedLabel = label.trim();
+  if (normalizedLabel === "\u5199\u5165\u6587\u4EF6" || /write/i.test(normalizedLabel)) return true;
+  const toolName = getStringArgValue(args, "tool_name");
+  if (/write/i.test(toolName)) return true;
+  return false;
+}
+function formatFileName(filePath) {
+  return filePath.split("/").pop() ?? filePath;
+}
+function isInternalStatusFile(filePath) {
+  const fileName = formatFileName(filePath).toLowerCase();
+  return fileName === "phase.json";
+}
+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;
+}
+function getToolDisplayLabel(toolCall) {
+  const normalized = formatToolName(toolCall.name);
+  const args = safeParseJson(toolCall.arguments);
+  const displayName = toolCall.display_name?.trim() ?? "";
+  const baseLabel = displayName || TOOL_DISPLAY_LABELS[normalized] || normalized;
+  const metaDisplayName = getStringArgValue(args, "_meta_display_name");
+  if (metaDisplayName) {
+    return metaDisplayName;
+  }
+  switch (normalized) {
+    case "RunSkillTool": {
+      const runSkillDisplayName = getRunSkillDisplayName(toolCall, args);
+      if (runSkillDisplayName) {
+        const filePath = extractToolFilePath(toolCall);
+        if (filePath && isWriteLikeRunSkillTool(runSkillDisplayName, args)) {
+          return `${runSkillDisplayName}\u300C${formatFileName(filePath)}\u300D`;
+        }
+        return runSkillDisplayName;
+      }
+      return "\u6267\u884C\u6280\u80FD\u5DE5\u5177";
+    }
+    case "Bash": {
+      const description = getCommandDescription(args);
+      return description ? `\u6267\u884C\u547D\u4EE4\u884C\u64CD\u4F5C\uFF1A${description}` : "\u6267\u884C\u547D\u4EE4\u884C\u64CD\u4F5C";
+    }
+    case "BgBash": {
+      const description = getCommandDescription(args);
+      return description ? `\u540E\u53F0\u6267\u884C\uFF1A${description}` : "\u540E\u53F0\u6267\u884C\u547D\u4EE4";
+    }
+    case "Ls": {
+      const path = args && typeof args.path === "string" ? args.path : "";
+      return path ? `${baseLabel}\u300C${path}\u300D` : baseLabel;
+    }
+    case "Glob": {
+      const pattern = args && typeof args.pattern === "string" ? args.pattern : "";
+      return pattern ? `${baseLabel}\u300C${pattern}\u300D` : baseLabel;
+    }
+    case "Grep": {
+      const pattern = args && typeof args.pattern === "string" ? args.pattern : "";
+      return pattern ? `${baseLabel}\u300C${pattern}\u300D` : baseLabel;
+    }
+    case "WebSearch":
+    case "WebFetch": {
+      const query = args && typeof args.query === "string" ? args.query : "";
+      return query ? `${baseLabel}\u300C${query}\u300D` : baseLabel;
+    }
+    case "GetSkillContent": {
+      const skillName = args && typeof args.skill_id === "string" ? args.skill_id : args && typeof args.skill_name === "string" ? args.skill_name : "";
+      return skillName ? `${baseLabel}\u300C${skillName}\u300D` : baseLabel;
+    }
+    case "SearchSkills": {
+      const query = args && typeof args.query === "string" ? args.query : "";
+      return query ? `${baseLabel}\u300C${query}\u300D` : baseLabel;
+    }
+    case "ListSkillTools": {
+      const skillId = args && typeof args.skill_id === "string" ? args.skill_id : "";
+      return skillId ? `${baseLabel}\u300C${skillId}\u300D` : baseLabel;
+    }
+    case "LoadSkillTools":
+      return "\u52A0\u8F7D\u6280\u80FD";
+    case "FinishTask": {
+      const title = args && typeof args.title === "string" ? args.title : "";
+      return title ? `${baseLabel}\uFF1A${title}` : baseLabel;
+    }
+    default:
+      return baseLabel;
+  }
+}
+function getToolTone(status) {
+  if (status === "error" || status === "cancelled") return "red";
+  if (status === "awaiting_answer") return "amber";
+  if (status === "pending") return "blue";
+  return "emerald";
+}
+function getToolStatusLabel(status) {
+  if (status === "pending") return "\u8FD0\u884C\u4E2D";
+  if (status === "awaiting_answer") return "\u7B49\u5F85\u56DE\u7B54";
+  if (status === "error") return "\u9519\u8BEF";
+  if (status === "cancelled") return "\u5DF2\u53D6\u6D88";
+  return "\u5B8C\u6210";
+}
+function extractToolFilePath(toolCall) {
+  const formattedName = formatToolName(toolCall.name);
+  const argsValue = safeParseJson(toolCall.arguments);
+  let filePath = null;
+  if (formattedName === "Read" || formattedName === "Write" || formattedName === "Edit") {
+    filePath = findFileLikeValue(argsValue);
+  } else if (formattedName === "RunSkillTool") {
+    filePath = findFileLikeValue(argsValue) ?? extractFilePathFromResult(toolCall.result);
+  }
+  if (!filePath || isInternalStatusFile(filePath)) return null;
+  return filePath;
+}
+function getToolOutputTag(toolCall) {
+  const toolName = formatToolName(toolCall.name);
+  const filePath = extractToolFilePath(toolCall);
+  const icon = OUTPUT_TOOL_ICONS[toolName];
+  if (!icon || !filePath) return null;
+  return {
+    key: `${toolCall.id}-${filePath}`,
+    label: `${icon} ${filePath.split("/").pop() ?? filePath}`,
+    tone: "blue"
+  };
+}
+
+// src/react/stores/ui-store.ts
+import { create as create2 } from "zustand";
+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 = create2()((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/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" || !isRecord3(block.content)) return false;
+    return block.content.notification_type === "agent:start" || block.content.notification_type === "agent:end";
+  });
+  if (latestAgentNotification?.type === "system_notification" && isRecord3(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 isRecord3(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" || !isRecord3(block.content)) continue;
+    const metadata = block.content.metadata;
+    if (!isRecord3(metadata)) continue;
+    const parentId = metadata.parent_fork_tool_call_id;
+    if (typeof parentId === "string" && parentId.length > 0) return parentId;
+  }
+  return null;
+}
+function buildMessageContent2(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 = buildMessageContent2(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 setOnSessionChange(fn) {
+  onSessionChange = fn;
+}
+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/connection-store.ts
+import { create as create8 } from "zustand";
+var initialConnectionState = {
+  status: "disconnected",
+  reconnectAttempt: 0,
+  lastConnectedAt: null,
+  lastDisconnectedAt: null,
+  hasEverConnected: false
+};
+var useConnectionStore = create8()((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 create9 } from "zustand";
+var useRuntimeStore = create9()((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 create10 } 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 = create10()((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/sockets/event-bridge.ts
+function extractSkillIdForAnalytics(message) {
+  const text = getTextContent(message);
+  const tagMatch = text.match(/<skill>([^<]+)<\/skill>/);
+  if (tagMatch?.[1]?.trim()) {
+    return tagMatch[1].trim();
+  }
+  const slashCommandMatch = text.match(/^请使用\s+(.+?)\s+skill\s+完成任务(?:\n|$)/);
+  if (slashCommandMatch?.[1]?.trim()) {
+    return slashCommandMatch[1].trim();
+  }
+  return void 0;
+}
+function invalidateSessionCheckpoints(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["checkpoints", sessionId] });
+}
+function invalidateFileTree(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+}
+function shouldSuppressOptimisticUserMessage(sessionId, askuserAnswer) {
+  if (askuserAnswer && typeof askuserAnswer.tool_call_id === "string") {
+    return true;
+  }
+  const session = useSessionStore.getState().sessions.find((item) => item.id === sessionId);
+  if (session?.status !== "waiting_for_input") {
+    return false;
+  }
+  const messages = useChatStore.getState().messages[sessionId] ?? [];
+  return messages.some(
+    (message) => (message.tool_calls ?? []).some((toolCall) => toolCall.status === "awaiting_answer")
+  );
+}
+function invalidateSkillStats2(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["skill-stats", sessionId] });
+}
+function invalidateSessionSkills(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["session-skills", sessionId] });
+}
+function invalidateSessionDetail(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["session-detail", sessionId] });
+}
+function invalidateContextStats(sessionId) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  void queryClient.invalidateQueries({ queryKey: ["context-stats", sessionId] });
+}
+var onWorkspaceFilesChanged = null;
+function setOnWorkspaceFilesChanged(fn) {
+  onWorkspaceFilesChanged = fn;
+}
+function invalidateSessionFiles(sessionId, filePath) {
+  const queryClient = globalThis.__agentQueryClient;
+  if (!queryClient) return;
+  if (filePath) {
+    void queryClient.invalidateQueries({ queryKey: ["session-file", sessionId, filePath] });
+    void queryClient.invalidateQueries({ queryKey: ["session-image", sessionId, filePath] });
+    return;
+  }
+  void queryClient.invalidateQueries({
+    predicate: (query) => {
+      const [root, sid] = query.queryKey;
+      return (root === "session-file" || root === "session-image") && sid === sessionId;
+    }
+  });
+}
+function notifyWorkspaceFilesChanged(sessionId, filePath) {
+  invalidateFileTree(sessionId);
+  invalidateSessionFiles(sessionId, filePath);
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(
+      new CustomEvent("blade:workspace-files-changed", {
+        detail: { sessionId, filePath }
+      })
+    );
+  }
+  onWorkspaceFilesChanged?.({ sessionId, filePath });
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractModeFromBlocks3(blocks) {
+  const modeBlock = blocks.find((block) => block.type === "mode_change");
+  if (modeBlock && isRecord4(modeBlock.content) && typeof modeBlock.content.to === "string") {
+    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 hasAuthenticatedSession(client) {
+  if (hasTokenValue(resolveClientToken(client))) return true;
+  const { token, socketAuthToken, user } = useAuthStore.getState();
+  return Boolean(hasTokenValue(token) || hasTokenValue(socketAuthToken) || user);
+}
+function resolveClientToken(client) {
+  const token = client.options.token;
+  return typeof token === "function" ? token() : token;
+}
+function hasTokenValue(token) {
+  return typeof token === "string" && token.trim() !== "";
+}
+function resolveArtifactType(contentType) {
+  const normalized = contentType.trim().toLowerCase();
+  if (normalized === "markdown" || normalized === "md" || normalized === "text/markdown" || normalized === "text/x-markdown") {
+    return "markdown";
+  }
+  if (normalized === "html" || normalized === "text/html") {
+    return "html";
+  }
+  if (normalized === "url" || normalized === "text/uri-list") {
+    return "url";
+  }
+  if (normalized === "pdf" || normalized === "application/pdf") {
+    return "pdf";
+  }
+  if (normalized === "docx" || normalized === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
+    return "docx";
+  }
+  if (normalized === "excel" || normalized === "xlsx" || normalized === "xls" || normalized === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || normalized === "application/vnd.ms-excel") {
+    return "excel";
+  }
+  if (normalized === "pptx" || normalized === "ppt" || normalized === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || normalized === "application/vnd.ms-powerpoint" || normalized === "application/vnd.ms-powerpoint.presentation.macroenabled.12") {
+    return "ppt";
+  }
+  if (normalized === "csv" || normalized === "text/csv") {
+    return "csv";
+  }
+  if (normalized === "image" || normalized.startsWith("image/")) {
+    return "image";
+  }
+  return "file";
+}
+function buildToolPreviewSignature(content, type2) {
+  return `${type2}:${content}`;
+}
+function isToolBridgeContent(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.action === "string";
+}
+function isGisGoalListPayload(value) {
+  return isRecord4(value) && Array.isArray(value.goals);
+}
+function isGisResourceListPayload(value) {
+  return isRecord4(value) && Array.isArray(value.resources);
+}
+function isGisTargetListPayload(value) {
+  return isRecord4(value) && Array.isArray(value.targets);
+}
+var AgentSocket = class {
+  constructor(client) {
+    this.client = client;
+    this.socket = client.socket();
+    this._bindStoreHandlers();
+    this._bindConnectionHandlers();
+    setOnSessionChange((sessionId) => {
+      if (sessionId) {
+        this.subscribe(sessionId);
+        return;
+      }
+      this.unsubscribe();
+    });
+    if (hasAuthenticatedSession(this.client)) {
+      useConnectionStore.getState().markConnecting();
+      this.socket.connect();
+    } else {
+      useConnectionStore.getState().markDisconnected();
+    }
+  }
+  client;
+  // The protocol socket is strongly typed in client/socket.ts; this bridge accepts
+  // legacy event payloads while stores finish moving to generated payload shapes.
+  // biome-ignore lint/suspicious/noExplicitAny: event bridge normalizes mixed legacy payloads.
+  socket;
+  subscribedSession = null;
+  previewArtifactsByToolCall = /* @__PURE__ */ new Map();
+  pendingReplayMessages = /* @__PURE__ */ new Map();
+  pendingReplayModes = /* @__PURE__ */ new Map();
+  _ensureConnected() {
+    if (this.socket.connected || this.socket.active) {
+      return;
+    }
+    if (!hasAuthenticatedSession(this.client)) {
+      return;
+    }
+    useConnectionStore.getState().markConnecting();
+    this.socket.connect();
+  }
+  _resolveSessionId(data) {
+    return data?.session_id ?? this.subscribedSession;
+  }
+  _bindStoreHandlers() {
+    const s = this.socket;
+    const applyTurn = (sessionId, turn) => {
+      useChatStore.getState().upsertTurn(sessionId, turn);
+      invalidateContextStats(sessionId);
+      const mode = extractModeFromBlocks3(turn.blocks);
+      if (mode === "planning" || mode === "executing") {
+        useSessionStore.getState().setMode(sessionId, mode);
+      }
+      this._applyProjectionSideEffects(sessionId, turn);
+    };
+    s.on("turn:start", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      applyTurn(sessionId, data);
+    });
+    s.on("turn:patch", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      useChatStore.getState().applyTurnPatch(sessionId, data);
+      if (data.data.workspace_changed) {
+        notifyWorkspaceFilesChanged(sessionId);
+      }
+      const turn = data.data.turn;
+      if (!turn) return;
+      const mode = extractModeFromBlocks3(turn.blocks);
+      if (mode === "planning" || mode === "executing") {
+        useSessionStore.getState().setMode(sessionId, mode);
+      }
+      this._applyProjectionSideEffects(sessionId, turn);
+    });
+    s.on("turn:end", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      applyTurn(sessionId, data);
+    });
+    s.on("chat:start", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      useSessionStore.getState().updateSessionStatus(sessionId, "running");
+      useChatStore.getState().setStreaming(sessionId, true);
+    });
+    s.on("chat:end", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (sessionId) {
+        const status = data?.status ?? "completed";
+        useSessionStore.getState().updateSessionStatus(
+          sessionId,
+          status === "paused" ? "waiting_for_input" : status === "interrupted" ? "interrupted" : status === "failed" ? "failed" : "completed"
+        );
+        if (status === "interrupted") {
+          useChatStore.getState().markInterrupted(sessionId);
+        } else if (status === "failed") {
+          useChatStore.getState().markFailed(sessionId);
+        }
+        useChatStore.getState().setStreaming(sessionId, false);
+        invalidateContextStats(sessionId);
+        useRuntimeStore.getState().addEvent(sessionId, {
+          type: "chat:end",
+          title: status === "paused" ? "Waiting for input" : status === "interrupted" ? "\u8FD0\u884C\u5DF2\u4E2D\u65AD" : status === "failed" ? "Run failed" : "Run completed",
+          status: status === "paused" ? "info" : status === "interrupted" || status === "failed" ? "error" : "done",
+          detail: status === "paused" ? "Paused for user input" : status === "interrupted" ? "\u7528\u6237\u5DF2\u4E2D\u65AD" : status === "failed" ? "Streaming failed" : "Streaming finished"
+        });
+      }
+    });
+    s.on("task:updated", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (sessionId) {
+        useTaskStore.getState().setTasks(sessionId, data.tasks);
+      }
+    });
+    s.on("system:error", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (sessionId) {
+        useSessionStore.getState().updateSessionStatus(sessionId, "failed");
+        useChatStore.getState().markFailed(sessionId);
+        useChatStore.getState().addErrorMessage(sessionId, data.message);
+        useChatStore.getState().setStreaming(sessionId, false);
+        useRuntimeStore.getState().addEvent(sessionId, {
+          type: "system:error",
+          title: "Runtime error",
+          status: "error",
+          detail: data.message
+        });
+      }
+    });
+    s.on(
+      "replay:input_mismatch",
+      (data) => {
+        const sessionId = this._resolveSessionId(data);
+        if (!sessionId) return;
+        const keepReplay = !window.confirm("\u5373\u5C06\u8F6C\u5165\u81EA\u4E3B\u6A21\u5F0F\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F");
+        const message = this.pendingReplayMessages.get(sessionId) ?? data.actual_message ?? "";
+        const mode = this.pendingReplayModes.get(sessionId);
+        this.pendingReplayMessages.delete(sessionId);
+        this.pendingReplayModes.delete(sessionId);
+        this.socket.emit("chat:send", {
+          session_id: sessionId,
+          message,
+          mode,
+          replay_decision: keepReplay ? "keep_replay" : "continue_replay"
+        });
+      }
+    );
+    s.on(
+      "system:notification",
+      (data) => {
+        const sessionId = this._resolveSessionId(data);
+        if (!sessionId) return;
+        this._applySystemNotification(sessionId, "root", data);
+      }
+    );
+    s.on("task:synced", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (sessionId) {
+        useTaskStore.getState().setTasks(sessionId, data.tasks);
+      }
+    });
+    s.on("workspace:files_changed", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (sessionId) {
+        notifyWorkspaceFilesChanged(sessionId, data.file_path);
+      }
+    });
+    s.on(
+      "session:updated",
+      (data) => {
+        const sessionId = this._resolveSessionId(data);
+        if (!sessionId) return;
+        const patch = {};
+        if (typeof data.intent === "string") patch.intent = data.intent;
+        if ("model" in data) patch.model = data.model;
+        if ("bound_skill_id" in data) patch.bound_skill_id = data.bound_skill_id;
+        if ("replay_state" in data) patch.replay_state = data.replay_state;
+        if (Object.keys(patch).length > 0) {
+          useSessionStore.getState().patchSession(sessionId, patch);
+        }
+        if (typeof data.intent === "string") {
+          invalidateHomeSidebarSessions();
+        }
+        invalidateSessionDetail(sessionId);
+      }
+    );
+    s.on("session:rewind", (data) => {
+      if (!this.subscribedSession) return;
+      const sessionId = this.subscribedSession;
+      const { modes, ...rest } = useSessionStore.getState();
+      const { [sessionId]: _, ...restModes } = modes;
+      useSessionStore.setState({ ...rest, modes: restModes });
+      useSessionStore.getState().setActiveSession(sessionId);
+      useRuntimeStore.getState().addEvent(sessionId, {
+        type: "session:rewind",
+        title: "Conversation rewound",
+        status: "info",
+        detail: data.checkpoint_id
+      });
+      invalidateSessionCheckpoints(sessionId);
+    });
+    const handleArtifact = (sessionId, data) => {
+      const type2 = resolveArtifactType(data.content_type);
+      const filePath = `/api/sessions/${sessionId}/files/${encodeURIComponent(data.file_path)}`;
+      const fileUrl = this.client.buildAuthedUrl(filePath);
+      const content = type2 === "ppt" ? filePath : type2 === "image" || type2 === "pdf" || type2 === "docx" || type2 === "excel" ? fileUrl : data.content;
+      if (data.session_id != null && data.session_id === this.subscribedSession) {
+        useUiStore.getState().setActiveRightTab("preview");
+      }
+      useUiStore.getState().pushArtifact({
+        type: type2,
+        content,
+        sourceUrl: type2 === "ppt" ? fileUrl : void 0,
+        title: data.title,
+        key: data.file_path,
+        revision: Date.now()
+      });
+    };
+    s.on("artifact:created", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      notifyWorkspaceFilesChanged(sessionId, data.file_path);
+      handleArtifact(sessionId, data);
+    });
+    s.on("bg:started", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      const taskId = typeof data.task_id === "string" ? data.task_id : typeof data.id === "string" ? data.id : "";
+      if (!taskId) return;
+      useBackgroundStore.getState().upsertTask(sessionId, {
+        id: taskId,
+        command: typeof data.command === "string" ? data.command : "",
+        description: typeof data.description === "string" ? data.description : void 0,
+        status: "running",
+        elapsed_seconds: typeof data.elapsed_seconds === "number" ? data.elapsed_seconds : 0
+      });
+    });
+    s.on("bg:tasks_completed", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      for (const task of data.tasks ?? []) {
+        const taskId = typeof task.id === "string" ? task.id : typeof task.task_id === "string" ? task.task_id : "";
+        if (!taskId) continue;
+        useBackgroundStore.getState().upsertTask(sessionId, {
+          id: taskId,
+          command: typeof task.command === "string" ? task.command : "",
+          description: typeof task.description === "string" ? task.description : void 0,
+          status: task.status === "running" || task.status === "failed" ? task.status : "done",
+          exit_code: typeof task.exit_code === "number" || task.exit_code === null ? task.exit_code : void 0,
+          elapsed_seconds: typeof task.elapsed_seconds === "number" ? task.elapsed_seconds : 0,
+          output_lines_count: typeof task.output_lines_count === "number" ? task.output_lines_count : void 0,
+          output: Array.isArray(task.output_preview) && task.output_preview.length > 0 ? task.output_preview.join("\n") : void 0
+        });
+      }
+    });
+    s.on("skills:changed", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      invalidateSkillStats2(sessionId);
+      invalidateSessionSkills(sessionId);
+    });
+    s.on("artifact:updated", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId) return;
+      notifyWorkspaceFilesChanged(sessionId, data.file_path);
+      if (data.old_string != null && data.new_string != null) {
+        useUiStore.getState().pushArtifact({
+          type: "diff",
+          content: data.new_string,
+          oldContent: data.old_string,
+          title: data.title,
+          key: data.file_path
+        });
+        return;
+      }
+      handleArtifact(sessionId, data);
+    });
+  }
+  _bindConnectionHandlers() {
+    this.socket.on("connect", () => {
+      useConnectionStore.getState().markConnected();
+      console.log("[agent-socket] connected, id:", this.socket.id);
+      const sessionId = this.subscribedSession;
+      if (sessionId) {
+        useSessionStore.getState().setActiveSession(sessionId);
+        this.socket.emit("session:subscribe", { session_id: sessionId });
+      }
+    });
+    this.socket.on("connect_error", (err) => {
+      useConnectionStore.getState().markDisconnected();
+      console.error("[agent-socket] connect_error:", err.message);
+    });
+    this.socket.on("disconnect", (reason) => {
+      useConnectionStore.getState().markDisconnected();
+      console.log("[agent-socket] disconnected:", reason);
+    });
+    this.socket.io.on("reconnect_attempt", (attempt) => {
+      useConnectionStore.getState().markConnecting(typeof attempt === "number" ? attempt : 0);
+    });
+  }
+  _applyProjectionSideEffects(sessionId, turn) {
+    for (const block of turn.blocks) {
+      if (block.type === "tool_bridge" && isToolBridgeContent(block.content)) {
+        if (block.content.action === "gis.goals.updated" && isGisGoalListPayload(block.content.payload)) {
+          useGisStore.getState().setGoals(sessionId, block.content.payload.goals);
+          continue;
+        }
+        if (block.content.action === "gis.resources.updated" && isGisResourceListPayload(block.content.payload)) {
+          useGisStore.getState().setResources(sessionId, block.content.payload.resources);
+          continue;
+        }
+        if (block.content.action === "gis.targets.updated" && isGisTargetListPayload(block.content.payload)) {
+          useGisStore.getState().setTargets(sessionId, block.content.payload.targets);
+          continue;
+        }
+        if (block.content.action.startsWith("map.")) {
+          useGisStore.getState().pushMapCommand(sessionId, {
+            action: block.content.action,
+            payload: block.content.payload,
+            toolCallId: block.tool_call_id
+          });
+          continue;
+        }
+        postToParent({
+          __bladeBridge: true,
+          direction: "agent-to-host",
+          action: block.content.action,
+          payload: block.content.payload,
+          meta: {
+            sessionId,
+            ...block.tool_call_id ? { toolCallId: block.tool_call_id } : {},
+            timestamp: Date.now()
+          }
+        });
+        continue;
+      }
+      if (block.type !== "tool_ui" || !block.tool_call_id || !isUiMeta(block.content)) {
+        continue;
+      }
+      const ui = block.content;
+      if (ui.target !== "preview") {
+        continue;
+      }
+      const previewType = ui.resourceHTML ? "resource-html" : "resource-uri";
+      const previewContent = ui.resourceHTML ?? ui.resourceUri ?? ui.resourceURI;
+      if (!previewContent) {
+        continue;
+      }
+      const previewKey = buildToolPreviewKey(previewContent, previewType, block.tool_call_id);
+      const signature = buildToolPreviewSignature(previewContent, previewType);
+      if (this.previewArtifactsByToolCall.get(previewKey) === signature) {
+        continue;
+      }
+      this.previewArtifactsByToolCall.set(previewKey, signature);
+      useUiStore.getState().pushArtifact({
+        type: previewType,
+        content: previewContent,
+        title: ui.title ?? "\u5DE5\u5177\u9884\u89C8",
+        key: previewKey,
+        bridgeSessionId: sessionId
+      });
+    }
+    for (const block of turn.blocks) {
+      if (block.type !== "system_notification" || !isRecord4(block.content)) {
+        continue;
+      }
+      this._applySystemNotification(sessionId, turn.loop_id, block.content);
+    }
+  }
+  _applySystemNotification(sessionId, loopId, notification) {
+    const notificationType = notification.notification_type ?? "system_notification";
+    const title = notification.title ?? notificationType;
+    const detail = typeof notification.detail === "string" ? notification.detail : notification.detail == null ? void 0 : JSON.stringify(notification.detail);
+    const status = notification.status === "running" || notification.status === "done" || notification.status === "error" ? notification.status : "info";
+    useRuntimeStore.getState().addEvent(sessionId, {
+      type: notificationType,
+      title,
+      status,
+      detail,
+      loopName: loopId
+    });
+    if (notificationType !== "bg:started" || !isRecord4(notification.metadata)) {
+      return;
+    }
+    const taskId = typeof notification.metadata.task_id === "string" ? notification.metadata.task_id : "";
+    const command = typeof notification.metadata.command === "string" ? notification.metadata.command : "";
+    const description = typeof notification.metadata.description === "string" ? notification.metadata.description : void 0;
+    if (!taskId) return;
+    useBackgroundStore.getState().upsertTask(sessionId, {
+      id: taskId,
+      command,
+      description,
+      status: "running",
+      elapsed_seconds: 0
+    });
+  }
+  subscribe(sessionId) {
+    const previousSessionId = this.subscribedSession;
+    const isSameSession = previousSessionId === sessionId;
+    if (previousSessionId && !isSameSession) {
+      this.socket.emit("session:unsubscribe", { session_id: previousSessionId });
+      useUiBridgeStore.getState().clearSession(previousSessionId);
+    }
+    this.subscribedSession = sessionId;
+    if (!isSameSession) {
+      this.previewArtifactsByToolCall.clear();
+      useUiStore.getState().clearArtifacts();
+      useCardStateStore.getState().clearAllStates();
+    }
+    this.socket.emit("session:subscribe", { session_id: sessionId });
+  }
+  unsubscribe() {
+    const previousSessionId = this.subscribedSession;
+    if (previousSessionId) {
+      this.socket.emit("session:unsubscribe", { session_id: previousSessionId });
+      useUiBridgeStore.getState().clearSession(previousSessionId);
+      this.subscribedSession = null;
+    }
+    this.previewArtifactsByToolCall.clear();
+  }
+  /**
+   * 附加订阅：仅把当前 sid 加进 sessionId 的 room，不切 subscribedSession，
+   * 也不清空当前会话的 artifact/card state。用于"并行拟制"这类场景 ——
+   * 创建 N 个后台 session 后需要收到它们的 chat:end / task:updated 才能让
+   * 成果表里那几条卡片状态流转到"已完成"；缺失订阅时广播事件永远到不了
+   * 前端，卡片就会停留在乐观写入的"运行中"态。
+   *
+   * 幂等：后端 session:subscribe handler 只做 enter_room，重复 emit 无副作用。
+   */
+  attachSession(sessionId) {
+    this.socket.emit("session:subscribe", { session_id: sessionId });
+  }
+  send(sessionId, message, mode, askuserAnswer, extras) {
+    this._ensureConnected();
+    const suppressOptimisticUserMessage = shouldSuppressOptimisticUserMessage(
+      sessionId,
+      askuserAnswer
+    );
+    if (!suppressOptimisticUserMessage) {
+      useChatStore.getState().addUserMessage(sessionId, message);
+    }
+    useChatStore.getState().setStreaming(sessionId, true);
+    if (askuserAnswer && typeof askuserAnswer.tool_call_id === "string") {
+      const { tool_call_id, ...rest } = askuserAnswer;
+      const current = useChatStore.getState().askAnswers[sessionId] ?? {};
+      useChatStore.getState().setAskAnswers(sessionId, {
+        ...current,
+        [tool_call_id]: rest
+      });
+    }
+    if (!suppressOptimisticUserMessage) {
+      useRuntimeStore.getState().addEvent(sessionId, {
+        type: "chat:start",
+        title: "User prompt sent",
+        status: "running",
+        detail: contentPreview(message)
+      });
+    }
+    if (!extras?.replay_decision) {
+      this.pendingReplayMessages.set(sessionId, message);
+      this.pendingReplayModes.set(sessionId, mode);
+    }
+    this.socket.emit("chat:send", {
+      session_id: sessionId,
+      message,
+      mode,
+      askuser_answer: askuserAnswer,
+      model: extras?.model,
+      whatif: extras?.whatif,
+      replay_decision: extras?.replay_decision
+    });
+    const skillId = extractSkillIdForAnalytics(message);
+    trackEvent("message_sent", {
+      session_id: sessionId,
+      ...skillId ? { skill_id: skillId } : {}
+    });
+    if (skillId) {
+      trackEvent("skill_invoked", {
+        session_id: sessionId,
+        skill_id: skillId
+      });
+    }
+  }
+  stop(sessionId) {
+    this.socket.emit("chat:stop", { session_id: sessionId });
+  }
+  compact(sessionId) {
+    return new Promise((resolve, reject) => {
+      this.socket.timeout(3e4).emit(
+        "chat:compact",
+        { session_id: sessionId },
+        (err, response) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(response ?? {});
+        }
+      );
+    });
+  }
+  reconnect() {
+    this.socket.disconnect();
+    useConnectionStore.getState().markConnecting();
+    this.socket.connect();
+  }
+  disconnect() {
+    this.socket.disconnect();
+    useConnectionStore.getState().markDisconnected();
+  }
+  destroy() {
+    this.socket.removeAllListeners();
+    this.socket.disconnect();
+    useConnectionStore.getState().markDisconnected();
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: socket.io listeners are event-specific and forwarded transparently.
+  on(event, listener) {
+    this.socket.on(event, listener);
+    return this;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: socket.io listeners are event-specific and forwarded transparently.
+  off(event, listener) {
+    this.socket.off(event, listener);
+    return this;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: generic emit for custom events.
+  emit(event, data) {
+    this.socket.emit(event, data);
+    return this;
+  }
+  getSubscribedSession() {
+    return this.subscribedSession;
+  }
+};
+function bridgeSocketEvents(client, _stores) {
+  agentSocket?.destroy();
+  const nextSocket = new AgentSocket(client);
+  setAgentSocket(nextSocket);
+  return nextSocket;
+}
+
+// src/react/stores/answer-callback-store.ts
+import { create as create11 } from "zustand";
+var useAnswerCallbackStore = create11()((set) => ({
+  ...createClientActions(set),
+  callbacks: {},
+  setAnswerCallback: (sessionId, callback) => {
+    set((state) => ({
+      callbacks: {
+        ...state.callbacks,
+        [sessionId]: callback
+      }
+    }));
+  }
+}));
+
+// src/react/stores/runtime-features-store.ts
+import { create as create12 } from "zustand";
+var useRuntimeFeaturesStore = create12((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;
+var detachHostBridgeListener = null;
+var stores = {
+  answerCallback: useAnswerCallbackStore,
+  auth: useAuthStore,
+  background: useBackgroundStore,
+  cardState: useCardStateStore,
+  chat: useChatStore,
+  connection: useConnectionStore,
+  gis: useGisStore,
+  runtime: useRuntimeStore,
+  runtimeFeatures: useRuntimeFeaturesStore,
+  session: useSessionStore,
+  task: useTaskStore,
+  ui: useUiStore,
+  uiBridge: useUiBridgeStore
+};
+function attachClientToStores(client) {
+  for (const store of Object.values(stores)) {
+    const state = store.getState();
+    state.setClient(client);
+  }
+  bridgeSocketEvents(client, stores);
+  detachHostBridgeListener?.();
+  detachHostBridgeListener = attachHostBridgeListener(() => {
+    const activeSessionId = useSessionStore.getState().activeSessionId;
+    return {
+      sessionId: activeSessionId,
+      activeSessionId,
+      isStreaming: activeSessionId ? useChatStore.getState().isStreaming[activeSessionId] ?? false : false
+    };
+  });
+}
+function bootstrapBladeClient(options) {
+  const client = new BladeClient(withStoreAuth(options));
+  if (options.token === void 0) {
+    client._attachStoreRestTokenResolver(() => useAuthStore.getState().token);
+    client._attachStoreSocketTokenResolver(() => {
+      const auth = useAuthStore.getState();
+      return auth.token ?? auth.socketAuthToken;
+    });
+  }
+  attachClientToStores(client);
+  bootstrappedClient = client;
+  return client;
+}
+function getBootstrappedClient() {
+  if (!bootstrappedClient) {
+    throw new Error("bootstrapBladeClient() must be called before any SDK usage");
+  }
+  return bootstrappedClient;
+}
+function withStoreAuth(options) {
+  if (options.token !== void 0) {
+    return options;
+  }
+  return {
+    ...options,
+    onRefreshSuccess: async () => {
+      await options.onRefreshSuccess?.();
+      useAuthStore.setState({ token: null });
+    }
+  };
+}
+
+// src/react/api/client.ts
+function getBaseUrl() {
+  return getClient().options.baseUrl;
+}
+function getAuthedUrl(path) {
+  return getClient().buildAuthedUrl(path);
+}
+async function apiFetch(path, init) {
+  return getClient().jsonFromInit(path, init);
+}
+async function apiFetchText(path, init) {
+  return getClient().textFromInit(path, init);
+}
+async function apiFetchResponse(path, init) {
+  return getClient().responseFromInit(path, init);
+}
+function getClient() {
+  return getBootstrappedClient();
+}
+
+export {
+  getBaseUrl,
+  getAuthedUrl,
+  apiFetch,
+  apiFetchText,
+  apiFetchResponse,
+  getClient,
+  listSkills,
+  listSessionSkills,
+  searchSkills,
+  getSkillStats,
+  getGlobalSkillStats,
+  skills_exports,
+  partner_skill_exports,
+  PartnerSkillName,
+  PartnerSkillFile,
+  PartnerSkillInstallPayload,
+  PartnerSkillInstallResult,
+  useUiBridgeStore,
+  resourceBridgeDispatch,
+  isInsideIframe,
+  attachHostBridgeListener,
+  getTextContent,
+  isHiddenInternalMessage,
+  buildMessageContent,
+  contentPreview,
+  transformSlashCommand,
+  extractTextAttachments,
+  getImageParts,
+  getFileParts,
+  groupMessagesByLoop,
+  setAnalyticsClient,
+  trackEvent,
+  buildToolPreviewKey,
+  isUiMeta,
+  auth_exports,
+  agentSocket,
+  getSocket,
+  listSessions,
+  getSessionTurns,
+  getSessionContextStats,
+  getSessionCheckpoints,
+  checkoutSession,
+  listBackgroundTasks,
+  listDir,
+  uploadFiles,
+  deleteFile,
+  writeFile,
+  renameFile,
+  copyFile,
+  getDownloadDirUrl,
+  sessions_exports,
+  formatToolName,
+  getToolDisplayLabel,
+  getToolTone,
+  getToolStatusLabel,
+  extractToolFilePath,
+  getToolOutputTag,
+  resolveEffectiveTheme,
+  useUiStore,
+  useChatStore,
+  useTaskStore,
+  invalidateHomeSidebarSessions,
+  useSessionStore,
+  useAuthStore,
+  useBackgroundStore,
+  useConnectionStore,
+  useRuntimeStore,
+  useGisStore,
+  setOnWorkspaceFilesChanged,
+  useAnswerCallbackStore,
+  useRuntimeFeaturesStore,
+  attachClientToStores,
+  bootstrapBladeClient,
+  getBootstrappedClient
+};
+//# sourceMappingURL=chunk-4VWLTG5L.js.map