@percena/weft 0.4.0-next.3 → 0.4.0-next.5

package/dist/index.cjs

@@ -32,774 +32,16 @@ var src_exports = {};
 __export(src_exports, {
   AgentChatPanel: () => AgentChatPanel,
   EN_FALLBACK: () => EN_FALLBACK,
-  RPC_CHANNELS: () => RPC_CHANNELS,
-  THINKING_LEVELS: () => THINKING_LEVELS,
-  THINKING_LEVEL_IDS: () => THINKING_LEVEL_IDS,
-  THINKING_TO_EFFORT: () => THINKING_TO_EFFORT,
   TimelineAgentChatPanel: () => TimelineAgentChatPanel,
-  appendTimelineItem: () => appendTimelineItem,
   createFlitroEmbedRuntime: () => createFlitroEmbedRuntime,
-  createInMemoryApprovalStore: () => createInMemoryApprovalStore,
-  createPermissionPolicy: () => createPermissionPolicy,
-  createPermissionPolicyFromConfig: () => createPermissionPolicyFromConfig,
-  createPolicyDecisionReceipt: () => createPolicyDecisionReceipt,
-  createRuntimeCapabilityReport: () => createRuntimeCapabilityReport,
-  createRuntimeExtensionContext: () => createRuntimeExtensionContext,
-  createSourcePolicyLayer: () => createSourcePolicyLayer,
-  createTimelineCursor: () => createTimelineCursor,
-  createTimelineSequencer: () => createTimelineSequencer,
-  debug: () => debug,
-  evaluateToolPolicy: () => evaluateToolPolicy,
-  explainToolPolicy: () => explainToolPolicy,
-  fetchTimeline: () => fetchTimeline,
-  findMentionMatches: () => findMentionMatches,
-  generateMessageId: () => generateMessageId,
-  getThinkingLevelNameKey: () => getThinkingLevelNameKey,
-  getThinkingTokens: () => getThinkingTokens,
-  invokeSessionTool: () => invokeSessionTool,
-  isValidThinkingLevel: () => isValidThinkingLevel,
-  mergeTimeline: () => mergeTimeline,
-  messageToStored: () => messageToStored,
-  normalizePath: () => normalizePath,
-  normalizeThinkingLevel: () => normalizeThinkingLevel,
-  parseMentions: () => parseMentions,
-  pathStartsWith: () => pathStartsWith,
-  reduceRuntimeState: () => reduceRuntimeState,
-  resolveFileMentions: () => resolveFileMentions,
-  resolvePathMentions: () => resolvePathMentions,
-  resolveSkillMentions: () => resolveSkillMentions,
-  resolveSourceMentions: () => resolveSourceMentions,
-  sanitizeProviderSourceTools: () => sanitizeProviderSourceTools,
-  selectRuntimeCandidate: () => selectRuntimeCandidate,
-  storedToMessage: () => storedToMessage,
-  stripAllMentions: () => stripAllMentions,
-  stripPathPrefix: () => stripPathPrefix,
   useAgentChatSession: () => useAgentChatSession,
-  useAgentSession: () => import_weft_react.useAgentSession,
-  useTimelineAgentChatSession: () => useTimelineAgentChatSession,
-  validatePolicyConfig: () => validatePolicyConfig
+  useAgentSession: () => useAgentSession,
+  useTimelineAgentChatSession: () => useTimelineAgentChatSession
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../packages/core/dist/chunk-QEEF5TZY.js
-function generateMessageId() {
-  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function messageToStored(msg) {
-  const { role, isStreaming, isPending, ...rest } = msg;
-  return { ...rest, type: role };
-}
-function storedToMessage(stored) {
-  const { type, ...rest } = stored;
-  return { ...rest, role: type, timestamp: stored.timestamp ?? Date.now() };
-}
-
-// ../packages/core/dist/chunk-LCDW7EA2.js
-function debug(..._args) {
-}
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-function pathStartsWith(filePath, dirPath) {
-  const normalizedFile = normalizePath(filePath);
-  const normalizedDir = normalizePath(dirPath);
-  return normalizedFile.startsWith(normalizedDir + "/") || normalizedFile === normalizedDir;
-}
-function stripPathPrefix(filePath, prefix) {
-  const normalizedFile = normalizePath(filePath);
-  const normalizedPrefix = normalizePath(prefix);
-  if (normalizedFile.startsWith(normalizedPrefix + "/")) {
-    return normalizedFile.slice(normalizedPrefix.length + 1);
-  }
-  return filePath;
-}
-
-// ../packages/core/dist/index.js
-var THINKING_LEVEL_IDS = [
-  "off",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-var THINKING_LEVELS = [
-  { id: "off", nameKey: "thinking.off", descriptionKey: "thinking.offDesc" },
-  { id: "low", nameKey: "thinking.low", descriptionKey: "thinking.lowDesc" },
-  { id: "medium", nameKey: "thinking.medium", descriptionKey: "thinking.mediumDesc" },
-  { id: "high", nameKey: "thinking.high", descriptionKey: "thinking.highDesc" },
-  { id: "xhigh", nameKey: "thinking.xhigh", descriptionKey: "thinking.xhighDesc" },
-  { id: "max", nameKey: "thinking.max", descriptionKey: "thinking.maxDesc" }
-];
-var THINKING_TO_EFFORT = {
-  off: null,
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "xhigh",
-  max: "max"
-};
-var TOKEN_BUDGETS = {
-  haiku: {
-    off: 0,
-    low: 2e3,
-    medium: 4e3,
-    high: 6e3,
-    xhigh: 7e3,
-    max: 8e3
-  },
-  default: {
-    off: 0,
-    low: 4e3,
-    medium: 1e4,
-    high: 2e4,
-    xhigh: 26e3,
-    max: 32e3
-  }
-};
-function getThinkingTokens(level, modelId) {
-  const isHaiku = modelId.toLowerCase().includes("haiku");
-  const budgets = isHaiku ? TOKEN_BUDGETS.haiku : TOKEN_BUDGETS.default;
-  return budgets[level];
-}
-function getThinkingLevelNameKey(level) {
-  const def = THINKING_LEVELS.find((l) => l.id === level);
-  return def?.nameKey ?? `thinking.${level}`;
-}
-function isValidThinkingLevel(value) {
-  return typeof value === "string" && THINKING_LEVEL_IDS.includes(value);
-}
-function normalizeThinkingLevel(value) {
-  if (value === "think") return "medium";
-  if (isValidThinkingLevel(value)) return value;
-  return void 0;
-}
-var RPC_CHANNELS = {
-  remote: {
-    TEST_CONNECTION: "remote:testConnection"
-  },
-  server: {
-    GET_WORKSPACES: "server:getWorkspaces",
-    CREATE_WORKSPACE: "server:createWorkspace",
-    GET_STATUS: "server:getStatus",
-    GET_HEALTH: "server:getHealth",
-    GET_ACTIVE_SESSIONS: "server:getActiveSessions",
-    SHUTTING_DOWN: "server:shuttingDown",
-    STATUS_CHANGED: "server:statusChanged",
-    HOME_DIR: "server:homeDir"
-  },
-  sessions: {
-    GET: "sessions:get",
-    GET_UNREAD_SUMMARY: "sessions:getUnreadSummary",
-    MARK_ALL_READ: "sessions:markAllRead",
-    UNREAD_SUMMARY_CHANGED: "sessions:unreadSummaryChanged",
-    CREATE: "sessions:create",
-    DELETE: "sessions:delete",
-    GET_MESSAGES: "sessions:getMessages",
-    SEND_MESSAGE: "sessions:sendMessage",
-    CANCEL: "sessions:cancel",
-    KILL_SHELL: "sessions:killShell",
-    RESPOND_TO_PERMISSION: "sessions:respondToPermission",
-    RESPOND_TO_CREDENTIAL: "sessions:respondToCredential",
-    COMMAND: "sessions:command",
-    GET_PENDING_PLAN_EXECUTION: "sessions:getPendingPlanExecution",
-    GET_PERMISSION_MODE_STATE: "sessions:getPermissionModeState",
-    EVENT: "session:event",
-    GET_MODEL: "session:getModel",
-    SET_MODEL: "session:setModel",
-    GET_FILES: "sessions:getFiles",
-    GET_NOTES: "sessions:getNotes",
-    SET_NOTES: "sessions:setNotes",
-    WATCH_FILES: "sessions:watchFiles",
-    UNWATCH_FILES: "sessions:unwatchFiles",
-    FILES_CHANGED: "sessions:filesChanged",
-    SEARCH_CONTENT: "sessions:searchContent",
-    EXPORT: "sessions:export",
-    IMPORT: "sessions:import",
-    EXPORT_REMOTE_TRANSFER: "sessions:exportRemoteTransfer",
-    IMPORT_REMOTE_TRANSFER: "sessions:importRemoteTransfer"
-  },
-  transfer: {
-    START: "transfer:start",
-    CHUNK: "transfer:chunk",
-    COMMIT: "transfer:commit",
-    ABORT: "transfer:abort"
-  },
-  tasks: {
-    GET_OUTPUT: "tasks:getOutput"
-  },
-  workspaces: {
-    GET: "workspaces:get",
-    CREATE: "workspaces:create",
-    CHECK_SLUG: "workspaces:checkSlug",
-    UPDATE_REMOTE: "workspaces:updateRemote"
-  },
-  window: {
-    GET_WORKSPACE: "window:getWorkspace",
-    GET_MODE: "window:getMode",
-    OPEN_WORKSPACE: "window:openWorkspace",
-    OPEN_SESSION_IN_NEW_WINDOW: "window:openSessionInNewWindow",
-    SWITCH_WORKSPACE: "window:switchWorkspace",
-    CLOSE: "window:close",
-    CLOSE_REQUESTED: "window:closeRequested",
-    CONFIRM_CLOSE: "window:confirmClose",
-    CANCEL_CLOSE: "window:cancelClose",
-    SET_TRAFFIC_LIGHTS: "window:setTrafficLights",
-    FOCUS_STATE: "window:focusState",
-    GET_FOCUS_STATE: "window:getFocusState"
-  },
-  file: {
-    READ: "file:read",
-    READ_DATA_URL: "file:readDataUrl",
-    READ_PREVIEW_DATA_URL: "file:readPreviewDataUrl",
-    READ_BINARY: "file:readBinary",
-    OPEN_DIALOG: "file:openDialog",
-    READ_ATTACHMENT: "file:readAttachment",
-    READ_USER_ATTACHMENT: "file:readUserAttachment",
-    STORE_ATTACHMENT: "file:storeAttachment",
-    GENERATE_THUMBNAIL: "file:generateThumbnail"
-  },
-  fs: {
-    SEARCH: "fs:search",
-    LIST_DIRECTORY: "fs:listDirectory"
-  },
-  debug: {
-    LOG: "debug:log"
-  },
-  theme: {
-    GET_SYSTEM_PREFERENCE: "theme:getSystemPreference",
-    SYSTEM_CHANGED: "theme:systemChanged",
-    APP_CHANGED: "theme:appChanged",
-    GET_APP: "theme:getApp",
-    GET_PRESETS: "theme:getPresets",
-    LOAD_PRESET: "theme:loadPreset",
-    GET_COLOR_THEME: "theme:getColorTheme",
-    SET_COLOR_THEME: "theme:setColorTheme",
-    BROADCAST_PREFERENCES: "theme:broadcastPreferences",
-    PREFERENCES_CHANGED: "theme:preferencesChanged",
-    GET_WORKSPACE_COLOR_THEME: "theme:getWorkspaceColorTheme",
-    SET_WORKSPACE_COLOR_THEME: "theme:setWorkspaceColorTheme",
-    GET_ALL_WORKSPACE_THEMES: "theme:getAllWorkspaceThemes",
-    BROADCAST_WORKSPACE_THEME: "theme:broadcastWorkspaceTheme",
-    WORKSPACE_THEME_CHANGED: "theme:workspaceThemeChanged"
-  },
-  system: {
-    VERSIONS: "system:versions",
-    HOME_DIR: "system:homeDir",
-    IS_DEBUG_MODE: "system:isDebugMode"
-  },
-  update: {
-    CHECK: "update:check",
-    GET_INFO: "update:getInfo",
-    INSTALL: "update:install",
-    DISMISS: "update:dismiss",
-    GET_DISMISSED: "update:getDismissed",
-    AVAILABLE: "update:available",
-    DOWNLOAD_PROGRESS: "update:downloadProgress"
-  },
-  shell: {
-    OPEN_URL: "shell:openUrl",
-    OPEN_FILE: "shell:openFile",
-    SHOW_IN_FOLDER: "shell:showInFolder"
-  },
-  menu: {
-    NEW_CHAT: "menu:newChat",
-    NEW_WINDOW: "menu:newWindow",
-    OPEN_SETTINGS: "menu:openSettings",
-    KEYBOARD_SHORTCUTS: "menu:keyboardShortcuts",
-    TOGGLE_FOCUS_MODE: "menu:toggleFocusMode",
-    TOGGLE_SIDEBAR: "menu:toggleSidebar",
-    QUIT: "menu:quit",
-    MINIMIZE: "menu:minimize",
-    MAXIMIZE: "menu:maximize",
-    ZOOM_IN: "menu:zoomIn",
-    ZOOM_OUT: "menu:zoomOut",
-    ZOOM_RESET: "menu:zoomReset",
-    TOGGLE_DEV_TOOLS: "menu:toggleDevTools",
-    UNDO: "menu:undo",
-    REDO: "menu:redo",
-    CUT: "menu:cut",
-    COPY: "menu:copy",
-    PASTE: "menu:paste",
-    SELECT_ALL: "menu:selectAll"
-  },
-  deeplink: {
-    NAVIGATE: "deeplink:navigate"
-  },
-  auth: {
-    LOGOUT: "auth:logout",
-    SHOW_LOGOUT_CONFIRMATION: "auth:showLogoutConfirmation",
-    SHOW_DELETE_SESSION_CONFIRMATION: "auth:showDeleteSessionConfirmation"
-  },
-  credentials: {
-    HEALTH_CHECK: "credentials:healthCheck"
-  },
-  onboarding: {
-    GET_AUTH_STATE: "onboarding:getAuthState",
-    VALIDATE_MCP: "onboarding:validateMcp",
-    START_MCP_OAUTH: "onboarding:startMcpOAuth",
-    START_CLAUDE_OAUTH: "onboarding:startClaudeOAuth",
-    EXCHANGE_CLAUDE_CODE: "onboarding:exchangeClaudeCode",
-    HAS_CLAUDE_OAUTH_STATE: "onboarding:hasClaudeOAuthState",
-    CLEAR_CLAUDE_OAUTH_STATE: "onboarding:clearClaudeOAuthState",
-    DEFER_SETUP: "onboarding:deferSetup"
-  },
-  llmConnections: {
-    LIST: "LLM_Connection:list",
-    LIST_WITH_STATUS: "LLM_Connection:listWithStatus",
-    GET: "LLM_Connection:get",
-    GET_API_KEY: "LLM_Connection:getApiKey",
-    SAVE: "LLM_Connection:save",
-    DELETE: "LLM_Connection:delete",
-    TEST: "LLM_Connection:test",
-    SET_DEFAULT: "LLM_Connection:setDefault",
-    SET_WORKSPACE_DEFAULT: "LLM_Connection:setWorkspaceDefault",
-    REFRESH_MODELS: "LLM_Connection:refreshModels",
-    CHANGED: "LLM_Connection:changed"
-  },
-  chatgpt: {
-    START_OAUTH: "chatgpt:startOAuth",
-    COMPLETE_OAUTH: "chatgpt:completeOAuth",
-    CANCEL_OAUTH: "chatgpt:cancelOAuth",
-    GET_AUTH_STATUS: "chatgpt:getAuthStatus",
-    LOGOUT: "chatgpt:logout"
-  },
-  copilot: {
-    START_OAUTH: "copilot:startOAuth",
-    CANCEL_OAUTH: "copilot:cancelOAuth",
-    GET_AUTH_STATUS: "copilot:getAuthStatus",
-    LOGOUT: "copilot:logout",
-    DEVICE_CODE: "copilot:deviceCode"
-  },
-  settings: {
-    SETUP_LLM_CONNECTION: "settings:setupLlmConnection",
-    TEST_LLM_CONNECTION_SETUP: "settings:testLlmConnectionSetup",
-    GET_DEFAULT_THINKING_LEVEL: "settings:getDefaultThinkingLevel",
-    SET_DEFAULT_THINKING_LEVEL: "settings:setDefaultThinkingLevel",
-    GET_NETWORK_PROXY: "settings:getNetworkProxy",
-    SET_NETWORK_PROXY: "settings:setNetworkProxy",
-    GET_SERVER_CONFIG: "settings:getServerConfig",
-    SET_SERVER_CONFIG: "settings:setServerConfig",
-    GET_SERVER_STATUS: "settings:getServerStatus"
-  },
-  pi: {
-    GET_API_KEY_PROVIDERS: "pi:getApiKeyProviders",
-    GET_PROVIDER_BASE_URL: "pi:getProviderBaseUrl",
-    GET_PROVIDER_MODELS: "pi:getProviderModels"
-  },
-  dialog: {
-    OPEN_FOLDER: "dialog:openFolder"
-  },
-  preferences: {
-    READ: "preferences:read",
-    WRITE: "preferences:write"
-  },
-  drafts: {
-    GET: "drafts:get",
-    SET: "drafts:set",
-    DELETE: "drafts:delete",
-    GET_ALL: "drafts:getAll"
-  },
-  sources: {
-    GET: "sources:get",
-    CREATE: "sources:create",
-    DELETE: "sources:delete",
-    START_OAUTH: "sources:startOAuth",
-    SAVE_CREDENTIALS: "sources:saveCredentials",
-    CHANGED: "sources:changed",
-    GET_PERMISSIONS: "sources:getPermissions",
-    GET_MCP_TOOLS: "sources:getMcpTools"
-  },
-  oauth: {
-    START: "oauth:start",
-    COMPLETE: "oauth:complete",
-    CANCEL: "oauth:cancel",
-    REVOKE: "oauth:revoke"
-  },
-  workspace: {
-    GET_PERMISSIONS: "workspace:getPermissions",
-    READ_IMAGE: "workspace:readImage",
-    WRITE_IMAGE: "workspace:writeImage",
-    SETTINGS_GET: "workspaceSettings:get",
-    SETTINGS_UPDATE: "workspaceSettings:update"
-  },
-  permissions: {
-    GET_DEFAULTS: "permissions:getDefaults",
-    DEFAULTS_CHANGED: "permissions:defaultsChanged"
-  },
-  skills: {
-    GET: "skills:get",
-    GET_FILES: "skills:getFiles",
-    DELETE: "skills:delete",
-    OPEN_EDITOR: "skills:openEditor",
-    OPEN_FINDER: "skills:openFinder",
-    CHANGED: "skills:changed"
-  },
-  statuses: {
-    LIST: "statuses:list",
-    REORDER: "statuses:reorder",
-    CHANGED: "statuses:changed"
-  },
-  labels: {
-    LIST: "labels:list",
-    CREATE: "labels:create",
-    DELETE: "labels:delete",
-    CHANGED: "labels:changed"
-  },
-  views: {
-    LIST: "views:list",
-    SAVE: "views:save"
-  },
-  toolIcons: {
-    GET_MAPPINGS: "toolIcons:getMappings"
-  },
-  logo: {
-    GET_URL: "logo:getUrl"
-  },
-  notification: {
-    SHOW: "notification:show",
-    NAVIGATE: "notification:navigate",
-    GET_ENABLED: "notification:getEnabled",
-    SET_ENABLED: "notification:setEnabled"
-  },
-  input: {
-    GET_AUTO_CAPITALISATION: "input:getAutoCapitalisation",
-    SET_AUTO_CAPITALISATION: "input:setAutoCapitalisation",
-    GET_SEND_MESSAGE_KEY: "input:getSendMessageKey",
-    SET_SEND_MESSAGE_KEY: "input:setSendMessageKey",
-    GET_SPELL_CHECK: "input:getSpellCheck",
-    SET_SPELL_CHECK: "input:setSpellCheck"
-  },
-  power: {
-    GET_KEEP_AWAKE: "power:getKeepAwake",
-    SET_KEEP_AWAKE: "power:setKeepAwake"
-  },
-  appearance: {
-    GET_RICH_TOOL_DESCRIPTIONS: "appearance:getRichToolDescriptions",
-    SET_RICH_TOOL_DESCRIPTIONS: "appearance:setRichToolDescriptions"
-  },
-  tools: {
-    GET_BROWSER_TOOL_ENABLED: "tools:getBrowserToolEnabled",
-    SET_BROWSER_TOOL_ENABLED: "tools:setBrowserToolEnabled"
-  },
-  caching: {
-    GET_EXTENDED_PROMPT_CACHE: "caching:getExtendedPromptCache",
-    SET_EXTENDED_PROMPT_CACHE: "caching:setExtendedPromptCache",
-    GET_ENABLE_1M_CONTEXT: "caching:getEnable1MContext",
-    SET_ENABLE_1M_CONTEXT: "caching:setEnable1MContext"
-  },
-  badge: {
-    REFRESH: "badge:refresh",
-    SET_ICON: "badge:setIcon",
-    DRAW: "badge:draw",
-    DRAW_WINDOWS: "badge:draw-windows"
-  },
-  releaseNotes: {
-    GET: "releaseNotes:get",
-    GET_LATEST_VERSION: "releaseNotes:getLatestVersion"
-  },
-  git: {
-    GET_BRANCH: "git:getBranch"
-  },
-  gitbash: {
-    CHECK: "gitbash:check",
-    BROWSE: "gitbash:browse",
-    SET_PATH: "gitbash:setPath"
-  },
-  browserPane: {
-    CREATE: "browser-pane:create",
-    DESTROY: "browser-pane:destroy",
-    LIST: "browser-pane:list",
-    NAVIGATE: "browser-pane:navigate",
-    GO_BACK: "browser-pane:go-back",
-    GO_FORWARD: "browser-pane:go-forward",
-    RELOAD: "browser-pane:reload",
-    STOP: "browser-pane:stop",
-    FOCUS: "browser-pane:focus",
-    SNAPSHOT: "browser-pane:snapshot",
-    CLICK: "browser-pane:click",
-    FILL: "browser-pane:fill",
-    SELECT: "browser-pane:select",
-    SCREENSHOT: "browser-pane:screenshot",
-    EVALUATE: "browser-pane:evaluate",
-    SCROLL: "browser-pane:scroll",
-    LAUNCH: "browser-empty-state:launch",
-    STATE_CHANGED: "browser-pane:state-changed",
-    REMOVED: "browser-pane:removed",
-    INTERACTED: "browser-pane:interacted"
-  },
-  automations: {
-    GET: "automations:get",
-    TEST: "automations:test",
-    SET_ENABLED: "automations:setEnabled",
-    DUPLICATE: "automations:duplicate",
-    DELETE: "automations:delete",
-    GET_HISTORY: "automations:getHistory",
-    GET_LAST_EXECUTED: "automations:getLastExecuted",
-    REPLAY: "automations:replay",
-    CHANGED: "automations:changed"
-  },
-  resources: {
-    EXPORT: "resources:export",
-    IMPORT: "resources:import"
-  },
-  messaging: {
-    // WhatsApp subprocess → Gateway (subprocess invokes on server)
-    WA_REGISTER: "messaging:wa:register",
-    WA_INCOMING: "messaging:wa:incoming",
-    WA_BUTTON_PRESS: "messaging:wa:buttonPress",
-    WA_STATUS: "messaging:wa:status",
-    WA_QR: "messaging:wa:qr",
-    // Gateway → WhatsApp subprocess (server invokes on client)
-    WA_SEND: "messaging:wa:send",
-    WA_SEND_BUTTONS: "messaging:wa:sendButtons",
-    WA_SEND_TYPING: "messaging:wa:sendTyping",
-    WA_SEND_FILE: "messaging:wa:sendFile",
-    WA_CONNECT: "messaging:wa:connect",
-    WA_DISCONNECT: "messaging:wa:disconnect",
-    // Gateway → UI clients (broadcast)
-    BINDING_CHANGED: "messaging:bindingChanged",
-    PLATFORM_STATUS: "messaging:platformStatus",
-    /** Broadcast when the workspace's pending-senders list mutates. */
-    PENDING_CHANGED: "messaging:pendingChanged",
-    // UI ↔ Server (config/binding CRUD)
-    GET_CONFIG: "messaging:getConfig",
-    UPDATE_CONFIG: "messaging:updateConfig",
-    TEST_TELEGRAM: "messaging:testTelegram",
-    SAVE_TELEGRAM: "messaging:saveTelegram",
-    TEST_LARK: "messaging:testLark",
-    SAVE_LARK: "messaging:saveLark",
-    DISCONNECT: "messaging:disconnect",
-    FORGET: "messaging:forget",
-    GET_BINDINGS: "messaging:getBindings",
-    GENERATE_CODE: "messaging:generateCode",
-    UNBIND: "messaging:unbind",
-    UNBIND_BINDING: "messaging:unbindBinding",
-    /** Workspace-supergroup pairing (Telegram forum support). UI ↔ Server. */
-    GENERATE_SUPERGROUP_CODE: "messaging:generateSupergroupCode",
-    GET_SUPERGROUP: "messaging:getSupergroup",
-    UNBIND_SUPERGROUP: "messaging:unbindSupergroup",
-    // UI ↔ Server — WhatsApp pairing/connection flow (Baileys subprocess adapter)
-    WA_START_CONNECT: "messaging:wa:startConnect",
-    WA_SUBMIT_PHONE: "messaging:wa:submitPhone",
-    /** Broadcast to UI clients: QR string, pairing code, status, unavailable, error. */
-    WA_UI_EVENT: "messaging:wa:uiEvent",
-    // UI ↔ Server — Access control (per-platform owners + per-binding allow-list)
-    GET_PLATFORM_OWNERS: "messaging:access:getOwners",
-    SET_PLATFORM_OWNERS: "messaging:access:setOwners",
-    GET_PLATFORM_ACCESS_MODE: "messaging:access:getMode",
-    SET_PLATFORM_ACCESS_MODE: "messaging:access:setMode",
-    GET_PENDING_SENDERS: "messaging:access:getPending",
-    DISMISS_PENDING_SENDER: "messaging:access:dismissPending",
-    ALLOW_PENDING_SENDER: "messaging:access:allowPending",
-    SET_BINDING_ACCESS: "messaging:access:setBindingAccess"
-  }
-};
-var SKILL_PATTERN = /\[skill:([^\]]+)\]/g;
-var SOURCE_PATTERN = /\[source:([^\]]+)\]/g;
-var FILE_PATTERN = /\[file:([^\]]+)\]/g;
-var FOLDER_PATTERN = /\[folder:([^\]]+)\]/g;
-function parseMentions(text, availableSkillSlugs, availableSourceSlugs) {
-  const skillSet = new Set(availableSkillSlugs);
-  const sourceSet = new Set(availableSourceSlugs);
-  const skills = [];
-  const invalidSkills = [];
-  const sources = [];
-  const files = [];
-  const folders = [];
-  for (const match of text.matchAll(SKILL_PATTERN)) {
-    const slug = extractSkillSlug(match[1]);
-    if (skillSet.has(slug)) {
-      if (!skills.includes(slug)) skills.push(slug);
-    } else {
-      if (!invalidSkills.includes(slug)) invalidSkills.push(slug);
-    }
-  }
-  for (const match of text.matchAll(SOURCE_PATTERN)) {
-    const slug = match[1].trim();
-    if (sourceSet.has(slug) && !sources.includes(slug)) {
-      sources.push(slug);
-    }
-  }
-  for (const match of text.matchAll(FILE_PATTERN)) {
-    const path = match[1].trim();
-    if (path && !files.includes(path)) files.push(path);
-  }
-  for (const match of text.matchAll(FOLDER_PATTERN)) {
-    const path = match[1].trim();
-    if (path && !folders.includes(path)) folders.push(path);
-  }
-  return { skills, invalidSkills, sources, files, folders };
-}
-function resolveSkillMentions(text, skillNames) {
-  return text.replace(SKILL_PATTERN, (full, raw) => {
-    const slug = extractSkillSlug(raw);
-    const displayName = skillNames.get(slug) ?? slug;
-    return `[Mentioned skill: ${displayName} (slug: ${slug})]`;
-  });
-}
-function resolveSourceMentions(text) {
-  return text.replace(SOURCE_PATTERN, (_, slug) => {
-    return `[Mentioned source: ${slug.trim()}]`;
-  });
-}
-async function resolvePathMentions(text, workingDirectory) {
-  const { basename } = await import("path");
-  const cwd = workingDirectory ?? process.cwd();
-  const fileMatches = [...text.matchAll(FILE_PATTERN)];
-  const folderMatches = [...text.matchAll(FOLDER_PATTERN)];
-  const fileReplacements = /* @__PURE__ */ new Map();
-  for (const match of fileMatches) {
-    const rawPath = match[1].trim();
-    const absPath = await resolvePath(rawPath, cwd);
-    const name = basename(absPath);
-    fileReplacements.set(match[0], `[Mentioned file: ${name} (at ${absPath})]`);
-  }
-  const folderReplacements = /* @__PURE__ */ new Map();
-  for (const match of folderMatches) {
-    const rawPath = match[1].trim();
-    const absPath = await resolvePath(rawPath, cwd);
-    const name = basename(absPath);
-    folderReplacements.set(match[0], `[Mentioned folder: ${name} (at ${absPath})]`);
-  }
-  let result = text;
-  for (const [original, replacement] of fileReplacements) {
-    result = result.replace(original, replacement);
-  }
-  for (const [original, replacement] of folderReplacements) {
-    result = result.replace(original, replacement);
-  }
-  return result;
-}
-function resolveFileMentions(text, workingDirectory) {
-  return resolvePathMentions(text, workingDirectory);
-}
-function stripAllMentions(text) {
-  let result = text;
-  result = result.replace(SKILL_PATTERN, (_, raw) => extractSkillSlug(raw));
-  result = result.replace(SOURCE_PATTERN, (_, slug) => slug.trim());
-  result = result.replace(FILE_PATTERN, (_, p) => p.trim());
-  result = result.replace(FOLDER_PATTERN, (_, p) => p.trim());
-  return result.replace(/\s{2,}/g, " ").trim();
-}
-function findMentionMatches(text, availableSkillSlugs, availableSourceSlugs) {
-  const matches = [];
-  for (const match of text.matchAll(SKILL_PATTERN)) {
-    matches.push({
-      type: "skill",
-      id: extractSkillSlug(match[1]),
-      fullMatch: match[0],
-      startIndex: match.index
-    });
-  }
-  for (const match of text.matchAll(SOURCE_PATTERN)) {
-    matches.push({
-      type: "source",
-      id: match[1].trim(),
-      fullMatch: match[0],
-      startIndex: match.index
-    });
-  }
-  for (const match of text.matchAll(FILE_PATTERN)) {
-    matches.push({
-      type: "file",
-      id: match[1].trim(),
-      fullMatch: match[0],
-      startIndex: match.index
-    });
-  }
-  for (const match of text.matchAll(FOLDER_PATTERN)) {
-    matches.push({
-      type: "folder",
-      id: match[1].trim(),
-      fullMatch: match[0],
-      startIndex: match.index
-    });
-  }
-  return matches.sort((a, b) => a.startIndex - b.startIndex);
-}
-function extractSkillSlug(raw) {
-  const parts = raw.trim().split(":");
-  return parts[parts.length - 1].trim();
-}
-async function resolvePath(path, cwd) {
-  const { resolve } = await import("path");
-  if (path.startsWith("~")) {
-    const { homedir } = await import("os");
-    return resolve(homedir(), path.slice(2));
-  }
-  if (path.startsWith("/")) return path;
-  return resolve(cwd, path);
-}
-
-// ../packages/timeline/dist/index.js
-function createTimelineSequencer(options) {
-  let seq = options.startSeq ?? 0;
-  const now = options.now ?? Date.now;
-  return {
-    append(item, rawRef) {
-      seq += 1;
-      return appendTimelineItem({
-        sessionId: options.sessionId,
-        provider: options.provider,
-        epoch: options.epoch,
-        seq,
-        timestamp: now(),
-        item,
-        rawRef
-      });
-    }
-  };
-}
-function appendTimelineItem(envelope) {
-  return {
-    ...envelope,
-    rawRef: envelope.rawRef ? { ...envelope.rawRef } : void 0
-  };
-}
-function createTimelineCursor(cursor) {
-  return {
-    epoch: cursor.epoch,
-    afterSeq: cursor.afterSeq
-  };
-}
-function fetchTimeline(timeline, request = {}) {
-  const ordered = sortTimeline(timeline);
-  const cursor = request.cursor ?? cursorFromTimelineStart(ordered);
-  const items = ordered.filter((item) => item.epoch === cursor.epoch && item.seq > cursor.afterSeq).slice(0, request.limit);
-  const lastSeq = items.at(-1)?.seq ?? cursor.afterSeq;
-  const firstSeq = items[0]?.seq;
-  return {
-    items,
-    nextCursor: {
-      epoch: cursor.epoch,
-      afterSeq: lastSeq
-    },
-    hasGap: firstSeq !== void 0 && firstSeq > cursor.afterSeq + 1
-  };
-}
-function mergeTimeline(existing, incoming) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const item of [...existing, ...incoming]) {
-    byKey.set(timelineKey(item), item);
-  }
-  return sortTimeline([...byKey.values()]);
-}
-function cursorFromTimelineStart(timeline) {
-  return {
-    epoch: timeline[0]?.epoch ?? "default",
-    afterSeq: 0
-  };
-}
-function sortTimeline(timeline) {
-  return [...timeline].sort((left, right) => {
-    if (left.epoch !== right.epoch) return left.epoch.localeCompare(right.epoch);
-    return left.seq - right.seq;
-  });
-}
-function timelineKey(item) {
-  return `${item.epoch}:${item.seq}`;
-}
+// ../packages/react/src/use-agent-session.ts
+var import_react = require("react");
 
 // ../packages/runtime-core/dist/index.js
 var RUNTIME_KINDS = ["native-sdk", "app-server", "compatible-sdk", "cli-fallback"];
