@xortex/xcode 3.0.1 → 3.0.2

package/hooks/useBackgroundTaskNavigation.ts

@@ -0,0 +1,251 @@
+import { useEffect, useRef } from 'react'
+import { KeyboardEvent } from '../ink/events/keyboard-event.js'
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until REPL wires handleKeyDown to <Box onKeyDown>
+import { useInput } from '../ink.js'
+import {
+  type AppState,
+  useAppState,
+  useSetAppState,
+} from '../state/AppState.js'
+import {
+  enterTeammateView,
+  exitTeammateView,
+} from '../state/teammateViewHelpers.js'
+import {
+  getRunningTeammatesSorted,
+  InProcessTeammateTask,
+} from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js'
+import {
+  type InProcessTeammateTaskState,
+  isInProcessTeammateTask,
+} from '../tasks/InProcessTeammateTask/types.js'
+import { isBackgroundTask } from '../tasks/types.js'
+
+// Step teammate selection by delta, wrapping across leader(-1)..teammates(0..n-1)..hide(n).
+// First step from a collapsed tree expands it and parks on leader.
+function stepTeammateSelection(
+  delta: 1 | -1,
+  setAppState: (updater: (prev: AppState) => AppState) => void,
+): void {
+  setAppState(prev => {
+    const currentCount = getRunningTeammatesSorted(prev.tasks).length
+    if (currentCount === 0) return prev
+
+    if (prev.expandedView !== 'teammates') {
+      return {
+        ...prev,
+        expandedView: 'teammates' as const,
+        viewSelectionMode: 'selecting-agent',
+        selectedIPAgentIndex: -1,
+      }
+    }
+
+    const maxIdx = currentCount // hide row
+    const cur = prev.selectedIPAgentIndex
+    const next =
+      delta === 1
+        ? cur >= maxIdx
+          ? -1
+          : cur + 1
+        : cur <= -1
+          ? maxIdx
+          : cur - 1
+    return {
+      ...prev,
+      selectedIPAgentIndex: next,
+      viewSelectionMode: 'selecting-agent',
+    }
+  })
+}
+
+/**
+ * Custom hook that handles Shift+Up/Down keyboard navigation for background tasks.
+ * When teammates (swarm) are present, navigates between leader and teammates.
+ * When only non-teammate background tasks exist, opens the background tasks dialog.
+ * Also handles Enter to confirm selection, 'f' to view transcript, and 'k' to kill.
+ */
+export function useBackgroundTaskNavigation(options?: {
+  onOpenBackgroundTasks?: () => void
+}): { handleKeyDown: (e: KeyboardEvent) => void } {
+  const tasks = useAppState(s => s.tasks)
+  const viewSelectionMode = useAppState(s => s.viewSelectionMode)
+  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)
+  const selectedIPAgentIndex = useAppState(s => s.selectedIPAgentIndex)
+  const setAppState = useSetAppState()
+
+  // Filter to running teammates and sort alphabetically to match TeammateSpinnerTree display
+  const teammateTasks = getRunningTeammatesSorted(tasks)
+  const teammateCount = teammateTasks.length
+
+  // Check for non-teammate background tasks (local_agent, local_bash, etc.)
+  const hasNonTeammateBackgroundTasks = Object.values(tasks).some(
+    t => isBackgroundTask(t) && t.type !== 'in_process_teammate',
+  )
+
+  // Track previous teammate count to detect when teammates are removed
+  const prevTeammateCountRef = useRef<number>(teammateCount)
+
+  // Clamp selection index if teammates are removed or reset when count becomes 0
+  useEffect(() => {
+    const prevCount = prevTeammateCountRef.current
+    prevTeammateCountRef.current = teammateCount
+
+    setAppState(prev => {
+      const currentTeammates = getRunningTeammatesSorted(prev.tasks)
+      const currentCount = currentTeammates.length
+
+      // When teammates are removed (count goes from >0 to 0), reset selection
+      // Only reset if we previously had teammates (not on initial mount with 0)
+      // Don't clobber viewSelectionMode if actively viewing a teammate transcript —
+      // the user may be reviewing a completed teammate and needs escape to exit
+      if (
+        currentCount === 0 &&
+        prevCount > 0 &&
+        prev.selectedIPAgentIndex !== -1
+      ) {
+        if (prev.viewSelectionMode === 'viewing-agent') {
+          return {
+            ...prev,
+            selectedIPAgentIndex: -1,
+          }
+        }
+        return {
+          ...prev,
+          selectedIPAgentIndex: -1,
+          viewSelectionMode: 'none',
+        }
+      }
+
+      // Clamp if index is out of bounds
+      // Max valid index is currentCount (the "hide" row) when spinner tree is shown
+      const maxIndex =
+        prev.expandedView === 'teammates' ? currentCount : currentCount - 1
+      if (currentCount > 0 && prev.selectedIPAgentIndex > maxIndex) {
+        return {
+          ...prev,
+          selectedIPAgentIndex: maxIndex,
+        }
+      }
+
+      return prev
+    })
+  }, [teammateCount, setAppState])
+
+  // Get the selected teammate's task info
+  const getSelectedTeammate = (): {
+    taskId: string
+    task: InProcessTeammateTaskState
+  } | null => {
+    if (teammateCount === 0) return null
+    const selectedIndex = selectedIPAgentIndex
+    const task = teammateTasks[selectedIndex]
+    if (!task) return null
+
+    return { taskId: task.id, task }
+  }
+
+  const handleKeyDown = (e: KeyboardEvent): void => {
+    // Escape in viewing mode:
+    // - If teammate is running: abort current work only (stops current turn, teammate stays alive)
+    // - If teammate is not running (completed/killed/failed): exit the view back to leader
+    if (e.key === 'escape' && viewSelectionMode === 'viewing-agent') {
+      e.preventDefault()
+      const taskId = viewingAgentTaskId
+      if (taskId) {
+        const task = tasks[taskId]
+        if (isInProcessTeammateTask(task) && task.status === 'running') {
+          // Abort currentWorkAbortController (stops current turn) NOT abortController (kills teammate)
+          task.currentWorkAbortController?.abort()
+          return
+        }
+      }
+      // Teammate is not running or task doesn't exist — exit the view
+      exitTeammateView(setAppState)
+      return
+    }
+
+    // Escape in selection mode: exit selection without aborting leader
+    if (e.key === 'escape' && viewSelectionMode === 'selecting-agent') {
+      e.preventDefault()
+      setAppState(prev => ({
+        ...prev,
+        viewSelectionMode: 'none',
+        selectedIPAgentIndex: -1,
+      }))
+      return
+    }
+
+    // Shift+Up/Down for teammate transcript switching (with wrapping)
+    // Index -1 represents the leader, 0+ are teammates
+    // When showSpinnerTree is true, index === teammateCount is the "hide" row
+    if (e.shift && (e.key === 'up' || e.key === 'down')) {
+      e.preventDefault()
+      if (teammateCount > 0) {
+        stepTeammateSelection(e.key === 'down' ? 1 : -1, setAppState)
+      } else if (hasNonTeammateBackgroundTasks) {
+        options?.onOpenBackgroundTasks?.()
+      }
+      return
+    }
+
+    // 'f' to view selected teammate's transcript (only in selecting mode)
+    if (
+      e.key === 'f' &&
+      viewSelectionMode === 'selecting-agent' &&
+      teammateCount > 0
+    ) {
+      e.preventDefault()
+      const selected = getSelectedTeammate()
+      if (selected) {
+        enterTeammateView(selected.taskId, setAppState)
+      }
+      return
+    }
+
+    // Enter to confirm selection (only when in selecting mode)
+    if (e.key === 'return' && viewSelectionMode === 'selecting-agent') {
+      e.preventDefault()
+      if (selectedIPAgentIndex === -1) {
+        exitTeammateView(setAppState)
+      } else if (selectedIPAgentIndex >= teammateCount) {
+        // "Hide" row selected - collapse the spinner tree
+        setAppState(prev => ({
+          ...prev,
+          expandedView: 'none' as const,
+          viewSelectionMode: 'none',
+          selectedIPAgentIndex: -1,
+        }))
+      } else {
+        const selected = getSelectedTeammate()
+        if (selected) {
+          enterTeammateView(selected.taskId, setAppState)
+        }
+      }
+      return
+    }
+
+    // k to kill selected teammate (only in selecting mode)
+    if (
+      e.key === 'k' &&
+      viewSelectionMode === 'selecting-agent' &&
+      selectedIPAgentIndex >= 0
+    ) {
+      e.preventDefault()
+      const selected = getSelectedTeammate()
+      if (selected && selected.task.status === 'running') {
+        void InProcessTeammateTask.kill(selected.taskId, setAppState)
+      }
+      return
+    }
+  }
+
+  // Backward-compat bridge: REPL.tsx doesn't yet wire handleKeyDown to
+  // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →
+  // KeyboardEvent until the consumer is migrated (separate PR).
+  // TODO(onKeyDown-migration): remove once REPL passes handleKeyDown.
+  useInput((_input, _key, event) => {
+    handleKeyDown(new KeyboardEvent(event.keypress))
+  })
+
+  return { handleKeyDown }
+}

