@miphamai/cli 0.55.0 → 0.57.0

package/src/shared/graft-stats.ts

@@ -0,0 +1,53 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join, resolve, dirname } from 'node:path'
+
+/** Graft's hook-maintained stats cache (`graft/.cache/stats.json`). */
+export interface GraftStats {
+  nodeCount: number
+  edgeCount: number
+  staleCount: number
+  dirty: boolean
+  syncing: boolean
+  lastFile: string | null
+}
+
+/**
+ * Read graft's stats cache for the given project. Returns null when graft is
+ * not built/installed in `cwd` (no `graft/.cache/stats.json`, or an empty
+ * graph) — callers render nothing in that case.
+ */
+export function readGraftStats(cwd: string): GraftStats | null {
+  const statsPath = join(cwd, 'graft', '.cache', 'stats.json')
+  if (!existsSync(statsPath)) return null
+  try {
+    const raw = JSON.parse(readFileSync(statsPath, 'utf-8')) as Record<string, unknown>
+    if (typeof raw.nodeCount !== 'number' || raw.nodeCount === 0) return null
+    return {
+      nodeCount: raw.nodeCount,
+      edgeCount: typeof raw.edgeCount === 'number' ? raw.edgeCount : 0,
+      staleCount: typeof raw.staleCount === 'number' ? raw.staleCount : 0,
+      dirty: raw.dirty === true,
+      syncing: raw.syncing === true,
+      lastFile: typeof raw.lastFile === 'string' ? raw.lastFile : null,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Find the nearest graft graph by walking up from `cwd` to the filesystem root.
+ * Graft builds its cache at the repo root (`graft/.cache/stats.json`), so this
+ * also resolves when `cwd` is a subdirectory of a graft-indexed repo — not only
+ * the repo root itself.
+ */
+export function findGraftStats(cwd: string): GraftStats | null {
+  let dir = resolve(cwd)
+  for (;;) {
+    const stats = readGraftStats(dir)
+    if (stats) return stats
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.55.0' as const
+export const PACKAGE_VERSION = '0.57.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/skills/loader.ts

@@ -82,6 +82,11 @@ export class SkillsLoader implements Skills {
     }
   }
 
+  /** Load a single skill file by path (used by Claude plugins: `skills/<name>/SKILL.md`). */
+  loadSkillFile(path: string, type: 'standard' | 'mipham' = 'standard'): void {
+    this.tryLoad(path, type)
+  }
+
   get(name: string): SkillDefinition | undefined {
     return this.skills.get(name)
   }
@@ -195,40 +200,13 @@ export class SkillsLoader implements Skills {
   }
 
   /**
-   * Recall the skills most relevant to a context (e.g. the session's system
-   * prompt / project context), mirroring MemoryManager.recall's keyword
-   * scoring. Name keywords are a strong signal (+3); description keywords are
-   * weak (+1). Returns up to `limit` skills sorted by relevance.
-   */
-  recall(context: string, limit: number = 5): SkillDefinition[] {
-    const ctxWords = new Set(context.toLowerCase().split(/\s+/))
-    const scored: Array<{ skill: SkillDefinition; score: number }> = []
-
-    for (const skill of this.list()) {
-      if (skill.disableModelInvocation) continue
-      let score = 0
-      for (const word of skill.name.toLowerCase().split(/[-_\s]+/)) {
-        if (word.length > 2 && ctxWords.has(word)) score += 3
-      }
-      for (const word of skill.description.toLowerCase().split(/\s+/)) {
-        if (word.length > 3 && ctxWords.has(word)) score += 1
-      }
-      if (score > 0) scored.push({ skill, score })
-    }
-
-    scored.sort((a, b) => b.score - a.score)
-    return scored.slice(0, limit).map((s) => s.skill)
-  }
-
-  /**
-   * Build the system-reminder block for AI auto-triggering.
-   * With a `context`, only the most relevant skills are injected (selective,
-   * to save tokens); without one, all skills are listed.
+   * Build the system-reminder block listing every skill the AI may invoke via
+   * the Skill tool. A single full listing keeps the whole catalog discoverable:
+   * at session start there is no query to match against, so a keyword "recall"
+   * would silently hide most skills. Capped at `maxTokens` to stay bounded.
    */
-  buildSystemReminder(context?: string, maxTokens: number = 5000): string {
-    const selected = context
-      ? this.recall(context)
-      : this.list().filter((s) => !s.disableModelInvocation)
+  buildSystemReminder(maxTokens: number = 5000): string {
+    const selected = this.list().filter((s) => !s.disableModelInvocation)
 
     if (selected.length === 0) return ''
 

package/src/skills/seam.ts

@@ -6,7 +6,7 @@ export interface Skills {
   get(name: string): SkillDefinition | undefined
   list(): SkillDefinition[]
   has(name: string): boolean
-  buildSystemReminder(context?: string, maxTokens?: number): string
+  buildSystemReminder(maxTokens?: number): string
 }
 
 /** 缝键：ctx.skills。 */

package/src/tools/agent/memory.ts

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import type { ToolDefinition } from '../../shared/index.ts'
+import { MemoryManager } from '../../core/memory/memory-manager'
 
 const MEMORY_DIR = join(homedir(), '.mipham', 'memory')
 
@@ -24,7 +25,7 @@ ${content}
 
 export const memoryTool: ToolDefinition = {
   name: 'Memory',
-  description: 'Read and write persistent memory files in ~/.mipham/memory/.',
+  description: 'Read, write, list, and search persistent memory files in ~/.mipham/memory/.',
   category: 'agent',
   permission: 'auto',
   parameters: {
@@ -32,11 +33,12 @@ export const memoryTool: ToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['read', 'write', 'list'],
+        enum: ['read', 'write', 'list', 'search'],
         description: 'Action to perform',
       },
       name: { type: 'string', description: 'Memory file name (slug)' },
       content: { type: 'string', description: 'Content to write (for write action)' },
+      query: { type: 'string', description: 'Search query (for search action)' },
     },
     required: ['action'],
   },
@@ -49,6 +51,22 @@ export const memoryTool: ToolDefinition = {
       return { success: true, content: files.join('\n') || '(no memories)' }
     }
 
+    // Semantic-less recall (keyword + wikilink + time-decay scoring) — lets the
+    // AI retrieve relevant memories mid-conversation, not only at session start.
+    if (action === 'search') {
+      const query = (params.query as string)?.trim()
+      if (!query) return { success: false, content: '', error: 'query is required' }
+      const mm = new MemoryManager(MEMORY_DIR)
+      mm.loadAll()
+      const results = mm.recall(query, 10)
+      if (results.length === 0) return { success: true, content: '(no matching memories)' }
+      const lines = results.map((entry) => {
+        const snippet = entry.content.replace(/\n+/g, ' ').trim().slice(0, 140)
+        return `- ${entry.name}: ${entry.description || snippet}\n  ${snippet}`
+      })
+      return { success: true, content: lines.join('\n') }
+    }
+
     const name = params.name as string
     if (!name) return { success: false, content: '', error: 'name is required' }
     const filePath = join(MEMORY_DIR, `${name}.md`)

package/src/tools/exec/bash.ts

@@ -29,10 +29,10 @@ const BLOCKED_PATTERNS = [
   />\s*\/dev\/sd[a-z]/,
   // SSH private key theft
   /\bcat\s+.*\/\.ssh\/id_/,
-  // Shell command substitution (commonly used for obfuscation/evasion)
-  /\$\(/,
-  // Backtick command substitution
-  /`[^`]+`/,
+  // NOTE: command substitution ($( … ) / `…`) is a legitimate Bash feature, so it is
+  // NOT blocked wholesale. The dangerous content inside a substitution (curl|sh,
+  // base64 -d, python -c, eval, bash -c, source, …) is still caught by the specific
+  // patterns below, which test the whole command string including inside $().
   // Interpreter code execution (bypass vector) — covers python, python2, python3
   /\bpython[23]?\s+-c\b/,
   /\bpython[23]?\s+-m\b/,

package/src/ui/app.tsx

@@ -22,6 +22,18 @@ import { ChatPanel } from './chat'
 import { InputBar } from './input'
 import { ModelPicker } from './picker'
 import { AgentFooter, type AgentEntry } from './agent-footer'
+import { GraftStatusLine } from './graft-status'
+
+/** Current context-window usage % — undefined when unknown (remote stub). */
+function contextUsagePct(engine: QueryEngine | RemoteEngine): number | undefined {
+  const ctx = engine.getContext() as {
+    getEstimatedTokens(): number
+    getMaxTokens?(): number
+  }
+  const max = ctx.getMaxTokens?.()
+  if (!max || max <= 0) return undefined
+  return Math.round((ctx.getEstimatedTokens() / max) * 100)
+}
 import { AgentViewDashboard } from '../agent-view/dashboard'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
@@ -779,7 +791,6 @@ export function App({
 
   useInput((_input, key) => {
     // Escape: close apiKeyPrompt → close picker → abort loading (does NOT exit app)
-    // Vim mode toggle is handled by InputBar
     if (key.escape) {
       if (apiKeyPrompt) {
         setApiKeyPrompt(null)
@@ -794,8 +805,7 @@ export function App({
         abortRef.current.abort()
         return
       }
-      // When input is empty and not loading, let InputBar handle Escape
-      // (it toggles vim mode or clears pending sequences)
+      // Otherwise let InputBar handle Escape (clear draft)
       return
     }
     // All other global hotkeys (Shift+Tab, Ctrl+P, Ctrl+F, Ctrl+O)
@@ -965,6 +975,9 @@ export function App({
               agentProgress={agentProgress}
             />
 
+            {/* graft status line — mirrors graft's own "◤ graft · …" bar */}
+            <GraftStatusLine cwd={process.cwd()} ctxPct={contextUsagePct(engine)} />
+
             {/* Status line — Claude Code style */}
             <Box marginTop={1} flexDirection="column">
               <Box flexDirection="row">

package/src/ui/graft-status.tsx

@@ -0,0 +1,63 @@
+import React, { useState } from 'react'
+import { Box, Text } from 'ink'
+import { basename } from 'node:path'
+import { findGraftStats, type GraftStats } from '../shared/graft-stats'
+import { getGraftSavings } from '../shared/graft-savings'
+
+/** Freshness segment mirroring graft's own statusline (see @nanonets/graft format.js). */
+function freshnessSegment(stats: GraftStats): { label: string; color: string } {
+  if (stats.syncing) return { label: 'syncing…', color: 'yellow' }
+  if (stats.dirty && stats.staleCount > 0)
+    return { label: `⚠ ${stats.staleCount} stale`, color: 'yellow' }
+  if (stats.dirty) return { label: '⚠ stale', color: 'yellow' }
+  return { label: '✓ synced', color: 'blue' }
+}
+
+/**
+ * Bottom-of-screen graft status line — mirrors graft's own "◤ graft · …" bar:
+ *   ◤ graft · N nodes / E edges · ✓ synced · ~T tok saved
+ *   ▸ ctx X% · last: file
+ * Reads `graft/.cache/stats.json` (walking up to the repo root) once at mount;
+ * the session's tok-saved total is read live each render (the app re-renders on
+ * the agent tick). Renders nothing only when there's no graft graph AND no known
+ * ctx% — the ctx% line shows even when graft isn't built in this directory.
+ */
+export function GraftStatusLine({ cwd, ctxPct }: { cwd: string; ctxPct?: number }) {
+  const [stats] = useState(() => findGraftStats(cwd))
+  const showCtx = typeof ctxPct === 'number'
+  if (!stats && !showCtx) return null
+  const fresh = stats ? freshnessSegment(stats) : null
+  const saved = getGraftSavings()
+  const lastFile = stats?.lastFile ? basename(stats.lastFile) : null
+
+  const bottom: string[] = []
+  if (typeof ctxPct === 'number') bottom.push(`ctx ${ctxPct}%`)
+  if (lastFile) bottom.push(`last: ${lastFile}`)
+
+  return (
+    <Box flexDirection="column">
+      {stats && fresh && (
+        <Box>
+          <Text dimColor>◤ </Text>
+          <Text color="blue">graft</Text>
+          <Text dimColor>
+            {' '}
+            · {stats.nodeCount} nodes / {stats.edgeCount} edges ·{' '}
+          </Text>
+          <Text color={fresh.color}>{fresh.label}</Text>
+          {saved > 0 && (
+            <>
+              <Text dimColor> · </Text>
+              <Text color="blue">~{saved.toLocaleString()} tok saved</Text>
+            </>
+          )}
+        </Box>
+      )}
+      {bottom.length > 0 && (
+        <Box>
+          <Text dimColor>▸ {bottom.join(' · ')}</Text>
+        </Box>
+      )}
+    </Box>
+  )
+}

package/src/ui/input.tsx

@@ -1,7 +1,6 @@
 import React, { useState, useEffect, useRef, useMemo } from 'react'
 import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
-import { VimMotionEngine, handleSearchBackspace, type VimMode } from './vim-motions.js'
 import { getCommandList } from './commands.js'
 import { CommandPicker } from './command-picker.js'
 import { useI18n } from '../i18n-context'
@@ -20,7 +19,7 @@ interface InputBarProps {
   onToggleAgentView?: () => void
   /** Shift+Tab → cycle permission mode */
   onCyclePermission?: () => void
-  /** Escape → cancel loading (when input is empty) */
+  /** Escape → cancel loading / clear draft */
   onCancel?: () => void
 }
 
@@ -145,15 +144,6 @@ export function InputBar({
     prevLoading.current = isLoading
   }, [isLoading])
 
-  const [vimMode, setVimMode] = useState<VimMode>('insert')
-  // NOTE: Dual mode state — React state (vimMode) drives UI re-renders (prompt color,
-  // placeholder); engine mode (vimEngine.current.mode) drives logic inside useInput so
-  // the handler always reads the authoritative mode without stale-closure risk.
-  const vimEngine = useRef(new VimMotionEngine())
-  const vimPending = useRef<string | null>(null)
-  const [searchMode, setSearchMode] = useState(false)
-  const [searchQuery, setSearchQuery] = useState('')
-
   // Track pre-shortcut value so we can revert ink-text-input's Ctrl-key insertions.
   // ink-text-input inserts 'p'/'f'/'o' for Ctrl+P/F/O (Ink normalizes control chars
   // to their letter names before passing to useInput).
@@ -163,32 +153,21 @@ export function InputBar({
     valueBeforeShortcut.current = value
   }, [value])
 
-  // ── Vim motions: intercept keys in normal mode ──
-
   useInput((input, key) => {
-    // ── Escape: cancel loading → toggle vim mode ──
+    // ── Escape: cancel loading → clear draft ──
     if (key.escape) {
-      // Cancel search mode if active
-      if (searchMode) {
-        setSearchMode(false)
-        setSearchQuery('')
-        return
-      }
-      // Escape while loading → abort (priority over vim toggle)
+      // Escape while loading → abort
       if (isLoading) {
         onCancel?.()
         return
       }
-      // Clear any pending multi-key sequence
-      if (vimPending.current) {
-        vimPending.current = null
-      }
-      setVimMode((prev) => (prev === 'insert' ? 'normal' : 'insert'))
-      vimEngine.current.mode = vimEngine.current.mode === 'insert' ? 'normal' : 'insert'
+      // Idle → clear the draft (the intuitive "cancel")
+      setValue('')
+      valueRef.current = ''
       return
     }
 
-    // ── Global hotkeys (work in both insert and normal modes) ──
+    // ── Global hotkeys ──
     // Shift+Tab → cycle permission mode
     if (key.shift && key.tab) {
       onCyclePermission?.()
@@ -221,121 +200,43 @@ export function InputBar({
       return
     }
 
-    // ── Arrow-key history navigation (insert mode only, Claude Code parity) ──
-    if (vimEngine.current.mode === 'insert' && !searchMode) {
-      if (key.upArrow || key.downArrow) {
-        // Ignore if picker is active (command picker handles its own arrows)
-        if (value.startsWith('/')) return
-
-        if (key.upArrow) {
-          if (submittedHistory.length === 0) return
-          // Save current draft the first time we enter history browsing
-          if (historyIndexRef.current === -1) {
-            // Flush any pending throttle so its deferred setValue doesn't overwrite
-            // history navigation (paste → immediate ↑ race). Save the latest value
-            // from the ref — state `value` is stale inside the throttle window.
-            if (onChangeTimerRef.current) {
-              clearTimeout(onChangeTimerRef.current)
-              onChangeTimerRef.current = null
-            }
-            savedDraftRef.current = valueRef.current
-          }
-          const newIndex = Math.min(historyIndexRef.current + 1, submittedHistory.length - 1)
-          historyIndexRef.current = newIndex
-          setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
-          return
-        }
-        if (key.downArrow) {
-          if (historyIndexRef.current === -1) return
-          const newIndex = historyIndexRef.current - 1
-          historyIndexRef.current = newIndex
-          if (newIndex === -1) {
-            // Back to the original draft
-            setValue(savedDraftRef.current)
-            savedDraftRef.current = ''
-          } else {
-            setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
+    // ── Arrow-key history navigation (Claude Code parity) ──
+    if (key.upArrow || key.downArrow) {
+      // Ignore if picker is active (command picker handles its own arrows)
+      if (value.startsWith('/')) return
+
+      if (key.upArrow) {
+        if (submittedHistory.length === 0) return
+        // Save current draft the first time we enter history browsing
+        if (historyIndexRef.current === -1) {
+          // Flush any pending throttle so its deferred setValue doesn't overwrite
+          // history navigation (paste → immediate ↑ race). Save the latest value
+          // from the ref — state `value` is stale inside the throttle window.
+          if (onChangeTimerRef.current) {
+            clearTimeout(onChangeTimerRef.current)
+            onChangeTimerRef.current = null
           }
-          return
+          savedDraftRef.current = valueRef.current
         }
-      }
-    }
-
-    if (vimEngine.current.mode !== 'normal') return
-
-    // Handle search mode — collect query characters
-    if (searchMode) {
-      if (key.return) {
-        const action = vimEngine.current.handleSearch(value, searchQuery)
-        if (action.text !== undefined) setValue(action.text)
-        // NOTE: action.cursor is not settable on ink-text-input — user repositions manually
-        setSearchMode(false)
-        setSearchQuery('')
+        const newIndex = Math.min(historyIndexRef.current + 1, submittedHistory.length - 1)
+        historyIndexRef.current = newIndex
+        setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
         return
       }
-      if (key.backspace || key.delete) {
-        const next = handleSearchBackspace(searchQuery)
-        setSearchQuery(next.query)
-        if (next.exit) setSearchMode(false)
+      if (key.downArrow) {
+        if (historyIndexRef.current === -1) return
+        const newIndex = historyIndexRef.current - 1
+        historyIndexRef.current = newIndex
+        if (newIndex === -1) {
+          // Back to the original draft
+          setValue(savedDraftRef.current)
+          savedDraftRef.current = ''
+        } else {
+          setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
+        }
         return
       }
-      // Accumulate printable characters
-      if (input && input.length === 1 && !key.escape && !key.return) {
-        setSearchQuery((q) => q + input)
-      }
-      return
     }
-
-    // Handle pending two-key sequences (dd, yy)
-    if (vimPending.current !== null) {
-      if (vimPending.current === 'd' && input === 'd') {
-        const action = vimEngine.current.handleDD(value)
-        setValue(action.text ?? value)
-      } else if (vimPending.current === 'y' && input === 'y') {
-        vimEngine.current.handleYY(value)
-      }
-      // Always clear pending — even when second key doesn't match
-      vimPending.current = null
-      return
-    }
-
-    // Handle p (paste) — pastes clipboard at cursor position
-    if (input === 'p') {
-      const action = vimEngine.current.handlePaste(value, value.length)
-      if (action.text !== undefined) setValue(action.text)
-      return
-    }
-
-    // Handle u (undo)
-    if (input === 'u') {
-      const action = vimEngine.current.handleUndo(value)
-      if (action.text !== undefined) setValue(action.text)
-      return
-    }
-
-    // Handle / (enter search mode)
-    if (input === '/') {
-      setSearchMode(true)
-      setSearchQuery('')
-      return
-    }
-
-    // Handle single-key motions (h, j, k, l, w, b, 0, $, d, y)
-    const action = vimEngine.current.handleNormal(input, value, value.length)
-    if (!action) return
-
-    if (action.pending) {
-      vimPending.current = action.pending
-      return
-    }
-
-    if (action.text !== undefined) {
-      setValue(action.text)
-    }
-
-    // NOTE: action.cursor is returned by motions (h/j/k/l/w/b/0/$) but
-    // ink-text-input does not expose a programmatic cursor-position API.
-    // The cursor hint is informational only; the user repositions manually.
   })
 
   // ── Command picker state ──
@@ -344,7 +245,7 @@ export function InputBar({
 
   // Auto-activate picker when user types "/"
   useEffect(() => {
-    if (value.startsWith('/') && !prevValueRef.current.startsWith('/') && vimMode === 'insert') {
+    if (value.startsWith('/') && !prevValueRef.current.startsWith('/')) {
       setPickerActive(true)
     }
     // Dismiss picker when user clears the / prefix
@@ -352,7 +253,7 @@ export function InputBar({
       setPickerActive(false)
     }
     prevValueRef.current = value
-  }, [value, vimMode])
+  }, [value])
 
   // Keep valueRef in sync with state (so useInput handlers read latest value)
   useEffect(() => {
@@ -379,7 +280,7 @@ export function InputBar({
   }
 
   // ── Picker mode: CommandPicker overlay ──
-  if (pickerActive && vimMode === 'insert') {
+  if (pickerActive) {
     return (
       <Box flexDirection="column" marginTop={1}>
         <CommandPicker
@@ -403,15 +304,11 @@ export function InputBar({
     <Box flexDirection="column" marginTop={1}>
       <Box>
         <Box marginRight={1}>
-          <Text color={vimMode === 'normal' ? 'magenta' : isLoading ? 'yellow' : 'cyan'}>
-            {vimMode === 'normal' ? ':' : '>'}
-          </Text>
+          <Text color={isLoading ? 'yellow' : 'cyan'}>{'>'}</Text>
         </Box>
         <TextInput
           value={value}
           onChange={(val) => {
-            // Block text changes during search mode — keys go to search query
-            if (searchMode) return
             // Reset history browsing when user starts typing
             if (historyIndexRef.current !== -1) {
               historyIndexRef.current = -1
@@ -434,20 +331,12 @@ export function InputBar({
           }}
           onSubmit={handleSubmit}
           placeholder={
-            searchMode
-              ? `/${searchQuery}`
-              : vimMode === 'normal'
-                ? t('ui.input.vim_help')
-                : isLoading
-                  ? `${verb}...`
-                  : completionVerb
-                    ? completionVerb
-                    : t('ui.input.placeholder')
+            isLoading ? `${verb}...` : completionVerb ? completionVerb : t('ui.input.placeholder')
           }
         />
       </Box>
-      {/* Slash command hints — shown when typing / in INSERT mode (only when picker is NOT active) */}
-      {slashHints.length > 0 && vimMode === 'insert' && !pickerActive && (
+      {/* Slash command hints — shown when typing / (only when picker is NOT active) */}
+      {slashHints.length > 0 && !pickerActive && (
         <Box marginTop={1} flexDirection="column" gap={1}>
           <Text dimColor>{t('ui.slash_hints.label')} </Text>
           {slashHints.map((cmd, _i) => (
@@ -468,7 +357,7 @@ export function InputBar({
         </Box>
       )}
       {/* @mention hints — active sessions (cross-session messaging) */}
-      {mentionHints.length > 0 && vimMode === 'insert' && !pickerActive && (
+      {mentionHints.length > 0 && !pickerActive && (
         <Box marginTop={1} flexDirection="column" gap={1}>
           <Text dimColor>{t('ui.mention_hints.label')} </Text>
           {mentionHints.map((name) => (