@xelauvas/xela-cli 0.1.0

package/src/hooks/useInputBuffer.ts

@@ -0,0 +1,132 @@
+import { useCallback, useRef, useState } from 'react'
+import type { PastedContent } from '../utils/config.js'
+
+export type BufferEntry = {
+  text: string
+  cursorOffset: number
+  pastedContents: Record<number, PastedContent>
+  timestamp: number
+}
+
+export type UseInputBufferProps = {
+  maxBufferSize: number
+  debounceMs: number
+}
+
+export type UseInputBufferResult = {
+  pushToBuffer: (
+    text: string,
+    cursorOffset: number,
+    pastedContents?: Record<number, PastedContent>,
+  ) => void
+  undo: () => BufferEntry | undefined
+  canUndo: boolean
+  clearBuffer: () => void
+}
+
+export function useInputBuffer({
+  maxBufferSize,
+  debounceMs,
+}: UseInputBufferProps): UseInputBufferResult {
+  const [buffer, setBuffer] = useState<BufferEntry[]>([])
+  const [currentIndex, setCurrentIndex] = useState(-1)
+  const lastPushTime = useRef<number>(0)
+  const pendingPush = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  const pushToBuffer = useCallback(
+    (
+      text: string,
+      cursorOffset: number,
+      pastedContents: Record<number, PastedContent> = {},
+    ) => {
+      const now = Date.now()
+
+      // Clear any pending push
+      if (pendingPush.current) {
+        clearTimeout(pendingPush.current)
+        pendingPush.current = null
+      }
+
+      // Debounce rapid changes
+      if (now - lastPushTime.current < debounceMs) {
+        pendingPush.current = setTimeout(
+          pushToBuffer,
+          debounceMs,
+          text,
+          cursorOffset,
+          pastedContents,
+        )
+        return
+      }
+
+      lastPushTime.current = now
+
+      setBuffer(prevBuffer => {
+        // If we're not at the end of the buffer, truncate everything after current position
+        const newBuffer =
+          currentIndex >= 0 ? prevBuffer.slice(0, currentIndex + 1) : prevBuffer
+
+        // Don't add if it's the same as the last entry
+        const lastEntry = newBuffer[newBuffer.length - 1]
+        if (lastEntry && lastEntry.text === text) {
+          return newBuffer
+        }
+
+        // Add new entry
+        const updatedBuffer = [
+          ...newBuffer,
+          { text, cursorOffset, pastedContents, timestamp: now },
+        ]
+
+        // Limit buffer size
+        if (updatedBuffer.length > maxBufferSize) {
+          return updatedBuffer.slice(-maxBufferSize)
+        }
+
+        return updatedBuffer
+      })
+
+      // Update current index to point to the new entry
+      setCurrentIndex(prev => {
+        const newIndex = prev >= 0 ? prev + 1 : buffer.length
+        return Math.min(newIndex, maxBufferSize - 1)
+      })
+    },
+    [debounceMs, maxBufferSize, currentIndex, buffer.length],
+  )
+
+  const undo = useCallback((): BufferEntry | undefined => {
+    if (currentIndex < 0 || buffer.length === 0) {
+      return undefined
+    }
+
+    const targetIndex = Math.max(0, currentIndex - 1)
+    const entry = buffer[targetIndex]
+
+    if (entry) {
+      setCurrentIndex(targetIndex)
+      return entry
+    }
+
+    return undefined
+  }, [buffer, currentIndex])
+
+  const clearBuffer = useCallback(() => {
+    setBuffer([])
+    setCurrentIndex(-1)
+    lastPushTime.current = 0
+    if (pendingPush.current) {
+      clearTimeout(pendingPush.current)
+      pendingPush.current = null
+    }
+  }, [lastPushTime, pendingPush])
+
+  const canUndo = currentIndex > 0 && buffer.length > 1
+
+  return {
+    pushToBuffer,
+    undo,
+    canUndo,
+    clearBuffer,
+  }
+}

package/src/hooks/useIssueFlagBanner.ts

