@zhushanwen/pi-scheduler 0.9.2 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-scheduler",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "type": "module",
   "main": "index.ts",
   "taiji": {
@@ -18,7 +18,7 @@
     "pi-package"
   ],
   "devDependencies": {
-    "@earendil-works/pi-tui": "^0.84.4",
+    "@earendil-works/pi-tui": "^1.0.0",
     "@vitest/coverage-v8": "^4.1.9",
     "fast-check": "^4.9.0",
     "vitest": "^4.1.8"
@@ -30,10 +30,10 @@
     "vitest.config.ts"
   ],
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "@earendil-works/pi-tui": "^0.84.4",
-    "typebox": "*"
+    "@earendil-works/pi-ai": "^1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@earendil-works/pi-tui": "^1.0.0",
+    "typebox": "1.3.27"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-ai": {
@@ -51,10 +51,11 @@
   },
   "dependencies": {
     "croner": "^9.0.0",
-    "@zhushanwen/extension-protocol": "0.16.0",
-    "@zhushanwen/pi-ext-guards": "0.4.2",
-    "@zhushanwen/pi-extension-logger": "0.6.1",
-    "@zhushanwen/pi-llm-shared": "0.10.1"
+    "@zhushanwen/extension-protocol": "0.18.0",
+    "@zhushanwen/pi-ext-guards": "0.4.3",
+    "@zhushanwen/pi-extension-logger": "0.6.2",
+    "@zhushanwen/pi-llm-shared": "0.11.1",
+    "@zhushanwen/pi-session-path": "0.1.0"
   },
   "scripts": {
     "test": "vitest run",

package/src/__tests__/U4-MODEL-SWITCH.test.ts

@@ -1,20 +1,24 @@
 /**
- * U4_MODEL_SWITCH：dispatch 模型切换（设计 D3 修订版）验收
+ * U4_MODEL_SWITCH：dispatch 模型切换（设计 D3 修订版 + D1 归属简化 + ADR-0122
+ * 事实查询翻转）验收
  *
- * 覆盖设计 §3.3 D3 的五块机制（探针 P-MODEL 修订后语义）：
+ * 覆盖五块机制（D1 终态：agent_settled + isIdle 复核拆 turnIndex 归属状态机——原
+ * turnIndex 归属：4 状态字段 + 6 事件挂点 + customType 前缀匹配）：
  * - 切换：dispatchTaskInner 在 sendMessage 前 setModel（busy 亦生效——本层不做 idle 检查）
- * - 归属与恢复：message_start customType 前缀匹配 + run 窗口内 turnIndex 序态关联；
- *   turn_end(dispatchedTurnIndex) + isIdle 复核推迟；agent_end 封口 run 窗口；
- *   agent_settled 封口 + awaiting-restore 即时兑现（恢复延迟从最长 1 tick 收敛到事件即时）
+ * - 恢复：判定锚点 = isIdle() 同步事实查询（判定层级最高）；agent_settled 确定性事件是
+ *   提前触发的加速器——事件到达即查询并兑现；非 idle（settled 与用户新 run 交错）不切
+ *   （记录保留），tick 的 isIdle() 查询在 idle 重入时兑现；不挂 agent_end（end 后可能
+ *   有自动续跑 turn，恢复只认 settled）
  * - 互斥：切换在途时其他需切模型任务 skip + pending 留待下 tick 重试
- * - 串行化（MF-2）：turn_end 恢复在途 / 切换 setModel 在途未建记录窗口内，后继需切模型
+ * - 串行化（MF-2）：settled 恢复在途 / 切换 setModel 在途未建记录窗口内，后继需切模型
  *   任务的 setModel 排队等前序模型 op 完成（任意两个 setModel 不并发、双记录不叠写）
- * - 对账兜底：严格先于同 tick dispatch 循环；在途标记 2 tick 过期强制开放；未决记录守卫
- *   （无记录时模型漂移 = 用户自主行为不动作）
+ * - tick 事实查询兜正确性（原 2-tick 计数对账已按 ADR-0122 删除）：严格先于同 tick
+ *   dispatch 循环；记录存在 + idle 即恢复（agent_settled 丢失时由查询收敛——拉保证
+ *   正确、事件只优化延迟）；未决记录守卫（无记录时模型漂移 = 用户自主行为不动作）
  * - 降级与接管副作用：setModel false 不阻塞 dispatch；sendMessage 抛错 catch 先恢复；
  *   模型语义异常只走日志（不进持久化词表）
  *
- * 事件注入：直接调用 runtime 的 handle* 事件入口（index.ts 的 pi.on 只做转发）。
+ * 事件注入：直接调用 runtime 的 handleRunSettled（index.ts 的 pi.on 只做转发）。
  * tick：fake timers 驱动真实 interval（对齐 runtime.test.ts F2 形态）。
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -30,10 +34,8 @@ vi.mock('@zhushanwen/pi-extension-logger', () => ({
 }))
 
 import { MockSchedulerBackend } from './mock-backend.js'
-import { SchedulerRuntime, type SchedulerModelOps } from '../runtime.js'
+import { TICK_INTERVAL_MS, SchedulerRuntime, type SchedulerModelOps } from '../runtime.js'
 import type { ScheduledTask } from '../types.js'
-
-const TICK_INTERVAL_MS = 30_000
 const ORIG = 'prov-a/model-1'
 const TASK_M = 'prov-b/model-2'
 const OTHER_M = 'prov-c/model-3'
@@ -60,7 +62,7 @@ class ModelOpsMock implements SchedulerModelOps {
   }
 }
 
-/** 纯 microtask 冲刷：handleTurnEnd 的恢复是 fire-and-forget async，断言前等待其 await 链完成 */
+/** 纯 microtask 冲刷：handleRunSettled 的恢复是 fire-and-forget async，断言前等待其 await 链完成 */
 async function flushAsync(): Promise<void> {
   for (let i = 0; i < 5; i++) await Promise.resolve()
 }
@@ -71,11 +73,6 @@ async function flushAsyncRounds(rounds: number): Promise<void> {
   for (let i = 0; i < rounds; i++) await Promise.resolve()
 }
 
-/** dispatch 注入的 custom message 形状（P-MODEL-④ 实测 payload） */
-function dispatchCustomMessage(): Record<string, unknown> {
-  return { role: 'custom', customType: 'pi-scheduler:dispatched', content: 'job', display: true, timestamp: 0 }
-}
-
 describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
   let backend: MockSchedulerBackend
   let ops: ModelOpsMock
@@ -102,27 +99,20 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
     return runtime.addTask(prompt, { mode: 'interval', intervalMs: 600_000 }, { model })
   }
 
