@miphamai/cli 0.85.1 → 0.85.3

package/src/tools/exec/task.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import type { BackgroundAgentRegistry, BackgroundTask } from '../../agent/background-registry'
 import { hasSupportedEvidenceSince } from '../../core/working-memory'
 
 export interface Task {
@@ -14,9 +15,7 @@ export interface Task {
   createdAt: string
   /** 完成证据：completed 时是否有 supported 决策接地（软门，unverified 只标记不阻断）。 */
   completionEvidence?: 'supported' | 'unverified'
-  /** Background task output content (set when a background agent completes). */
-  output?: string
-  /** Background task error message (set when a background agent fails). */
+  /** Set by the `stop` action on a running task ("Task stopped by user."). */
   outputError?: string
 }
 
@@ -36,6 +35,66 @@ function formatTask(t: Task): string {
   return `[${t.status}] #${t.id}: ${t.subject}${owner}${blocks}${blocked}${meta}`
 }
 
+/**
+ * Render a **background agent** the way the `output` action renders a session task.
+ *
+ * Background agents are not in the local `tasks` map: BackgroundAgentRegistry mints
+ * their ids in a separate space (`bg-<n>-<base36>`) and keeps results on the registry
+ * itself. The Agent tool hands those ids to the model with an explicit
+ * `Use Task output taskId="bg-…"` line, so this action has to answer for them —
+ * without this path the advertised call can only return `Task #bg-… not found`.
+ */
+function formatBackgroundOutput(bg: BackgroundTask): {
+  success: boolean
+  content: string
+  error?: string
+} {
+  const head = `Background task ${bg.id}`
+  const meta = `Status: ${bg.status}\nAgent type: ${bg.agentType}\nTask: ${bg.description}`
+
+  if (bg.status === 'running') {
+    return {
+      success: true,
+      content: `${head} is still running — output not yet available.\n${meta}\n\nUse Task output again once it completes.`,
+    }
+  }
+
+  if (bg.status === 'failed') {
+    return {
+      success: false,
+      content: '',
+      error: `${head} failed: ${bg.error ?? '(no error recorded)'}`,
+    }
+  }
+
+  return {
+    success: true,
+    content: `── ${head} Output ──\n${meta}\n\n${(bg.result ?? '(no output recorded)').slice(0, 5000)}`,
+  }
+}
+
+/** Stop a running background agent through the registry that owns it. */
+function stopBackgroundTask(
+  bg: BackgroundTask,
+  registry: BackgroundAgentRegistry,
+): { success: boolean; content: string; error?: string } {
+  if (bg.status !== 'running') {
+    return {
+      success: true,
+      content: `Background task ${bg.id} is already ${bg.status}. Nothing to stop.`,
+    }
+  }
+  // `stop()` also returns false when the task is no longer running (it completed
+  // between the lookup above and this call), so the message must not claim why.
+  const aborted = registry.stop(bg.id)
+  return {
+    success: true,
+    content: aborted
+      ? `Background task ${bg.id} stopped.\nTask: ${bg.description}`
+      : `Background task ${bg.id} was not stopped — it is no longer running.`,
+  }
+}
+
 /** Check if a task is blocked — has unresolved dependencies. */
 function isBlocked(task: Task): boolean {
   if (task.blockedBy.length === 0) return false
@@ -238,11 +297,6 @@ export const taskTool: ToolDefinition = {
         }
       }
       if (task.metadata) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`)
-      if (task.output) {
-        lines.push('')
-        lines.push('── Output ──')
-        lines.push(task.output.slice(0, 2000))
-      }
       if (task.outputError) {
         lines.push('')
         lines.push(`── Error ──`)
@@ -320,7 +374,14 @@ export const taskTool: ToolDefinition = {
     if (action === 'output') {
       const taskId = params.taskId as string
       const task = tasks.get(taskId)
-      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+      if (!task) {
+        // Not a session task — it may be a background agent id (`bg-…`), which is
+        // the id space this action is advertised for. The registry is wired onto
+        // the tool context by the engine (`engine.ts` defaultToolContext).
+        const bg = _ctx.backgroundAgentRegistry?.get(taskId)
+        if (bg) return formatBackgroundOutput(bg)
+        return { success: false, content: '', error: `Task #${taskId} not found` }
+      }
 
       if (task.status === 'pending') {
         return {
@@ -336,13 +397,6 @@ export const taskTool: ToolDefinition = {
         }
       }
 
-      if (task.status === 'completed' && task.output) {
-        return {
-          success: true,
-          content: `── Task #${taskId} Output ──\nStatus: completed\nSubject: ${task.subject}\n\n${task.output.slice(0, 5000)}`,
-        }
-      }
-
       if (task.status === 'failed' && task.outputError) {
         return {
           success: false,
@@ -361,7 +415,15 @@ export const taskTool: ToolDefinition = {
     if (action === 'stop') {
       const taskId = params.taskId as string
       const task = tasks.get(taskId)
-      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+      if (!task) {
+        // Background agent id (`bg-…`) — the other id space. The local branch
+        // below only marks a status; an actual running agent is aborted through
+        // the registry that owns it.
+        const registry = _ctx.backgroundAgentRegistry
+        const bg = registry?.get(taskId)
+        if (registry && bg) return stopBackgroundTask(bg, registry)
+        return { success: false, content: '', error: `Task #${taskId} not found` }
+      }
 
       if (task.status === 'completed' || task.status === 'deleted') {
         return {
@@ -376,22 +438,12 @@ export const taskTool: ToolDefinition = {
         return { success: true, content: `Task #${taskId} cancelled (was pending).` }
       }
 
-      // For in_progress tasks: mark as failed — actual process termination is handled
-      // by BackgroundAgentRegistry.stop() when wired via the engine context
+      // For in_progress session tasks: mark as failed. There is no process behind
+      // one — a *background agent* is aborted by stopBackgroundTask() above, which
+      // the registry owns.
       task.status = 'failed'
       task.outputError = 'Task stopped by user.'
 
-      // If BackgroundAgentRegistry is available in context, try to abort
-      if (_ctx.registry) {
-        // Signal to any background registry that this task should stop
-        // The background registry will be injected via the engine context
-        const bgRegistry = (_ctx as unknown as Record<string, unknown>).backgroundAgentRegistry as
-          { stop(id: string): boolean } | undefined
-        if (bgRegistry) {
-          bgRegistry.stop(taskId)
-        }
-      }
-
       return { success: true, content: `Task #${taskId} stopped.` }
     }
 

package/src/tools/scheduling/cron.ts

@@ -1,11 +1,5 @@
-import {
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  readdirSync,
-  existsSync,
-} from 'node:fs'
+import { mkdirSync, readFileSync, unlinkSync, readdirSync, existsSync } from 'node:fs'
+import { atomicWriteFileSync } from '../../shared/atomic-write'
 import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import type { ToolDefinition } from '../../shared/index.ts'
@@ -78,7 +72,7 @@ export function readAllJobs(): CronJob[] {
 /** Persist a job (create or update) to its JSON file. */
 export function writeJob(job: CronJob): void {
   ensureCronDir()
-  writeFileSync(jobPath(job.id), JSON.stringify(job, null, 2), 'utf-8')
+  atomicWriteFileSync(jobPath(job.id), JSON.stringify(job, null, 2), { mode: 0o644 })
 }
 
 /** Delete a job's file. Returns false when the job did not exist. */

package/src/ui/app.tsx

@@ -3,6 +3,7 @@ import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
 import { execSync } from 'node:child_process'
 import { ErrorBoundary } from './error-boundary'
+import { useCtrlCConfirm } from './ctrl-c-confirm'
 import { formatThinking } from './thinking'
 import type { QueryEngine } from '../core/engine'
 import type { RemoteEngine } from '../daemon/remote-engine'
@@ -45,6 +46,7 @@ function contextUsagePct(engine: QueryEngine | RemoteEngine): number | undefined
   return Math.round((ctx.getEstimatedTokens() / max) * 100)
 }
 import { AgentViewDashboard } from '../agent-view/dashboard'
+import { AgentSessionView } from '../agent-view/session-view'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
 import { GoalProgress } from './goal-progress.js'
@@ -317,6 +319,11 @@ export function App({
   }, [])
 
   const [agentViewOpen, setAgentViewOpen] = useState(false)
+  // Non-null when the dashboard's Enter ("attach") picked a session to read.
+  // It replaces the chat panel — the transcript on screen is the session's, not
+  // this conversation's, so leaving the input bar visible would invite typing
+  // into a buffer that goes somewhere else entirely.
+  const [attachedSessionId, setAttachedSessionId] = useState<string | null>(null)
   const [apiKeyPrompt, setApiKeyPrompt] = useState<{
     providerId: string
     modelId: string
@@ -334,6 +341,14 @@ export function App({
   const [permissionMode, setPermissionMode] = useState<PermissionMode>(() =>
     livePermissionMode(engine.getPermission()),
   )
+  // 远端 attach：闸门在 daemon 上，而它的答案是**异步**来的（组织级限制会在那边把请求
+  // 静默钳小）。按键不等于渲染，所以只靠上行的 `useState` 初始化 + 按键回读，页脚会永远
+  // 停在钳制前的那一档 —— 报得比实际宽。本地引擎没有这条订阅：它的 `getMode()` 在
+  // `setMode` 返回时就已经是钳后值。
+  useEffect(() => {
+    if (!('onPermissionModeChange' in engine)) return
+    return engine.onPermissionModeChange((mode) => setPermissionMode(mode))
+  }, [engine])
   const abortRef = useRef<AbortController | null>(null)
   // Monotonic turn id — lets a stale turn's finally() skip resetting shared UI
   // state (isLoading/abortRef/progress) after a newer turn has already started.
@@ -1136,22 +1151,55 @@ export function App({
     [engine, mkCtx, runTurn],
   )
 
-  useInput((_input, key) => {
-    // Escape: close apiKeyPrompt → close picker → abort loading (does NOT exit app)
-    if (key.escape) {
-      if (apiKeyPrompt) {
-        setApiKeyPrompt(null)
-        setApiKeyInput('')
-        return
-      }
-      if (pickerOpen) {
-        setPickerOpen(false)
+  /**
+   * 关掉「最上面那一层」—— 密钥提示框 / 选择器 / 正在跑的回合。关掉了返回 true。
+   *
+   * Esc 与 Ctrl+C 共用这一份：在用户心里这两个键是同一件事（「停」），分成两套
+   * 判断迟早会漂移。没有可关的东西 ⇒ false，由调用方决定下一步。
+   */
+  const dismissTopmost = (): boolean => {
+    if (apiKeyPrompt) {
+      setApiKeyPrompt(null)
+      setApiKeyInput('')
+      return true
+    }
+    if (pickerOpen) {
+      setPickerOpen(false)
+      return true
+    }
+    if (isLoading && abortRef.current) {
+      abortRef.current.abort()
+      return true
+    }
+    return false
+  }
+
+  // Ctrl+C 的「再按一次才退」，语义与计时器见 ui/ctrl-c-confirm.ts
+  const ctrlC = useCtrlCConfirm()
+
+  useInput((input, key) => {
+    // Ctrl+C：先关最上面那一层；没得关时**不退出**，只提示「再按一次」。
+    //
+    // 从前这里没有这个分支，而 Ink 自己的 Ctrl+C 处理（`exitOnCtrlC`，默认
+    // true）在按键**到达任何 handler 之前**就把进程退了 —— 于是对话框里一次
+    // 误按就把整个会话带走。`render()` 三处均已传 `exitOnCtrlC: false`，
+    // 否则这个分支永远不会被调用（见 src/index.tsx 的注释）。
+    if (key.ctrl && input === 'c') {
+      if (dismissTopmost()) {
+        // 这一按被「关掉最上面一层」消费掉了 —— 用户想的是「停」，不是「退」，
+        // 所以待确认窗口要一并撤掉，免得下一次误按直接退出。
+        ctrlC.reset()
         return
       }
-      if (isLoading && abortRef.current) {
-        abortRef.current.abort()
-        return
+      if (ctrlC.isArmed()) {
+        process.exit(0)
       }
+      ctrlC.arm()
+      return
+    }
+    // Escape: close apiKeyPrompt → close picker → abort loading (does NOT exit app)
+    if (key.escape) {
+      if (dismissTopmost()) return
       // Otherwise let InputBar handle Escape (clear draft)
       return
     }
@@ -1230,9 +1278,24 @@ export function App({
         {agentViewOpen && agentViewManager ? (
           <AgentViewDashboard
             manager={agentViewManager}
-            onAttach={() => {}}
+            // Enter used to be wired to a no-op here, so `attach` — the key the
+            // footer advertises — did nothing observable. It now hands the
+            // session to the read-only view below; Esc there comes back here.
+            onAttach={(session) => {
+              setAttachedSessionId(session.id)
+              setAgentViewOpen(false)
+            }}
             onExit={() => setAgentViewOpen(false)}
           />
+        ) : attachedSessionId && agentViewManager ? (
+          <AgentSessionView
+            manager={agentViewManager}
+            sessionId={attachedSessionId}
+            onDetach={() => {
+              setAttachedSessionId(null)
+              setAgentViewOpen(true)
+            }}
+          />
         ) : (
           <>
             {/* Chat panel */}
@@ -1372,6 +1435,7 @@ export function App({
                   {' · '}
                   {t('ui.status.left_for_agents')}
                 </Text>
+                {ctrlC.armed && <Text color="yellow"> {t('ui.status.ctrl_c_again')}</Text>}
               </Box>
             </Box>
 

package/src/ui/commands.ts

@@ -389,6 +389,16 @@ const contextCmd: CommandHandler = (ctx) => {
   }
 }
 
+/**
+ * The mode the gate is actually enforcing. `ctx.config.permission` is only one of
+ * the doors — the Shift+Tab wheel, an org `maxAllowedMode` clamp and the user's
+ * `settings.json` all move the live value — so a report that prints the config
+ * value can name a different mode than the one refusing the calls.
+ */
+function liveMode(ctx: CommandContext): string {
+  return ctx.engine.getPermission().getMode()
+}
+
 const statusCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const c = ctx.engine.getContext()
@@ -411,7 +421,7 @@ const statusCmd: CommandHandler = async (ctx) => {
       ${t('commands.status.messages')}   ${c.getMessages().length}
       ${t('commands.status.tokens')}     ~${c.getEstimatedTokens().toLocaleString()} / ${c.getMaxTokens().toLocaleString()}
       ${t('commands.status.tools')}      ${tools.size} ${t('commands.status.loaded')}
-      ${t('commands.status.permission')} ${ctx.config.permission}
+      ${t('commands.status.permission')} ${liveMode(ctx)}
 
       ${t('commands.status.system_title')}
       ${t('commands.status.platform')}   ${process.platform} ${process.arch}
@@ -2504,7 +2514,8 @@ const marketplaceCmd: CommandHandler = async (_ctx, args) => {
     isValidMarketplaceRef,
     MARKETPLACES_PATH,
   } = await import('../skills/marketplace')
-  const { readFileSync, writeFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { readFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { atomicWriteFileSync } = await import('../shared/atomic-write')
   const { dirname } = await import('node:path')
 
   const readSources = () =>
@@ -2537,7 +2548,9 @@ const marketplaceCmd: CommandHandler = async (_ctx, args) => {
     const changed = 'added' in result ? result.added : result.removed
     try {
       mkdirSync(dirname(MARKETPLACES_PATH), { recursive: true })
-      writeFileSync(MARKETPLACES_PATH, JSON.stringify(result.sources, null, 2), 'utf-8')
+      atomicWriteFileSync(MARKETPLACES_PATH, JSON.stringify(result.sources, null, 2), {
+        mode: 0o644,
+      })
     } catch (err) {
       return { content: `❌ Failed to save marketplaces: ${String(err)}` }
     }
@@ -3208,7 +3221,7 @@ const doctorCmd: CommandHandler = async (ctx) => {
     '',
     t('commands.doctor.config_section'),
     `Provider     ${ctx.providerId} / ${ctx.modelId}`,
-    `Permission   ${ctx.config.permission}`,
+    `Permission   ${liveMode(ctx)}`,
     `Providers    ${ctx.config.providers.length} configured (${ctx.config.providers.filter((p) => p.status !== 'upcoming').length} active)`,
     '',
     t('commands.doctor.session_section'),
@@ -3724,7 +3737,7 @@ const statsCmd: CommandHandler = (ctx) => {
     t('commands.stats.tools', { count: String(tools.size) }),
     t('commands.stats.provider', { provider: ctx.providerId }),
     t('commands.stats.model', { model: ctx.modelId }),
-    t('commands.stats.permission', { permission: ctx.config.permission }),
+    t('commands.stats.permission', { permission: liveMode(ctx) }),
     '',
     t('commands.stats.usage', { pct: ((tokens / c.getMaxTokens()) * 100).toFixed(1) }),
   ]
@@ -5197,10 +5210,14 @@ Background agents appear in the Agent View dashboard (/agents).`,
   // wrote a dashboard entry and reported success — the prompt was never handed
   // to a model, and the row sat at `working` forever.
   const bgReg = (await import('../agent/background-registry')).getBackgroundAgentRegistry()
-  bgReg.spawn(
+  // Keep the registry's id on the row: it is the only handle that can stop the
+  // run. `AgentViewManager.kill()` flips a status label and nothing else, so a
+  // Ctrl+X that held no task id would discard the row and leave the agent
+  // running with no way to reach it again.
+  session.taskId = bgReg.spawn(
     prompt,
     'general',
-    async (_signal) => {
+    async (signal) => {
       const { SubAgent } = await import('../agent/sub-agent')
       const sa = new SubAgent(
         ctx.engine.getRegistry(),
@@ -5213,7 +5230,10 @@ Background agents appear in the Agent View dashboard (/agents).`,
       try {
         // The prompt came from the user typing `/bg …`, so it stays unframed —
         // unlike a workflow script's computed prompt.
-        const result = await sa.execute(prompt, 'bg: ' + prompt.slice(0, 60), { type: 'general' })
+        const result = await sa.execute(prompt, 'bg: ' + prompt.slice(0, 60), {
+          type: 'general',
+          signal,
+        })
         agentViewManager.addMessage(session.id, {
           role: 'assistant',
           content: result || '(no output)',
@@ -5326,10 +5346,10 @@ const forkCmd: CommandHandler = async (ctx, args) => {
   session.kind = 'forked'
 
   const bgReg = (await import('../agent/background-registry')).getBackgroundAgentRegistry()
-  bgReg.spawn(
+  session.taskId = bgReg.spawn(
     prompt,
     'general',
-    async (_signal) => {
+    async (signal) => {
       const { SubAgent } = await import('../agent/sub-agent')
       const sa = new SubAgent(
         ctx.engine.getRegistry(),
@@ -5340,32 +5360,54 @@ const forkCmd: CommandHandler = async (ctx, args) => {
         ctx.engine.getLlm(),
       )
       const parentContext = ctx.engine.getContext()
-      const result = await sa.execute(prompt, 'fork: ' + prompt.slice(0, 60), {
-        worktreePath: wtPath,
-        inheritContext: { messages: parentContext.getMessages() },
-      })
+      // The row has to come back from `working` on both outcomes: the fork
+      // executor used to return its summary to the registry and never touch the
+      // session, so a finished (or crashed) fork stayed `working` on the
+      // dashboard for the life of the process — the same lie `/bg` already
+      // closes on its own path.
       try {
-        const { execSync: ex } = await import('node:child_process')
-        ex(`git -C ${wtPath} add -A`, { stdio: 'ignore', timeout: 10_000 })
-        const st = ex(`git -C ${wtPath} status --porcelain`, { encoding: 'utf-8', timeout: 10_000 })
-        if (st.trim()) {
-          ex(`git -C ${wtPath} commit -m "feat: ${prompt.slice(0, 60)}\n\n${COAUTHOR_TRAILER}"`, {
-            stdio: 'ignore',
+        const result = await sa.execute(prompt, 'fork: ' + prompt.slice(0, 60), {
+          worktreePath: wtPath,
+          inheritContext: { messages: parentContext.getMessages() },
+          signal,
+        })
+        try {
+          const { execSync: ex } = await import('node:child_process')
+          ex(`git -C ${wtPath} add -A`, { stdio: 'ignore', timeout: 10_000 })
+          const st = ex(`git -C ${wtPath} status --porcelain`, {
+            encoding: 'utf-8',
             timeout: 10_000,
           })
-          ex(`git push origin ${branch}`, { stdio: 'ignore', timeout: 30_000 })
+          if (st.trim()) {
+            ex(`git -C ${wtPath} commit -m "feat: ${prompt.slice(0, 60)}\n\n${COAUTHOR_TRAILER}"`, {
+              stdio: 'ignore',
+              timeout: 10_000,
+            })
+            ex(`git push origin ${branch}`, { stdio: 'ignore', timeout: 30_000 })
+          }
+        } catch {
+          /* best-effort */
         }
-      } catch {
-        /* best-effort */
+        const summary = [
+          `## Fork done: ${prompt}`,
+          '',
+          `Branch: \`${branch}\``,
+          `Worktree: \`${wtPath}\``,
+          '',
+          result || '(no output)',
+        ].join('\n')
+        agentViewManager.addMessage(session.id, { role: 'assistant', content: summary })
+        agentViewManager.updateStatus(session.id, 'completed')
+        return summary
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err)
+        agentViewManager.addMessage(session.id, {
+          role: 'assistant',
+          content: `Fork failed: ${message}`,
+        })
+        agentViewManager.updateStatus(session.id, 'failed')
+        throw err
       }
-      return [
-        `## Fork done: ${prompt}`,
-        '',
-        `Branch: \`${branch}\``,
-        `Worktree: \`${wtPath}\``,
-        '',
-        result || '(no output)',
-      ].join('\n')
     },
     'forked',
   )

package/src/ui/ctrl-c-confirm.ts

@@ -0,0 +1,63 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+/**
+ * Ctrl+C 的「再按一次才退出」窗口。
+ *
+ * 为什么需要它：Ink 默认的 Ctrl+C 语义是**立刻退出**，而 TUI 里 Ctrl+C 的合
+ * 理语义是「停下手上这件事」—— 对话框开着、回合跑着的时候，误按一次不该把
+ * 整个会话带走。所以 `render()` 处一律传 `exitOnCtrlC: false`（见
+ * `src/index.tsx`），退出的决定权收回到这里：第一次按只「上膛」，窗口内再按
+ * 一次才真退。
+ *
+ * 两个入口（主界面 `ui/app.tsx`、看板 `agent-view/dashboard.tsx`）共用这一份，
+ * 而不是各写一遍 —— 同一条语义有两份实现，迟早会长成两个东西。
+ *
+ * 注意 `isArmed()` 与 `armed` 是**两条路**，不是冗余：
+ * - 判据要走 `isArmed()`（ref）—— 在同一个按键回调里 `arm()` 之后 state 还没
+ *   重渲染，用 state 读的话第二次按键看到的仍是 false，就永远退不出去；
+ * - `armed`（state）只给渲染用（页脚那句提示）。
+ */
+export interface CtrlCConfirm {
+  /** 渲染用：当前是否处于「待确认」窗口内。 */
+  armed: boolean
+  /** 判据用：同步读数，同一次按键回调里 `arm()` 之后立刻为 true。 */
+  isArmed: () => boolean
+  /** 上膛：进入待确认窗口，`windowMs` 后自动撤。 */
+  arm: () => void
+  /** 撤膛：关掉窗口并清掉计时器（例如这次按键被别的事情消费掉了）。 */
+  reset: () => void
+}
+
+export function useCtrlCConfirm(windowMs = 2000): CtrlCConfirm {
+  const armedRef = useRef(false)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const [armed, setArmed] = useState(false)
+
+  const clear = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current)
+    timerRef.current = null
+  }, [])
+
+  const reset = useCallback(() => {
+    clear()
+    armedRef.current = false
+    setArmed(false)
+  }, [clear])
+
+  const arm = useCallback(() => {
+    clear()
+    armedRef.current = true
+    setArmed(true)
+    timerRef.current = setTimeout(() => {
+      armedRef.current = false
+      setArmed(false)
+    }, windowMs)
+  }, [clear, windowMs])
+
+  // 卸载时撤掉计时器 —— 否则它到点后会往已经卸掉的组件里 setState。
+  useEffect(() => clear, [clear])
+
+  const isArmed = useCallback(() => armedRef.current, [])
+
+  return { armed, isArmed, arm, reset }
+}