@miphamai/cli 0.85.4 → 0.85.6

package/src/ui/commands.ts

@@ -11,7 +11,7 @@ import type { SkillsLoader } from '../skills/loader'
 import { loadSkillUsage } from '../skills/usage'
 import type { PluginManager } from '../plugin/plugin-manager'
 import type { Message } from '../shared/types.js'
-import type { UpdateStatus } from '../shared/update'
+import type { InstallState, UpdateStatus } from '../shared/update'
 import { McpClient } from '../mcp/client'
 import { unregisterMcpServerTools } from '../mcp/registry'
 import { buildCapabilityReport } from '../core/capability-inventory'
@@ -4438,6 +4438,21 @@ const memoryCmd: CommandHandler = async (ctx, args) => {
 // Upgrade
 // ═══════════════════════════════════════════════════════════════
 
+/**
+ * 失败后「我手里还有没有 CLI」这句话的四种说法。
+ *
+ * `Record<InstallState, …>` 而非内联三元：漏一个状态**编译期就红**。写成
+ * `result.rolledBack ? A : B` 时漏掉的那一格会静默落进 else，而 else 说的正是**最重的
+ * 那句**（「原安装未能恢复」）—— 拿「最坏情况」当兜底，就等于把每条没想清楚的路径都
+ * 报成灾难。
+ */
+const UPGRADE_FAILURE_NOTE: Record<InstallState, string> = {
+  untouched: 'commands.upgrade.install_untouched',
+  restored: 'commands.upgrade.rolled_back',
+  broken: 'commands.upgrade.no_rollback',
+  unknown: 'commands.upgrade.install_unknown',
+}
+
 const upgradeCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const { checkForUpdates, backupConfig, performUpdate, restoreConfig, getConfigPath } =
@@ -4500,10 +4515,9 @@ const upgradeCmd: CommandHandler = async (ctx) => {
     lines.push(t('commands.upgrade.old_version_warning'))
   } else {
     lines.push('')
-    // 失败信息必须回答两件事：为什么，以及**我手里还有没有 CLI**。
-    const rollbackNote = t(
-      result.rolledBack ? 'commands.upgrade.rolled_back' : 'commands.upgrade.no_rollback',
-    )
+    // 失败信息必须回答两件事：为什么，以及**我手里还有没有 CLI**。四态各有各的说法 ——
+    // 尤其「旧树没被碰过」与「旧树没能恢复」是两件不同的事，合并成一句后者必定说谎。
+    const rollbackNote = t(UPGRADE_FAILURE_NOTE[result.installState])
     lines.push(
       t('commands.upgrade.update_failed', {
         reason: result.reason ?? '',
@@ -4593,7 +4607,7 @@ const workflowsCmd: CommandHandler = async () => {
   } else {
     lines.push('')
     lines.push(`${found} workflow(s) found.`)
-    lines.push('Use /workflows <name> to run a specific workflow.')
+    lines.push('Use /workflow run <name> to run one.')
   }
 
   return { content: lines.join('\n') }

package/src/ui/config-wizard.tsx

@@ -11,6 +11,7 @@
 import React, { useState, useEffect } from 'react'
 import { Box, Text, useInput } from 'ink'
 import { useI18n } from '../i18n-context'
+import { useKeyState } from './use-key-state'
 import TextInput from 'ink-text-input'
 import { DEFAULT_PROVIDERS, OLLAMA_PRESET_MODELS } from '../shared/constants'
 import type { ModelInfo } from '../shared/types'
@@ -159,7 +160,9 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
   const [error, setError] = useState<string | null>(null)
 
   // List navigation cursor
-  const [cursor, setCursor] = useState(0)
+  // 光标走 `useKeyState`：一组按键可能在同一拍里到达（↓ 之后紧跟 Enter），确认时
+  // 必须读得到本次按键刚写下的那个索引，而不是上一张闭包里的。
+  const cursor = useKeyState(0)
 
   // Ollama
   const [ollamaModel, _setOllamaModel] = useState('')
@@ -174,7 +177,7 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
 
   // Reset cursor when step changes
   const goStep = (s: Step) => {
-    setCursor(0)
+    cursor.set(0)
     setOllamaCursor(0)
     setError(null)
     setStep(s)
@@ -265,10 +268,10 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
 
     // ── Mode selection ──
     if (step === 'mode') {
-      if (key.upArrow) setCursor((c) => (c === 0 ? 1 : 0))
-      if (key.downArrow) setCursor((c) => (c === 0 ? 1 : 0))
+      if (key.upArrow) cursor.set((c) => (c === 0 ? 1 : 0))
+      if (key.downArrow) cursor.set((c) => (c === 0 ? 1 : 0))
       if (key.return) {
-        if (cursor === 0) {
+        if (cursor.read() === 0) {
           // Cloud
           setMode('cloud')
           goStep('provider')
@@ -284,10 +287,10 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
 
     // ── Cloud provider selection ──
     if (step === 'provider') {
-      if (key.upArrow) setCursor((c) => (c > 0 ? c - 1 : providerList.length - 1))
-      if (key.downArrow) setCursor((c) => (c < providerList.length - 1 ? c + 1 : 0))
+      if (key.upArrow) cursor.set((c) => (c > 0 ? c - 1 : providerList.length - 1))
+      if (key.downArrow) cursor.set((c) => (c < providerList.length - 1 ? c + 1 : 0))
       if (key.return) {
-        const p = providerList[cursor]
+        const p = providerList[cursor.read()]
         if (p) {
           setProviderId(p.id)
           goStep('model')
@@ -299,10 +302,10 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
     // ── Cloud model selection ──
     if (step === 'model') {
       if (modelList.length === 0) return
-      if (key.upArrow) setCursor((c) => (c > 0 ? c - 1 : modelList.length - 1))
-      if (key.downArrow) setCursor((c) => (c < modelList.length - 1 ? c + 1 : 0))
+      if (key.upArrow) cursor.set((c) => (c > 0 ? c - 1 : modelList.length - 1))
+      if (key.downArrow) cursor.set((c) => (c < modelList.length - 1 ? c + 1 : 0))
       if (key.return) {
-        const m = modelList[cursor]
+        const m = modelList[cursor.read()]
         if (m) {
           setModelId(m.id)
           goStep('apikey')
@@ -381,8 +384,8 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
           </Box>
 
           <Box marginBottom={1}>
-            <Text color={cursor === 0 ? SELECTED_COLOR : undefined}>
-              {cursor === 0 ? '▶' : ' '} {t('ui.wizard.mode_cloud')}
+            <Text color={cursor.value === 0 ? SELECTED_COLOR : undefined}>
+              {cursor.value === 0 ? '▶' : ' '} {t('ui.wizard.mode_cloud')}
             </Text>
           </Box>
           <Text dimColor>
@@ -390,8 +393,8 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
           </Text>
 
           <Box marginTop={2} marginBottom={1}>
-            <Text color={cursor === 1 ? SELECTED_COLOR : undefined}>
-              {cursor === 1 ? '▶' : ' '} {t('ui.wizard.mode_local')}
+            <Text color={cursor.value === 1 ? SELECTED_COLOR : undefined}>
+              {cursor.value === 1 ? '▶' : ' '} {t('ui.wizard.mode_local')}
             </Text>
           </Box>
           <Text dimColor>{t('ui.wizard.mode_local_hint')}</Text>
@@ -410,8 +413,8 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
           </Box>
           {providerList.map((p, i) => (
             <Box key={p.id} marginBottom={1}>
-              <Text color={i === cursor ? SELECTED_COLOR : undefined}>
-                {i === cursor ? '▶' : '  '} {p.name}
+              <Text color={i === cursor.value ? SELECTED_COLOR : undefined}>
+                {i === cursor.value ? '▶' : '  '} {p.name}
               </Text>
               <Text dimColor>
                 {t('ui.wizard.provider_count', {
@@ -439,8 +442,8 @@ export function ConfigWizard({ onComplete, onSkip }: Props) {
           </Box>
           {modelList.map((m, i) => (
             <Box key={m.id} marginBottom={1}>
-              <Text color={i === cursor ? SELECTED_COLOR : undefined}>
-                {i === cursor ? '▶' : '  '} {m.name}
+              <Text color={i === cursor.value ? SELECTED_COLOR : undefined}>
+                {i === cursor.value ? '▶' : '  '} {m.name}
               </Text>
               <Text dimColor> ({m.id})</Text>
             </Box>

package/src/ui/graft-status.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react'
+import React, { useEffect, useState } from 'react'
 import { Box, Text } from 'ink'
 import { basename } from 'node:path'
 import { findGraftStats, type GraftStats } from '../shared/graft-stats'
@@ -13,17 +13,46 @@ function freshnessSegment(stats: GraftStats): { label: string; color: string } {
   return { label: '✓ synced', color: 'blue' }
 }
 
+/**
+ * 只有**真变了**才换 state —— 否则每秒一次 setState 会把整棵树重渲染一遍。
+ * 两侧都出自 `findGraftStats` 的同一个 return 字面量，键序恒等，故字符串比较是稳的；
+ * 用整体比较而不是逐字段比，是为了将来给 `GraftStats` 加字段时**不必回来补这一行**。
+ */
+function sameStats(a: GraftStats | null, b: GraftStats | null): boolean {
+  if (a === b) return true
+  if (!a || !b) return false
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
+/** 重读间隔。与 `goal-progress` / `workflow-progress` 同法（那两处也是 1s 一拍）。 */
+const STATS_REFRESH_MS = 1000
+
 /**
  * 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.
+ *
+ * `graft/.cache/stats.json`（向上走到仓库根）是**别人在后台写的**：graft 自己重建索引时
+ * 先落 `syncing: true`，建完再落回来。挂载时读一次就永远说那一拍的话 ⇒ 启动正好撞上索引
+ * 重建的话，页脚会一直挂着 `syncing…`，而磁盘上早已 `"syncing": false` ——「有人的读数与
+ * 没人读的那个对象不一致」。故这里**按拍重读**。
+ *
+ * 别把它降成「每次渲染读一遍」：那要靠别的组件把这一棵带着重渲染（敲键盘 / agent tick）
+ * 才生效，而索引建完的那一刻**恰恰可能一个键都没有** —— 页脚会一直撒谎到用户下次敲键。
+ *
+ * 其余同前：tok-saved 每次渲染实时读；只在有 graft 图或有已知 ctx% 时渲染 —— ctx% 行
+ * 在本目录没建过 graft 时也照常显示。
  */
 export function GraftStatusLine({ cwd, ctxPct }: { cwd: string; ctxPct?: number }) {
-  const [stats] = useState(() => findGraftStats(cwd))
+  const [stats, setStats] = useState(() => findGraftStats(cwd))
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      const next = findGraftStats(cwd)
+      setStats((prev) => (sameStats(prev, next) ? prev : next))
+    }, STATS_REFRESH_MS)
+    return () => clearInterval(timer)
+  }, [cwd])
   const showCtx = typeof ctxPct === 'number'
   if (!stats && !showCtx) return null
   const fresh = stats ? freshnessSegment(stats) : null

package/src/ui/input.tsx

@@ -324,7 +324,12 @@ export function InputBar({
   const suggestionReqIdRef = useRef(0)
 
   // 统一清理：清 suggestion + 使在途/待发请求失效 + 取消防抖定时器。
-  // Escape / handleSubmit / 翻历史三处共用，避免各自手写漏掉某一环（rule of three）。
+  // Escape / handleSubmit / 翻历史 / **Tab 接受** 四处共用，避免各自手写漏掉某一环。
+  // Tab 那一处原先只手写 `setSuggestion(null)`（ROADMAP D8 缺口③）：今天**不可达**
+  // ——有建议显示就说明上次请求已结束、定时器早烧掉了——但「接受后继续续写」一加上，
+  // 那个漏掉的环立刻变成洞。走同一入口，洞就不存在了。
+  // （`onChange` 里另有一处内联的同样三步，**不共用**：那里要的是把 reqId 推成**新**的，
+  // 与这里的「作废」是两件事。）
   const clearSuggestion = () => {
     setSuggestion(null)
     suggestionReqIdRef.current++
@@ -411,7 +416,7 @@ export function InputBar({
       const next = valueRef.current + suggestion
       setValue(next)
       valueRef.current = next
-      setSuggestion(null)
+      clearSuggestion()
       return
     }
     // Ctrl+P → toggle model picker

package/src/ui/picker.tsx

@@ -1,8 +1,15 @@
 import React, { useState, useCallback } from 'react'
 import { Box, Text, useInput } from 'ink'
 import { useI18n } from '../i18n-context'
+import { useKeyState } from './use-key-state'
 import type { MiphamConfig, ProviderConfig } from '../shared/index.ts'
 
+/** 环绕取模 —— 列表两端互为首尾。 */
+const wrap = (i: number, len: number) => ((i % len) + len) % len
+
+/** 只列启用中的模型（与 `providerList` 的 `upcoming` 过滤同一条口径）。 */
+const activeModels = (p: ProviderConfig) => p.models.filter((m) => m.status === 'active')
+
 interface PickerProps {
   config: MiphamConfig
   currentProvider: string
@@ -25,54 +32,58 @@ export function ModelPicker({
   const { t } = useI18n()
   // Get active providers only
   const providers = config.providers.filter((p) => p.status !== 'upcoming')
-  const activeModels = (p: ProviderConfig) => p.models.filter((m) => m.status === 'active')
 
   // State
   const [activePanel, setActivePanel] = useState<Panel>('provider')
-  const [providerIdx, setProviderIdx] = useState(() => {
+  // 光标走 `useKeyState`：一组按键可能在同一拍里到达（↓ 之后紧跟 Enter），判据必须
+  // 读得到本次按键刚写下的那个索引，而不是上一张闭包里的。
+  const providerIdx = useKeyState(() => {
     const idx = providers.findIndex((p) => p.id === currentProvider)
     return idx >= 0 ? idx : 0
   })
-  const [modelIdx, setModelIdx] = useState(0)
+  const modelIdx = useKeyState(0)
 
-  const selectedProvider = providers[providerIdx]
+  const selectedProvider = providers[providerIdx.value]
   const models = selectedProvider ? activeModels(selectedProvider) : []
 
   // Reset model index when provider changes
   const goToProvider = useCallback(
     (idx: number) => {
-      const wrapped = ((idx % providers.length) + providers.length) % providers.length
-      setProviderIdx(wrapped)
-      setModelIdx(0)
+      providerIdx.set(wrap(idx, providers.length))
+      modelIdx.set(0)
       setActivePanel('model') // auto-switch to model panel
     },
-    [providers.length],
+    [providers.length, providerIdx, modelIdx],
   )
 
-  const selectModel = useCallback(
-    (idx: number) => {
+  /** 相对移动 —— 按 `read()` 叠加，同一拍里的两次 ↓ 就是两步。 */
+  const stepModel = useCallback(
+    (delta: number) => {
       if (!selectedProvider) return
-      const wrapped = ((idx % models.length) + models.length) % models.length
-      setModelIdx(wrapped)
+      const len = models.length
+      if (len === 0) return
+      modelIdx.set((prev) => wrap(prev + delta, len))
     },
-    [selectedProvider, models.length],
+    [selectedProvider, models.length, modelIdx],
   )
 
   const confirmSelection = useCallback(() => {
-    if (!selectedProvider) return
-    const model = models[modelIdx]
+    // 按 `read()` 取当前光标，而不是渲染时那份闭包 —— 否则「↓ Enter」确认的是上一行。
+    const provider = providers[providerIdx.read()]
+    if (!provider) return
+    const model = activeModels(provider)[modelIdx.read()]
     if (model) {
       // Check API key before confirming switch
-      const apiKey = selectedProvider.apiKey
+      const apiKey = provider.apiKey
       if (!apiKey || apiKey.trim() === '' || /^\$\{[A-Z_]+\}$/.test(apiKey.trim())) {
-        if (selectedProvider.id !== 'ollama' && onNeedsApiKey) {
-          onNeedsApiKey(selectedProvider.id, model.id, selectedProvider.name)
+        if (provider.id !== 'ollama' && onNeedsApiKey) {
+          onNeedsApiKey(provider.id, model.id, provider.name)
           return
         }
       }
-      onSelect(selectedProvider.id, model.id)
+      onSelect(provider.id, model.id)
     }
-  }, [selectedProvider, models, modelIdx, onSelect, onNeedsApiKey])
+  }, [providers, providerIdx, modelIdx, onSelect, onNeedsApiKey])
 
   useInput((input, key) => {
     // Global keys
@@ -83,7 +94,7 @@ export function ModelPicker({
 
     if (key.return) {
       if (activePanel === 'provider') {
-        goToProvider(providerIdx) // switches to model panel
+        goToProvider(providerIdx.read()) // switches to model panel
       } else {
         confirmSelection()
       }
@@ -105,18 +116,18 @@ export function ModelPicker({
     // Up/Down navigation
     if (key.upArrow) {
       if (activePanel === 'provider') {
-        setProviderIdx((providerIdx - 1 + providers.length) % providers.length)
+        providerIdx.set((prev) => wrap(prev - 1, providers.length))
       } else {
-        selectModel(modelIdx - 1)
+        stepModel(-1)
       }
       return
     }
 
     if (key.downArrow) {
       if (activePanel === 'provider') {
-        setProviderIdx((providerIdx + 1) % providers.length)
+        providerIdx.set((prev) => wrap(prev + 1, providers.length))
       } else {
-        selectModel(modelIdx + 1)
+        stepModel(1)
       }
       return
     }
@@ -150,7 +161,7 @@ export function ModelPicker({
           </Text>
           {providers.map((p, i) => {
             const isCurrent = p.id === currentProvider
-            const isSelected = i === providerIdx
+            const isSelected = i === providerIdx.value
             const isUpcoming = p.status === 'upcoming'
             return (
               <Box key={p.id}>
@@ -185,7 +196,7 @@ export function ModelPicker({
           {models.length === 0 && <Text dimColor> {t('ui.picker.no_active_models')}</Text>}
           {models.map((m, i) => {
             const isCurrentModel = selectedProvider?.id === currentProvider && m.id === currentModel
-            const isSelected = i === modelIdx
+            const isSelected = i === modelIdx.value
             return (
               <Box key={m.id} flexDirection="column">
                 <Text

package/src/ui/use-key-state.ts

@@ -0,0 +1,55 @@
+import { useCallback, useRef, useState } from 'react'
+
+/**
+ * 一个状态 + 一个「在同一次按键回调里也读得到最新值」的镜像。
+ *
+ * 为什么需要它：一组按键会在同一个 chunk 里到达（远端/远程控制，或键盘把
+ * 「↓ 然后 Enter」一起写进来），Ink 的输入解析器会把这种转义序列打头的 chunk
+ * 切开**逐个派发** —— 而 React 还没提交第一个回调里的 setState，第二个回调拿到的
+ * 就还是上一张闭包。于是「↓ Enter」按在**按下 ↓ 之前**那一行上：按键有反应，
+ * 世界却是上一拍的。
+ *
+ * 与 `useCtrlCConfirm` 的两条路同源（那里的 `isArmed()` / `armed`）：
+ * - `value` 只给渲染用；
+ * - `read()` 给判据用 —— 同步读数，同一次按键回调里 `set()` 之后立刻为新值；
+ * - `set()` 接受函数式写法，并按 `read()` 的当前值求值，于是同一个 burst 里的多次
+ *   修改能**叠加**（两次 ↓ 是两步，而不是把两次都算在同一个起点上）。
+ *
+ * 注意 `set()` 之外不要再写这个 state —— 绕过它写会让镜像与真值分叉。
+ */
+export interface KeyState<T> {
+  /** 渲染用。 */
+  value: T
+  /**
+   * 写入。函数式写法按 `read()` 求值后落盘：同一个 burst 里调用多次会依次叠加。
+   *
+   * `T` 是函数时函数式写法不可用（按值处理）—— 本仓库的调用点都是索引/枚举。
+   */
+  set: (next: T | ((prev: T) => T)) => void
+  /** 判据用：同步读数，`set()` 之后立刻为新值。 */
+  read: () => T
+}
+
+export function useKeyState<T>(initial: T | (() => T)): KeyState<T> {
+  const [value, setValue] = useState(initial)
+  const ref = useRef(value)
+
+  const set = useCallback((next: T | ((prev: T) => T)) => {
+    const resolved = typeof next === 'function' ? (next as (prev: T) => T)(ref.current) : next
+    ref.current = resolved
+    setValue(resolved)
+  }, [])
+
+  const read = useCallback(() => ref.current, [])
+
+  // 返回的对象**身份稳定**（每次渲染只刷新 `.value`）：调用点会把它整个放进依赖
+  // 数组，每次渲染换一个身份会让依赖它的 effect 每次都重跑。
+  const apiRef = useRef<KeyState<T> | null>(null)
+  let api = apiRef.current
+  if (!api) {
+    api = { value, set, read }
+    apiRef.current = api
+  }
+  api.value = value
+  return api
+}

package/src/daemon/message-bus.ts

@@ -1,84 +0,0 @@
-// apps/cli/src/daemon/message-bus.ts — Phase 3: Inter-Agent Message Bus
-//
-// MessageBus provides asynchronous message passing between agents:
-//   - send()    — enqueue a message from one agent to another
-//   - poll()    — retrieve and clear pending messages (discards TTL-expired)
-//   - broadcastToSession() — send a message to all agents in a session
-//
-// Messages older than 5 minutes are automatically discarded on poll.
-// Session-to-agent mapping is maintained externally via registerAgent/unregisterAgent.
-
-interface BusMessage {
-  sender: string
-  content: string
-  timestamp: number
-}
-
-export class MessageBus {
-  private queues = new Map<string, BusMessage[]>()
-  private sessionAgents = new Map<string, Set<string>>()
-  private readonly ttlMs = 5 * 60 * 1000 // 5 minutes
-
-  /**
-   * Register an agent to a session so that broadcastToSession can reach it.
-   */
-  registerAgent(sessionId: string, agentId: string): void {
-    if (!this.sessionAgents.has(sessionId)) {
-      this.sessionAgents.set(sessionId, new Set())
-    }
-    this.sessionAgents.get(sessionId)!.add(agentId)
-  }
-
-  /**
-   * Remove an agent from all session registrations and clear its message queue.
-   */
-  unregisterAgent(agentId: string): void {
-    for (const [, agents] of this.sessionAgents) {
-      agents.delete(agentId)
-    }
-    this.queues.delete(agentId)
-  }
-
-  /**
-   * Enqueue a message from senderAgentId to receiverAgentId.
-   */
-  send(senderAgentId: string, receiverAgentId: string, content: string): void {
-    if (!this.queues.has(receiverAgentId)) {
-      this.queues.set(receiverAgentId, [])
-    }
-    this.queues.get(receiverAgentId)!.push({
-      sender: senderAgentId,
-      content,
-      timestamp: Date.now(),
-    })
-  }
-
-  /**
-   * Retrieve and clear all pending messages for an agent.
-   * Messages older than the TTL (5 min) are discarded.
-   */
-  poll(agentId: string): BusMessage[] {
-    const queue = this.queues.get(agentId)
-    if (!queue || queue.length === 0) return []
-
-    const now = Date.now()
-    const valid = queue.filter((msg) => now - msg.timestamp < this.ttlMs)
-
-    this.queues.delete(agentId)
-    return valid
-  }
-
-  /**
-   * Send a message to every agent in a session except the one specified.
-   * The sender is recorded as 'system'.
-   */
-  broadcastToSession(sessionId: string, content: string, excludeAgentId?: string): void {
-    const agents = this.sessionAgents.get(sessionId)
-    if (!agents) return
-    for (const agentId of agents) {
-      if (agentId !== excludeAgentId) {
-        this.send('system', agentId, content)
-      }
-    }
-  }
-}