@@ -0,0 +1,133 @@
+import { useMemo, useRef } from 'react'
+import { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js'
+import type { Message } from '../types/message.js'
+import { getUserMessageText } from '../utils/messages.js'
+
+const EXTERNAL_COMMAND_PATTERNS = [
+  /\bcurl\b/,
+  /\bwget\b/,
+  /\bssh\b/,
+  /\bkubectl\b/,
+  /\bsrun\b/,
+  /\bdocker\b/,
+  /\bbq\b/,
+  /\bgsutil\b/,
+  /\bgcloud\b/,
+  /\baws\b/,
+  /\bgit\s+push\b/,
+  /\bgit\s+pull\b/,
+  /\bgit\s+fetch\b/,
+  /\bgh\s+(pr|issue)\b/,
+  /\bnc\b/,
+  /\bncat\b/,
+  /\btelnet\b/,
+  /\bftp\b/,
+]
+
+const FRICTION_PATTERNS = [
+  // "No," or "No!" at start — comma/exclamation implies correction tone
+  // (avoids "No problem", "No thanks", "No I think we should...")
+  /^no[,!]\s/i,
+  // Direct corrections about Claude's output
+  /\bthat'?s (wrong|incorrect|not (what|right|correct))\b/i,
+  /\bnot what I (asked|wanted|meant|said)\b/i,
+  // Referencing prior instructions Claude missed
+  /\bI (said|asked|wanted|told you|already said)\b/i,
+  // Questioning Claude's actions
+  /\bwhy did you\b/i,
+  /\byou should(n'?t| not)? have\b/i,
+  /\byou were supposed to\b/i,
+  // Explicit retry/revert of Claude's work
+  /\btry again\b/i,
+  /\b(undo|revert) (that|this|it|what you)\b/i,
+]
+
+export function isSessionContainerCompatible(messages: Message[]): boolean {
+  for (const msg of messages) {
+    if (msg.type !== 'assistant') {
+      continue
+    }
+    const content = msg.message.content
+    if (!Array.isArray(content)) {
+      continue
+    }
+    for (const block of content) {
+      if (block.type !== 'tool_use' || !('name' in block)) {
+        continue
+      }
+      const toolName = block.name as string
+      if (toolName.startsWith('mcp__')) {
+        return false
+      }
+      if (toolName === BASH_TOOL_NAME) {
+        const input = (block as { input?: Record<string, unknown> }).input
+        const command = (input?.command as string) || ''
+        if (EXTERNAL_COMMAND_PATTERNS.some(p => p.test(command))) {
+          return false
+        }
+      }
+    }
+  }
+  return true
+}
+
+export function hasFrictionSignal(messages: Message[]): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!
+    if (msg.type !== 'user') {
+      continue
+    }
+    const text = getUserMessageText(msg)
+    if (!text) {
+      continue
+    }
+    return FRICTION_PATTERNS.some(p => p.test(text))
+  }
+  return false
+}
+
+const MIN_SUBMIT_COUNT = 3
+const COOLDOWN_MS = 30 * 60 * 1000
+
+export function useIssueFlagBanner(
+  messages: Message[],
+  submitCount: number,
+): boolean {
+  if (process.env.USER_TYPE !== 'ant') {
+    return false
+  }
+
+  // biome-ignore lint/correctness/useHookAtTopLevel: process.env.USER_TYPE is a compile-time constant
+  const lastTriggeredAtRef = useRef(0)
+  // biome-ignore lint/correctness/useHookAtTopLevel: process.env.USER_TYPE is a compile-time constant
+  const activeForSubmitRef = useRef(-1)
+
+  // Memoize the O(messages) scans. This hook runs on every REPL render
+  // (including every keystroke), but messages is stable during typing.
+  // isSessionContainerCompatible walks all messages + regex-tests each
+  // bash command — by far the heaviest work here.
+  // biome-ignore lint/correctness/useHookAtTopLevel: process.env.USER_TYPE is a compile-time constant
+  const shouldTrigger = useMemo(
+    () => isSessionContainerCompatible(messages) && hasFrictionSignal(messages),
+    [messages],
+  )
+
+  // Keep showing the banner until the user submits another message
+  if (activeForSubmitRef.current === submitCount) {
+    return true
+  }
+
+  if (Date.now() - lastTriggeredAtRef.current < COOLDOWN_MS) {
+    return false
+  }
+  if (submitCount < MIN_SUBMIT_COUNT) {
+    return false
+  }
+  if (!shouldTrigger) {
+    return false
+  }
+
+  lastTriggeredAtRef.current = Date.now()
+  activeForSubmitRef.current = submitCount
+  return true
+}

package/src/hooks/useLogMessages.ts

