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

package/dist/index.js

@@ -1,722 +1,5 @@
-// ../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
+import { useEffect, useMemo, useRef } from "react";
 
 // ../packages/runtime-core/dist/index.js
 var RUNTIME_KINDS = ["native-sdk", "app-server", "compatible-sdk", "cli-fallback"];
@@ -819,203 +102,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);
 }
@@ -1101,463 +190,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
-import { useAgentSession } from "@percena/weft-react";
-
 // ../packages/client/dist/index.js
 var FlitroHttpClient = class {
   baseUrl;
@@ -2218,6 +895,109 @@ var PushTimelineStream = class {
   }
 };
 
+// ../packages/react/src/use-agent-session.ts
+function useAgentSession(options) {
+  const onTokenExpiredRef = useRef(options.onTokenExpired);
+  onTokenExpiredRef.current = options.onTokenExpired;
+  const tokenRef = useRef(options.token);
+  tokenRef.current = options.token;
+  const runtime = 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]);
+  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
 import { useState as useState22 } from "react";
 
@@ -2258,6 +1038,33 @@ 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
 import * as React10 from "react";
 import { useMemo as useMemo5, useEffect as useEffect4, useRef as useRef5, useCallback as useCallback6, useState as useState7 } from "react";
@@ -2329,7 +1136,7 @@ import * as React7 from "react";
 import { jsx as jsx20, jsxs as jsxs8 } from "react/jsx-runtime";
 import * as React8 from "react";
 import * as React9 from "react";
-import { useCallback as useCallback4, useEffect as useEffect2, useRef as useRef3, useState as useState5 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect22, useRef as useRef32, useState as useState5 } from "react";
 import { useTranslation as useTranslation2 } from "react-i18next";
 import * as ReactDOM from "react-dom";
 import { ChevronDown } from "lucide-react";
@@ -2347,7 +1154,7 @@ import { jsx as jsx25, jsxs as jsxs12 } from "react/jsx-runtime";
 import { useTranslation as useTranslation4 } from "react-i18next";
 import { CheckCircle2 as CheckCircle22, XCircle as XCircle2, X } from "lucide-react";
 import { Fragment as Fragment9, jsx as jsx26, jsxs as jsxs13 } from "react/jsx-runtime";
-import { useMemo as useMemo6, useState as useState9, useCallback as useCallback7 } from "react";
+import { useMemo as useMemo62, useState as useState9, useCallback as useCallback7 } from "react";
 import { useEffect as useEffect5, useRef as useRef6, useState as useState8 } from "react";
 import { Clock } from "lucide-react";
 import { File, Image as ImageIcon } from "lucide-react";
@@ -2885,7 +1692,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) {
@@ -2895,7 +1702,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;
 }
@@ -4812,8 +3619,8 @@ function AcceptPlanDropdown({
   const effectiveAcceptOptionLabel = acceptOptionLabel ?? t2("plan.accept");
   const [isOpen, setIsOpen] = useState5(false);
   const [position, setPosition] = useState5(null);
-  const triggerRef = useRef3(null);
-  const menuRef = useRef3(null);
+  const triggerRef = useRef32(null);
+  const menuRef = useRef32(null);
   const updatePosition = useCallback4(() => {
     if (!triggerRef.current) return;
     const rect = triggerRef.current.getBoundingClientRect();
@@ -4862,12 +3669,12 @@ function AcceptPlanDropdown({
     handleClose();
     onAcceptWithCompact();
   }, [handleClose, onAcceptWithCompact]);
-  useEffect2(() => {
+  useEffect22(() => {
     if (isOpen) {
       updatePosition();
     }
   }, [isOpen, updatePosition]);
-  useEffect2(() => {
+  useEffect22(() => {
     if (!isOpen) return;
     const handleClickOutside = (e) => {
       if (menuRef.current && !menuRef.current.contains(e.target) && triggerRef.current && !triggerRef.current.contains(e.target)) {
@@ -6990,7 +5797,7 @@ function ChatTranscript({
   sessionFolderPath,
   children
 }) {
-  const turns = useMemo6(() => groupMessagesByTurn(messages), [messages]);
+  const turns = useMemo62(() => groupMessagesByTurn(messages), [messages]);
   const [expandedTurns, setExpandedTurns] = useState9(() => {
     if (defaultExpanded) {
       return new Set(
@@ -8986,7 +7793,7 @@ function useEventProcessor(options) {
 // ../packages/local-chat/dist/index.js
 import { useCallback as useCallback9, useEffect as useEffect9, useMemo as useMemo8, useRef as useRef8, useState as useState12 } from "react";
 import { jsx as jsx39, jsxs as jsxs21 } from "react/jsx-runtime";
-import { useCallback as useCallback22, useEffect as useEffect22, useMemo as useMemo22, useRef as useRef22, useState as useState32 } from "react";
+import { useCallback as useCallback22, useEffect as useEffect23, useMemo as useMemo22, useRef as useRef22, useState as useState32 } from "react";
 import { jsx as jsx210, jsxs as jsxs22 } from "react/jsx-runtime";
 function createAgentChatPanelModel(args) {
   return {
@@ -9550,7 +8357,7 @@ function TimelineAgentChatPanel({
     [chat.timeline]
   );
   const scrollRef = useRef22(null);
-  useEffect22(() => {
+  useEffect23(() => {
     if (scrollRef.current) {
       scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
     }
@@ -9711,50 +8518,9 @@ function TimelineAgentChatPanel({
 export {
   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
 };