@@ -34,7 +34,8 @@
  */
 
 import { Decider } from './decide.ts'
-import type { DecisionResult } from './vocab-decision.ts'
+import type { DecisionSpec, DecisionResult } from './vocab-decision.ts'
+import type { AnswerMap, QuestionSet } from './vocab.ts'
 import { Meter } from './meter.ts'
 import { clip } from './budget.ts'
 import {
@@ -103,6 +104,19 @@ export interface AgentOptions {
   onEvent?: AgentObserver
 }
 
+/**
+ * 「问一次判定」的形状。
+ *
+ * 抽出来是为了让 `resolveInput` 也拿到**同一个**入口 —— 它原本收的是
+ * `decider` 和 `record` 两个参数，于是「播报 phase」这件事在那个函数里
+ * 根本做不到（它够不到 `runAgent` 的闭包）。只传一个 `ask` 之后，
+ * 「问判定」只有一种写法，漏掉播报是不可能的。
+ */
+type Ask = <C, Q extends QuestionSet>(
+  spec: DecisionSpec<C, Q>,
+  ctx: C,
+) => Promise<DecisionResult<AnswerMap<Q>>>
+
 export interface AgentResult {
   answer: string
   /** 停机原因 */
@@ -247,21 +261,42 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
     return d
   }
 
+  /**
+   * 问一次判定 —— **先播报「要问了」，再问**。
+   *
+   * ★ 两件事的顺序是重点，不是风格。`decision` 事件是**做完之后**才发的
+   *   （它带着 `latencyMs` 和答案），所以只靠它，观察者只能拿「上一次干完
+   *   的是什么」去猜「现在在干什么」—— 而它在**最长的那一步上错得最久**。
+   *
+   *   实测（2026-09-21，用户报的）：生成那 2 秒里界面显示「正在判定」，
+   *   因为最后一条事件是 `isDone`。`tool:call` 本来就在跑之前发，所以
+   *   工具段一直是对的；判定段和生成段缺「开始」，这里补上。
+   *
+   * 顺带把 `record` 收进来：每个判定点都必须过这一道，**漏一处界面就少
+   * 一个决策点**，而那种缺失不会报错（`record` 的注释也是这么写的）。
+   * 合成一个函数之后，「忘了发 phase」和「忘了记 decision」变成同一个
+   * 错误 —— 只有一种写法。
+   */
+  const ask: Ask = async (spec, c) => {
+    emit({ type: 'phase', step, kind: 'decide', id: spec.id })
+    return record(await decider.decide(spec, c))
+  }
+
   // ── 工具循环 ──────────────────────────────────────────────
   while (step < maxSteps) {
     step++
     decider.setStep(step)
 
     // ↗ 需要动手吗
-    const need = record(await decider.decide(needsTool, ctx))
+    const need = await ask(needsTool, ctx)
     if (need.action === 'answer') {
       halt = 'answered_directly'
       trace(`  answering directly (no tool needed)`)
       break
     }
 
     // ↗ 用哪个工具（候选每步重建）
-    const pick = record(await decider.decide(pickTool, ctx))
+    const pick = await ask(pickTool, ctx)
     if (pick.escalate || pick.action !== 'call') {
       halt = 'tool_unclear'
       trace(`  tool choice unclear → stopping (${pick.reason})`)
@@ -289,7 +324,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
     ctx.lastTool = tool
 
     // 工具参数是一次**判定**，不是写死的代码（审计 N3）
-    const input = await resolveInput(tool, ctx, decider, record, opts.provideWriteContent)
+    const input = await resolveInput(tool, ctx, ask, opts.provideWriteContent)
     if (input === undefined) {
       halt = 'input_unclear'
       trace(`  could not choose an input for ${tool} → stopping`)
@@ -300,7 +335,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
     ctx.history = [...(ctx.history ?? []), pending]
 
     // ↗ 这个操作多危险
-    const risk = record(await decider.decide(gradeRisk, ctx))
+    const risk = await ask(gradeRisk, ctx)
     if (risk.escalate || risk.action === 'ask_human') {
       const approved = opts.onAskHuman ? await opts.onAskHuman(risk.reason, tool) : false
       emit({ type: 'authorize', step, tool, reason: risk.reason, approved })
@@ -351,15 +386,15 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
     }
 
     // ↗ 成功了吗
-    const ok = record(await decider.decide(stepOk, ctx))
+    const ok = await ask(stepOk, ctx)
     if (ok.action !== 'continue') {
       halt = 'step_failed'
       trace(`  this step did not succeed → stopping (${ok.reason})`)
       break
     }
 
     // ↗ 做完了吗
-    const done = record(await decider.decide(isDone, ctx))
+    const done = await ask(isDone, ctx)
     if (done.action === 'finish') {
       halt = 'task_done'
       break
@@ -454,6 +489,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
 
   let genStep = step + 1
   decider.setStep(genStep)
+  emit({ type: 'phase', step: genStep, kind: 'generate' })
   const gen = await generator.generate({
     task: ctx.task,
     evidence: evidenceText,
@@ -484,7 +520,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
   ctx.draft = gen.text
 
   // ↗ 能交付吗
-  let deliver = record(await decider.decide(canDeliver, ctx))
+  let deliver = await ask(canDeliver, ctx)
 
   // `revise` 承诺了「修订」，那修订就必须真的发生 ——
   // 以前它只是被拼进 halt 字符串，草稿原样返回。
@@ -493,6 +529,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
     trace(`  the delivery gate asked for a revision (${deliver.reason}) → regenerating once with that feedback`)
     genStep += 1
     decider.setStep(genStep)
+    emit({ type: 'phase', step: genStep, kind: 'generate' })
     const retry = await generator.generate({
       task: ctx.task,
       // 同一份证据和同一份上文 —— 循环早就结束了，两者都没变过
@@ -517,7 +554,7 @@ export async function runAgent(opts: AgentOptions): Promise<AgentResult> {
       estimatedInputTokens: evidenceEstimate.controlTokens,
     })
     ctx.draft = retry.text
-    deliver = record(await decider.decide(canDeliver, ctx))
+    deliver = await ask(canDeliver, ctx)
   }
 
   if (deliver.action !== 'deliver') {
@@ -647,15 +684,14 @@ function noteForConversation(r: ConversationReport): string {
  *
  * @param tool 已经过 `isToolName` 校验的工具名
  * @param ctx 当前上下文，`pickInput` 的候选从这里构造
- * @param decider 判定器
+ * @param ask 问一次判定的唯一入口（见 `Ask`）—— 它负责播报 phase 和记 decision
  * @param writeContent `write_file` 的内容来源，见 `AgentOptions.provideWriteContent`
  * @returns 工具的输入字符串；无法确定时返回 `undefined`（调用方应停机，不要猜）
  */
 async function resolveInput(
   tool: ToolName,
   ctx: AgentCtx,
-  decider: Decider,
-  record: <A>(d: DecisionResult<A>) => DecisionResult<A>,
+  ask: Ask,
   writeContent?: AgentOptions['provideWriteContent'],
 ): Promise<string | undefined> {
   switch (tool) {
@@ -668,7 +704,7 @@ async function resolveInput(
     case 'write_file': {
       // 没有候选就**不要问** —— criteria 为空的 choice 是无效问题
       if (!hasFileOptions(ctx)) return undefined
-      const d = record(await decider.decide(pickInput, ctx))
+      const d = await ask(pickInput, ctx)
       if (d.escalate || d.action !== 'use') return undefined
       const file = d.answers.file.choice
       if (tool === 'read_file') return file
 
@@ -35,6 +35,37 @@ export type AgentEvent =
       degraded: boolean
       escalate: boolean
     }
+  /**
+   * 一步操作**开始了**。
+   *
+   * ══════════════════════════════════════════════════════════════
+   *  ★ 为什么需要它：**上面所有事件都是「做完之后」才发的。**
+   * ══════════════════════════════════════════════════════════════
+   *
+   * `decision` 带着 `latencyMs`、`generate` 带着 token 数 —— 它们都是
+   * **记录**。于是「现在在干什么」这个问题，观察者只能拿「上一次干完的是
+   * 什么」去猜，而这个猜法在**最长的那一步上错得最久**。
+   *
+   * 实测（2026-09-21，用户报的）：生成要 2 秒以上，那段时间界面显示的
+   * 是「正在判定」—— 因为最后一条事件是 `isDone` 判定。等 `generate`
+   * 到了，它把标签改成「正在生成回答」，可那时生成**已经结束**了，
+   * 而且下一条 `canDeliver` 立刻又改回「正在判定」。
+   *
+   * `tool:call` 本来就在跑之前发，所以工具那一段一直是对的。判定和生成
+   * 这两段缺「开始」，补上之后三段形状一致。
+   *
+   * ⚠️ **它刻意不进 `EVENT_META`**（界面的那张分类表）：那一张描述的是
+   * **做完的事**，每一行都有耗时和泳道；「开始」没有耗时，进去只会多出
+   * 一行空记录。界面在 `onEvent` 里单独处理它。
+   */
+  | {
+      type: 'phase'
+      step: number
+      /** 这一段在干什么 */
+      kind: 'decide' | 'generate'
+      /** `kind: 'decide'` 时是判定节点 id，如 `loop.pickTool` */
+      id?: string
+    }
   /** 判定节点要求人工授权，以及结果 */
   | { type: 'authorize'; step: number; tool: string; reason: string; approved: boolean }
   /** `auto_audit` 承诺的留痕真的发生了 */
 
@@ -785,3 +785,92 @@ test('★ stepOk 的问题与判据都在说「这次调用」，不是「这个
   assert.match(q.instructions, /this tool call/i, '要明说判的是这次调用')
   assert.match(q.instructions, /decided elsewhere/i, '要明说任务完成度在别处判')
 })
+
+// ═══════════════════════════════════════════════════════════
+// phase 事件：界面显示「现在在干什么」的唯一依据
+//
+// ★ 起因是一个真 bug（2026-09-21，用户报的）：生成那 2 秒里界面显示的是
+//   「正在判定」。因为所有事件都是**做完之后**才发的（`decision` 带
+//   latencyMs、`generate` 带 token 数），界面只能拿「上一次干完的是什么」
+//   去猜，而这个猜法在最长的那一步上错得最久。
+// ═══════════════════════════════════════════════════════════
+
+test('★ 每个 decision / generate **之前**都有一条 phase —— 界面靠它显示当前阶段', async () => {
+  const { runAgent } = await import('../src/agent.ts')
+  const { Decider } = await import('../src/decide.ts')
+  const { Meter } = await import('../src/meter.ts')
+
+  const seq: string[] = []
+  const decider = new Decider({
+    meter: new Meter(),
+    provider: {
+      name: 'spy',
+      decide: async () => ({ answers: { needs_tool: { type: 'noul', noul: 0.1 } }, provider: 'spy', latencyMs: 0 }),
+    } as never,
+  })
+
+  await runAgent({
+    task: 'T',
+    cwd: '/tmp',
+    decider,
+    generator: {
+      name: 'capture',
+      generate: async () => ({ text: 'ok', latencyMs: 0, inputTokens: 0, outputTokens: 0, model: 'capture' }),
+    },
+    maxSteps: 1,
+    onEvent: (e) => {
+      seq.push(e.type === 'phase' ? `phase:${e.kind}` : e.type)
+    },
+  })
+
+  // 走一遍序列：每个 decision / generate 前面**紧邻**的必须是对应的 phase
+  const missing: string[] = []
+  for (const [i, x] of seq.entries()) {
+    if (x === 'decision' && seq[i - 1] !== 'phase:decide') missing.push(`第 ${i} 条 decision 前面是 ${seq[i - 1]}`)
+    if (x === 'generate' && seq[i - 1] !== 'phase:generate') missing.push(`第 ${i} 条 generate 前面是 ${seq[i - 1]}`)
+  }
+  assert.deepEqual(missing, [], '有操作没有先播报 phase —— 界面会在那一段显示上一个阶段的标签')
+
+  // 防呆：别因为一次判定都没发生而静默通过
+  assert.ok(seq.filter((x) => x === 'phase:decide').length >= 1, `一次判定都没发生：${seq.join(' → ')}`)
+  assert.ok(seq.includes('phase:generate'), `没有生成阶段：${seq.join(' → ')}`)
+})
+
+test('phase 事件带得上判定节点 id —— 排查「哪个判定慢」要看它', async () => {
+  const { runAgent } = await import('../src/agent.ts')
+  const { Decider } = await import('../src/decide.ts')
+  const { Meter } = await import('../src/meter.ts')
+
+  const ids: string[] = []
+  const decider = new Decider({
+    meter: new Meter(),
+    provider: {
+      name: 'spy',
+      decide: async () => ({ answers: { needs_tool: { type: 'noul', noul: 0.1 } }, provider: 'spy', latencyMs: 0 }),
+    } as never,
+  })
+  await runAgent({
+    task: 'T',
+    cwd: '/tmp',
+    decider,
+    generator: {
+      name: 'capture',
+      generate: async () => ({ text: 'ok', latencyMs: 0, inputTokens: 0, outputTokens: 0, model: 'capture' }),
+    },
+    maxSteps: 1,
+    onEvent: (e) => {
+      if (e.type === 'phase' && e.kind === 'decide') ids.push(e.id ?? '(没有 id)')
+    },
+  })
+  // ⚠️ 不要写成 `['loop.needsTool']` —— spy provider 对**每个**判定都返回
+  //    同一份答案，所以 `canDeliver` 也拿到 `needs_tool:0.1`，它的策略在缺
+  //    `deliverable` / `unsupported` 时走到 `revise`，于是**又一次生成 +
+  //    又一次 canDeliver**。实测序列是 needsTool → canDeliver → canDeliver。
+  //    （同一个坑今天绊了两次：修订那条路径让「一次运行有几次生成」比
+  //     直觉多一次。）
+  assert.equal(ids[0], 'loop.needsTool', '第一个判定是 needsTool')
+  assert.ok(
+    ids.every((id) => /^loop\.[a-zA-Z]+$/.test(id)),
+    `每个 phase 都要带真实的节点 id，实际拿到：${JSON.stringify(ids)}`,
+  )
+})
@@ -419,7 +419,18 @@ function processRow(e, dur) {
  * 没有这个，一次 37 秒的运行看起来和挂掉没有区别 —— 而它其实一直在跑，
  * 只是每次判定之间隔着几百毫秒的静默。
  */
-const STALL_AFTER_MS = 6000
+/**
+ * 「比平时久」的界线，**按阶段分开**。
+ *
+ * ★ 一个数管三段是错的：托管 Jev 一次判定约 **390ms**（§8.11），而一次
+ *   生成 **2 秒起、几十秒都正常**（生成器自己的超时是 60 秒）。用同一个
+ *   6 秒，既会把正常的生成报成「比平时久」，又对真卡住的判定太宽容。
+ *
+ * 数字的来源：判定 6 秒 ≈ 托管 Jev 的 15 倍；生成 30 秒 ≈ 实测常见的
+ * 10 倍，同时留在 60 秒超时之内 —— 超过它多半是真出问题了，但**还可能
+ * 正常返回**，所以文案是「比平时久」而不是「失败」。
+ */
+const STALL_AFTER_MS = { decide: 6000, tool: 6000, generate: 30000 }
 let ticker = null
 
 function startTicker() {
@@ -428,7 +439,7 @@ function startTicker() {
     if (!current || current.finished || current.stopped) return
     const waited = Date.now() - (current.lastEventAt ?? Date.now())
     const secs = (waited / 1000).toFixed(0)
-    const stalled = waited >= STALL_AFTER_MS
+    const stalled = waited >= (STALL_AFTER_MS[current.phaseKind] ?? 6000)
     current.running.className = `running-row${stalled ? ' stalled' : ''}`
     current.running.replaceChildren(
       h('span', { class: 'pulse' }),
@@ -444,16 +455,38 @@ function stopTicker() {
   }
 }
 
-function setWaiting(text) {
+/**
+ * 换「现在在干什么」，并把秒数从头数起。
+ *
+ * **只有「开始」信号该调它** —— `phase` 事件和 `tool:call`。其余事件都是
+ * 做完之后才发的，拿它们改标签就是原来那个 bug（生成期间显示「正在判定」）。
+ */
+function setPhase(text, kind) {
   if (!current) return
   current.waitingOn = text
+  current.phaseKind = kind
   current.lastEventAt = Date.now()
   if (!current.stopped) {
     current.running.className = 'running-row'
     current.running.replaceChildren(h('span', { class: 'pulse' }), `${text}  ·  已等待 0s`)
   }
 }
 
+/**
+ * 又来了一条事件 —— **只把秒数从头数起，不动标签**。
+ *
+ * 两件事分开是因为它们回答不同的问题：标签是「在做什么」（由开始信号决定），
+ * 秒数是「上一次有动静是多久以前」（任何事件都算）。
+ */
+function touch() {
+  if (current) current.lastEventAt = Date.now()
+}
+
+/** `phase` 事件 → 那句话。判定节点 id 不进去 —— 轨迹里有，这里加只会变吵 */
+function phaseText(e) {
+  return e.kind === 'generate' ? '正在生成回答' : '正在判定'
+}
+
 /**
  * 「判定 : 模型」的显示文本。**两个调用点共用这一个函数。**
  *
@@ -1100,9 +1133,13 @@ function onEvent(e) {
       followTail()
       syncTurnRail()
     }
-    if (e.type === 'tool:call') setWaiting(`正在执行 ${e.tool}`)
-    else if (e.type === 'generate') setWaiting('正在生成回答')
-    else setWaiting('正在判定')
+    // ★ 「现在在干什么」**只由开始信号决定**：`phase` 和 `tool:call`。
+    //   其余事件（`decision` / `generate` / `tool:result`）都是**做完之后**
+    //   才发的，拿它们猜就会在最长的那一步上错得最久 —— 实测生成那 2 秒
+    //   显示的是「正在判定」，因为最后一条事件是 `isDone`。
+    if (e.type === 'phase') setPhase(phaseText(e), e.kind)
+    else if (e.type === 'tool:call') setPhase(`正在执行 ${e.tool}`, 'tool')
+    else touch()
   }
 
   // 轨迹侧：账本加一行，时间轴加一条