@@ -0,0 +1,119 @@
+import type { UUID } from 'crypto'
+import { useEffect, useRef } from 'react'
+import { useAppState } from '../state/AppState.js'
+import type { Message } from '../types/message.js'
+import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js'
+import {
+  cleanMessagesForLogging,
+  isChainParticipant,
+  recordTranscript,
+} from '../utils/sessionStorage.js'
+
+/**
+ * Hook that logs messages to the transcript
+ * conversation ID that only changes when a new conversation is started.
+ *
+ * @param messages The current conversation messages
+ * @param ignore When true, messages will not be recorded to the transcript
+ */
+export function useLogMessages(messages: Message[], ignore: boolean = false) {
+  const teamContext = useAppState(s => s.teamContext)
+
+  // messages is append-only between compactions, so track where we left off
+  // and only pass the new tail to recordTranscript. Avoids O(n) filter+scan
+  // on every setMessages (~20x/turn, so n=3000 was ~120k wasted iterations).
+  const lastRecordedLengthRef = useRef(0)
+  const lastParentUuidRef = useRef<UUID | undefined>(undefined)
+  // First-uuid change = compaction or /clear rebuilt the array; length alone
+  // can't detect this since post-compact [CB,summary,...keep,new] may be longer.
+  const firstMessageUuidRef = useRef<UUID | undefined>(undefined)
+  // Guard against stale async .then() overwriting a fresher sync update when
+  // an incremental render fires before the compaction .then() resolves.
+  const callSeqRef = useRef(0)
+
+  useEffect(() => {
+    if (ignore) return
+
+    const currentFirstUuid = messages[0]?.uuid as UUID | undefined
+    const prevLength = lastRecordedLengthRef.current
+
+    // First-render: firstMessageUuidRef is undefined. Compaction: first uuid changes.
+    // Both are !isIncremental, but first-render sync-walk is safe (no messagesToKeep).
+    const wasFirstRender = firstMessageUuidRef.current === undefined
+    const isIncremental =
+      currentFirstUuid !== undefined &&
+      !wasFirstRender &&
+      currentFirstUuid === firstMessageUuidRef.current &&
+      prevLength <= messages.length
+    // Same-head shrink: tombstone filter, rewind, snip, partial-compact.
+    // Distinguished from compaction (first uuid changes) because the tail
+    // is either an existing on-disk message or a fresh message that this
+    // same effect's recordTranscript(fullArray) will write — see sync-walk
+    // guard below.
+    const isSameHeadShrink =
+      currentFirstUuid !== undefined &&
+      !wasFirstRender &&
+      currentFirstUuid === firstMessageUuidRef.current &&
+      prevLength > messages.length
+
+    const startIndex = isIncremental ? prevLength : 0
+    if (startIndex === messages.length) return
+
+    // Full array on first call + after compaction: recordTranscript's own
+    // O(n) dedup loop handles messagesToKeep interleaving correctly there.
+    const slice = startIndex === 0 ? messages : messages.slice(startIndex)
+    const parentHint = isIncremental ? lastParentUuidRef.current : undefined
+
+    // Fire and forget - we don't want to block the UI.
+    const seq = ++callSeqRef.current
+    void recordTranscript(
+      slice,
+      isAgentSwarmsEnabled()
+        ? {
+            teamName: teamContext?.teamName,
+            agentName: teamContext?.selfAgentName,
+          }
+        : {},
+      parentHint,
+      messages,
+    ).then(lastRecordedUuid => {
+      // For compaction/full array case (!isIncremental): use the async return
+      // value. After compaction, messagesToKeep in the array are skipped
+      // (already in transcript), so the sync loop would find a wrong UUID.
+      // Skip if a newer effect already ran (stale closure would overwrite the
+      // fresher sync update from the subsequent incremental render).
+      if (seq !== callSeqRef.current) return
+      if (lastRecordedUuid && !isIncremental) {
+        lastParentUuidRef.current = lastRecordedUuid
+      }
+    })
+
+    // Sync-walk safe for: incremental (pure new-tail slice), first-render
+    // (no messagesToKeep interleaving), and same-head shrink. Shrink is the
+    // subtle one: the picked uuid is either already on disk (tombstone/rewind
+    // — survivors were written before) or is being written by THIS effect's
+    // recordTranscript(fullArray) call (snip boundary / partial-compact tail
+    // — enqueueWrite ordering guarantees it lands before any later write that
+    // chains to it). Without this, the ref stays stale at a tombstoned uuid:
+    // the async .then() correction is raced out by the next effect's seq bump
+    // on large sessions where recordTranscript(fullArray) is slow. Only the
+    // compaction case (first uuid changed) remains unsafe — tail may be
+    // messagesToKeep whose last-actually-recorded uuid differs.
+    if (isIncremental || wasFirstRender || isSameHeadShrink) {
+      // Match EXACTLY what recordTranscript persists: cleanMessagesForLogging
+      // applies both the isLoggableMessage filter and (for external users) the
+      // REPL-strip + isVirtual-promote transform. Using the raw predicate here
+      // would pick a UUID that the transform drops, leaving the parent hint
+      // pointing at a message that never reached disk. Pass full messages as
+      // replId context — REPL tool_use and its tool_result land in separate
+      // render cycles, so the slice alone can't pair them.
+      const last = cleanMessagesForLogging(slice, messages).findLast(
+        isChainParticipant,
+      )
+      if (last) lastParentUuidRef.current = last.uuid as UUID
+    }
+
+    lastRecordedLengthRef.current = messages.length
+    firstMessageUuidRef.current = currentFirstUuid
+  }, [messages, ignore, teamContext?.teamName, teamContext?.selfAgentName])
+}

package/src/hooks/useLspPluginRecommendation.tsx