@@ -902,203 +144,9 @@ function createRuntimeExtensionContext(context = {}) {
     hostServices: context.hostServices
   };
 }
-function sanitizeProviderSourceTools(sourceTools) {
-  if (!sourceTools || sourceTools.length === 0) return [];
-  const sanitized = [];
-  for (const sourceTool of sourceTools) {
-    if (sourceTool.kind === "api-source") {
-      const defaultHeaders = sourceTool.defaultHeaders ? copyNonCredentialStringRecord(sourceTool.defaultHeaders) : void 0;
-      sanitized.push({
-        kind: "api-source",
-        sourceSlug: sourceTool.sourceSlug,
-        baseUrl: sourceTool.baseUrl,
-        authType: sourceTool.authType,
-        ...defaultHeaders && Object.keys(defaultHeaders).length > 0 ? { defaultHeaders } : {},
-        ...sourceTool.credentialRef ? { credentialRef: sanitizeSourceCredentialRef(sourceTool.credentialRef) } : {}
-      });
-      continue;
-    }
-    if (sourceTool.kind === "local-source") {
-      sanitized.push({
-        kind: "local-source",
-        sourceSlug: sourceTool.sourceSlug,
-        path: sourceTool.path,
-        ...sourceTool.format ? { format: sourceTool.format } : {}
-      });
-      continue;
-    }
-    if (sourceTool.kind === "mcp-server") {
-      const env = sourceTool.env ? copyNonCredentialStringRecord(sourceTool.env) : void 0;
-      const headers = sourceTool.headers ? copyNonCredentialStringRecord(sourceTool.headers) : void 0;
-      sanitized.push({
-        kind: "mcp-server",
-        sourceSlug: sourceTool.sourceSlug,
-        transport: sourceTool.transport,
-        ...sourceTool.url ? { url: sourceTool.url } : {},
-        ...sourceTool.command ? { command: sourceTool.command } : {},
-        ...sourceTool.args ? { args: sourceTool.args.filter((value) => typeof value === "string") } : {},
-        ...env && Object.keys(env).length > 0 ? { env } : {},
-        ...headers && Object.keys(headers).length > 0 ? { headers } : {},
-        ...sourceTool.credentialRef ? { credentialRef: sanitizeSourceCredentialRef(sourceTool.credentialRef) } : {}
-      });
-    }
-  }
-  return sanitized;
-}
-var sessionToolRequestCounter = 0;
-async function invokeSessionTool(options) {
-  const requestId = `session-tool-${++sessionToolRequestCounter}`;
-  const origin = originFromSessionToolRequest(options.request) ?? options.commandOrigin;
-  const policyDecision = await evaluateSessionToolPolicy(options, requestId);
-  const timelineRefs = [];
-  const append = (item) => {
-    const envelope = options.appendTimeline?.(item);
-    if (envelope) {
-      timelineRefs.push({ epoch: envelope.epoch, seq: envelope.seq });
-    }
-  };
-  if (policyDecision.decision !== "allow") {
-    const reason = policyDecision.decision === "deny" ? policyDecision.reason : policyDecision.reason;
-    append({
-      type: "host_state_changed",
-      state: {
-        kind: "host_tool_denied",
-        requestId,
-        toolName: options.toolName,
-        reason
-      }
-    });
-    return {
-      ok: false,
-      requestId,
-      toolName: options.toolName,
-      origin,
-      policyDecision,
-      reason,
-      timelineRefs
-    };
-  }
-  append({
-    type: "host_state_changed",
-    state: {
-      kind: "host_tool_invoked",
-      requestId,
-      toolName: options.toolName,
-      ...origin ? { origin } : {}
-    }
-  });
-  const callback = options.bridge[options.toolName];
-  if (!callback) {
-    const reason = `Session tool bridge callback is not registered: ${String(options.toolName)}`;
-    append({
-      type: "host_state_changed",
-      state: {
-        kind: "host_tool_result",
-        requestId,
-        toolName: options.toolName,
-        ok: false,
-        reason
-      }
-    });
-    return {
-      ok: false,
-      requestId,
-      toolName: options.toolName,
-      origin,
-      policyDecision,
-      reason,
-      timelineRefs
-    };
-  }
-  try {
-    const result = await callback(options.request);
-    append({
-      type: "host_state_changed",
-      state: {
-        kind: "host_tool_result",
-        requestId,
-        toolName: options.toolName,
-        ok: true
-      }
-    });
-    return {
-      ok: true,
-      requestId,
-      toolName: options.toolName,
-      origin,
-      policyDecision,
-      result,
-      timelineRefs
-    };
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    append({
-      type: "host_state_changed",
-      state: {
-        kind: "host_tool_result",
-        requestId,
-        toolName: options.toolName,
-        ok: false,
-        reason
-      }
-    });
-    return {
-      ok: false,
-      requestId,
-      toolName: options.toolName,
-      origin,
-      policyDecision,
-      reason,
-      timelineRefs
-    };
-  }
-}
-async function evaluateSessionToolPolicy(options, requestId) {
-  if (!options.policy) return { decision: "allow" };
-  return options.policy({
-    toolName: `host.${String(options.toolName)}`,
-    input: recordFromSessionToolRequest(options.request),
-    toolIntent: { kind: "unknown", toolName: `host.${String(options.toolName)}` },
-    scope: { type: "session", sessionId: options.sessionId }
-  });
-}
-function originFromSessionToolRequest(request) {
-  const record = recordFromSessionToolRequest(request);
-  const origin = record.origin ?? record.commandOrigin;
-  return isCommandOrigin(origin) ? origin : void 0;
-}
-function recordFromSessionToolRequest(request) {
-  return request && typeof request === "object" ? { ...request } : {};
-}
-function isCommandOrigin(value) {
-  if (!value || typeof value !== "object") return false;
-  const type = value.type;
-  return type === "user" || type === "automation" || type === "scheduler" || type === "host" || type === "replay" || type === "system";
-}
 function unique(values) {
   return [...new Set(values)];
 }