-  /** 事件序注入（P-MODEL-④ 实测序态）：agent_start → turn_start(n) → message_start(custom) → turn_end(n) */
-  function injectDispatchTurn(turnIndex: number): void {
-    runtime.handleAgentStart()
-    runtime.handleTurnStart(turnIndex)
-    runtime.handleMessageStart(dispatchCustomMessage())
-    runtime.handleTurnEnd(turnIndex)
-  }
-
-  describe('切换与归属恢复', () => {
-    it('task.model ≠ 当前 → setModel(目标) + 归属 turn 结束后恢复(原)', async () => {
+  describe('切换与 settled 恢复', () => {
+    it('task.model ≠ 当前 → setModel(目标)；agent_settled + idle 即恢复(原)，重复 settled 不二次恢复', async () => {
       task = await addModelTask('job', TASK_M)
       const ok = await runtime.dispatchTask(task)
       expect(ok).toBe(true)
       expect(ops.setModelCalls).toEqual([TASK_M])
 
-      injectDispatchTurn(0)
+      // run 完全落定（agent_settled）+ idle：唯一事件通道立即兑现，无需推进 tick
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
 
-      // 记录已清：重复 turn_end 不二次恢复
-      runtime.handleTurnEnd(0)
+      // 记录已清：重复 settled 不二次恢复
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
     })
@@ -133,158 +123,43 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(ok).toBe(true)
       expect(ops.setModelCalls).toEqual([])
 
-      injectDispatchTurn(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([])
-    })
-
-    it('turn_end 非 idle → 推迟（无立即恢复），tick 重入 idle 即兑现', async () => {
-      task = await addModelTask('job', TASK_M)
-      await runtime.dispatchTask(task)
-
-      // 用户长 run 在途（非 idle）：turn_end 只推迟
-      ops.idle = false
-      injectDispatchTurn(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // run 沉降后 tick 重入：恢复兑现
-      ops.idle = true
-      runtime.startScheduler()
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
-      expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
-    })
-
-    it('agent_settled 即时兑现：awaiting-restore + idle → 不等 tick 立即恢复', async () => {
-      task = await addModelTask('job', TASK_M)
-      await runtime.dispatchTask(task)
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // 用户长 run 在途：turn_end 推迟为 awaiting-restore
-      ops.idle = false
-      injectDispatchTurn(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // run 完全沉降（agent_settled）：立即恢复，无需推进 30s tick
-      ops.idle = true
       runtime.handleRunSettled()
       await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
+      expect(ops.setModelCalls).toEqual([])
     })
 
-    it('agent_settled 与用户新 run 交错（非 idle）→ 不动作，tick 兜底仍兑现', async () => {
+    it('settled 非 idle（与用户新 run 交错）→ 不切（记录保留），tick 重入 idle 兑现', async () => {
       task = await addModelTask('job', TASK_M)
       await runtime.dispatchTask(task)
-
-      ops.idle = false
-      injectDispatchTurn(0)
-      await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M])
 
       // settled 事件处理时用户已开始新 run（isIdle false）：不能切（会把新 run 模型换掉）
+      ops.idle = false
       runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M])
 
-      // 兜底不变：后续 tick 重入 idle 仍恢复
+      // 兜底不变：后续 tick 的 isIdle() 查询在 idle 重入时恢复（记录无时间窗过期）
       ops.idle = true
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
     })
 
-    it('agent_end 纯封口不恢复（只有 settled 兑现）：awaiting-restore 态下 end 后仍不动作', async () => {
-      task = await addModelTask('job', TASK_M)
-      await runtime.dispatchTask(task)
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // 构造 awaiting-restore：归属 turn_end 时非 idle（用户长 run 在途）→ 推迟
-      ops.idle = false
-      runtime.handleAgentStart()
-      runtime.handleTurnStart(0)
-      runtime.handleMessageStart(dispatchCustomMessage())
-      runtime.handleTurnEnd(0)
-      ops.idle = true
-      // run 末尾 agent_end：纯封口——end 后可能仍有自动续跑 turn（retry/compaction/
-      // queued continuation），此时切回会把续跑 turn 的模型换掉
-      runtime.handleRunClosed()
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // 对照：同一状态下 agent_settled 立即兑现（a 段不动作 ≠ 状态机卡死）
-      runtime.handleRunSettled()
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
-    })
-
-    it('in-flight 态（归属 turn_end 未到达）settled 不动作：归属异常归 tick 对账', async () => {
-      task = await addModelTask('job', TASK_M)
-      await runtime.dispatchTask(task)
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // in-flight + idle：settled 不动 in-flight（turn_end 丢失的强制开放归 2-tick 对账）
-      ops.idle = true
-      runtime.handleRunSettled()
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // 归属 turn_end 到达后既有通道正常恢复
-      injectDispatchTurn(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
-    })
-
-    it('非匹配事件不触发恢复：非 custom / 非前缀 / turnIndex 不匹配 / run 窗口封口', async () => {
-      task = await addModelTask('job', TASK_M)
-      await runtime.dispatchTask(task)
-
-      // a) 非 custom message（assistant 形状）不归属
-      runtime.handleAgentStart()
-      runtime.handleTurnStart(0)
-      runtime.handleMessageStart({ role: 'assistant', provider: 'p', model: 'm', content: [], timestamp: 0 })
-      runtime.handleTurnEnd(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // b) customType 非 pi-scheduler: 前缀不归属
-      runtime.handleMessageStart({ role: 'custom', customType: 'other-ext:thing', content: '', display: true, timestamp: 0 })
-      runtime.handleTurnEnd(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // c) 前缀命中但 turnIndex 不匹配（归属 0，结束 1）
-      runtime.handleMessageStart(dispatchCustomMessage())
-      runtime.handleTurnEnd(1)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // d) run 窗口封口（agent_end/agent_settled）后陈旧索引失效
-      runtime.handleRunClosed()
-      runtime.handleTurnEnd(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      // sanity：封口后新 run 的正常归属仍可恢复（封口只清陈旧索引，不杀记录）
-      injectDispatchTurn(0)
-      await flushAsync()
-      expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
-    })
-
-    it('恢复 setModel(原) false → restore-failed 终态：warn 日志 + 清标记 + 对账不再动作', async () => {
+    it('恢复 setModel(原) false → restore-failed 终态：warn 日志 + 清标记 + 后续查询不再动作', async () => {
       task = await addModelTask('job', TASK_M)
       await runtime.dispatchTask(task)
       expect(ops.setModelCalls).toEqual([TASK_M])
 
       // 模拟恢复期 setModel 失败（无可用 key 等）
       ops.setModelResult = false
-      injectDispatchTurn(0)
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
       const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('restore-failed')
 
-      // 标记已清：后续对账窗口不重复动作
+      // 标记已清：后续 tick 的 isIdle() 查询不重复动作
       ops.setModelResult = true
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 3)
@@ -296,7 +171,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       await runtime.dispatchTask(task)
       ops.currentRef = ORIG // 用户手动切回
 
-      injectDispatchTurn(0)
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M]) // 无恢复调用
     })
@@ -306,8 +181,10 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
     it('切换在途时第二个需切模型任务 skip + pending 保留 + A 结算后重试成功', async () => {
       const taskA = await addModelTask('job-a', TASK_M)
       await runtime.dispatchTask(taskA)
+      ops.idle = false // A 的 run 在途（isIdle 事实查询非 idle）：互斥窗口成立的前提
 
       // B 到期走 tick 路径：step2 标 pending → step3 dispatch 命中互斥 skip
+      //（tick 开头的事实查询因非 idle 不动作，记录保留 → 互斥命中）
       const taskB = await addModelTask('job-b', OTHER_M)
       taskB.nextRunAt = 0
       runtime.startScheduler()
@@ -324,8 +201,9 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(okC).toBe(true)
       expect(backend.sentMessages).toHaveLength(2)
 
-      // A 结算（turn_end + idle 恢复）后 B 重试成功
-      injectDispatchTurn(0)
+      // A 结算（run 落定后会话空闲 → settled + idle 恢复）后 B 重试成功
+      ops.idle = true
+      runtime.handleRunSettled()
       await flushAsync()
       const okRetry = await runtime.dispatchTask(taskB)
       expect(okRetry).toBe(true)
@@ -333,23 +211,22 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG, OTHER_M])
     })
 
-    it('互斥强制结算的恢复与后续切换串行：恢复(原)完成前新切换目标不得写入（无交错）', async () => {
-      // 场景（runTaskNow 直连路径）：互斥命中触发 mutex-forced 强制结算恢复；若恢复
+    it('互斥结算的恢复与后续切换串行：恢复(原)完成前新切换目标不得写入（无交错）', async () => {
+      // 场景（runTaskNow 直连路径）：互斥命中触发事实查询结算恢复；若恢复
       // fire-and-forget，恢复先同步清记录再 await setModel(原)，紧随的需切模型任务 B 的
       // setModel(目标) 与之并发、完成顺序不定（恢复后完成则 B 的 turn 用错模型）。修复后
-      // 互斥分支 await 强制结算——锁定「恢复(原)记账并完成前，新切换不得发起」的顺序契约。
+      // 互斥分支 await 结算——锁定「恢复(原)记账并完成前，新切换不得发起」的顺序契约。
       //
-      // 状态构造说明：公开行为下 reconcile 在 ticksOpen 递增过窗口的同一 tick 内即结算
-      //（idle 恢复 / 非 idle 转推迟），互斥分支命中的「in-flight 过窗口残留」是防御分支——
-      // 此处直接注入该内部状态（extensions 测试目录豁免 unsafe-cast 规则，ask-user 等先例）。
+      // 状态构造说明：公开行为下「记录存在 + idle」即结算（ADR-0122 事实查询，无窗口
+      // 计数），互斥分支命中的未决记录直接可用——此处只断言记录存在
+      //（extensions 测试目录豁免 unsafe-cast 规则，ask-user 等先例）。
       const taskA = await addModelTask('job-a', TASK_M)
       await runtime.dispatchTask(taskA)
       expect(ops.setModelCalls).toEqual([TASK_M])
 
-      // A 的事件全部丢失；把在途标记推过对账窗口（> MODEL_SWITCH_RECONCILE_TICKS = 2）
-      const internal = runtime as unknown as { pendingModelSwitch: { ticksOpen: number } | null }
+      // A 的事件丢失（无 settled 注入）；未决记录直接可结算
+      const internal = runtime as unknown as { pendingModelSwitch: unknown | null }
       expect(internal.pendingModelSwitch).not.toBeNull()
-      internal.pendingModelSwitch!.ticksOpen = 3
 
       // 恢复(ORIG) 的 setModel 在「已记账未完成」态挂起（模拟真实 RPC 在途窗口）
       let releaseRestore: (() => void) | undefined
@@ -360,7 +237,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       vi.spyOn(ops, 'setModelByRef').mockImplementation(async (ref: string) => {
         ops.setModelCalls.push(ref)
         if (ops.setModelResult) ops.currentRef = ref
-        if (gatedCalls++ === 0) await restoreInFlight // 首个调用 = mutex-forced 恢复
+        if (gatedCalls++ === 0) await restoreInFlight // 首个调用 = mutex-settle 事实查询恢复
         return ops.setModelResult
       })
 
@@ -460,7 +337,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(internal.pendingModelSwitch!.targetModelRef).toBe(TASK_M)
 
       // A 结算后 B 重试成功（系统收敛，目标模型生效）
-      injectDispatchTurn(0)
+      runtime.handleRunSettled()
       await flushAsync()
       const okRetry = await runtime.dispatchTask(taskB)
       expect(okRetry).toBe(true)
@@ -468,7 +345,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(ops.currentRef).toBe(OTHER_M)
     })
 
-    it('同 tick 双任务顺序：A 恢复过期强制开放 + B 到期切换 → B 生效不被 A 回滚', async () => {
+    it('同 tick 双任务顺序：A 结算恢复 + B 到期切换 → B 生效不被 A 回滚', async () => {
       // A dispatch（记录在途）后事件全部丢失
       const taskA = await addModelTask('job-a', TASK_M)
       await runtime.dispatchTask(taskA)
@@ -476,16 +353,9 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       taskB.nextRunAt = 0 // 到期
 
       runtime.startScheduler()
-      // tick1：对账 ticksOpen=1（窗口内等事件）；B pending → 互斥 skip
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
-      expect(backend.sentMessages).toHaveLength(1)
-      expect(taskB.pending).toBe(true)
-      // tick2：ticksOpen=2 仍在窗口内；B 仍 skip
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
-      expect(backend.sentMessages).toHaveLength(1)
-      // tick3：ticksOpen=3 > 2 → A 强制开放（idle 即恢复）→ dispatch 循环 B 切换成功。
-      // 顺序约束（对账 await 先于 dispatch 循环）：A 的恢复 setModel 完成后 B 才 setModel，
-      // B 生效且不被 A 回滚（若交错则最后写入是 ORIG）
+      // 首 tick：结算先于 dispatch 循环（顺序约束）——记录存在 + idle 即恢复 A（isIdle
+      // 事实查询，无窗口计数），B 的 setModel 在恢复完成后执行，B 生效且不被 A 回滚
+      //（若交错则最后写入是 ORIG）
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG, OTHER_M])
       expect(ops.currentRef).toBe(OTHER_M)
@@ -493,15 +363,15 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(taskB.lastStatus).toBe('success')
 
       // B 的恢复链路随后正常闭环
-      injectDispatchTurn(0)
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG, OTHER_M, ORIG])
     })
   })
 
   describe('模型 op 串行化（MF-2 回归）', () => {
-    it('turn_end 恢复在途时新需切模型任务 dispatch → 新 setModel 排队等恢复完成（先恢复后切换）', async () => {
-      // MF-2 回归：handleTurnEnd 的恢复是 fire-and-forget（先同步清记录再 await setModel(原)）。
+    it('settled 恢复在途时新需切模型任务 dispatch → 新 setModel 排队等恢复完成（先恢复后切换）', async () => {
+      // MF-2 回归：handleRunSettled 的恢复是 fire-and-forget（先同步清记录再 await setModel(原)）。
       // 修复前恢复在途窗口内 pendingModelSwitch 已为 null → 新 dispatch 的互斥检查放行，
       // setModel(目标) 与在途 setModel(原) 并发、完成顺序不定（恢复后完成则该任务 turn
       // 静默跑错模型）。修复后恢复持模型 op 队列，后继 setModel 排队等其完成。
@@ -519,12 +389,12 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       vi.spyOn(ops, 'setModelByRef').mockImplementation(async (ref: string) => {
         ops.setModelCalls.push(ref)
         if (ops.setModelResult) ops.currentRef = ref
-        if (ref === ORIG) await restoreGate // turn_end 恢复挂起在「已发起未完成」态
+        if (ref === ORIG) await restoreGate // settled 恢复挂起在「已发起未完成」态
         return ops.setModelResult
       })
 
-      // A 的 turn 正常结束且 idle → fire-and-forget 恢复启动并挂起
-      injectDispatchTurn(0)
+      // A 的 run 完全落定且 idle → fire-and-forget 恢复启动并挂起
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
       // 记录已同步清（先关后恢复不变）——修复前正是这个窗口放行了并发 setModel
@@ -558,28 +428,24 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(backend.sentMessages).toHaveLength(2)
 
       // B 的恢复链路随后正常闭环（终态回 ORIG）
-      injectDispatchTurn(0)
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG, OTHER_M, ORIG])
     })
   })
 
-  describe('对账兜底', () => {
-    it('在途标记超过 2 tick 未关闭 → 强制开放并对账恢复（事件丢失路径）', async () => {
+  describe('tick 事实查询兜正确性（事件丢失路径）', () => {
+    it('agent_settled 丢失：记录存在 + idle → 下个 tick 的 isIdle() 查询恢复', async () => {
       task = await addModelTask('job', TASK_M)
       await runtime.dispatchTask(task)
-      // 无任何事件注入（恢复回调永不执行）
+      // 无任何事件注入（settled 恢复通道不触发）
 
       runtime.startScheduler()
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1: ticksOpen=1
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick2: ticksOpen=2，窗口内
-      expect(ops.setModelCalls).toEqual([TASK_M])
-
-      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick3: >2 → 强制开放（idle）→ 恢复
+      await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // 首 tick：isIdle() 事实查询 → 恢复
       expect(ops.setModelCalls).toEqual([TASK_M, ORIG])
     })
 
-    it('无未决记录时模型漂移 = 用户自主行为，对账不动作', async () => {
+    it('无未决记录时模型漂移 = 用户自主行为，查询不动作', async () => {
       ops.currentRef = 'prov-x/model-y' // 无 dispatch，用户手动改模型
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 5)
@@ -598,8 +464,8 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('model switch failed')
 
-      // 无未决记录：事件归属不建立、turn_end 无恢复
-      injectDispatchTurn(0)
+      // 无未决记录：settled 不动作（切换失败 = 无恢复对象）
+      runtime.handleRunSettled()
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M])
     })