@@ -0,0 +1,194 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Hook for LSP plugin recommendations
+ *
+ * Detects file edits and recommends LSP plugins when:
+ * - File extension matches an LSP plugin
+ * - LSP binary is already installed on the system
+ * - Plugin is not already installed
+ * - User hasn't disabled recommendations
+ *
+ * Only shows one recommendation per session.
+ */
+
+import { extname, join } from 'path';
+import * as React from 'react';
+import { hasShownLspRecommendationThisSession, setLspRecommendationShownThisSession } from '../bootstrap/state.js';
+import { useNotifications } from '../context/notifications.js';
+import { useAppState } from '../state/AppState.js';
+import { saveGlobalConfig } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { logError } from '../utils/log.js';
+import { addToNeverSuggest, getMatchingLspPlugins, incrementIgnoredCount } from '../utils/plugins/lspRecommendation.js';
+import { cacheAndRegisterPlugin } from '../utils/plugins/pluginInstallationHelpers.js';
+import { getSettingsForSource, updateSettingsForSource } from '../utils/settings/settings.js';
+import { installPluginAndNotify, usePluginRecommendationBase } from './usePluginRecommendationBase.js';
+
+// Threshold for detecting timeout vs explicit dismiss (ms)
+// Menu auto-dismisses at 30s, so anything over 28s is likely timeout
+const TIMEOUT_THRESHOLD_MS = 28_000;
+export type LspRecommendationState = {
+  pluginId: string;
+  pluginName: string;
+  pluginDescription?: string;
+  fileExtension: string;
+  shownAt: number; // Timestamp for timeout detection
+} | null;
+type UseLspPluginRecommendationResult = {
+  recommendation: LspRecommendationState;
+  handleResponse: (response: 'yes' | 'no' | 'never' | 'disable') => void;
+};
+export function useLspPluginRecommendation() {
+  const $ = _c(12);
+  const trackedFiles = useAppState(_temp);
+  const {
+    addNotification
+  } = useNotifications();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = new Set();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const checkedFilesRef = React.useRef(t0);
+  const {
+    recommendation,
+    clearRecommendation,
+    tryResolve
+  } = usePluginRecommendationBase();
+  let t1;
+  let t2;
+  if ($[1] !== trackedFiles || $[2] !== tryResolve) {
+    t1 = () => {
+      tryResolve(async () => {
+        if (hasShownLspRecommendationThisSession()) {
+          return null;
+        }
+        const newFiles = [];
+        for (const file of trackedFiles) {
+          if (!checkedFilesRef.current.has(file)) {
+            checkedFilesRef.current.add(file);
+            newFiles.push(file);
+          }
+        }
+        for (const filePath of newFiles) {
+          ;
+          try {
+            const matches = await getMatchingLspPlugins(filePath);
+            const match = matches[0];
+            if (match) {
+              logForDebugging(`[useLspPluginRecommendation] Found match: ${match.pluginName} for ${filePath}`);
+              setLspRecommendationShownThisSession(true);
+              return {
+                pluginId: match.pluginId,
+                pluginName: match.pluginName,
+                pluginDescription: match.description,
+                fileExtension: extname(filePath),
+                shownAt: Date.now()
+              };
+            }
+          } catch (t3) {
+            const error = t3;
+            logError(error);
+          }
+        }
+        return null;
+      });
+    };
+    t2 = [trackedFiles, tryResolve];
+    $[1] = trackedFiles;
+    $[2] = tryResolve;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  React.useEffect(t1, t2);
+  let t3;
+  if ($[5] !== addNotification || $[6] !== clearRecommendation || $[7] !== recommendation) {
+    t3 = response => {
+      if (!recommendation) {
+        return;
+      }
+      const {
+        pluginId,
+        pluginName,
+        shownAt
+      } = recommendation;
+      logForDebugging(`[useLspPluginRecommendation] User response: ${response} for ${pluginName}`);
+      bb60: switch (response) {
+        case "yes":
+          {
+            installPluginAndNotify(pluginId, pluginName, "lsp-plugin", addNotification, async pluginData => {
+              logForDebugging(`[useLspPluginRecommendation] Installing plugin: ${pluginId}`);
+              const localSourcePath = typeof pluginData.entry.source === "string" ? join(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
+              await cacheAndRegisterPlugin(pluginId, pluginData.entry, "user", undefined, localSourcePath);
+              const settings = getSettingsForSource("userSettings");
+              updateSettingsForSource("userSettings", {
+                enabledPlugins: {
+                  ...settings?.enabledPlugins,
+                  [pluginId]: true
+                }
+              });
+              logForDebugging(`[useLspPluginRecommendation] Plugin installed: ${pluginId}`);
+            });
+            break bb60;
+          }
+        case "no":
+          {
+            const elapsed = Date.now() - shownAt;
+            if (elapsed >= TIMEOUT_THRESHOLD_MS) {
+              logForDebugging(`[useLspPluginRecommendation] Timeout detected (${elapsed}ms), incrementing ignored count`);
+              incrementIgnoredCount();
+            }
+            break bb60;
+          }
+        case "never":
+          {
+            addToNeverSuggest(pluginId);
+            break bb60;
+          }
+        case "disable":
+          {
+            saveGlobalConfig(_temp2);
+          }
+      }
+      clearRecommendation();
+    };
+    $[5] = addNotification;
+    $[6] = clearRecommendation;
+    $[7] = recommendation;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const handleResponse = t3;
+  let t4;
+  if ($[9] !== handleResponse || $[10] !== recommendation) {
+    t4 = {
+      recommendation,
+      handleResponse
+    };
+    $[9] = handleResponse;
+    $[10] = recommendation;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  return t4;
+}
+function _temp2(current) {
+  if (current.lspRecommendationDisabled) {
+    return current;
+  }
+  return {
+    ...current,
+    lspRecommendationDisabled: true
+  };
+}
+function _temp(s) {
+  return s.fileHistory.trackedFiles;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["extname","join","React","hasShownLspRecommendationThisSession","setLspRecommendationShownThisSession","useNotifications","useAppState","saveGlobalConfig","logForDebugging","logError","addToNeverSuggest","getMatchingLspPlugins","incrementIgnoredCount","cacheAndRegisterPlugin","getSettingsForSource","updateSettingsForSource","installPluginAndNotify","usePluginRecommendationBase","TIMEOUT_THRESHOLD_MS","LspRecommendationState","pluginId","pluginName","pluginDescription","fileExtension","shownAt","UseLspPluginRecommendationResult","recommendation","handleResponse","response","useLspPluginRecommendation","$","_c","trackedFiles","_temp","addNotification","t0","Symbol","for","Set","checkedFilesRef","useRef","clearRecommendation","tryResolve","t1","t2","newFiles","file","current","has","add","push","filePath","matches","match","description","Date","now","t3","error","useEffect","bb60","pluginData","localSourcePath","entry","source","marketplaceInstallLocation","undefined","settings","enabledPlugins","elapsed","_temp2","t4","lspRecommendationDisabled","s","fileHistory"],"sources":["useLspPluginRecommendation.tsx"],"sourcesContent":["/**\n * Hook for LSP plugin recommendations\n *\n * Detects file edits and recommends LSP plugins when:\n * - File extension matches an LSP plugin\n * - LSP binary is already installed on the system\n * - Plugin is not already installed\n * - User hasn't disabled recommendations\n *\n * Only shows one recommendation per session.\n */\n\nimport { extname, join } from 'path'\nimport * as React from 'react'\nimport {\n  hasShownLspRecommendationThisSession,\n  setLspRecommendationShownThisSession,\n} from '../bootstrap/state.js'\nimport { useNotifications } from '../context/notifications.js'\nimport { useAppState } from '../state/AppState.js'\nimport { saveGlobalConfig } from '../utils/config.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { logError } from '../utils/log.js'\nimport {\n  addToNeverSuggest,\n  getMatchingLspPlugins,\n  incrementIgnoredCount,\n} from '../utils/plugins/lspRecommendation.js'\nimport { cacheAndRegisterPlugin } from '../utils/plugins/pluginInstallationHelpers.js'\nimport {\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../utils/settings/settings.js'\nimport {\n  installPluginAndNotify,\n  usePluginRecommendationBase,\n} from './usePluginRecommendationBase.js'\n\n// Threshold for detecting timeout vs explicit dismiss (ms)\n// Menu auto-dismisses at 30s, so anything over 28s is likely timeout\nconst TIMEOUT_THRESHOLD_MS = 28_000\n\nexport type LspRecommendationState = {\n  pluginId: string\n  pluginName: string\n  pluginDescription?: string\n  fileExtension: string\n  shownAt: number // Timestamp for timeout detection\n} | null\n\ntype UseLspPluginRecommendationResult = {\n  recommendation: LspRecommendationState\n  handleResponse: (response: 'yes' | 'no' | 'never' | 'disable') => void\n}\n\nexport function useLspPluginRecommendation(): UseLspPluginRecommendationResult {\n  const trackedFiles = useAppState(s => s.fileHistory.trackedFiles)\n  const { addNotification } = useNotifications()\n  const checkedFilesRef = React.useRef<Set<string>>(new Set())\n  const { recommendation, clearRecommendation, tryResolve } =\n    usePluginRecommendationBase<NonNullable<LspRecommendationState>>()\n\n  React.useEffect(() => {\n    tryResolve(async () => {\n      if (hasShownLspRecommendationThisSession()) return null\n\n      const newFiles: string[] = []\n      for (const file of trackedFiles) {\n        if (!checkedFilesRef.current.has(file)) {\n          checkedFilesRef.current.add(file)\n          newFiles.push(file)\n        }\n      }\n\n      for (const filePath of newFiles) {\n        try {\n          const matches = await getMatchingLspPlugins(filePath)\n          const match = matches[0] // official plugins prioritized\n          if (match) {\n            logForDebugging(\n              `[useLspPluginRecommendation] Found match: ${match.pluginName} for ${filePath}`,\n            )\n            setLspRecommendationShownThisSession(true)\n            return {\n              pluginId: match.pluginId,\n              pluginName: match.pluginName,\n              pluginDescription: match.description,\n              fileExtension: extname(filePath),\n              shownAt: Date.now(),\n            }\n          }\n        } catch (error) {\n          logError(error)\n        }\n      }\n      return null\n    })\n  }, [trackedFiles, tryResolve])\n\n  const handleResponse = React.useCallback(\n    (response: 'yes' | 'no' | 'never' | 'disable') => {\n      if (!recommendation) return\n\n      const { pluginId, pluginName, shownAt } = recommendation\n\n      logForDebugging(\n        `[useLspPluginRecommendation] User response: ${response} for ${pluginName}`,\n      )\n\n      switch (response) {\n        case 'yes':\n          void installPluginAndNotify(\n            pluginId,\n            pluginName,\n            'lsp-plugin',\n            addNotification,\n            async pluginData => {\n              logForDebugging(\n                `[useLspPluginRecommendation] Installing plugin: ${pluginId}`,\n              )\n              const localSourcePath =\n                typeof pluginData.entry.source === 'string'\n                  ? join(\n                      pluginData.marketplaceInstallLocation,\n                      pluginData.entry.source,\n                    )\n                  : undefined\n              await cacheAndRegisterPlugin(\n                pluginId,\n                pluginData.entry,\n                'user',\n                undefined, // projectPath - not needed for user scope\n                localSourcePath,\n              )\n              // Enable in user settings so it loads on restart\n              const settings = getSettingsForSource('userSettings')\n              updateSettingsForSource('userSettings', {\n                enabledPlugins: {\n                  ...settings?.enabledPlugins,\n                  [pluginId]: true,\n                },\n              })\n              logForDebugging(\n                `[useLspPluginRecommendation] Plugin installed: ${pluginId}`,\n              )\n            },\n          )\n          break\n\n        case 'no': {\n          const elapsed = Date.now() - shownAt\n          if (elapsed >= TIMEOUT_THRESHOLD_MS) {\n            logForDebugging(\n              `[useLspPluginRecommendation] Timeout detected (${elapsed}ms), incrementing ignored count`,\n            )\n            incrementIgnoredCount()\n          }\n          break\n        }\n\n        case 'never':\n          addToNeverSuggest(pluginId)\n          break\n\n        case 'disable':\n          saveGlobalConfig(current => {\n            if (current.lspRecommendationDisabled) return current\n            return { ...current, lspRecommendationDisabled: true }\n          })\n          break\n      }\n\n      clearRecommendation()\n    },\n    [recommendation, addNotification, clearRecommendation],\n  )\n\n  return { recommendation, handleResponse }\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,OAAO,EAAEC,IAAI,QAAQ,MAAM;AACpC,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SACEC,oCAAoC,EACpCC,oCAAoC,QAC/B,uBAAuB;AAC9B,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SAASC,WAAW,QAAQ,sBAAsB;AAClD,SAASC,gBAAgB,QAAQ,oBAAoB;AACrD,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SACEC,iBAAiB,EACjBC,qBAAqB,EACrBC,qBAAqB,QAChB,uCAAuC;AAC9C,SAASC,sBAAsB,QAAQ,+CAA+C;AACtF,SACEC,oBAAoB,EACpBC,uBAAuB,QAClB,+BAA+B;AACtC,SACEC,sBAAsB,EACtBC,2BAA2B,QACtB,kCAAkC;;AAEzC;AACA;AACA,MAAMC,oBAAoB,GAAG,MAAM;AAEnC,OAAO,KAAKC,sBAAsB,GAAG;EACnCC,QAAQ,EAAE,MAAM;EAChBC,UAAU,EAAE,MAAM;EAClBC,iBAAiB,CAAC,EAAE,MAAM;EAC1BC,aAAa,EAAE,MAAM;EACrBC,OAAO,EAAE,MAAM,EAAC;AAClB,CAAC,GAAG,IAAI;AAER,KAAKC,gCAAgC,GAAG;EACtCC,cAAc,EAAEP,sBAAsB;EACtCQ,cAAc,EAAE,CAACC,QAAQ,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,EAAE,GAAG,IAAI;AACxE,CAAC;AAED,OAAO,SAAAC,2BAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EACL,MAAAC,YAAA,GAAqB1B,WAAW,CAAC2B,KAA+B,CAAC;EACjE;IAAAC;EAAA,IAA4B7B,gBAAgB,CAAC,CAAC;EAAA,IAAA8B,EAAA;EAAA,IAAAL,CAAA,QAAAM,MAAA,CAAAC,GAAA;IACIF,EAAA,OAAIG,GAAG,CAAC,CAAC;IAAAR,CAAA,MAAAK,EAAA;EAAA;IAAAA,EAAA,GAAAL,CAAA;EAAA;EAA3D,MAAAS,eAAA,GAAwBrC,KAAK,CAAAsC,MAAO,CAAcL,EAAS,CAAC;EAC5D;IAAAT,cAAA;IAAAe,mBAAA;IAAAC;EAAA,IACEzB,2BAA2B,CAAsC,CAAC;EAAA,IAAA0B,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAd,CAAA,QAAAE,YAAA,IAAAF,CAAA,QAAAY,UAAA;IAEpDC,EAAA,GAAAA,CAAA;MACdD,UAAU,CAAC;QACT,IAAIvC,oCAAoC,CAAC,CAAC;UAAA,OAAS,IAAI;QAAA;QAEvD,MAAA0C,QAAA,GAA2B,EAAE;QAC7B,KAAK,MAAAC,IAAU,IAAId,YAAY;UAC7B,IAAI,CAACO,eAAe,CAAAQ,OAAQ,CAAAC,GAAI,CAACF,IAAI,CAAC;YACpCP,eAAe,CAAAQ,OAAQ,CAAAE,GAAI,CAACH,IAAI,CAAC;YACjCD,QAAQ,CAAAK,IAAK,CAACJ,IAAI,CAAC;UAAA;QACpB;QAGH,KAAK,MAAAK,QAAc,IAAIN,QAAQ;UAAA;UAC7B;YACE,MAAAO,OAAA,GAAgB,MAAMzC,qBAAqB,CAACwC,QAAQ,CAAC;YACrD,MAAAE,KAAA,GAAcD,OAAO,GAAG;YACxB,IAAIC,KAAK;cACP7C,eAAe,CACb,6CAA6C6C,KAAK,CAAAhC,UAAW,QAAQ8B,QAAQ,EAC/E,CAAC;cACD/C,oCAAoC,CAAC,IAAI,CAAC;cAAA,OACnC;gBAAAgB,QAAA,EACKiC,KAAK,CAAAjC,QAAS;gBAAAC,UAAA,EACZgC,KAAK,CAAAhC,UAAW;gBAAAC,iBAAA,EACT+B,KAAK,CAAAC,WAAY;gBAAA/B,aAAA,EACrBvB,OAAO,CAACmD,QAAQ,CAAC;gBAAA3B,OAAA,EACvB+B,IAAI,CAAAC,GAAI,CAAC;cACpB,CAAC;YAAA;UACF,SAAAC,EAAA;YACMC,KAAA,CAAAA,KAAA,CAAAA,CAAA,CAAAA,EAAK;YACZjD,QAAQ,CAACiD,KAAK,CAAC;UAAA;QAChB;QACF,OACM,IAAI;MAAA,CACZ,CAAC;IAAA,CACH;IAAEd,EAAA,IAACZ,YAAY,EAAEU,UAAU,CAAC;IAAAZ,CAAA,MAAAE,YAAA;IAAAF,CAAA,MAAAY,UAAA;IAAAZ,CAAA,MAAAa,EAAA;IAAAb,CAAA,MAAAc,EAAA;EAAA;IAAAD,EAAA,GAAAb,CAAA;IAAAc,EAAA,GAAAd,CAAA;EAAA;EAnC7B5B,KAAK,CAAAyD,SAAU,CAAChB,EAmCf,EAAEC,EAA0B,CAAC;EAAA,IAAAa,EAAA;EAAA,IAAA3B,CAAA,QAAAI,eAAA,IAAAJ,CAAA,QAAAW,mBAAA,IAAAX,CAAA,QAAAJ,cAAA;IAG5B+B,EAAA,GAAA7B,QAAA;MACE,IAAI,CAACF,cAAc;QAAA;MAAA;MAEnB;QAAAN,QAAA;QAAAC,UAAA;QAAAG;MAAA,IAA0CE,cAAc;MAExDlB,eAAe,CACb,+CAA+CoB,QAAQ,QAAQP,UAAU,EAC3E,CAAC;MAAAuC,IAAA,EAED,QAAQhC,QAAQ;QAAA,KACT,KAAK;UAAA;YACHZ,sBAAsB,CACzBI,QAAQ,EACRC,UAAU,EACV,YAAY,EACZa,eAAe,EACf,MAAA2B,UAAA;cACErD,eAAe,CACb,mDAAmDY,QAAQ,EAC7D,CAAC;cACD,MAAA0C,eAAA,GACE,OAAOD,UAAU,CAAAE,KAAM,CAAAC,MAAO,KAAK,QAKtB,GAJT/D,IAAI,CACF4D,UAAU,CAAAI,0BAA2B,EACrCJ,UAAU,CAAAE,KAAM,CAAAC,MAEV,CAAC,GALbE,SAKa;cACf,MAAMrD,sBAAsB,CAC1BO,QAAQ,EACRyC,UAAU,CAAAE,KAAM,EAChB,MAAM,EACNG,SAAS,EACTJ,eACF,CAAC;cAED,MAAAK,QAAA,GAAiBrD,oBAAoB,CAAC,cAAc,CAAC;cACrDC,uBAAuB,CAAC,cAAc,EAAE;gBAAAqD,cAAA,EACtB;kBAAA,GACXD,QAAQ,EAAAC,cAAgB;kBAAA,CAC1BhD,QAAQ,GAAG;gBACd;cACF,CAAC,CAAC;cACFZ,eAAe,CACb,kDAAkDY,QAAQ,EAC5D,CAAC;YAAA,CAEL,CAAC;YACD,MAAAwC,IAAA;UAAK;QAAA,KAEF,IAAI;UAAA;YACP,MAAAS,OAAA,GAAgBd,IAAI,CAAAC,GAAI,CAAC,CAAC,GAAGhC,OAAO;YACpC,IAAI6C,OAAO,IAAInD,oBAAoB;cACjCV,eAAe,CACb,kDAAkD6D,OAAO,iCAC3D,CAAC;cACDzD,qBAAqB,CAAC,CAAC;YAAA;YAEzB,MAAAgD,IAAA;UAAK;QAAA,KAGF,OAAO;UAAA;YACVlD,iBAAiB,CAACU,QAAQ,CAAC;YAC3B,MAAAwC,IAAA;UAAK;QAAA,KAEF,SAAS;UAAA;YACZrD,gBAAgB,CAAC+D,MAGhB,CAAC;UAAA;MAEN;MAEA7B,mBAAmB,CAAC,CAAC;IAAA,CACtB;IAAAX,CAAA,MAAAI,eAAA;IAAAJ,CAAA,MAAAW,mBAAA;IAAAX,CAAA,MAAAJ,cAAA;IAAAI,CAAA,MAAA2B,EAAA;EAAA;IAAAA,EAAA,GAAA3B,CAAA;EAAA;EA1EH,MAAAH,cAAA,GAAuB8B,EA4EtB;EAAA,IAAAc,EAAA;EAAA,IAAAzC,CAAA,QAAAH,cAAA,IAAAG,CAAA,SAAAJ,cAAA;IAEM6C,EAAA;MAAA7C,cAAA;MAAAC;IAAiC,CAAC;IAAAG,CAAA,MAAAH,cAAA;IAAAG,CAAA,OAAAJ,cAAA;IAAAI,CAAA,OAAAyC,EAAA;EAAA;IAAAA,EAAA,GAAAzC,CAAA;EAAA;EAAA,OAAlCyC,EAAkC;AAAA;AA1HpC,SAAAD,OAAAvB,OAAA;EA+GK,IAAIA,OAAO,CAAAyB,yBAA0B;IAAA,OAASzB,OAAO;EAAA;EAAA,OAC9C;IAAA,GAAKA,OAAO;IAAAyB,yBAAA,EAA6B;EAAK,CAAC;AAAA;AAhH3D,SAAAvC,MAAAwC,CAAA;EAAA,OACiCA,CAAC,CAAAC,WAAY,CAAA1C,YAAa;AAAA","ignoreList":[]}

package/src/hooks/useMailboxBridge.ts

@@ -0,0 +1,21 @@
+import { useCallback, useEffect, useMemo, useSyncExternalStore } from 'react'
+import { useMailbox } from '../context/mailbox.js'
+
+type Props = {
+  isLoading: boolean
+  onSubmitMessage: (content: string) => boolean
+}
+
+export function useMailboxBridge({ isLoading, onSubmitMessage }: Props): void {
+  const mailbox = useMailbox()
+
+  const subscribe = useMemo(() => mailbox.subscribe.bind(mailbox), [mailbox])
+  const getSnapshot = useCallback(() => mailbox.revision, [mailbox])
+  const revision = useSyncExternalStore(subscribe, getSnapshot)
+
+  useEffect(() => {
+    if (isLoading) return
+    const msg = mailbox.poll()
+    if (msg) onSubmitMessage(msg.content)
+  }, [isLoading, revision, mailbox, onSubmitMessage])
+}

package/src/hooks/useMainLoopModel.ts

@@ -0,0 +1,34 @@
+import { useEffect, useReducer } from 'react'
+import { onGrowthBookRefresh } from '../services/analytics/growthbook.js'
+import { useAppState } from '../state/AppState.js'
+import {
+  getDefaultMainLoopModelSetting,
+  type ModelName,
+  parseUserSpecifiedModel,
+} from '../utils/model/model.js'
+
+// The value of the selector is a full model name that can be used directly in
+// API calls. Use this over getMainLoopModel() when the component needs to
+// update upon a model config change.
+export function useMainLoopModel(): ModelName {
+  const mainLoopModel = useAppState(s => s.mainLoopModel)
+  const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession)
+
+  // parseUserSpecifiedModel reads tengu_ant_model_override via
+  // _CACHED_MAY_BE_STALE (in resolveAntModel). Until GB init completes,
+  // that's the stale disk cache; after, it's the in-memory remoteEval map.
+  // AppState doesn't change when GB init finishes, so we subscribe to the
+  // refresh signal and force a re-render to re-resolve with fresh values.
+  // Without this, the alias resolution is frozen until something else
+  // happens to re-render the component — the API would sample one model
+  // while /model (which also re-resolves) displays another.
+  const [, forceRerender] = useReducer(x => x + 1, 0)
+  useEffect(() => onGrowthBookRefresh(forceRerender), [])
+
+  const model = parseUserSpecifiedModel(
+    mainLoopModelForSession ??
+      mainLoopModel ??
+      getDefaultMainLoopModelSetting(),
+  )
+  return model
+}