-function sanitizeSourceCredentialRef(credentialRef) {
-  return {
-    type: credentialRef.type,
-    sourceSlug: credentialRef.sourceSlug,
-    ...credentialRef.workspaceId ? { workspaceId: credentialRef.workspaceId } : {}
-  };
-}
-function copyStringRecord(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string")
-  );
-}
-function copyNonCredentialStringRecord(record) {
-  return Object.fromEntries(
-    Object.entries(copyStringRecord(record)).filter(([key]) => !isCredentialKey(key))
-  );
-}
-function isCredentialKey(key) {
-  const normalized = key.toLowerCase();
-  return normalized === "authorization" || normalized === "proxy-authorization" || normalized === "cookie" || normalized === "set-cookie" || normalized.includes("api-key") || normalized.includes("apikey") || normalized.includes("token") || normalized.includes("secret") || normalized.includes("password");
-}
 function findCandidate(candidates, kind) {
   return candidates.find((candidate) => candidate.kind === kind);
 }
@@ -1184,463 +232,51 @@ function normalizeExtensionCapabilities(capabilities = {}) {
   };
 }
 
-// ../packages/policy/dist/index.js
-var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
-var DANGEROUS_BASH_COMMANDS = /* @__PURE__ */ new Set([
-  "rm",
-  "rmdir",
-  "sudo",
-  "su",
-  "chmod",
-  "chown",
-  "chgrp",
-  "mv",
-  "cp",
-  "dd",
-  "mkfs",
-  "fdisk",
-  "parted",
-  "kill",
-  "killall",
-  "pkill",
-  "reboot",
-  "shutdown",
-  "halt",
-  "poweroff",
-  "curl",
-  "wget",
-  "ssh",
-  "scp",
-  "rsync"
-]);
-var READ_ONLY_BASH_PATTERNS = [
-  /^git\s+status(\s|$)/,
-  /^git\s+diff(\s|$)/,
-  /^git\s+log(\s|$)/,
-  /^ls(\s|$)/,
-  /^pwd(\s|$)/,
-  /^cat\s+/,
-  /^sed\s+-n\s+/,
-  /^rg(\s|$)/,
-  /^find\s+/
-];
-function createPermissionPolicy(options = {}) {
-  return {
-    mode: options.mode ?? "ask",
-    alwaysAllow: [...options.alwaysAllow ?? []],
-    approvals: [...options.approvals ?? []],
-    layers: [...options.layers ?? []]
-  };
-}
-function createSourcePolicyLayer(options) {
-  return {
-    id: options.id ?? `source:${options.sourceSlug}`,
-    rules: {
-      ...options.rules,
-      allowedMcpPatterns: options.rules.allowedMcpPatterns?.map(
-        (pattern) => scopeMcpPatternToSource(options.sourceSlug, pattern)
-      )
-    }
-  };
-}
-function validatePolicyConfig(input) {
-  const errors = [];
-  const warnings = [];
-  const config = asRecord(input);
-  const mode = config.mode;
-  if (mode !== void 0 && !isPermissionMode(mode)) {
-    errors.push({
-      path: "mode",
-      message: `Invalid permission mode: ${String(mode)}`,
-      suggestion: "Use one of: safe, ask, allow-all"
-    });
-  }
-  if (config.layers !== void 0 && !Array.isArray(config.layers)) {
-    errors.push({
-      path: "layers",
-      message: "Expected layers to be an array"
-    });
-  }
-  if (Array.isArray(config.layers)) {
-    config.layers.forEach((layerValue, layerIndex) => {
-      const layer = asRecord(layerValue);
-      const basePath = `layers[${layerIndex}]`;
-      if (typeof layer.id !== "string" || layer.id.length === 0) {
-        errors.push({
-          path: `${basePath}.id`,
-          message: "Layer id is required"
-        });
-      }
-      validateRuleSet(layer.rules, `${basePath}.rules`, errors);
-    });
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function createPermissionPolicyFromConfig(input) {
-  const validation = validatePolicyConfig(input);
-  if (!validation.valid) return { validation };
-  const config = asRecord(input);
-  return {
-    validation,
-    policy: createPermissionPolicy({
-      mode: config.mode,
-      alwaysAllow: config.alwaysAllow,
-      approvals: config.approvals,
-      layers: (config.layers ?? []).map(
-        (layer) => layer.sourceSlug ? createSourcePolicyLayer({
-          id: layer.id,
-          sourceSlug: layer.sourceSlug,
-          rules: layer.rules
-        }) : {
-          id: layer.id,
-          rules: layer.rules,
-          scope: layer.scope
-        }
-      )
-    })
-  };
-}
-function evaluateToolPolicy(policy, request) {
-  const explanation = explainToolPolicy(policy, request);
-  if (explanation.decision === "allow") return { decision: "allow" };
+// ../packages/timeline/dist/index.js
+function createTimelineCursor(cursor) {
   return {
-    decision: explanation.decision,
-    reason: explanation.reason
+    epoch: cursor.epoch,
+    afterSeq: cursor.afterSeq
   };
 }
-function createPolicyDecisionReceipt(options) {
-  const explanation = explainToolPolicy(options.policy, options.request);
-  const decision = explanation.decision === "allow" ? { decision: "allow" } : { decision: explanation.decision, reason: explanation.reason };
+function fetchTimeline(timeline, request = {}) {
+  const ordered = sortTimeline(timeline);
+  const cursor = request.cursor ?? cursorFromTimelineStart(ordered);
+  const items = ordered.filter((item) => item.epoch === cursor.epoch && item.seq > cursor.afterSeq).slice(0, request.limit);
+  const lastSeq = items.at(-1)?.seq ?? cursor.afterSeq;
+  const firstSeq = items[0]?.seq;
   return {
-    requestId: options.requestId,
-    decision,
-    explain: explanation,
-    intent: explanation.intent,
-    ...explanation.matchedRule ? { matchedRule: explanation.matchedRule } : {},
-    ...options.request.scope ? { scope: options.request.scope } : {},
-    ...options.origin ? { origin: options.origin } : {},
-    ...options.ttl !== void 0 ? { ttl: options.ttl } : {},
-    ...explanation.hint ? { hint: explanation.hint } : {},
-    ...options.timelineRefs ? { timelineRefs: options.timelineRefs } : {}
+    items,
+    nextCursor: {
+      epoch: cursor.epoch,
+      afterSeq: lastSeq
+    },
+    hasGap: firstSeq !== void 0 && firstSeq > cursor.afterSeq + 1
   };
 }
-function explainToolPolicy(policy, request) {
-  const intent = normalizeToolIntent(request);
-  if (matchesApproval(policy, request)) {
-    return { decision: "allow", intent };
-  }
-  if (matchesAlwaysAllow(policy, request)) {
-    return { decision: "allow", intent };
-  }
-  if (policy.mode === "allow-all") {
-    return { decision: "allow", intent };
-  }
-  const layeredAllow = findLayeredAllow(policy, intent, request.scope);
-  if (layeredAllow) {
-    return {
-      decision: "allow",
-      intent,
-      matchedRule: layeredAllow
-    };
-  }
-  if (intent.kind === "file_write") {
-    if (policy.mode === "ask") {
-      return {
-        decision: "ask",
-        reason: `${intent.toolName} requires approval in ask mode`,
-        intent
-      };
-    }
-    return {
-      decision: "deny",
-      reason: `${intent.toolName} is blocked in safe mode`,
-      intent
-    };
-  }
-  if (intent.kind === "bash") {
-    return evaluateBashPolicy(policy, intent);
-  }
-  if (intent.kind === "mcp" && policy.mode === "safe") {
-    return {
-      decision: "deny",
-      reason: `MCP tool is blocked in safe mode: ${intent.name}`,
-      intent
-    };
-  }
-  if (intent.kind === "api" && policy.mode === "safe") {
-    return {
-      decision: "deny",
-      reason: `API endpoint is blocked in safe mode: ${intent.method} ${intent.path}`,
-      intent
-    };
+function mergeTimeline(existing, incoming) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of [...existing, ...incoming]) {
+    byKey.set(timelineKey(item), item);
   }
-  return { decision: "allow", intent };
+  return sortTimeline([...byKey.values()]);
 }
-function createInMemoryApprovalStore(options = {}) {
-  const approvals = /* @__PURE__ */ new Map();
-  const now = options.now ?? Date.now;
+function cursorFromTimelineStart(timeline) {
   return {
-    remember(approval) {
-      approvals.set(approval.id, {
-        ...approval,
-        createdAt: approval.createdAt ?? now()
-      });
-    },
-    revoke(id) {
-      approvals.delete(id);
-    },
-    snapshot() {
-      const currentTime = now();
-      return [...approvals.values()].filter((approval) => !approval.expiresAt || approval.expiresAt > currentTime);
-    }
+    epoch: timeline[0]?.epoch ?? "default",
+    afterSeq: 0
   };
 }
-function matchesApproval(policy, request) {
-  const requestScope = scopeKey(request.scope);
-  return policy.approvals.some((approval) => approval.toolName === request.toolName && scopeKey(approval.scope) === requestScope);
-}
-function matchesAlwaysAllow(policy, request) {
-  const requestScope = scopeKey(request.scope);
-  return policy.alwaysAllow.some((rule) => {
-    if (rule.toolName !== request.toolName) return false;
-    if (!rule.scope) return true;
-    return scopeKey(rule.scope) === requestScope;
-  });
-}
-function scopeKey(scope) {
-  if (!scope) return "global";
-  if (typeof scope === "string") return scope;
-  switch (scope.type) {
-    case "session":
-      return `session:${scope.sessionId}`;
-    case "workspace":
-      return `workspace:${scope.workspaceId}`;
-    case "source":
-      return `source:${scope.sourceSlug}`;
-    case "skill":
-      return `skill:${scope.skillSlug}`;
-    case "automation":
-      return `automation:${scope.automationId}`;
-    case "tool-call":
-      return `tool-call:${scope.callId}`;
-  }
-}
-function evaluateBashPolicy(policy, intent) {
-  if (intent.kind !== "bash") {
-    return { decision: "allow", intent };
-  }
-  if (policy.mode === "ask" && DANGEROUS_BASH_COMMANDS.has(intent.baseCommand)) {
-    return {
-      decision: "ask",
-      reason: `${intent.baseCommand} requires approval in ask mode`,
-      intent
-    };
-  }
-  if (policy.mode === "safe") {
-    const layeredAllow = findLayeredAllow(policy, intent);
-    const readOnly = READ_ONLY_BASH_PATTERNS.some((pattern) => pattern.test(intent.command.trim()));
-    if (!readOnly) {
-      const hint = findBlockedCommandHint(policy, intent);
-      return {
-        decision: "deny",
-        reason: `Bash command is blocked in safe mode: ${intent.baseCommand || "unknown command"}`,
-        intent,
-        hint: hint?.reason,
-        matchedRule: hint?.match,
-        ...hint?.tryInstead?.length ? { tryInstead: hint.tryInstead } : {},
-        ...hint?.context ? { hintContext: hint.context } : {}
-      };
-    }
-    if (layeredAllow) {
-      return { decision: "allow", intent, matchedRule: layeredAllow };
-    }
-  }
-  return { decision: "allow", intent };
-}
-function normalizeToolIntent(request) {
-  if (request.toolIntent) return request.toolIntent;
-  if (request.toolName === "Bash") {
-    const command = String(request.input?.command ?? "");
-    const baseCommand = command.trim().split(/\s+/)[0] ?? "";
-    return { kind: "bash", command, baseCommand };
-  }
-  if (FILE_WRITE_TOOLS.has(request.toolName)) {
-    return {
-      kind: "file_write",
-      toolName: request.toolName,
-      path: String(request.input?.file_path ?? request.input?.path ?? "")
-    };
-  }
-  if (request.toolName === "MCP") {
-    return {
-      kind: "mcp",
-      name: String(request.input?.name ?? request.input?.toolName ?? request.input?.tool ?? "")
-    };
-  }
-  if (request.toolName === "API") {
-    const url = request.input?.url ? String(request.input.url) : void 0;
-    return {
-      kind: "api",
-      method: String(request.input?.method ?? "GET").toUpperCase(),
-      path: pathFromUrl(url ?? String(request.input?.path ?? "/")),
-      url
-    };
-  }
-  return { kind: "unknown", toolName: request.toolName };
-}
-function findLayeredAllow(policy, intent, scope) {
-  for (const layer of policy.layers) {
-    if (layer.scope && scopeKey(layer.scope) !== scopeKey(scope)) continue;
-    const match = matchLayerRules(layer, intent);
-    if (match) return match;
-  }
-  return void 0;
-}
-function matchLayerRules(layer, intent) {
-  if (intent.kind === "file_write") {
-    const pattern = layer.rules.allowedWritePaths?.find((rule) => globMatches(rule, intent.path));
-    return pattern ? { layerId: layer.id, ruleType: "write-path", pattern } : void 0;
-  }
-  if (intent.kind === "mcp") {
-    const pattern = layer.rules.allowedMcpPatterns?.find((rule) => regexMatches(rule, intent.name));
-    return pattern ? { layerId: layer.id, ruleType: "mcp-pattern", pattern } : void 0;
-  }
-  if (intent.kind === "api") {
-    const rule = layer.rules.allowedApiEndpoints?.find((candidate) => candidate.method.toUpperCase() === intent.method && globMatches(candidate.pattern, intent.path));
-    return rule ? { layerId: layer.id, ruleType: "api-endpoint", pattern: `${rule.method.toUpperCase()} ${rule.pattern}` } : void 0;
-  }
-  if (intent.kind === "bash") {
-    const pattern = layer.rules.allowedBashPatterns?.find((rule) => regexMatches(rule, intent.command));
-    return pattern ? { layerId: layer.id, ruleType: "bash-pattern", pattern } : void 0;
-  }
-  return void 0;
-}
-function findBlockedCommandHint(policy, intent) {
-  for (const layer of policy.layers) {
-    const hint = layer.rules.blockedCommandHints?.find((rule) => {
-      if (rule.command !== intent.baseCommand) return false;
-      if (!rule.whenNotMatching) return true;
-      return !regexMatches(rule.whenNotMatching, intent.command);
-    });
-    if (hint) {
-      return {
-        reason: hint.reason,
-        match: {
-          layerId: layer.id,
-          ruleType: "blocked-command-hint",
-          pattern: hint.command
-        },
-        ...hint.tryInstead?.length ? { tryInstead: hint.tryInstead } : {},
-        ...hint.context ? { context: hint.context } : {}
-      };
-    }
-  }
-  return void 0;
-}
-function pathFromUrl(value) {
-  try {
-    return new URL(value).pathname;
-  } catch {
-    return value.startsWith("/") ? value : `/${value}`;
-  }
-}
-function regexMatches(pattern, value) {
-  try {
-    return new RegExp(pattern).test(value);
-  } catch {
-    return pattern === value;
-  }
-}
-function globMatches(pattern, value) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
-  return new RegExp(`^${escaped}$`).test(value);
-}
-function scopeMcpPatternToSource(sourceSlug, pattern) {
-  if (pattern.includes("mcp__")) return pattern;
-  return `^mcp__${escapeRegex(sourceSlug)}__.*${pattern}`;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function validateRuleSet(rulesValue, path, errors) {
-  if (rulesValue === void 0) {
-    errors.push({
-      path,
-      message: "Layer rules are required"
-    });
-    return;
-  }
-  const rules = asRecord(rulesValue);
-  validateRegexList(rules.allowedBashPatterns, `${path}.allowedBashPatterns`, errors);
-  validateRegexList(rules.allowedMcpPatterns, `${path}.allowedMcpPatterns`, errors);
-  validateApiEndpointRules(rules.allowedApiEndpoints, `${path}.allowedApiEndpoints`, errors);
-}
-function validateRegexList(value, path, errors) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    errors.push({ path, message: "Expected an array of regular expression strings" });
-    return;
-  }
-  value.forEach((pattern, index) => {
-    if (typeof pattern !== "string") {
-      errors.push({ path: `${path}[${index}]`, message: "Expected a regular expression string" });
-      return;
-    }
-    if (!isValidRegex(pattern)) {
-      errors.push({
-        path: `${path}[${index}]`,
-        message: `Invalid regular expression: ${pattern}`
-      });
-    }
-  });
-}
-function validateApiEndpointRules(value, path, errors) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    errors.push({ path, message: "Expected an array of API endpoint rules" });
-    return;
-  }
-  value.forEach((ruleValue, index) => {
-    const rule = asRecord(ruleValue);
-    const method = rule.method;
-    if (typeof method !== "string" || !HTTP_METHODS.has(method.toUpperCase())) {
-      errors.push({
-        path: `${path}[${index}].method`,
-        message: `Invalid HTTP method: ${String(method)}`,
-        suggestion: "Use one of: GET, POST, PUT, PATCH, DELETE"
-      });
-    }
-    if (typeof rule.pattern !== "string") {
-      errors.push({
-        path: `${path}[${index}].pattern`,
-        message: "API endpoint pattern is required"
-      });
-    }
+function sortTimeline(timeline) {
+  return [...timeline].sort((left, right) => {
+    if (left.epoch !== right.epoch) return left.epoch.localeCompare(right.epoch);
+    return left.seq - right.seq;
   });
 }
-function isPermissionMode(value) {
-  return value === "safe" || value === "ask" || value === "allow-all";
-}
-var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-function isValidRegex(pattern) {
-  try {
-    new RegExp(pattern);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function asRecord(value) {
-  return value && typeof value === "object" ? value : {};
+function timelineKey(item) {
+  return `${item.epoch}:${item.seq}`;
 }
 
-// src/index.ts
-var import_weft_react = require("@percena/weft-react");
-
 // ../packages/client/dist/index.js
 var FlitroHttpClient = class {
   baseUrl;
@@ -2301,8 +937,111 @@ var PushTimelineStream = class {
   }
 };
 
+// ../packages/react/src/use-agent-session.ts
+function useAgentSession(options) {
+  const onTokenExpiredRef = (0, import_react.useRef)(options.onTokenExpired);
+  onTokenExpiredRef.current = options.onTokenExpired;
+  const tokenRef = (0, import_react.useRef)(options.token);
+  tokenRef.current = options.token;
+  const runtime = (0, import_react.useMemo)(() => {
+    return createDeferredAgentRuntime({
+      provider: "flitro",
+      runtimeKind: "app-server",
+      sessionId: options.sessionId,
+      createRuntime: () => createFlitroEmbedRuntime({
+        baseUrl: options.server,
+        token: tokenRef.current,
+        sessionId: options.sessionId,
+        onTokenExpired: () => onTokenExpiredRef.current?.()
+      })
+    });
+  }, [options.server, options.sessionId]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      void runtime.disposeIfCreated();
+    };
+  }, [runtime]);
+  return { runtime, sessionId: options.sessionId, server: options.server };
+}
+function createDeferredAgentRuntime(options) {
+  let runtime = null;
+  let disposed = false;
+  const getRuntime = () => {
+    if (disposed) {
+      throw new Error("Agent runtime has been disposed");
+    }
+    runtime ??= options.createRuntime();
+    return runtime;
+  };
+  return {
+    get sessionId() {
+      return runtime?.sessionId ?? options.sessionId;
+    },
+    get provider() {
+      return runtime?.provider ?? options.provider;
+    },
+    get runtimeKind() {
+      return runtime?.runtimeKind ?? options.runtimeKind;
+    },
+    events: {
+      connect(onEvent, onError, onClose) {
+        getRuntime().events.connect(onEvent, onError, onClose);
+      },
+      disconnect() {
+        runtime?.events.disconnect();
+      },
+      isConnected() {
+        return runtime?.events.isConnected() ?? false;
+      }
+    },
+    commands: {
+      sendMessage(message, sendOptions) {
+        return getRuntime().commands.sendMessage(message, sendOptions);
+      },
+      abort(reason) {
+        return getRuntime().commands.abort(reason);
+      },
+      respondToPermission(requestId, allowed, remember) {
+        return getRuntime().commands.respondToPermission(requestId, allowed, remember);
+      },
+      async resumeTool(runId, resumeData) {
+        const commands = getRuntime().commands;
+        if (!commands.resumeTool) {
+          throw new Error(`resumeTool is not supported by the ${options.provider} runtime`);
+        }
+        await commands.resumeTool(runId, resumeData);
+      },
+      dispose() {
+        disposed = true;
+        const current = runtime;
+        runtime = null;
+        return current?.commands.dispose() ?? Promise.resolve();
+      }
+    },
+    preflight() {
+      return getRuntime().preflight();
+    },
+    fetchTimeline(request) {
+      return getRuntime().fetchTimeline(request);
+    },
+    getState() {
+      return runtime?.getState() ?? {
+        status: initialRuntimeState.status,
+        acceptedMessages: [],
+        queuedMessages: []
+      };
+    },
+    async disposeIfCreated() {
+      if (!runtime) return;
+      const current = runtime;
+      runtime = null;
+      await current.commands.dispose();
+    }
+  };
+}
+
 // ../packages/local-chat/dist/index.js
-var import_react18 = require("react");
+var import_react19 = require("react");
 
 // ../packages/ui/dist/chunk-MRPTNS4U.js
 var EN_FALLBACK = {
@@ -2341,11 +1080,38 @@ var EN_FALLBACK = {
   "plan.acceptAndSendFollowups": "Accept & send follow-ups"
 };
 
+// ../packages/core/dist/chunk-QEEF5TZY.js
+function generateMessageId() {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function storedToMessage(stored) {
+  const { type, ...rest } = stored;
+  return { ...rest, role: type, timestamp: stored.timestamp ?? Date.now() };
+}
+
+// ../packages/core/dist/chunk-LCDW7EA2.js
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function pathStartsWith(filePath, dirPath) {
+  const normalizedFile = normalizePath(filePath);
+  const normalizedDir = normalizePath(dirPath);
+  return normalizedFile.startsWith(normalizedDir + "/") || normalizedFile === normalizedDir;
+}
+function stripPathPrefix(filePath, prefix) {
+  const normalizedFile = normalizePath(filePath);
+  const normalizedPrefix = normalizePath(prefix);
+  if (normalizedFile.startsWith(normalizedPrefix + "/")) {
+    return normalizedFile.slice(normalizedPrefix.length + 1);
+  }
+  return filePath;
+}
+
 // ../packages/ui/dist/index.js
 var React10 = __toESM(require("react"), 1);
-var import_react = require("react");
+var import_react2 = require("react");
 var import_i18next = __toESM(require("i18next"), 1);
-var import_react2 = require("motion/react");
+var import_react3 = require("motion/react");
 var import_lucide_react = require("lucide-react");
 var import_jsx_runtime = require("react/jsx-runtime");
 var React2 = __toESM(require("react"), 1);
@@ -2355,12 +1121,12 @@ var React = __toESM(require("react"), 1);
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var import_i18next2 = __toESM(require("i18next"), 1);
-var import_react3 = require("react");
-var import_react4 = require("motion/react");
+var import_react4 = require("react");
+var import_react5 = require("motion/react");
 var import_lucide_react3 = require("lucide-react");
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var import_jsx_runtime5 = require("react/jsx-runtime");
-var import_react5 = require("react");
+var import_react6 = require("react");
 var import_react_i18next2 = require("react-i18next");
 var import_lucide_react4 = require("lucide-react");
 var React6 = __toESM(require("react"), 1);
@@ -2372,7 +1138,7 @@ var import_remark_math = __toESM(require("remark-math"), 1);
 var React3 = __toESM(require("react"), 1);
 var import_core2 = require("@shikijs/core");
 var import_engine_javascript = require("@shikijs/engine-javascript");
-var import_react6 = require("react");
+var import_react7 = require("react");
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var React4 = __toESM(require("react"), 1);
@@ -2387,31 +1153,31 @@ var import_jsx_runtime15 = require("react/jsx-runtime");
 var import_jsx_runtime16 = require("react/jsx-runtime");
 var React5 = __toESM(require("react"), 1);
 var import_lucide_react5 = require("lucide-react");
-var import_react7 = require("motion/react");
+var import_react8 = require("motion/react");
 var import_jsx_runtime17 = require("react/jsx-runtime");
-var import_react8 = require("react");
+var import_react9 = require("react");
 var import_jsx_runtime18 = require("react/jsx-runtime");
 var import_jsx_runtime19 = require("react/jsx-runtime");
 var React7 = __toESM(require("react"), 1);
 var import_jsx_runtime20 = require("react/jsx-runtime");
 var React8 = __toESM(require("react"), 1);
 var React9 = __toESM(require("react"), 1);
-var import_react9 = require("react");
+var import_react10 = require("react");
 var import_react_i18next3 = require("react-i18next");
 var ReactDOM = __toESM(require("react-dom"), 1);
 var import_lucide_react6 = require("lucide-react");
 var import_jsx_runtime21 = require("react/jsx-runtime");
 var import_jsx_runtime22 = require("react/jsx-runtime");
 var import_jsx_runtime23 = require("react/jsx-runtime");
-var import_react10 = require("motion/react");
+var import_react11 = require("motion/react");
 var import_lucide_react7 = require("lucide-react");
 var import_jsx_runtime24 = require("react/jsx-runtime");
 var import_jsx_runtime25 = require("react/jsx-runtime");
 var import_react_i18next4 = require("react-i18next");
 var import_lucide_react8 = require("lucide-react");
 var import_jsx_runtime26 = require("react/jsx-runtime");
-var import_react11 = require("react");
 var import_react12 = require("react");
+var import_react13 = require("react");
 var import_lucide_react9 = require("lucide-react");
 var import_lucide_react10 = require("lucide-react");
 var import_jsx_runtime27 = require("react/jsx-runtime");
@@ -2420,18 +1186,18 @@ var import_jsx_runtime28 = require("react/jsx-runtime");
 var import_jsx_runtime29 = require("react/jsx-runtime");
 var import_jsx_runtime30 = require("react/jsx-runtime");
 var import_jsx_runtime31 = require("react/jsx-runtime");
-var import_react13 = require("react");
 var import_react14 = require("react");
+var import_react15 = require("react");
 var import_jsx_runtime32 = require("react/jsx-runtime");
 var import_jsx_runtime33 = require("react/jsx-runtime");
 var import_jsx_runtime34 = require("react/jsx-runtime");
-var import_react15 = require("react");
+var import_react16 = require("react");
 var import_jsx_runtime35 = require("react/jsx-runtime");
 var import_jsx_runtime36 = require("react/jsx-runtime");
-var import_react16 = require("react");
+var import_react17 = require("react");
 var import_jsx_runtime37 = require("react/jsx-runtime");
 var import_jsx_runtime38 = require("react/jsx-runtime");
-var import_react17 = require("react");
+var import_react18 = require("react");
 function getAssistantTurnUiKey(turn, index) {
   if (turn.response?.messageId) {
     return `assistant:msg:${turn.response.messageId}`;
@@ -2948,7 +1714,7 @@ function groupActivitiesByParent(activities) {
   }
   return result;
 }
-function asRecord2(value) {
+function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function normalizeFollowUpText(text) {
@@ -2958,7 +1724,7 @@ function getAnnotationNoteText(annotation) {
   const noteBody = annotation.body.find((body) => body.type === "note");
   const bodyText = noteBody?.text?.trim() ?? "";
   if (bodyText.length > 0) return bodyText;
-  const followUpMeta = asRecord2(asRecord2(annotation.meta)?.followUp);
+  const followUpMeta = asRecord(asRecord(annotation.meta)?.followUp);
   const metaText = typeof followUpMeta?.text === "string" ? followUpMeta.text.trim() : "";
   return metaText;
 }
@@ -3521,8 +2287,8 @@ function ActivityStatusIcon({
         return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react3.XCircle, { className: cn(SIZE_CONFIG.iconSize, "shrink-0 text-destructive") });
     }
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react4.AnimatePresence, { mode: "wait", initial: false, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-    import_react4.motion.div,
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react5.AnimatePresence, { mode: "wait", initial: false, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    import_react5.motion.div,
     {
       initial: { opacity: 0, scale: 0.8 },
       animate: { opacity: 1, scale: 1 },
@@ -3748,12 +2514,12 @@ function ActivityRow({ activity, onOpenDetails, isLastChild, sessionFolderPath,
   ] });
 }
 function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExpandedGroupsChange, onOpenActivityDetails, animationIndex = 0, sessionFolderPath, displayMode = "detailed" }) {
-  const [localExpandedGroups, setLocalExpandedGroups] = (0, import_react3.useState)(/* @__PURE__ */ new Set());
+  const [localExpandedGroups, setLocalExpandedGroups] = (0, import_react4.useState)(/* @__PURE__ */ new Set());
   const expandedGroups = externalExpandedGroups ?? localExpandedGroups;
   const setExpandedGroups = onExpandedGroupsChange ?? setLocalExpandedGroups;
   const groupId = group.parent.id;
   const isExpanded = expandedGroups.has(groupId);
-  const toggleExpanded = (0, import_react3.useCallback)(() => {
+  const toggleExpanded = (0, import_react4.useCallback)(() => {
     const next = new Set(expandedGroups);
     if (next.has(groupId)) {
       next.delete(groupId);
@@ -3767,7 +2533,7 @@ function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExp
   const isComplete = group.parent.status === "completed" || group.parent.status === "error";
   const hasError = group.parent.status === "error";
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
-    import_react4.motion.div,
+    import_react5.motion.div,
     {
       initial: { opacity: 0, x: -8 },
       animate: { opacity: 1, x: 0 },
@@ -3785,7 +2551,7 @@ function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExp
             onClick: toggleExpanded,
             children: [
               /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-                import_react4.motion.div,
+                import_react5.motion.div,
                 {
                   initial: false,
                   animate: { rotate: isExpanded ? 90 : 0 },
@@ -3834,8 +2600,8 @@ function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExp
             ]
           }
         ),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react4.AnimatePresence, { initial: false, children: isExpanded && group.children.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-          import_react4.motion.div,
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react5.AnimatePresence, { initial: false, children: isExpanded && group.children.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          import_react5.motion.div,
           {
             initial: { height: 0, opacity: 0 },
             animate: { height: "auto", opacity: 1 },
@@ -3846,7 +2612,7 @@ function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExp
             },
             className: "overflow-hidden",
             children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "pl-0 space-y-0.5 border-l-2 border-muted ml-[5px]", children: group.children.map((child, idx) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-              import_react4.motion.div,
+              import_react5.motion.div,
               {
                 initial: { opacity: 0, x: -4 },
                 animate: { opacity: 1, x: 0 },
@@ -3871,9 +2637,9 @@ function ActivityGroupRow({ group, expandedGroups: externalExpandedGroups, onExp
     }
   );
 }
-var ShikiThemeContext = (0, import_react6.createContext)(null);
+var ShikiThemeContext = (0, import_react7.createContext)(null);
 function useShikiTheme() {
-  return (0, import_react6.useContext)(ShikiThemeContext);
+  return (0, import_react7.useContext)(ShikiThemeContext);
 }
 var LANGUAGE_LOADERS = {
   bash: () => import("@shikijs/langs/bash"),
@@ -4123,8 +2889,8 @@ var remarkCollapsibleSections = function() {
 };
 var remarkCollapsibleSections_default = remarkCollapsibleSections;
 function AnimatedCollapsibleContent({ isOpen, children }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react7.AnimatePresence, { initial: false, children: isOpen && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
-    import_react7.motion.div,
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react8.AnimatePresence, { initial: false, children: isOpen && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    import_react8.motion.div,
     {
       initial: { height: 0, opacity: 0 },
       animate: { height: "auto", opacity: 1 },
@@ -4161,7 +2927,7 @@ function CollapsibleSection({
         onClick: () => hasContent && onToggle(sectionId),
         children: [
           /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
-            import_react7.motion.div,
+            import_react8.motion.div,
             {
               initial: false,
               animate: { rotate: isExpanded ? 90 : 0 },
@@ -4182,9 +2948,9 @@ function CollapsibleSection({
     hasContent && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(AnimatedCollapsibleContent, { isOpen: isExpanded, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "collapsible-section-content", children: content }) })
   ] });
 }
-var CollapsibleMarkdownContext = (0, import_react8.createContext)(null);
+var CollapsibleMarkdownContext = (0, import_react9.createContext)(null);
 function useCollapsibleMarkdown() {
-  return (0, import_react8.useContext)(CollapsibleMarkdownContext);
+  return (0, import_react9.useContext)(CollapsibleMarkdownContext);
 }
 function wrapWithSafeProxy(components) {
   return components;
@@ -4873,11 +3639,11 @@ function AcceptPlanDropdown({
   const { t: t2 } = (0, import_react_i18next3.useTranslation)();
   const effectiveAcceptLabel = acceptLabel ?? t2("plan.acceptPlan");
   const effectiveAcceptOptionLabel = acceptOptionLabel ?? t2("plan.accept");
-  const [isOpen, setIsOpen] = (0, import_react9.useState)(false);
-  const [position, setPosition] = (0, import_react9.useState)(null);
-  const triggerRef = (0, import_react9.useRef)(null);
-  const menuRef = (0, import_react9.useRef)(null);
-  const updatePosition = (0, import_react9.useCallback)(() => {
+  const [isOpen, setIsOpen] = (0, import_react10.useState)(false);
+  const [position, setPosition] = (0, import_react10.useState)(null);
+  const triggerRef = (0, import_react10.useRef)(null);
+  const menuRef = (0, import_react10.useRef)(null);
+  const updatePosition = (0, import_react10.useCallback)(() => {
     if (!triggerRef.current) return;
     const rect = triggerRef.current.getBoundingClientRect();
     const menuWidth = 280;
@@ -4892,7 +3658,7 @@ function AcceptPlanDropdown({
     }
     setPosition({ top, left });
   }, []);
-  const handleToggle = (0, import_react9.useCallback)((e) => {
+  const handleToggle = (0, import_react10.useCallback)((e) => {
     e.stopPropagation();
     if (!isOpen) {
       if (triggerRef.current) {
@@ -4912,25 +3678,25 @@ function AcceptPlanDropdown({
     }
     setIsOpen((prev) => !prev);
   }, [isOpen]);
-  const handleClose = (0, import_react9.useCallback)(() => {
+  const handleClose = (0, import_react10.useCallback)(() => {
     setIsOpen(false);
   }, []);
-  const handleSelectAccept = (0, import_react9.useCallback)((e) => {
+  const handleSelectAccept = (0, import_react10.useCallback)((e) => {
     e.stopPropagation();
     handleClose();
     onAccept();
   }, [handleClose, onAccept]);
-  const handleSelectCompact = (0, import_react9.useCallback)((e) => {
+  const handleSelectCompact = (0, import_react10.useCallback)((e) => {
     e.stopPropagation();
     handleClose();
     onAcceptWithCompact();
   }, [handleClose, onAcceptWithCompact]);
-  (0, import_react9.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     if (isOpen) {
       updatePosition();
     }
   }, [isOpen, updatePosition]);
-  (0, import_react9.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     if (!isOpen) return;
     const handleClickOutside = (e) => {
       if (menuRef.current && !menuRef.current.contains(e.target) && triggerRef.current && !triggerRef.current.contains(e.target)) {
@@ -5139,11 +3905,11 @@ function ResponseCard({
   annotationInteractionMode = "interactive"
 }) {
   const { t: t2 } = (0, import_react_i18next2.useTranslation)();
-  const [displayedText, setDisplayedText] = (0, import_react5.useState)(text);
-  const lastUpdateRef = (0, import_react5.useRef)(Date.now());
-  const [copied, setCopied] = (0, import_react5.useState)(false);
-  const [isFullscreen, setIsFullscreen] = (0, import_react5.useState)(false);
-  const [isDarkMode, setIsDarkMode] = (0, import_react5.useState)(false);
+  const [displayedText, setDisplayedText] = (0, import_react6.useState)(text);
+  const lastUpdateRef = (0, import_react6.useRef)(Date.now());
+  const [copied, setCopied] = (0, import_react6.useState)(false);
+  const [isFullscreen, setIsFullscreen] = (0, import_react6.useState)(false);
+  const [isDarkMode, setIsDarkMode] = (0, import_react6.useState)(false);
   const interaction = useAnnotationInteractionController();
   const {
     state: interactionState,
@@ -5163,23 +3929,23 @@ function ResponseCard({
   const followUpDraft = interactionState.followUpDraft;
   const followUpMode = interactionState.followUpMode;
   const activeAnnotationDetail = interactionState.activeAnnotationDetail;
-  const [selectionMenuShowNonce, setSelectionMenuShowNonce] = (0, import_react5.useState)(0);
-  const [selectionMenuTransitionConfig, setSelectionMenuTransitionConfig] = (0, import_react5.useState)(
+  const [selectionMenuShowNonce, setSelectionMenuShowNonce] = (0, import_react6.useState)(0);
+  const [selectionMenuTransitionConfig, setSelectionMenuTransitionConfig] = (0, import_react6.useState)(
     buildAnnotationChipEntryTransition()
   );
-  const [annotationOverlay, setAnnotationOverlay] = (0, import_react5.useState)({ rects: [], chips: [] });
-  const contentRef = (0, import_react5.useRef)(null);
-  const contentLayerRef = (0, import_react5.useRef)(null);
-  const lastPointerRef = (0, import_react5.useRef)(null);
-  const dragStartPointerRef = (0, import_react5.useRef)(null);
-  const selectionStartedInContentRef = (0, import_react5.useRef)(false);
+  const [annotationOverlay, setAnnotationOverlay] = (0, import_react6.useState)({ rects: [], chips: [] });
+  const contentRef = (0, import_react6.useRef)(null);
+  const contentLayerRef = (0, import_react6.useRef)(null);
+  const lastPointerRef = (0, import_react6.useRef)(null);
+  const dragStartPointerRef = (0, import_react6.useRef)(null);
+  const selectionStartedInContentRef = (0, import_react6.useRef)(false);
   const canAnnotate = canAnnotateMessage({
     hasAddAnnotationHandler: !!onAddAnnotation,
     hasMessageId: !!messageId,
     isStreaming
   });
   const allowAnnotationIsland = annotationInteractionMode === "interactive";
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     const checkDarkMode = () => {
       setIsDarkMode(document.documentElement.classList.contains("dark"));
     };
@@ -5188,22 +3954,22 @@ function ResponseCard({
     observer.observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
     return () => observer.disconnect();
   }, []);
-  const closeSelectionMenu = (0, import_react5.useCallback)(() => {
+  const closeSelectionMenu = (0, import_react6.useCallback)(() => {
     closeAll();
   }, [closeAll]);
-  const isTargetInsideAnnotationIsland = (0, import_react5.useCallback)((target) => {
+  const isTargetInsideAnnotationIsland = (0, import_react6.useCallback)((target) => {
     if (!target) return false;
     const element = target instanceof Element ? target : target.parentElement;
     if (!element) return false;
     return !!element.closest('[data-ca-annotation-island="true"]');
   }, []);
-  const triggerSelectionMenuEntryReplay = (0, import_react5.useCallback)(() => {
+  const triggerSelectionMenuEntryReplay = (0, import_react6.useCallback)(() => {
     setSelectionMenuShowNonce((prev) => prev + 1);
   }, []);
-  const activeMenuAnchor = (0, import_react5.useMemo)(() => {
+  const activeMenuAnchor = (0, import_react6.useMemo)(() => {
     return getAnnotationInteractionAnchor(interactionState);
   }, [interactionState]);
-  const selectionMenuSourceKey = (0, import_react5.useMemo)(() => {
+  const selectionMenuSourceKey = (0, import_react6.useMemo)(() => {
     const messageScope = messageId ?? "no-message";
     return getAnnotationInteractionSourceKey(interactionState, messageScope);
   }, [interactionState, messageId]);
@@ -5218,7 +3984,7 @@ function ResponseCard({
     anchor: activeMenuAnchor,
     sourceKey: selectionMenuSourceKey
   });
-  const handleCopy = (0, import_react5.useCallback)(async () => {
+  const handleCopy = (0, import_react6.useCallback)(async () => {
     try {
       await navigator.clipboard.writeText(text);
       setCopied(true);
@@ -5227,7 +3993,7 @@ function ResponseCard({
       console.error("Failed to copy:", err);
     }
   }, [text]);
-  const renderedAnnotations = (0, import_react5.useMemo)(() => {
+  const renderedAnnotations = (0, import_react6.useMemo)(() => {
     const persisted = annotations ?? [];
     if (!pendingSelection || !selectionMenuView || !messageId) {
       return persisted;
@@ -5240,17 +4006,17 @@ function ResponseCard({
       createSelectionPreviewAnnotation(messageId, pendingSelection, sessionId ?? "")
     ];
   }, [annotations, pendingSelection, selectionMenuView, messageId]);
-  const activeAnnotation = (0, import_react5.useMemo)(() => {
+  const activeAnnotation = (0, import_react6.useMemo)(() => {
     if (!activeAnnotationDetail) return null;
     return (annotations ?? []).find((annotation) => annotation.id === activeAnnotationDetail.annotationId) ?? null;
   }, [annotations, activeAnnotationDetail]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!activeAnnotationDetail) return;
     if (!activeAnnotation) {
       closeSelectionMenu();
     }
   }, [activeAnnotationDetail, activeAnnotation, closeSelectionMenu]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     const root = contentLayerRef.current;
     if (!root) {
       setAnnotationOverlay({ rects: [], chips: [] });
@@ -5286,18 +4052,18 @@ function ResponseCard({
       window.removeEventListener("resize", recomputeOverlay);
     };
   }, [annotations, renderedAnnotations, text, displayedText, isStreaming]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!canAnnotate) {
       closeSelectionMenu();
     }
   }, [canAnnotate, closeSelectionMenu]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     closeSelectionMenu();
     resetPresentation();
     dragStartPointerRef.current = null;
     lastPointerRef.current = null;
   }, [sessionId, closeSelectionMenu, resetPresentation]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!hasAnnotationInteraction(interactionState) || !isSelectionMenuVisible) return;
     const handleSelectionChange = () => {
       if (selectionMenuOpenedAtRef.current == null || Date.now() - selectionMenuOpenedAtRef.current < 180) {
@@ -5327,15 +4093,15 @@ function ResponseCard({
       document.removeEventListener("selectionchange", handleSelectionChange);
     };
   }, [interactionState, isSelectionMenuVisible, closeSelectionMenu, isTargetInsideAnnotationIsland, selectionMenuOpenedAtRef]);
-  const handleOpenFollowUpView = (0, import_react5.useCallback)(() => {
+  const handleOpenFollowUpView = (0, import_react6.useCallback)(() => {
     if (!pendingSelection) return;
     clearDomSelection();
     openFollowUpFromSelection();
   }, [pendingSelection, openFollowUpFromSelection]);
-  const handleRequestFollowUpEdit = (0, import_react5.useCallback)(() => {
+  const handleRequestFollowUpEdit = (0, import_react6.useCallback)(() => {
     requestEdit();
   }, [requestEdit]);
-  const saveFollowUp = (0, import_react5.useCallback)(async (note) => {
+  const saveFollowUp = (0, import_react6.useCallback)(async (note) => {
     const normalizedNote = note.trim();
     if (!messageId) return null;
     if (activeAnnotationDetail) {
@@ -5409,10 +4175,10 @@ function ResponseCard({
     markSubmitSuccess,
     text
   ]);
-  const handleSubmitFollowUp = (0, import_react5.useCallback)((note) => {
+  const handleSubmitFollowUp = (0, import_react6.useCallback)((note) => {
     void saveFollowUp(note);
   }, [saveFollowUp]);
-  const handleSubmitAndSendFollowUp = (0, import_react5.useCallback)((note) => {
+  const handleSubmitAndSendFollowUp = (0, import_react6.useCallback)((note) => {
     void saveFollowUp(note).then((savedFollowUp) => {
       if (!savedFollowUp) return;
       onSaveAndSendFollowUp?.(savedFollowUp);
@@ -5422,7 +4188,7 @@ function ResponseCard({
     contentRootRef: contentLayerRef,
     cancelFollowUp
   });
-  const handleOpenAnnotationDetail = (0, import_react5.useCallback)((annotationId, index, anchorX, anchorY, mode = "view") => {
+  const handleOpenAnnotationDetail = (0, import_react6.useCallback)((annotationId, index, anchorX, anchorY, mode = "view") => {
     if (!allowAnnotationIsland) return;
     const annotation = (annotations ?? []).find((item) => item.id === annotationId);
     const noteText = annotation ? getAnnotationNoteText(annotation) : "";
@@ -5431,7 +4197,7 @@ function ResponseCard({
     triggerSelectionMenuEntryReplay();
     openFromAnnotation({ annotationId, index, anchorX, anchorY }, noteText, mode);
   }, [allowAnnotationIsland, annotations, triggerSelectionMenuEntryReplay, openFromAnnotation]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!allowAnnotationIsland) return;
     const contentRect = contentLayerRef.current?.getBoundingClientRect();
     const fallbackAnchor = {
@@ -5455,12 +4221,12 @@ function ResponseCard({
     consumeExternalOpenRequest,
     triggerSelectionMenuEntryReplay
   ]);
-  const handleDeleteActiveAnnotation = (0, import_react5.useCallback)(() => {
+  const handleDeleteActiveAnnotation = (0, import_react6.useCallback)(() => {
     if (!onRemoveAnnotation || !messageId || !activeAnnotationDetail) return;
     onRemoveAnnotation(messageId, activeAnnotationDetail.annotationId);
     markDeleteSuccess();
   }, [onRemoveAnnotation, messageId, activeAnnotationDetail, markDeleteSuccess]);
-  const handleSelectionPointerDown = (0, import_react5.useCallback)((event) => {
+  const handleSelectionPointerDown = (0, import_react6.useCallback)((event) => {
     selectionStartedInContentRef.current = true;
     const snapshot = {
       x: event.clientX,
@@ -5470,7 +4236,7 @@ function ResponseCard({
     dragStartPointerRef.current = snapshot;
     lastPointerRef.current = snapshot;
   }, []);
-  const showSelectionMenuFromCurrentSelection = (0, import_react5.useCallback)(() => {
+  const showSelectionMenuFromCurrentSelection = (0, import_react6.useCallback)(() => {
     const root = contentLayerRef.current;
     if (!root) return;
     requestAnimationFrame(() => {
@@ -5561,7 +4327,7 @@ function ResponseCard({
       dragStartPointerRef.current = null;
     });
   }, [annotations, closeSelectionMenu, triggerSelectionMenuEntryReplay, openFromSelection]);
-  const handleTextSelection = (0, import_react5.useCallback)((event) => {
+  const handleTextSelection = (0, import_react6.useCallback)((event) => {
     if (!canAnnotate || !onAddAnnotation || !messageId) return;
     const root = contentLayerRef.current;
     if (!root) return;
@@ -5622,7 +4388,7 @@ function ResponseCard({
     selectionStartedInContentRef.current = false;
     showSelectionMenuFromCurrentSelection();
   }, [canAnnotate, onAddAnnotation, messageId, annotations, showSelectionMenuFromCurrentSelection, closeSelectionMenu]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!canAnnotate || !onAddAnnotation || !messageId) return;
     const handleDocumentMouseUp = (event) => {
       if (!selectionStartedInContentRef.current) return;
@@ -5645,7 +4411,7 @@ function ResponseCard({
       document.removeEventListener("mouseup", handleDocumentMouseUp);
     };
   }, [canAnnotate, onAddAnnotation, messageId, showSelectionMenuFromCurrentSelection]);
-  const handleSelectionMenuRequestBack = (0, import_react5.useCallback)(() => {
+  const handleSelectionMenuRequestBack = (0, import_react6.useCallback)(() => {
     if (selectionMenuView !== "compact") {
       handleCancelFollowUp();
       return true;
@@ -5697,7 +4463,7 @@ function ResponseCard({
       }
     }
   );
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!isStreaming) {
       setDisplayedText(text);
       return;
@@ -5715,7 +4481,7 @@ function ResponseCard({
       return () => clearTimeout(timeout);
     }
   }, [text, isStreaming]);
-  const bufferDecision = (0, import_react5.useMemo)(() => {
+  const bufferDecision = (0, import_react6.useMemo)(() => {
     return shouldShowStreamingContent(text, isStreaming, streamStartTime);
   }, [text, isStreaming, streamStartTime]);
   const isCompleted = !isStreaming;
@@ -5941,7 +4707,7 @@ function TodoList({ todos }) {
   return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("div", { className: "pl-4 pr-2 pt-2.5 pb-1.5 space-y-0.5 border-l-2 border-muted ml-[13px]", children: [
     /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("div", { className: cn("text-muted-foreground pb-1", SIZE_CONFIG.fontSize), children: "Todo List" }),
     todos.map((todo, index) => /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
-      import_react10.motion.div,
+      import_react11.motion.div,
       {
         initial: { opacity: 0, x: -8 },
         animate: { opacity: 1, x: 0 },
@@ -5991,7 +4757,7 @@ var TurnCard = React10.memo(function TurnCard2({
   openAnnotationRequest,
   annotationInteractionMode = "interactive"
 }) {
-  const turnPhase = (0, import_react.useMemo)(() => {
+  const turnPhase = (0, import_react2.useMemo)(() => {
     const turnData = {
       isComplete,
       response,
@@ -5999,15 +4765,15 @@ var TurnCard = React10.memo(function TurnCard2({
     };
     return deriveTurnPhase(turnData);
   }, [isComplete, response, activities]);
-  const [localExpandedTurns, setLocalExpandedTurns] = (0, import_react.useState)(() => defaultExpanded ? /* @__PURE__ */ new Set([turnId]) : /* @__PURE__ */ new Set());
+  const [localExpandedTurns, setLocalExpandedTurns] = (0, import_react2.useState)(() => defaultExpanded ? /* @__PURE__ */ new Set([turnId]) : /* @__PURE__ */ new Set());
   const isExpanded = externalIsExpanded ?? localExpandedTurns.has(turnId);
-  const hasUserToggled = (0, import_react.useRef)(false);
-  const activitiesContainerRef = (0, import_react.useRef)(null);
-  const hasMounted = (0, import_react.useRef)(false);
-  (0, import_react.useEffect)(() => {
+  const hasUserToggled = (0, import_react2.useRef)(false);
+  const activitiesContainerRef = (0, import_react2.useRef)(null);
+  const hasMounted = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
     hasMounted.current = true;
   }, []);
-  const toggleExpanded = (0, import_react.useCallback)(() => {
+  const toggleExpanded = (0, import_react2.useCallback)(() => {
     hasUserToggled.current = true;
     const newExpanded = !isExpanded;
     if (onExpandedChange) {
@@ -6024,7 +4790,7 @@ var TurnCard = React10.memo(function TurnCard2({
       });
     }
   }, [turnId, isExpanded, onExpandedChange]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     if (isExpanded && hasUserToggled.current && activitiesContainerRef.current) {
       const timer = setTimeout(() => {
         activitiesContainerRef.current?.scrollTo({
@@ -6035,38 +4801,38 @@ var TurnCard = React10.memo(function TurnCard2({
       return () => clearTimeout(timer);
     }
   }, [isExpanded]);
-  const [localExpandedActivityGroups, setLocalExpandedActivityGroups] = (0, import_react.useState)(/* @__PURE__ */ new Set());
+  const [localExpandedActivityGroups, setLocalExpandedActivityGroups] = (0, import_react2.useState)(/* @__PURE__ */ new Set());
   const expandedActivityGroups = externalExpandedActivityGroups ?? localExpandedActivityGroups;
   const handleExpandedActivityGroupsChange = onExpandedActivityGroupsChange ?? setLocalExpandedActivityGroups;
-  const isBuffering = (0, import_react.useMemo)(
+  const isBuffering = (0, import_react2.useMemo)(
     () => isResponseBuffering(response),
     [response]
   );
-  const previewText = (0, import_react.useMemo)(
+  const previewText = (0, import_react2.useMemo)(
     () => getPreviewText(activities, intent, isStreaming, !!response, isComplete),
     [activities, intent, isStreaming, response, isComplete, import_i18next.default.language]
   );
-  const allSortedActivities = (0, import_react.useMemo)(
+  const allSortedActivities = (0, import_react2.useMemo)(
     () => [...activities].sort((a, b) => a.timestamp - b.timestamp),
     [activities]
   );
-  const planActivities = (0, import_react.useMemo)(
+  const planActivities = (0, import_react2.useMemo)(
     () => allSortedActivities.filter((a) => a.type === "plan"),
     [allSortedActivities]
   );
-  const sortedActivities = (0, import_react.useMemo)(
+  const sortedActivities = (0, import_react2.useMemo)(
     () => allSortedActivities.filter((a) => a.type !== "plan"),
     [allSortedActivities]
   );
-  const hasTaskSubagents = (0, import_react.useMemo)(
+  const hasTaskSubagents = (0, import_react2.useMemo)(
     () => sortedActivities.some((a) => a.toolName === "Task"),
     [sortedActivities]
   );
-  const groupedActivities = (0, import_react.useMemo)(
+  const groupedActivities = (0, import_react2.useMemo)(
     () => hasTaskSubagents ? groupActivitiesByParent(sortedActivities) : null,
     [sortedActivities, hasTaskSubagents]
   );
-  const lastChildSet = (0, import_react.useMemo)(
+  const lastChildSet = (0, import_react2.useMemo)(
     () => !hasTaskSubagents ? computeLastChildSet(sortedActivities) : /* @__PURE__ */ new Set(),
     [sortedActivities, hasTaskSubagents]
   );
@@ -6099,7 +4865,7 @@ var TurnCard = React10.memo(function TurnCard2({
           ),
           children: [
             /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
-              import_react2.motion.div,
+              import_react3.motion.div,
               {
                 initial: false,
                 animate: { rotate: isExpanded ? 90 : 0 },
@@ -6109,8 +4875,8 @@ var TurnCard = React10.memo(function TurnCard2({
               }
             ),
             /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("span", { className: "-ml-0.5 shrink-0 px-1.5 py-0.5 rounded-[4px] bg-background shadow-minimal text-[10px] font-medium tabular-nums", children: activities.length }),
-            /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("span", { className: "relative flex-1 min-w-0 h-5 flex items-center", children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react2.AnimatePresence, { initial: false, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
-              import_react2.motion.span,
+            /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("span", { className: "relative flex-1 min-w-0 h-5 flex items-center", children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react3.AnimatePresence, { initial: false, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+              import_react3.motion.span,
               {
                 initial: { opacity: 0 },
                 animate: { opacity: 1 },
@@ -6132,8 +4898,8 @@ var TurnCard = React10.memo(function TurnCard2({
           ]
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react2.AnimatePresence, { initial: false, children: isExpanded && /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(
-        import_react2.motion.div,
+      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react3.AnimatePresence, { initial: false, children: isExpanded && /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(
+        import_react3.motion.div,
         {
           initial: { height: 0, opacity: 0 },
           animate: { height: "auto", opacity: 1 },
@@ -6155,7 +4921,7 @@ var TurnCard = React10.memo(function TurnCard2({
                 style: {
                   maxHeight: sortedActivities.length > SIZE_CONFIG.maxVisibleActivities ? SIZE_CONFIG.maxVisibleActivities * SIZE_CONFIG.activityRowHeight : void 0
                 },
-                children: /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_react2.AnimatePresence, { mode: "sync", children: [
+                children: /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_react3.AnimatePresence, { mode: "sync", children: [
                   groupedActivities ? groupedActivities.map((item, index) => isActivityGroup(item) ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
                     ActivityGroupRow,
                     {
@@ -6169,7 +4935,7 @@ var TurnCard = React10.memo(function TurnCard2({
                     },
                     item.parent.id
                   ) : /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
-                    import_react2.motion.div,
+                    import_react3.motion.div,
                     {
                       initial: hasUserToggled.current || hasMounted.current ? { opacity: 0, x: -8 } : false,
                       animate: { opacity: 1, x: 0 },
@@ -6188,7 +4954,7 @@ var TurnCard = React10.memo(function TurnCard2({
                   )) : (
                     /* Flat view for simple tool calls */
                     sortedActivities.map((activity, index) => /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
-                      import_react2.motion.div,
+                      import_react3.motion.div,
                       {
                         initial: hasUserToggled.current || hasMounted.current ? { opacity: 0, x: -8 } : false,
                         animate: { opacity: 1, x: 0 },
@@ -6208,7 +4974,7 @@ var TurnCard = React10.memo(function TurnCard2({
                     ))
                   ),
                   isThinking && /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(
-                    import_react2.motion.div,
+                    import_react3.motion.div,
                     {
                       initial: { opacity: 0, x: -8 },
                       animate: { opacity: 1, x: 0 },
@@ -6264,8 +5030,8 @@ var TurnCard = React10.memo(function TurnCard2({
         annotationInteractionMode
       }
     ) }, planActivity.id)),
-    animateResponse && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react2.AnimatePresence, { children: response && !isBuffering && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
-      import_react2.motion.div,
+    animateResponse && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react3.AnimatePresence, { children: response && !isBuffering && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+      import_react3.motion.div,
       {
         initial: { opacity: 0, y: 8 },
         animate: { opacity: 1, y: 0 },
@@ -6749,15 +5515,15 @@ function UserMessageBubble({
 }) {
   const { t: t2 } = (0, import_react_i18next5.useTranslation)();
   const hasAttachments = attachments && attachments.length > 0;
-  const [showQueued, setShowQueued] = (0, import_react12.useState)(isQueued ?? false);
-  const queuedShownAtRef = (0, import_react12.useRef)(isQueued ? Date.now() : null);
-  const clearTimerRef = (0, import_react12.useRef)(null);
-  (0, import_react12.useEffect)(() => {
+  const [showQueued, setShowQueued] = (0, import_react13.useState)(isQueued ?? false);
+  const queuedShownAtRef = (0, import_react13.useRef)(isQueued ? Date.now() : null);
+  const clearTimerRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useEffect)(() => {
     return () => {
       if (clearTimerRef.current) clearTimeout(clearTimerRef.current);
     };
   }, []);
-  (0, import_react12.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     if (clearTimerRef.current) {
       clearTimeout(clearTimerRef.current);
       clearTimerRef.current = null;
@@ -7053,8 +5819,8 @@ function ChatTranscript({
   sessionFolderPath,
   children
 }) {
-  const turns = (0, import_react11.useMemo)(() => groupMessagesByTurn(messages), [messages]);
-  const [expandedTurns, setExpandedTurns] = (0, import_react11.useState)(() => {
+  const turns = (0, import_react12.useMemo)(() => groupMessagesByTurn(messages), [messages]);
+  const [expandedTurns, setExpandedTurns] = (0, import_react12.useState)(() => {
     if (defaultExpanded) {
       return new Set(
         turns.map(
@@ -7064,8 +5830,8 @@ function ChatTranscript({
     }
     return /* @__PURE__ */ new Set();
   });
-  const [expandedActivityGroups, setExpandedActivityGroups] = (0, import_react11.useState)(/* @__PURE__ */ new Set());
-  const handleExpandedChange = (0, import_react11.useCallback)((turnId, expanded) => {
+  const [expandedActivityGroups, setExpandedActivityGroups] = (0, import_react12.useState)(/* @__PURE__ */ new Set());
+  const handleExpandedChange = (0, import_react12.useCallback)((turnId, expanded) => {
     setExpandedTurns((prev) => {
       const next = new Set(prev);
       if (expanded) {
@@ -7076,17 +5842,17 @@ function ChatTranscript({
       return next;
     });
   }, []);
-  const handleExpandedActivityGroupsChange = (0, import_react11.useCallback)((groups) => {
+  const handleExpandedActivityGroupsChange = (0, import_react12.useCallback)((groups) => {
     setExpandedActivityGroups(groups);
   }, []);
-  const handleOpenActivityDetails = (0, import_react11.useCallback)((activity) => {
+  const handleOpenActivityDetails = (0, import_react12.useCallback)((activity) => {
     if (onActivityClick) {
       onActivityClick(activity);
     } else if (platformActions.onOpenActivityDetails) {
       platformActions.onOpenActivityDetails(sessionId, activity.id);
     }
   }, [onActivityClick, platformActions, sessionId]);
-  const handleOpenTurnDetails = (0, import_react11.useCallback)((turnId) => {
+  const handleOpenTurnDetails = (0, import_react12.useCallback)((turnId) => {
     if (onTurnClick) {
       onTurnClick(turnId);
     } else if (platformActions.onOpenTurnDetails) {
@@ -7191,7 +5957,7 @@ function ChatTranscript({
     }
   );
 }
-var PlatformContext = (0, import_react14.createContext)({});
+var PlatformContext = (0, import_react15.createContext)({});
 function PlatformProvider({
   actions,
   children
@@ -7210,7 +5976,7 @@ function SessionViewer({
   footer,
   sessionFolderPath
 }) {
-  const messages = (0, import_react13.useMemo)(
+  const messages = (0, import_react14.useMemo)(
     () => session.messages.map(storedToMessage),
     [session.messages]
   );
@@ -7266,9 +6032,9 @@ function AssistantTurnCard({
   isLast,
   onInspectActivity
 }) {
-  const [isExpanded, setIsExpanded] = (0, import_react15.useState)(true);
-  const [expandedActivityGroups, setExpandedActivityGroups] = (0, import_react15.useState)(/* @__PURE__ */ new Set());
-  (0, import_react15.useEffect)(() => {
+  const [isExpanded, setIsExpanded] = (0, import_react16.useState)(true);
+  const [expandedActivityGroups, setExpandedActivityGroups] = (0, import_react16.useState)(/* @__PURE__ */ new Set());
+  (0, import_react16.useEffect)(() => {
     if (turn.isStreaming) {
       setIsExpanded(true);
     }
@@ -7343,7 +6109,7 @@ function ActivityDetailsPanel({
   activity,
   onClose
 }) {
-  (0, import_react16.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     if (!activity) return;
     const handleKeyDown = (e) => {
       if (e.key === "Escape") onClose();
@@ -8982,12 +7748,12 @@ function normalizeTokenUsage(usage) {
 }
 function useEventProcessor(options) {
   const { eventSource, sessionId, workspaceId, workspaceName, onEffect, onError, onClose } = options;
-  const [session, setSession] = (0, import_react17.useState)(null);
-  const sessionRef = (0, import_react17.useRef)(null);
-  const streamingStates = (0, import_react17.useRef)(/* @__PURE__ */ new Map());
-  const [isConnected, setIsConnected] = (0, import_react17.useState)(false);
-  const processedCount = (0, import_react17.useRef)(0);
-  const processAgentEvent = (0, import_react17.useCallback)((event) => {
+  const [session, setSession] = (0, import_react18.useState)(null);
+  const sessionRef = (0, import_react18.useRef)(null);
+  const streamingStates = (0, import_react18.useRef)(/* @__PURE__ */ new Map());
+  const [isConnected, setIsConnected] = (0, import_react18.useState)(false);
+  const processedCount = (0, import_react18.useRef)(0);
+  const processAgentEvent = (0, import_react18.useCallback)((event) => {
     const processorEvent = mapCoreEventToProcessorEvent(event, sessionId);
     const currentSession = sessionRef.current ?? createEmptySession(sessionId, workspaceId, workspaceName ?? "");
     const currentState = {
@@ -9007,7 +7773,7 @@ function useEventProcessor(options) {
       effects: result.effects
     };
   }, [sessionId, workspaceId, workspaceName]);
-  (0, import_react17.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     eventSource.connect(
       (coreEvent) => {
         const result = processAgentEvent(coreEvent);
@@ -9030,10 +7796,10 @@ function useEventProcessor(options) {
       setIsConnected(false);
     };
   }, [eventSource, processAgentEvent, onEffect, onError, onClose]);
-  const clearStreamingState = (0, import_react17.useCallback)(() => {
+  const clearStreamingState = (0, import_react18.useCallback)(() => {
     streamingStates.current.delete(sessionId);
   }, [sessionId]);
-  const getStreamingState = (0, import_react17.useCallback)(() => {
+  const getStreamingState = (0, import_react18.useCallback)(() => {
     return streamingStates.current.get(sessionId) ?? null;
   }, [sessionId]);
   return {
@@ -9047,9 +7813,9 @@ function useEventProcessor(options) {
 }
 
 // ../packages/local-chat/dist/index.js
-var import_react19 = require("react");
-var import_jsx_runtime39 = require("react/jsx-runtime");
 var import_react20 = require("react");
+var import_jsx_runtime39 = require("react/jsx-runtime");
+var import_react21 = require("react");
 var import_jsx_runtime40 = require("react/jsx-runtime");
 function createAgentChatPanelModel(args) {
   return {
@@ -9099,8 +7865,8 @@ function createTimelineDetailItems(timeline) {
 }
 function useAgentChatSession(options) {
   const { runtime, workspaceId = "local-workspace", workspaceName = "Local Workspace" } = options;
-  const [auth, setAuth] = (0, import_react19.useState)(null);
-  const [error, setError] = (0, import_react19.useState)(null);
+  const [auth, setAuth] = (0, import_react20.useState)(null);
+  const [error, setError] = (0, import_react20.useState)(null);
   const processor = useEventProcessor({
     eventSource: runtime.events,
     sessionId: runtime.sessionId,
@@ -9108,7 +7874,7 @@ function useAgentChatSession(options) {
     workspaceName,
     onError: setError
   });
-  const sendMessage = (0, import_react19.useCallback)(async (message) => {
+  const sendMessage = (0, import_react20.useCallback)(async (message) => {
     setError(null);
     try {
       if (!auth) {
@@ -9124,13 +7890,13 @@ function useAgentChatSession(options) {
       throw err;
     }
   }, [auth, runtime]);
-  const abort = (0, import_react19.useCallback)(async () => {
+  const abort = (0, import_react20.useCallback)(async () => {
     await runtime.commands.abort("User aborted");
   }, [runtime]);
-  const respondToPermission = (0, import_react19.useCallback)(async (requestId, allowed, remember) => {
+  const respondToPermission = (0, import_react20.useCallback)(async (requestId, allowed, remember) => {
     await runtime.commands.respondToPermission(requestId, allowed, remember);
   }, [runtime]);
-  const model = (0, import_react19.useMemo)(
+  const model = (0, import_react20.useMemo)(
     () => createAgentChatPanelModel({ session: processor.session, runtime, auth, error }),
     [processor.session, runtime, auth, error]
   );
@@ -9147,8 +7913,8 @@ function useAgentChatSession(options) {
 }
 function useTimelineAgentChatSession(options) {
   const { runtime, workspaceId = "local-workspace", workspaceName = "Local Workspace" } = options;
-  const [timeline, setTimeline] = (0, import_react19.useState)([]);
-  const [sessionState, setSessionState] = (0, import_react19.useState)(() => ({
+  const [timeline, setTimeline] = (0, import_react20.useState)([]);
+  const [sessionState, setSessionState] = (0, import_react20.useState)(() => ({
     session: {
       id: runtime.sessionId,
       workspaceId,
@@ -9159,12 +7925,12 @@ function useTimelineAgentChatSession(options) {
     },
     streaming: null
   }));
-  const [capabilityReport, setCapabilityReport] = (0, import_react19.useState)(null);
-  const [error, setError] = (0, import_react19.useState)(null);
-  const [isReconnecting, setIsReconnecting] = (0, import_react19.useState)(false);
-  const [hasGap, setHasGap] = (0, import_react19.useState)(false);
-  const lastCursorRef = (0, import_react19.useRef)(null);
-  (0, import_react19.useEffect)(() => {
+  const [capabilityReport, setCapabilityReport] = (0, import_react20.useState)(null);
+  const [error, setError] = (0, import_react20.useState)(null);
+  const [isReconnecting, setIsReconnecting] = (0, import_react20.useState)(false);
+  const [hasGap, setHasGap] = (0, import_react20.useState)(false);
+  const lastCursorRef = (0, import_react20.useRef)(null);
+  (0, import_react20.useEffect)(() => {
     let catchupAbort = false;
     const onEvent = (envelope) => {
       lastCursorRef.current = { epoch: envelope.epoch, afterSeq: envelope.seq };
@@ -9215,7 +7981,7 @@ function useTimelineAgentChatSession(options) {
       runtime.events.disconnect();
     };
   }, [runtime]);
-  const sendMessage = (0, import_react19.useCallback)(async (message, options2) => {
+  const sendMessage = (0, import_react20.useCallback)(async (message, options2) => {
     setError(null);
     setHasGap(false);
     try {
@@ -9230,13 +7996,13 @@ function useTimelineAgentChatSession(options) {
       throw err;
     }
   }, [capabilityReport, runtime]);
-  const abort = (0, import_react19.useCallback)(async () => {
+  const abort = (0, import_react20.useCallback)(async () => {
     await runtime.commands.abort("User aborted");
   }, [runtime]);
-  const respondToPermission = (0, import_react19.useCallback)(async (requestId, allowed, remember) => {
+  const respondToPermission = (0, import_react20.useCallback)(async (requestId, allowed, remember) => {
     await runtime.commands.respondToPermission(requestId, allowed, remember);
   }, [runtime]);
-  const turns = (0, import_react19.useMemo)(
+  const turns = (0, import_react20.useMemo)(
     () => groupMessagesByTurn(sessionState.session.messages),
     [sessionState]
   );
@@ -9471,7 +8237,7 @@ function AgentChatPanel({
   className
 }) {
   const chat = useAgentChatSession({ runtime, workspaceId, workspaceName });
-  const [draft, setDraft] = (0, import_react18.useState)("");
+  const [draft, setDraft] = (0, import_react19.useState)("");
   async function handleSubmit(event) {
     event.preventDefault();
     const message = draft.trim();
@@ -9587,15 +8353,15 @@ function TimelineAgentChatPanel({
   className
 }) {
   const chat = useTimelineAgentChatSession({ runtime, workspaceId, workspaceName });
-  const [draft, setDraft] = (0, import_react20.useState)("");
-  const [selectedActivity, setSelectedActivity] = (0, import_react20.useState)(null);
-  const [selectedDetail, setSelectedDetail] = (0, import_react20.useState)(null);
-  const [permissionMode, setPermissionMode] = (0, import_react20.useState)("ask");
-  const [isPermMenuOpen, setIsPermMenuOpen] = (0, import_react20.useState)(false);
+  const [draft, setDraft] = (0, import_react21.useState)("");
+  const [selectedActivity, setSelectedActivity] = (0, import_react21.useState)(null);
+  const [selectedDetail, setSelectedDetail] = (0, import_react21.useState)(null);
+  const [permissionMode, setPermissionMode] = (0, import_react21.useState)("ask");
+  const [isPermMenuOpen, setIsPermMenuOpen] = (0, import_react21.useState)(false);
   const runtimeState = runtime.getState();
   const isWaitingPermission = runtimeState.status === "waiting_for_permission";
   const waitingRequestId = runtimeState.waitingPermissionRequestId;
-  const { visibleTurns, showPendingIndicator } = (0, import_react20.useMemo)(() => {
+  const { visibleTurns, showPendingIndicator } = (0, import_react21.useMemo)(() => {
     const lastTurn = chat.turns.at(-1);
     if (!chat.isConnected && !chat.isReconnecting) return { visibleTurns: chat.turns, showPendingIndicator: false };
     if (lastTurn?.type === "assistant" && lastTurn.activities.length === 0 && !lastTurn.response && lastTurn.isStreaming) {
@@ -9604,16 +8370,16 @@ function TimelineAgentChatPanel({
     if (lastTurn?.type === "user") return { visibleTurns: chat.turns, showPendingIndicator: true };
     return { visibleTurns: chat.turns, showPendingIndicator: false };
   }, [chat.turns, chat.isConnected, chat.isReconnecting]);
-  const permissionRequest = (0, import_react20.useMemo)(() => {
+  const permissionRequest = (0, import_react21.useMemo)(() => {
     if (!isWaitingPermission || !waitingRequestId) return null;
     return findActivePermissionRequest(chat.timeline);
   }, [isWaitingPermission, waitingRequestId, chat.timeline]);
-  const detailItems = (0, import_react20.useMemo)(
+  const detailItems = (0, import_react21.useMemo)(
     () => createTimelineDetailItems(chat.timeline),
     [chat.timeline]
   );
-  const scrollRef = (0, import_react20.useRef)(null);
-  (0, import_react20.useEffect)(() => {
+  const scrollRef = (0, import_react21.useRef)(null);
+  (0, import_react21.useEffect)(() => {
     if (scrollRef.current) {
       scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
     }
@@ -9628,10 +8394,10 @@ function TimelineAgentChatPanel({
     } catch {
     }
   }
-  const handlePermissionAllow = (0, import_react20.useCallback)((requestId, remember) => {
+  const handlePermissionAllow = (0, import_react21.useCallback)((requestId, remember) => {
     void chat.respondToPermission(requestId, true, remember);
   }, [chat]);
-  const handlePermissionDeny = (0, import_react20.useCallback)((requestId) => {
+  const handlePermissionDeny = (0, import_react21.useCallback)((requestId) => {
     void chat.respondToPermission(requestId, false);
   }, [chat]);
   return /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("div", { className: `flex flex-col h-full ${className ?? ""}`, children: [
@@ -9775,50 +8541,9 @@ function TimelineAgentChatPanel({
 0 && (module.exports = {
   AgentChatPanel,
   EN_FALLBACK,
-  RPC_CHANNELS,
-  THINKING_LEVELS,
-  THINKING_LEVEL_IDS,
-  THINKING_TO_EFFORT,
   TimelineAgentChatPanel,
-  appendTimelineItem,
   createFlitroEmbedRuntime,
-  createInMemoryApprovalStore,
-  createPermissionPolicy,
-  createPermissionPolicyFromConfig,
-  createPolicyDecisionReceipt,
-  createRuntimeCapabilityReport,
-  createRuntimeExtensionContext,
-  createSourcePolicyLayer,
-  createTimelineCursor,
-  createTimelineSequencer,
-  debug,
-  evaluateToolPolicy,
-  explainToolPolicy,
-  fetchTimeline,
-  findMentionMatches,
-  generateMessageId,
-  getThinkingLevelNameKey,
-  getThinkingTokens,
-  invokeSessionTool,
-  isValidThinkingLevel,
-  mergeTimeline,
-  messageToStored,
-  normalizePath,
-  normalizeThinkingLevel,
-  parseMentions,
-  pathStartsWith,
-  reduceRuntimeState,
-  resolveFileMentions,
-  resolvePathMentions,
-  resolveSkillMentions,
-  resolveSourceMentions,
-  sanitizeProviderSourceTools,
-  selectRuntimeCandidate,
-  storedToMessage,
-  stripAllMentions,
-  stripPathPrefix,
   useAgentChatSession,
   useAgentSession,
-  useTimelineAgentChatSession,
-  validatePolicyConfig
+  useTimelineAgentChatSession
 });