package/hooks/useBlink.ts

@@ -0,0 +1,34 @@
+import { type DOMElement, useAnimationFrame, useTerminalFocus } from '../ink.js'
+
+const BLINK_INTERVAL_MS = 600
+
+/**
+ * Hook for synchronized blinking animations that pause when offscreen.
+ *
+ * Returns a ref to attach to the animated element and the current blink state.
+ * All instances blink together because they derive state from the same
+ * animation clock. The clock only runs when at least one subscriber is visible.
+ * Pauses when the terminal is blurred.
+ *
+ * @param enabled - Whether blinking is active
+ * @returns [ref, isVisible] - Ref to attach to element, true when visible in blink cycle
+ *
+ * @example
+ * function BlinkingDot({ shouldAnimate }) {
+ *   const [ref, isVisible] = useBlink(shouldAnimate)
+ *   return <Box ref={ref}>{isVisible ? '●' : ' '}</Box>
+ * }
+ */
+export function useBlink(
+  enabled: boolean,
+  intervalMs: number = BLINK_INTERVAL_MS,
+): [ref: (element: DOMElement | null) => void, isVisible: boolean] {
+  const focused = useTerminalFocus()
+  const [ref, time] = useAnimationFrame(enabled && focused ? intervalMs : null)
+
+  if (!enabled || !focused) return [ref, true]
+
+  // Derive blink state from time - all instances see the same time so they sync
+  const isVisible = Math.floor(time / intervalMs) % 2 === 0
+  return [ref, isVisible]
+}

package/hooks/useCanUseTool.tsx

@@ -0,0 +1,204 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import { APIUserAbortError } from '@anthropic-ai/sdk';
+import * as React from 'react';
+import { useCallback } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js';
+import type { ToolUseConfirm } from '../components/permissions/PermissionRequest.js';
+import { Text } from '../ink.js';
+import type { ToolPermissionContext, Tool as ToolType, ToolUseContext } from '../Tool.js';
+import { consumeSpeculativeClassifierCheck, peekSpeculativeClassifierCheck } from '../tools/BashTool/bashPermissions.js';
+import { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js';
+import type { AssistantMessage } from '../types/message.js';
+import { recordAutoModeDenial } from '../utils/autoModeDenials.js';
+import { clearClassifierChecking, setClassifierApproval, setYoloClassifierApproval } from '../utils/classifierApprovals.js';
+import { logForDebugging } from '../utils/debug.js';
+import { AbortError } from '../utils/errors.js';
+import { logError } from '../utils/log.js';
+import type { PermissionDecision } from '../utils/permissions/PermissionResult.js';
+import { hasPermissionsToUseTool } from '../utils/permissions/permissions.js';
+import { jsonStringify } from '../utils/slowOperations.js';
+import { handleCoordinatorPermission } from './toolPermission/handlers/coordinatorHandler.js';
+import { handleInteractivePermission } from './toolPermission/handlers/interactiveHandler.js';
+import { handleSwarmWorkerPermission } from './toolPermission/handlers/swarmWorkerHandler.js';
+import { createPermissionContext, createPermissionQueueOps } from './toolPermission/PermissionContext.js';
+import { logPermissionDecision } from './toolPermission/permissionLogging.js';
+export type CanUseToolFn<Input extends Record<string, unknown> = Record<string, unknown>> = (tool: ToolType, input: Input, toolUseContext: ToolUseContext, assistantMessage: AssistantMessage, toolUseID: string, forceDecision?: PermissionDecision<Input>) => Promise<PermissionDecision<Input>>;
+function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
+  const $ = _c(3);
+  let t0;
+  if ($[0] !== setToolPermissionContext || $[1] !== setToolUseConfirmQueue) {
+    t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise(resolve => {
+      const ctx = createPermissionContext(tool, input, toolUseContext, assistantMessage, toolUseID, setToolPermissionContext, createPermissionQueueOps(setToolUseConfirmQueue));
+      if (ctx.resolveIfAborted(resolve)) {
+        return;
+      }
+      const decisionPromise = forceDecision !== undefined ? Promise.resolve(forceDecision) : hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID);
+      return decisionPromise.then(async result => {
+        if (result.behavior === "allow") {
+          if (ctx.resolveIfAborted(resolve)) {
+            return;
+          }
+          if (feature("TRANSCRIPT_CLASSIFIER") && result.decisionReason?.type === "classifier" && result.decisionReason.classifier === "auto-mode") {
+            setYoloClassifierApproval(toolUseID, result.decisionReason.reason);
+          }
+          ctx.logDecision({
+            decision: "accept",
+            source: "config"
+          });
+          resolve(ctx.buildAllow(result.updatedInput ?? input, {
+            decisionReason: result.decisionReason
+          }));
+          return;
+        }
+        const appState = toolUseContext.getAppState();
+        const description = await tool.description(input as never, {
+          isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession,
+          toolPermissionContext: appState.toolPermissionContext,
+          tools: toolUseContext.options.tools
+        });
+        if (ctx.resolveIfAborted(resolve)) {
+          return;
+        }
+        switch (result.behavior) {
+          case "deny":
+            {
+              logPermissionDecision({
+                tool,
+                input,
+                toolUseContext,
+                messageId: ctx.messageId,
+                toolUseID
+              }, {
+                decision: "reject",
+                source: "config"
+              });
+              if (feature("TRANSCRIPT_CLASSIFIER") && result.decisionReason?.type === "classifier" && result.decisionReason.classifier === "auto-mode") {
+                recordAutoModeDenial({
+                  toolName: tool.name,
+                  display: description,
+                  reason: result.decisionReason.reason ?? "",
+                  timestamp: Date.now()
+                });
+                toolUseContext.addNotification?.({
+                  key: "auto-mode-denied",
+                  priority: "immediate",
+                  jsx: <><Text color="error">{tool.userFacingName(input).toLowerCase()} denied by auto mode</Text><Text dimColor={true}> · /permissions</Text></>
+                });
+              }
+              resolve(result);
+              return;
+            }
+          case "ask":
+            {
+              if (appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog) {
+                const coordinatorDecision = await handleCoordinatorPermission({
+                  ctx,
+                  ...(feature("BASH_CLASSIFIER") ? {
+                    pendingClassifierCheck: result.pendingClassifierCheck
+                  } : {}),
+                  updatedInput: result.updatedInput,
+                  suggestions: result.suggestions,
+                  permissionMode: appState.toolPermissionContext.mode
+                });
+                if (coordinatorDecision) {
+                  resolve(coordinatorDecision);
+                  return;
+                }
+              }
+              if (ctx.resolveIfAborted(resolve)) {
+                return;
+              }
+              const swarmDecision = await handleSwarmWorkerPermission({
+                ctx,
+                description,
+                ...(feature("BASH_CLASSIFIER") ? {
+                  pendingClassifierCheck: result.pendingClassifierCheck
+                } : {}),
+                updatedInput: result.updatedInput,
+                suggestions: result.suggestions
+              });
+              if (swarmDecision) {
+                resolve(swarmDecision);
+                return;
+              }
+              if (feature("BASH_CLASSIFIER") && result.pendingClassifierCheck && tool.name === BASH_TOOL_NAME && !appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog) {
+                const speculativePromise = peekSpeculativeClassifierCheck((input as {
+                  command: string;
+                }).command);
+                if (speculativePromise) {
+                  const raceResult = await Promise.race([speculativePromise.then(_temp), new Promise(_temp2)]);
+                  if (ctx.resolveIfAborted(resolve)) {
+                    return;
+                  }
+                  if (raceResult.type === "result" && raceResult.result.matches && raceResult.result.confidence === "high" && feature("BASH_CLASSIFIER")) {
+                    consumeSpeculativeClassifierCheck((input as {
+                      command: string;
+                    }).command);
+                    const matchedRule = raceResult.result.matchedDescription ?? undefined;
+                    if (matchedRule) {
+                      setClassifierApproval(toolUseID, matchedRule);
+                    }
+                    ctx.logDecision({
+                      decision: "accept",
+                      source: {
+                        type: "classifier"
+                      }
+                    });
+                    resolve(ctx.buildAllow(result.updatedInput ?? input as Record<string, unknown>, {
+                      decisionReason: {
+                        type: "classifier" as const,
+                        classifier: "bash_allow" as const,
+                        reason: `Allowed by prompt rule: "${raceResult.result.matchedDescription}"`
+                      }
+                    }));
+                    return;
+                  }
+                }
+              }
+              handleInteractivePermission({
+                ctx,
+                description,
+                result,
+                awaitAutomatedChecksBeforeDialog: appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog,
+                bridgeCallbacks: feature("BRIDGE_MODE") ? appState.replBridgePermissionCallbacks : undefined,
+                channelCallbacks: feature("KAIROS") || feature("KAIROS_CHANNELS") ? appState.channelPermissionCallbacks : undefined
+              }, resolve);
+              return;
+            }
+        }
+      }).catch(error => {
+        if (error instanceof AbortError || error instanceof APIUserAbortError) {
+          logForDebugging(`Permission check threw ${error.constructor.name} for tool=${tool.name}: ${error.message}`);
+          ctx.logCancelled();
+          resolve(ctx.cancelAndAbort(undefined, true));
+        } else {
+          logError(error);
+          resolve(ctx.cancelAndAbort(undefined, true));
+        }
+      }).finally(() => {
+        clearClassifierChecking(toolUseID);
+      });
+    });
+    $[0] = setToolPermissionContext;
+    $[1] = setToolUseConfirmQueue;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function _temp2(res) {
+  return setTimeout(res, 2000, {
+    type: "timeout" as const
+  });
+}
+function _temp(r) {
+  return {
+    type: "result" as const,
+    result: r
+  };
+}
+export default useCanUseTool;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","APIUserAbortError","React","useCallback","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","sanitizeToolNameForAnalytics","ToolUseConfirm","Text","ToolPermissionContext","Tool","ToolType","ToolUseContext","consumeSpeculativeClassifierCheck","peekSpeculativeClassifierCheck","BASH_TOOL_NAME","AssistantMessage","recordAutoModeDenial","clearClassifierChecking","setClassifierApproval","setYoloClassifierApproval","logForDebugging","AbortError","logError","PermissionDecision","hasPermissionsToUseTool","jsonStringify","handleCoordinatorPermission","handleInteractivePermission","handleSwarmWorkerPermission","createPermissionContext","createPermissionQueueOps","logPermissionDecision","CanUseToolFn","Record","tool","input","Input","toolUseContext","assistantMessage","toolUseID","forceDecision","Promise","useCanUseTool","setToolUseConfirmQueue","setToolPermissionContext","$","_c","t0","resolve","ctx","resolveIfAborted","decisionPromise","undefined","then","result","behavior","decisionReason","type","classifier","reason","logDecision","decision","source","buildAllow","updatedInput","appState","getAppState","description","isNonInteractiveSession","options","toolPermissionContext","tools","messageId","toolName","name","display","timestamp","Date","now","addNotification","key","priority","jsx","userFacingName","toLowerCase","awaitAutomatedChecksBeforeDialog","coordinatorDecision","pendingClassifierCheck","suggestions","permissionMode","mode","swarmDecision","speculativePromise","command","raceResult","race","_temp","_temp2","matches","confidence","matchedRule","matchedDescription","const","bridgeCallbacks","replBridgePermissionCallbacks","channelCallbacks","channelPermissionCallbacks","catch","error","constructor","message","logCancelled","cancelAndAbort","finally","res","setTimeout","r"],"sources":["useCanUseTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { APIUserAbortError } from '@anthropic-ai/sdk'\nimport * as React from 'react'\nimport { useCallback } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'\nimport type { ToolUseConfirm } from '../components/permissions/PermissionRequest.js'\nimport { Text } from '../ink.js'\nimport type {\n  ToolPermissionContext,\n  Tool as ToolType,\n  ToolUseContext,\n} from '../Tool.js'\nimport {\n  consumeSpeculativeClassifierCheck,\n  peekSpeculativeClassifierCheck,\n} from '../tools/BashTool/bashPermissions.js'\nimport { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js'\nimport type { AssistantMessage } from '../types/message.js'\nimport { recordAutoModeDenial } from '../utils/autoModeDenials.js'\nimport {\n  clearClassifierChecking,\n  setClassifierApproval,\n  setYoloClassifierApproval,\n} from '../utils/classifierApprovals.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { AbortError } from '../utils/errors.js'\nimport { logError } from '../utils/log.js'\nimport type { PermissionDecision } from '../utils/permissions/PermissionResult.js'\nimport { hasPermissionsToUseTool } from '../utils/permissions/permissions.js'\nimport { jsonStringify } from '../utils/slowOperations.js'\nimport { handleCoordinatorPermission } from './toolPermission/handlers/coordinatorHandler.js'\nimport { handleInteractivePermission } from './toolPermission/handlers/interactiveHandler.js'\nimport { handleSwarmWorkerPermission } from './toolPermission/handlers/swarmWorkerHandler.js'\nimport {\n  createPermissionContext,\n  createPermissionQueueOps,\n} from './toolPermission/PermissionContext.js'\nimport { logPermissionDecision } from './toolPermission/permissionLogging.js'\n\nexport type CanUseToolFn<\n  Input extends Record<string, unknown> = Record<string, unknown>,\n> = (\n  tool: ToolType,\n  input: Input,\n  toolUseContext: ToolUseContext,\n  assistantMessage: AssistantMessage,\n  toolUseID: string,\n  forceDecision?: PermissionDecision<Input>,\n) => Promise<PermissionDecision<Input>>\n\nfunction useCanUseTool(\n  setToolUseConfirmQueue: React.Dispatch<\n    React.SetStateAction<ToolUseConfirm[]>\n  >,\n  setToolPermissionContext: (context: ToolPermissionContext) => void,\n): CanUseToolFn {\n  return useCallback<CanUseToolFn>(\n    async (\n      tool,\n      input,\n      toolUseContext,\n      assistantMessage,\n      toolUseID,\n      forceDecision,\n    ) => {\n      return new Promise(resolve => {\n        const ctx = createPermissionContext(\n          tool,\n          input,\n          toolUseContext,\n          assistantMessage,\n          toolUseID,\n          setToolPermissionContext,\n          createPermissionQueueOps(setToolUseConfirmQueue),\n        )\n\n        if (ctx.resolveIfAborted(resolve)) return\n\n        const decisionPromise =\n          forceDecision !== undefined\n            ? Promise.resolve(forceDecision)\n            : hasPermissionsToUseTool(\n                tool,\n                input,\n                toolUseContext,\n                assistantMessage,\n                toolUseID,\n              )\n\n        return decisionPromise\n          .then(async result => {\n            // [ANT-ONLY] Log all tool permission decisions with tool name and args\n            if (\"external\" === 'ant') {\n              logEvent('tengu_internal_tool_permission_decision', {\n                toolName: sanitizeToolNameForAnalytics(tool.name),\n                behavior:\n                  result.behavior as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                // Note: input contains code/filepaths, only log for ants\n                input: jsonStringify(\n                  input,\n                ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                messageID:\n                  ctx.messageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                isMcp: tool.isMcp ?? false,\n              })\n            }\n\n            // Has permissions to use tool, granted in config\n            if (result.behavior === 'allow') {\n              if (ctx.resolveIfAborted(resolve)) return\n              // Track auto mode classifier approvals for UI display\n              if (\n                feature('TRANSCRIPT_CLASSIFIER') &&\n                result.decisionReason?.type === 'classifier' &&\n                result.decisionReason.classifier === 'auto-mode'\n              ) {\n                setYoloClassifierApproval(\n                  toolUseID,\n                  result.decisionReason.reason,\n                )\n              }\n\n              ctx.logDecision({ decision: 'accept', source: 'config' })\n\n              resolve(\n                ctx.buildAllow(result.updatedInput ?? input, {\n                  decisionReason: result.decisionReason,\n                }),\n              )\n              return\n            }\n\n            const appState = toolUseContext.getAppState()\n            const description = await tool.description(input as never, {\n              isNonInteractiveSession:\n                toolUseContext.options.isNonInteractiveSession,\n              toolPermissionContext: appState.toolPermissionContext,\n              tools: toolUseContext.options.tools,\n            })\n\n            if (ctx.resolveIfAborted(resolve)) return\n\n            // Does not have permissions to use tool, check the behavior\n            switch (result.behavior) {\n              case 'deny': {\n                logPermissionDecision(\n                  {\n                    tool,\n                    input,\n                    toolUseContext,\n                    messageId: ctx.messageId,\n                    toolUseID,\n                  },\n                  { decision: 'reject', source: 'config' },\n                )\n                if (\n                  feature('TRANSCRIPT_CLASSIFIER') &&\n                  result.decisionReason?.type === 'classifier' &&\n                  result.decisionReason.classifier === 'auto-mode'\n                ) {\n                  recordAutoModeDenial({\n                    toolName: tool.name,\n                    display: description,\n                    reason: result.decisionReason.reason ?? '',\n                    timestamp: Date.now(),\n                  })\n                  toolUseContext.addNotification?.({\n                    key: 'auto-mode-denied',\n                    priority: 'immediate',\n                    jsx: (\n                      <>\n                        <Text color=\"error\">\n                          {tool.userFacingName(input).toLowerCase()} denied by\n                          auto mode\n                        </Text>\n                        <Text dimColor> · /permissions</Text>\n                      </>\n                    ),\n                  })\n                }\n                resolve(result)\n                return\n              }\n\n              case 'ask': {\n                // For coordinator workers, await automated checks before showing dialog.\n                // Background workers should only interrupt the user when automated checks can't decide.\n                if (\n                  appState.toolPermissionContext\n                    .awaitAutomatedChecksBeforeDialog\n                ) {\n                  const coordinatorDecision = await handleCoordinatorPermission(\n                    {\n                      ctx,\n                      ...(feature('BASH_CLASSIFIER')\n                        ? {\n                            pendingClassifierCheck:\n                              result.pendingClassifierCheck,\n                          }\n                        : {}),\n                      updatedInput: result.updatedInput,\n                      suggestions: result.suggestions,\n                      permissionMode: appState.toolPermissionContext.mode,\n                    },\n                  )\n                  if (coordinatorDecision) {\n                    resolve(coordinatorDecision)\n                    return\n                  }\n                  // null means neither automated check resolved -- fall through to dialog below.\n                  // Hooks already ran, classifier already consumed.\n                }\n\n                // After awaiting automated checks, verify the request wasn't aborted\n                // while we were waiting. Without this check, a stale dialog could appear.\n                if (ctx.resolveIfAborted(resolve)) return\n\n                // For swarm workers, try classifier auto-approval then\n                // forward permission requests to the leader via mailbox.\n                const swarmDecision = await handleSwarmWorkerPermission({\n                  ctx,\n                  description,\n                  ...(feature('BASH_CLASSIFIER')\n                    ? {\n                        pendingClassifierCheck: result.pendingClassifierCheck,\n                      }\n                    : {}),\n                  updatedInput: result.updatedInput,\n                  suggestions: result.suggestions,\n                })\n                if (swarmDecision) {\n                  resolve(swarmDecision)\n                  return\n                }\n\n                // Grace period: wait up to 2s for speculative classifier\n                // to resolve before showing the dialog (main agent only)\n                if (\n                  feature('BASH_CLASSIFIER') &&\n                  result.pendingClassifierCheck &&\n                  tool.name === BASH_TOOL_NAME &&\n                  !appState.toolPermissionContext\n                    .awaitAutomatedChecksBeforeDialog\n                ) {\n                  const speculativePromise = peekSpeculativeClassifierCheck(\n                    (input as { command: string }).command,\n                  )\n                  if (speculativePromise) {\n                    const raceResult = await Promise.race([\n                      speculativePromise.then(r => ({\n                        type: 'result' as const,\n                        result: r,\n                      })),\n                      new Promise<{ type: 'timeout' }>(res =>\n                        // eslint-disable-next-line no-restricted-syntax -- resolves with a value, not void\n                        setTimeout(res, 2000, { type: 'timeout' as const }),\n                      ),\n                    ])\n\n                    if (ctx.resolveIfAborted(resolve)) return\n\n                    if (\n                      raceResult.type === 'result' &&\n                      raceResult.result.matches &&\n                      raceResult.result.confidence === 'high' &&\n                      feature('BASH_CLASSIFIER')\n                    ) {\n                      // Classifier approved within grace period — skip dialog\n                      void consumeSpeculativeClassifierCheck(\n                        (input as { command: string }).command,\n                      )\n\n                      const matchedRule =\n                        raceResult.result.matchedDescription ?? undefined\n                      if (matchedRule) {\n                        setClassifierApproval(toolUseID, matchedRule)\n                      }\n\n                      ctx.logDecision({\n                        decision: 'accept',\n                        source: { type: 'classifier' },\n                      })\n                      resolve(\n                        ctx.buildAllow(\n                          result.updatedInput ??\n                            (input as Record<string, unknown>),\n                          {\n                            decisionReason: {\n                              type: 'classifier' as const,\n                              classifier: 'bash_allow' as const,\n                              reason: `Allowed by prompt rule: \"${raceResult.result.matchedDescription}\"`,\n                            },\n                          },\n                        ),\n                      )\n                      return\n                    }\n                    // Timeout or no match — fall through to show dialog\n                  }\n                }\n\n                // Show dialog and start hooks/classifier in background\n                handleInteractivePermission(\n                  {\n                    ctx,\n                    description,\n                    result,\n                    awaitAutomatedChecksBeforeDialog:\n                      appState.toolPermissionContext\n                        .awaitAutomatedChecksBeforeDialog,\n                    bridgeCallbacks: feature('BRIDGE_MODE')\n                      ? appState.replBridgePermissionCallbacks\n                      : undefined,\n                    channelCallbacks:\n                      feature('KAIROS') || feature('KAIROS_CHANNELS')\n                        ? appState.channelPermissionCallbacks\n                        : undefined,\n                  },\n                  resolve,\n                )\n\n                return\n              }\n            }\n          })\n          .catch(error => {\n            if (\n              error instanceof AbortError ||\n              error instanceof APIUserAbortError\n            ) {\n              logForDebugging(\n                `Permission check threw ${error.constructor.name} for tool=${tool.name}: ${error.message}`,\n              )\n              ctx.logCancelled()\n              resolve(ctx.cancelAndAbort(undefined, true))\n            } else {\n              logError(error)\n              resolve(ctx.cancelAndAbort(undefined, true))\n            }\n          })\n          .finally(() => {\n            clearClassifierChecking(toolUseID)\n          })\n      })\n    },\n    [setToolUseConfirmQueue, setToolPermissionContext],\n  )\n}\n\nexport default useCanUseTool\n"],"mappings":";AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,SAASC,iBAAiB,QAAQ,mBAAmB;AACrD,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,WAAW,QAAQ,OAAO;AACnC,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,iCAAiC;AACxC,SAASC,4BAA4B,QAAQ,oCAAoC;AACjF,cAAcC,cAAc,QAAQ,gDAAgD;AACpF,SAASC,IAAI,QAAQ,WAAW;AAChC,cACEC,qBAAqB,EACrBC,IAAI,IAAIC,QAAQ,EAChBC,cAAc,QACT,YAAY;AACnB,SACEC,iCAAiC,EACjCC,8BAA8B,QACzB,sCAAsC;AAC7C,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,cAAcC,gBAAgB,QAAQ,qBAAqB;AAC3D,SAASC,oBAAoB,QAAQ,6BAA6B;AAClE,SACEC,uBAAuB,EACvBC,qBAAqB,EACrBC,yBAAyB,QACpB,iCAAiC;AACxC,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,UAAU,QAAQ,oBAAoB;AAC/C,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,cAAcC,kBAAkB,QAAQ,0CAA0C;AAClF,SAASC,uBAAuB,QAAQ,qCAAqC;AAC7E,SAASC,aAAa,QAAQ,4BAA4B;AAC1D,SAASC,2BAA2B,QAAQ,iDAAiD;AAC7F,SAASC,2BAA2B,QAAQ,iDAAiD;AAC7F,SAASC,2BAA2B,QAAQ,iDAAiD;AAC7F,SACEC,uBAAuB,EACvBC,wBAAwB,QACnB,uCAAuC;AAC9C,SAASC,qBAAqB,QAAQ,uCAAuC;AAE7E,OAAO,KAAKC,YAAY,CACtB,cAAcC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAGA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAChE,GAAG,CACFC,IAAI,EAAExB,QAAQ,EACdyB,KAAK,EAAEC,KAAK,EACZC,cAAc,EAAE1B,cAAc,EAC9B2B,gBAAgB,EAAEvB,gBAAgB,EAClCwB,SAAS,EAAE,MAAM,EACjBC,aAAyC,CAA3B,EAAEjB,kBAAkB,CAACa,KAAK,CAAC,EACzC,GAAGK,OAAO,CAAClB,kBAAkB,CAACa,KAAK,CAAC,CAAC;AAEvC,SAAAM,cAAAC,sBAAA,EAAAC,wBAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAF,CAAA,QAAAD,wBAAA,IAAAC,CAAA,QAAAF,sBAAA;IAOII,EAAA,SAAAA,CAAAb,IAAA,EAAAC,KAAA,EAAAE,cAAA,EAAAC,gBAAA,EAAAC,SAAA,EAAAC,aAAA,KAQS,IAAIC,OAAO,CAACO,OAAA;MACjB,MAAAC,GAAA,GAAYpB,uBAAuB,CACjCK,IAAI,EACJC,KAAK,EACLE,cAAc,EACdC,gBAAgB,EAChBC,SAAS,EACTK,wBAAwB,EACxBd,wBAAwB,CAACa,sBAAsB,CACjD,CAAC;MAED,IAAIM,GAAG,CAAAC,gBAAiB,CAACF,OAAO,CAAC;QAAA;MAAA;MAEjC,MAAAG,eAAA,GACEX,aAAa,KAAKY,SAQb,GAPDX,OAAO,CAAAO,OAAQ,CAACR,aAOhB,CAAC,GANDhB,uBAAuB,CACrBU,IAAI,EACJC,KAAK,EACLE,cAAc,EACdC,gBAAgB,EAChBC,SACF,CAAC;MAAA,OAEAY,eAAe,CAAAE,IACf,CAAC,MAAAC,MAAA;QAkBJ,IAAIA,MAAM,CAAAC,QAAS,KAAK,OAAO;UAC7B,IAAIN,GAAG,CAAAC,gBAAiB,CAACF,OAAO,CAAC;YAAA;UAAA;UAEjC,IACEjD,OAAO,CAAC,uBACmC,CAAC,IAA5CuD,MAAM,CAAAE,cAAqB,EAAAC,IAAA,KAAK,YACgB,IAAhDH,MAAM,CAAAE,cAAe,CAAAE,UAAW,KAAK,WAAW;YAEhDvC,yBAAyB,CACvBoB,SAAS,EACTe,MAAM,CAAAE,cAAe,CAAAG,MACvB,CAAC;UAAA;UAGHV,GAAG,CAAAW,WAAY,CAAC;YAAAC,QAAA,EAAY,QAAQ;YAAAC,MAAA,EAAU;UAAS,CAAC,CAAC;UAEzDd,OAAO,CACLC,GAAG,CAAAc,UAAW,CAACT,MAAM,CAAAU,YAAsB,IAA5B7B,KAA4B,EAAE;YAAAqB,cAAA,EAC3BF,MAAM,CAAAE;UACxB,CAAC,CACH,CAAC;UAAA;QAAA;QAIH,MAAAS,QAAA,GAAiB5B,cAAc,CAAA6B,WAAY,CAAC,CAAC;QAC7C,MAAAC,WAAA,GAAoB,MAAMjC,IAAI,CAAAiC,WAAY,CAAChC,KAAK,IAAI,KAAK,EAAE;UAAAiC,uBAAA,EAEvD/B,cAAc,CAAAgC,OAAQ,CAAAD,uBAAwB;UAAAE,qBAAA,EACzBL,QAAQ,CAAAK,qBAAsB;UAAAC,KAAA,EAC9ClC,cAAc,CAAAgC,OAAQ,CAAAE;QAC/B,CAAC,CAAC;QAEF,IAAItB,GAAG,CAAAC,gBAAiB,CAACF,OAAO,CAAC;UAAA;QAAA;QAGjC,QAAQM,MAAM,CAAAC,QAAS;UAAA,KAChB,MAAM;YAAA;cACTxB,qBAAqB,CACnB;gBAAAG,IAAA;gBAAAC,KAAA;gBAAAE,cAAA;gBAAAmC,SAAA,EAIavB,GAAG,CAAAuB,SAAU;gBAAAjC;cAE1B,CAAC,EACD;gBAAAsB,QAAA,EAAY,QAAQ;gBAAAC,MAAA,EAAU;cAAS,CACzC,CAAC;cACD,IACE/D,OAAO,CAAC,uBACmC,CAAC,IAA5CuD,MAAM,CAAAE,cAAqB,EAAAC,IAAA,KAAK,YACgB,IAAhDH,MAAM,CAAAE,cAAe,CAAAE,UAAW,KAAK,WAAW;gBAEhD1C,oBAAoB,CAAC;kBAAAyD,QAAA,EACTvC,IAAI,CAAAwC,IAAK;kBAAAC,OAAA,EACVR,WAAW;kBAAAR,MAAA,EACZL,MAAM,CAAAE,cAAe,CAAAG,MAAa,IAAlC,EAAkC;kBAAAiB,SAAA,EAC/BC,IAAI,CAAAC,GAAI,CAAC;gBACtB,CAAC,CAAC;gBACFzC,cAAc,CAAA0C,eAYZ,GAZ+B;kBAAAC,GAAA,EAC1B,kBAAkB;kBAAAC,QAAA,EACb,WAAW;kBAAAC,GAAA,EAEnB,EACE,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAChB,CAAAhD,IAAI,CAAAiD,cAAe,CAAChD,KAAK,CAAC,CAAAiD,WAAY,CAAC,EAAE,oBAE5C,EAHC,IAAI,CAIL,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,eAAe,EAA7B,IAAI,CAAgC;gBAG3C,CAAC,CAAC;cAAA;cAEJpC,OAAO,CAACM,MAAM,CAAC;cAAA;YAAA;UAAA,KAIZ,KAAK;YAAA;cAGR,IACEW,QAAQ,CAAAK,qBAAsB,CAAAe,gCACK;gBAEnC,MAAAC,mBAAA,GAA4B,MAAM5D,2BAA2B,CAC3D;kBAAAuB,GAAA;kBAAA,IAEMlD,OAAO,CAAC,iBAKP,CAAC,GALF;oBAAAwF,sBAAA,EAGIjC,MAAM,CAAAiC;kBAET,CAAC,GALF,CAKC,CAAC;kBAAAvB,YAAA,EACQV,MAAM,CAAAU,YAAa;kBAAAwB,WAAA,EACpBlC,MAAM,CAAAkC,WAAY;kBAAAC,cAAA,EACfxB,QAAQ,CAAAK,qBAAsB,CAAAoB;gBAChD,CACF,CAAC;gBACD,IAAIJ,mBAAmB;kBACrBtC,OAAO,CAACsC,mBAAmB,CAAC;kBAAA;gBAAA;cAE7B;cAOH,IAAIrC,GAAG,CAAAC,gBAAiB,CAACF,OAAO,CAAC;gBAAA;cAAA;cAIjC,MAAA2C,aAAA,GAAsB,MAAM/D,2BAA2B,CAAC;gBAAAqB,GAAA;gBAAAkB,WAAA;gBAAA,IAGlDpE,OAAO,CAAC,iBAIP,CAAC,GAJF;kBAAAwF,sBAAA,EAE0BjC,MAAM,CAAAiC;gBAE/B,CAAC,GAJF,CAIC,CAAC;gBAAAvB,YAAA,EACQV,MAAM,CAAAU,YAAa;gBAAAwB,WAAA,EACpBlC,MAAM,CAAAkC;cACrB,CAAC,CAAC;cACF,IAAIG,aAAa;gBACf3C,OAAO,CAAC2C,aAAa,CAAC;gBAAA;cAAA;cAMxB,IACE5F,OAAO,CAAC,iBACoB,CAAC,IAA7BuD,MAAM,CAAAiC,sBACsB,IAA5BrD,IAAI,CAAAwC,IAAK,KAAK5D,cAEqB,IAJnC,CAGCmD,QAAQ,CAAAK,qBAAsB,CAAAe,gCACI;gBAEnC,MAAAO,kBAAA,GAA2B/E,8BAA8B,CACvD,CAACsB,KAAK,IAAI;kBAAE0D,OAAO,EAAE,MAAM;gBAAC,CAAC,EAAAA,OAC/B,CAAC;gBACD,IAAID,kBAAkB;kBACpB,MAAAE,UAAA,GAAmB,MAAMrD,OAAO,CAAAsD,IAAK,CAAC,CACpCH,kBAAkB,CAAAvC,IAAK,CAAC2C,KAGtB,CAAC,EACH,IAAIvD,OAAO,CAAsBwD,MAGjC,CAAC,CACF,CAAC;kBAEF,IAAIhD,GAAG,CAAAC,gBAAiB,CAACF,OAAO,CAAC;oBAAA;kBAAA;kBAEjC,IACE8C,UAAU,CAAArC,IAAK,KAAK,QACK,IAAzBqC,UAAU,CAAAxC,MAAO,CAAA4C,OACsB,IAAvCJ,UAAU,CAAAxC,MAAO,CAAA6C,UAAW,KAAK,MACP,IAA1BpG,OAAO,CAAC,iBAAiB,CAAC;oBAGrBa,iCAAiC,CACpC,CAACuB,KAAK,IAAI;sBAAE0D,OAAO,EAAE,MAAM;oBAAC,CAAC,EAAAA,OAC/B,CAAC;oBAED,MAAAO,WAAA,GACEN,UAAU,CAAAxC,MAAO,CAAA+C,kBAAgC,IAAjDjD,SAAiD;oBACnD,IAAIgD,WAAW;sBACblF,qBAAqB,CAACqB,SAAS,EAAE6D,WAAW,CAAC;oBAAA;oBAG/CnD,GAAG,CAAAW,WAAY,CAAC;sBAAAC,QAAA,EACJ,QAAQ;sBAAAC,MAAA,EACV;wBAAAL,IAAA,EAAQ;sBAAa;oBAC/B,CAAC,CAAC;oBACFT,OAAO,CACLC,GAAG,CAAAc,UAAW,CACZT,MAAM,CAAAU,YAC8B,IAAjC7B,KAAK,IAAIF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EACpC;sBAAAuB,cAAA,EACkB;wBAAAC,IAAA,EACR,YAAY,IAAI6C,KAAK;wBAAA5C,UAAA,EACf,YAAY,IAAI4C,KAAK;wBAAA3C,MAAA,EACzB,4BAA4BmC,UAAU,CAAAxC,MAAO,CAAA+C,kBAAmB;sBAC1E;oBACF,CACF,CACF,CAAC;oBAAA;kBAAA;gBAEF;cAEF;cAIH1E,2BAA2B,CACzB;gBAAAsB,GAAA;gBAAAkB,WAAA;gBAAAb,MAAA;gBAAA+B,gCAAA,EAKIpB,QAAQ,CAAAK,qBAAsB,CAAAe,gCACK;gBAAAkB,eAAA,EACpBxG,OAAO,CAAC,aAEb,CAAC,GADTkE,QAAQ,CAAAuC,6BACC,GAFIpD,SAEJ;gBAAAqD,gBAAA,EAEX1G,OAAO,CAAC,QAAsC,CAAC,IAA1BA,OAAO,CAAC,iBAAiB,CAEjC,GADTkE,QAAQ,CAAAyC,0BACC,GAFbtD;cAGJ,CAAC,EACDJ,OACF,CAAC;cAAA;YAAA;QAIL;MAAC,CACF,CAAC,CAAA2D,KACI,CAACC,KAAA;QACL,IACEA,KAAK,YAAYvF,UACiB,IAAlCuF,KAAK,YAAY5G,iBAAiB;UAElCoB,eAAe,CACb,0BAA0BwF,KAAK,CAAAC,WAAY,CAAAnC,IAAK,aAAaxC,IAAI,CAAAwC,IAAK,KAAKkC,KAAK,CAAAE,OAAQ,EAC1F,CAAC;UACD7D,GAAG,CAAA8D,YAAa,CAAC,CAAC;UAClB/D,OAAO,CAACC,GAAG,CAAA+D,cAAe,CAAC5D,SAAS,EAAE,IAAI,CAAC,CAAC;QAAA;UAE5C9B,QAAQ,CAACsF,KAAK,CAAC;UACf5D,OAAO,CAACC,GAAG,CAAA+D,cAAe,CAAC5D,SAAS,EAAE,IAAI,CAAC,CAAC;QAAA;MAC7C,CACF,CAAC,CAAA6D,OACM,CAAC;QACPhG,uBAAuB,CAACsB,SAAS,CAAC;MAAA,CACnC,CAAC;IAAA,CACL,CACF;IAAAM,CAAA,MAAAD,wBAAA;IAAAC,CAAA,MAAAF,sBAAA;IAAAE,CAAA,MAAAE,EAAA;EAAA;IAAAA,EAAA,GAAAF,CAAA;EAAA;EAAA,OAhSIE,EAkSN;AAAA;AAxSH,SAAAkD,OAAAiB,GAAA;EAAA,OA6MwBC,UAAU,CAACD,GAAG,EAAE,IAAI,EAAE;IAAAzD,IAAA,EAAQ,SAAS,IAAI6C;EAAM,CAAC,CAAC;AAAA;AA7M3E,SAAAN,MAAAoB,CAAA;EAAA,OAuMoD;IAAA3D,IAAA,EACtB,QAAQ,IAAI6C,KAAK;IAAAhD,MAAA,EACf8D;EACV,CAAC;AAAA;AAiGvB,eAAe1E,aAAa","ignoreList":[]}