@zhushanwen/pi-scheduler 0.9.3 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-scheduler",
-  "version": "0.9.3",
+  "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,10 @@
   },
   "dependencies": {
     "croner": "^9.0.0",
-    "@zhushanwen/extension-protocol": "0.17.0",
-    "@zhushanwen/pi-ext-guards": "0.4.2",
-    "@zhushanwen/pi-extension-logger": "0.6.1",
-    "@zhushanwen/pi-llm-shared": "0.11.0",
+    "@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": {

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

@@ -1,18 +1,20 @@
 /**
- * U4_MODEL_SWITCH：dispatch 模型切换（设计 D3 修订版 + D1 归属简化）验收
+ * U4_MODEL_SWITCH：dispatch 模型切换（设计 D3 修订版 + D1 归属简化 + ADR-0122
+ * 事实查询翻转）验收
  *
- * 覆盖设计 §3.3 D-B4-4 D1 的五块机制（D1 终态：agent_settled + isIdle 复核拆 turnIndex
- * 归属状态机——原 turnIndex 归属：4 状态字段 + 6 事件挂点 + customType 前缀匹配）：
+ * 覆盖五块机制（D1 终态：agent_settled + isIdle 复核拆 turnIndex 归属状态机——原
+ * turnIndex 归属：4 状态字段 + 6 事件挂点 + customType 前缀匹配）：
  * - 切换：dispatchTaskInner 在 sendMessage 前 setModel（busy 亦生效——本层不做 idle 检查）
- * - 恢复：agent_settled（run 完全落定）+ isIdle 复核是唯一事件通道——idle 即恢复；
- *   非 idle（settled 与用户新 run 交错）转 awaiting-restore 推迟，tick 重入 idle 兑现；
- *   不挂 agent_end（end 后可能有自动续跑 turn，恢复只认 settled）
+ * - 恢复：判定锚点 = isIdle() 同步事实查询（判定层级最高）；agent_settled 确定性事件是
+ *   提前触发的加速器——事件到达即查询并兑现；非 idle（settled 与用户新 run 交错）不切
+ *   （记录保留），tick 的 isIdle() 查询在 idle 重入时兑现；不挂 agent_end（end 后可能
+ *   有自动续跑 turn，恢复只认 settled）
  * - 互斥：切换在途时其他需切模型任务 skip + pending 留待下 tick 重试
  * - 串行化（MF-2）：settled 恢复在途 / 切换 setModel 在途未建记录窗口内，后继需切模型
  *   任务的 setModel 排队等前序模型 op 完成（任意两个 setModel 不并发、双记录不叠写）
- * - 对账兜底（时间平抑红线登记见 runtime.ts MODEL_SWITCH_RECONCILE_TICKS）：严格先于同
- *   tick dispatch 循环；在途标记 2 tick 过期强制开放（agent_settled 丢失的兜底路径）；
- *   未决记录守卫（无记录时模型漂移 = 用户自主行为不动作）
+ * - tick 事实查询兜正确性（原 2-tick 计数对账已按 ADR-0122 删除）：严格先于同 tick
+ *   dispatch 循环；记录存在 + idle 即恢复（agent_settled 丢失时由查询收敛——拉保证
+ *   正确、事件只优化延迟）；未决记录守卫（无记录时模型漂移 = 用户自主行为不动作）
  * - 降级与接管副作用：setModel false 不阻塞 dispatch；sendMessage 抛错 catch 先恢复；
  *   模型语义异常只走日志（不进持久化词表）
  *
@@ -126,7 +128,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(ops.setModelCalls).toEqual([])
     })
 
-    it('settled 非 idle（与用户新 run 交错）→ 转 awaiting-restore 推迟，tick 重入 idle 兑现', async () => {
+    it('settled 非 idle（与用户新 run 交错）→ 不切（记录保留），tick 重入 idle 兑现', async () => {
       task = await addModelTask('job', TASK_M)
       await runtime.dispatchTask(task)
       expect(ops.setModelCalls).toEqual([TASK_M])
@@ -137,14 +139,14 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       await flushAsync()
       expect(ops.setModelCalls).toEqual([TASK_M])
 
-      // 兜底不变：后续 tick 重入 idle 仍恢复（awaiting-restore 无窗口过期）
+      // 兜底不变：后续 tick 的 isIdle() 查询在 idle 重入时恢复（记录无时间窗过期）
       ops.idle = true
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
       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])
@@ -157,7 +159,7 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       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)
@@ -179,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()
@@ -197,7 +201,8 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
       expect(okC).toBe(true)
       expect(backend.sentMessages).toHaveLength(2)
 
-      // A 结算（settled + idle 恢复）后 B 重试成功
+      // A 结算（run 落定后会话空闲 → settled + idle 恢复）后 B 重试成功
+      ops.idle = true
       runtime.handleRunSettled()
       await flushAsync()
       const okRetry = await runtime.dispatchTask(taskB)
@@ -206,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
@@ -233,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
       })
 
@@ -341,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)
@@ -349,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)
@@ -437,22 +434,18 @@ describe('U4_MODEL_SWITCH: dispatch 模型切换', () => {
     })
   })
 
-  describe('对账兜底', () => {
-    it('agent_settled 丢失：在途标记超过 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)

package/src/__tests__/index-generation.test.ts

@@ -47,13 +47,15 @@ vi.mock('../widget.js', async (importOriginal) => {
 })
 
 // vi.mock factory 会被提升，跨模块共享状态必须经 vi.hoisted。
-const { isCtxStaleCaptures, runtimeInstances } = vi.hoisted(() => ({
+const { isCtxStaleCaptures, runtimeInstances, stopSchedulerCalls } = vi.hoisted(() => ({
   isCtxStaleCaptures: [] as Array<(() => boolean) | undefined>,
   runtimeInstances: [] as Array<{ stopScheduler(): void }>,
+  stopSchedulerCalls: [] as Array<{ stopScheduler(): void }>,
 }))
 
 // InstrumentedRuntime 继承真实实现（loadTasks/onAfterTick/startScheduler 均真实执行），
-// 仅捕获构造参（isCtxStale）并登记实例（afterEach 统一停 timer，避免真实 setInterval 残留）。
+// 仅捕获构造参（isCtxStale）并登记实例（afterEach 统一停 timer，避免真实 setInterval 残留）；
+// stopScheduler 调用按序记录（F1 验收断言面：新装配前旧实例必须被停）。
 vi.mock('../runtime.js', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../runtime.js')>()
   const RealSchedulerRuntime = actual.SchedulerRuntime
@@ -66,6 +68,10 @@ vi.mock('../runtime.js', async (importOriginal) => {
       isCtxStaleCaptures.push(isCtxStale)
       runtimeInstances.push(this)
     }
+    override stopScheduler(): void {
+      stopSchedulerCalls.push(this)
+      super.stopScheduler()
+    }
   }
   return { ...actual, SchedulerRuntime: InstrumentedRuntime }
 })
@@ -73,8 +79,6 @@ vi.mock('../runtime.js', async (importOriginal) => {
 import schedulerExtension from '../index.js'
 import { TICK_INTERVAL_MS } from '../runtime.js'
 import { TASK_ENTRY_TYPE } from '../types.js'
-/** 与 index.ts 的 WIDGET_KEEPALIVE_INTERVAL_MS 同值（常量不导出，测试锚定同值）。 */
-const KEEPALIVE_INTERVAL_MS = 10 * 60 * 1000
 
 /**
  * 最小 fake pi：覆盖 factory 消费的 API 面
@@ -206,12 +210,9 @@ describe('G1: index.ts 代际接线（S9）', () => {
 // 下一 tick 的 refreshWidget 访问 stale ctx.ui 抛错 → unhandledRejection → pi 主进程 exit 1。
 // F1 在 session_start 开头幂等 stopScheduler，从源头消灭。
 //
-// 行为断言口径（验收 U4）：观测面 = refreshWidget 的推送调用序列（本文件 mock 环境下
-// refreshWidget 走 setSchedulerWidgetMock，与真实 ctx.ui.setWidget 同一调用序列）。widget
-// 推送修正（D1 指纹跳推 + D2 保活底线帧）后每次 tick 不再必然推帧——任务集静态期间零推送、
-// 空任务集恒零推送，故注入非空任务集、以「跨 10min 保活窗口必推一帧」作为「该 runtime 的
-// timer 是否还在 tick」的行为观测面（保活帧间隔与 index.ts WIDGET_KEEPALIVE_INTERVAL_MS
-// 同值 10min）。F1 缺失时旧 timer 跨窗口必多推一帧，即被捕获。
+// 行为断言口径（验收 U4）：观测面 = InstrumentedRuntime 的 stopScheduler 调用序列
+// （widget 推送是 D1 指纹跳推语义——任务集静态期间零推送，不能靠推送计数区分新旧 timer；
+// stopScheduler 白盒断言直接锁定「新装配前旧实例必须被停」的 F1 语义本身）。
 describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
   const BASE = Date.parse('2026-01-01T00:00:00Z')
 
@@ -243,7 +244,7 @@ describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
     }
   }
 
-  /** 同 createFakeCtx，但注入非空任务集（保活帧只在非空任务集时推送，见上方口径注释）。 */
+  /** 同 createFakeCtx，但注入非空任务集（首帧渲染需要非空任务集可断言）。 */
   function createFakeCtxWithTasks(sessionFile: string): ExtensionContext {
     return {
       cwd: '/test-index-session-start',
@@ -260,6 +261,7 @@ describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
   beforeEach(() => {
     isCtxStaleCaptures.length = 0
     runtimeInstances.length = 0
+    stopSchedulerCalls.length = 0
     setSchedulerWidgetMock.mockClear()
     vi.useFakeTimers()
     vi.setSystemTime(new Date(BASE))
@@ -272,7 +274,7 @@ describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
     vi.useRealTimers()
   })
 
-  it('U4: 双 session_start 后旧 timer 已停——跨保活窗口只有新 runtime 推帧', async () => {
+  it('U4: 双 session_start 后旧 timer 已停（stopScheduler 恰命中首个实例）', async () => {
     const { pi, events } = createMockPi()
     schedulerExtension(pi)
     const sessionStart = events.get('session_start')
@@ -281,19 +283,19 @@ describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
     // 第一次 session_start：runtime1 + timer1 启动，初始渲染 1 次
     sessionStart!({ type: 'session_start', reason: 'startup' }, createFakeCtxWithTasks('/test/session-1.json'))
     expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(1)
+    expect(runtimeInstances).toHaveLength(1)
 
-    // 前置因果锚点：静置越过保活窗口，timer1 推一帧保活帧（排除「timer 从未启动」的假绿；
-    // 也锁定跳推行为——窗口内其余 tick 零推送）
-    await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS + TICK_INTERVAL_MS)
-    expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(2)
+    // 前置因果锚点：静置数个 tick——timer1 在 tick（无异常），任务集静态零推送（D1 跳推）
+    await vi.advanceTimersByTimeAsync(2 * TICK_INTERVAL_MS)
+    expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(1)
 
     // 第二次 session_start（session 替换）：F1 在装配新 runtime 前停掉 timer1
     sessionStart!({ type: 'session_start', reason: 'new_session' }, createFakeCtxWithTasks('/test/session-2.json'))
-    expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(3) // runtime2 初始渲染（实例态重置，首帧必推）
+    expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(2) // runtime2 初始渲染（实例态重置，首帧必推）
+    expect(runtimeInstances).toHaveLength(2)
 
-    // 行为断言（验收口径）：再静置一个保活窗口，只有 runtime2 的 timer 触发推送——恰 +1；
-    // F1 缺失时 timer1/timer2 都活着，此处为 +2
-    await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS + TICK_INTERVAL_MS)
-    expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(4)
+    // 行为断言（验收口径）：stopScheduler 恰被调一次且命中 runtime1；
+    // F1 缺失时旧 timer 不被停（数组为空或不含 runtime1）
+    expect(stopSchedulerCalls).toEqual([runtimeInstances[0]])
   })
 })

package/src/__tests__/widget-push.test.ts

@@ -1,18 +1,18 @@
 // src/__tests__/widget-push.test.ts
 //
-// scheduler widget 推送修正（D1 指纹跳推 + D2 保活底线帧）集成单测：
+// scheduler widget 推送（D1 指纹跳推）集成单测：
 // 走 index.ts 真实装配链（session_start → runtime.onAfterTick → refreshWidget），
 // 观测面 = ctx.ui.setWidget 调用序列（每个实际推送恰一次调用——跳推判定在
 // setSchedulerWidget 之前，setWidgetDual 的 TUI 分支与清屏分支都落 setWidget）。
 //
-// 行为契约（scheduler widget 推送修正设计 D1-b/D2）：
-// - 任务集指纹不变 → 跳推（时间流逝不是状态变化，静态期零推送——G1）
-// - 保活底线双条件：任务集非空（含 disabled——任务存在即调度意图）且距上次实际推送
-//   ≥10min → 强制推一帧；空任务集不发保活帧（清屏后零帧，会话可被 idle reaper 正常回收——G3）
+// 行为契约（scheduler widget 推送修正设计 D1-b）：
+// - 任务集指纹不变 → 跳推（时间流逝不是状态变化，静态期零推送——G1；跨原保活窗口
+//   时长仍零推送，锁定原 D2 保活底线帧已随 idle reaper 退役不回归）
+// - 空任务集同样静态期零推送（清屏帧只推一次）
 // - fail-open：指纹计算异常即推送（宁可多推不可漏显）+ warn 留痕
 // - locale 入指纹：切语言一次推送自愈（集成臂；kind 字段在 widget.test.ts 纯函数臂锁定）
 //
-// timer 红线：fake timers（vitest useFakeTimers），保活窗口用大步进 advance（fake 无墙钟成本）。
+// timer 红线：fake timers（vitest useFakeTimers），静置用大步进 advance（fake 无墙钟成本）。
 
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
@@ -37,8 +37,8 @@ vi.mock('@zhushanwen/pi-extension-logger', () => ({
 import schedulerExtension from '../index.js'
 import { TICK_INTERVAL_MS } from '../runtime.js'
 import { TASK_ENTRY_TYPE } from '../types.js'
-/** 与 index.ts 的 WIDGET_KEEPALIVE_INTERVAL_MS 同值（10min；常量不导出，测试锚定同值）。 */
-const KEEPALIVE_INTERVAL_MS = 10 * 60 * 1000
+/** 原保活窗口时长（10min；原 D2 已退役）——静态用例静置越过后断言仍零推送。 */
+const RETIRED_KEEPALIVE_WINDOW_MS = 10 * 60 * 1000
 const BASE = Date.parse('2026-01-01T00:00:00Z')
 
 /** 构造一个远期到期的启用任务 upsert entry（owner = sessionFile，避免 fork owner 过滤）。 */
@@ -98,7 +98,7 @@ function createFakeCtx(sessionFile: string, entries: unknown[] = []): {
   return { ctx, setWidget }
 }
 
-describe('widget 推送判定（D1 指纹跳推 + D2 保活底线帧）', () => {
+describe('widget 推送判定（D1 指纹跳推）', () => {
   beforeEach(() => {
     vi.useFakeTimers()
     vi.setSystemTime(BASE)
@@ -109,7 +109,7 @@ describe('widget 推送判定（D1 指纹跳推 + D2 保活底线帧）', () =>
     vi.useRealTimers()
   })
 
-  it('D1: 任务集静态期间零推送（指纹不变跳推），任务集内但有 disabled 同样静态', async () => {
+  it('D1: 任务集静态期间零推送——静置越过原保活窗口仍零推送（D2 退役不回归）', async () => {
     const { pi, events } = createMockPi()
     schedulerExtension(pi)
     const sessionStart = events.get('session_start')!
@@ -117,34 +117,12 @@ describe('widget 推送判定（D1 指纹跳推 + D2 保活底线帧）', () =>
     sessionStart({ type: 'session_start', reason: 'startup' }, ctx)
     expect(setWidget).toHaveBeenCalledTimes(1) // 首帧必推（实例态重置）
 
-    // 静置 9.5min（17 个 tick）：每次 tick 指纹相同、保活未到期 → 零推送
-    await vi.advanceTimersByTimeAsync(17 * TICK_INTERVAL_MS)
+    // 静置越过原保活窗口（10min + 2 个 tick）：指纹相同 → 零推送（无保活底线帧）
+    await vi.advanceTimersByTimeAsync(RETIRED_KEEPALIVE_WINDOW_MS + 2 * TICK_INTERVAL_MS)
     expect(setWidget).toHaveBeenCalledTimes(1)
   })
 
-  it('D2: 非空任务集跨保活窗口 → 强制推一帧，内容与首帧相同（静态面恒定）', async () => {
-    const { pi, events } = createMockPi()
-    schedulerExtension(pi)
-    const sessionStart = events.get('session_start')!
-    const { ctx, setWidget } = createFakeCtx('/test/wp-keepalive.json', [
-      taskEntry('/test/wp-keepalive.json'),
-    ])
-    sessionStart({ type: 'session_start', reason: 'startup' }, ctx)
-    expect(setWidget).toHaveBeenCalledTimes(1)
-    const firstFrame = setWidget.mock.calls[0]![1]
-
-    // 静置越过保活窗口：下一 tick（保活到期后首个 30s 节拍）强制推一帧
-    await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS + TICK_INTERVAL_MS)
-    expect(setWidget).toHaveBeenCalledTimes(2)
-    // 保活帧纯粹为心跳：文本与首帧相同（D1 静态化后显示面不随时间变化）
-    expect(setWidget.mock.calls[1]![1]).toEqual(firstFrame)
-
-    // 第二个保活窗口同样恰好一帧（有界心跳，非恢复 30s 节拍）
-    await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS + TICK_INTERVAL_MS)
-    expect(setWidget).toHaveBeenCalledTimes(3)
-  })
-
-  it('D2: 空任务集不发保活帧（清屏后零帧，会话保持可回收）', async () => {
+  it('D1: 空任务集静态期零推送（清屏帧只推一次）', async () => {
     const { pi, events } = createMockPi()
     schedulerExtension(pi)
     const sessionStart = events.get('session_start')!
@@ -153,28 +131,11 @@ describe('widget 推送判定（D1 指纹跳推 + D2 保活底线帧）', () =>
     expect(setWidget).toHaveBeenCalledTimes(1) // 首帧 = 清屏帧（setWidget(key, undefined)）
     expect(setWidget.mock.calls[0]![1]).toBeUndefined()
 
-    // 静置 30min（远超保活窗口）：无任务 → 无保活帧
+    // 静置 30min：空任务集指纹稳定 → 零推送
     await vi.advanceTimersByTimeAsync(30 * 60 * 1000)
     expect(setWidget).toHaveBeenCalledTimes(1)
   })
 
-  it('D2: 全 disabled 的任务集仍保活（任务存在即调度意图）', async () => {
-    const { pi, events } = createMockPi()
-    schedulerExtension(pi)
-    const sessionStart = events.get('session_start')!
-    const file = '/test/wp-disabled.json'
-    const { ctx, setWidget } = createFakeCtx(file, [taskEntry(file, { enabled: false })])
-    sessionStart({ type: 'session_start', reason: 'startup' }, ctx)
-    expect(setWidget).toHaveBeenCalledTimes(1)
-
-    await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS + TICK_INTERVAL_MS)
-    expect(setWidget).toHaveBeenCalledTimes(2) // disabled 不豁免保活（re-enable 后须可执行）
-    // 用户可见面：保活帧携带完整静态行（计数段在场——TUI 最近任务行只取 enabled 任务，
-    // 全 disabled 时行 = 计数段，这是既有 enabled 过滤行为）
-    const frame = String((setWidget.mock.calls[1]![1] as string[])[0] ?? '')
-    expect(frame).toBe('[scheduler] 0 scheduled')
-  })
-
   it('fail-open: 指纹计算异常 → 该 tick 照常推送 + warn 留痕', async () => {
     const { pi, events } = createMockPi()
     schedulerExtension(pi)

package/src/ack-turn.ts

@@ -11,9 +11,9 @@
 //   ① 建任务成功 ⇒ maybeStartAck：只读检查未落盘 + 空闲 + 可用，注入 custom 触发器
 //      （triggerTurn）；写盘兜底判定收敛在 session 边界；
 //   ② 触发器的 message_start 到达（本轮首次模型请求之前——pi-agent-core
-//      agent-loop.js:51-53 初始 prompt 逐条 emit message_start/message_end 先于
-//      :56 runLoop → :122 streamAssistantResponse 首次模型请求，按 0.84.4 实装核实；
-//      直达链锚 PS-08）⇒ 同步 registerProvider 覆写当前 provider 的 streamSimple；
+//      agent-loop.js 初始 prompt 逐条 emit message_start/message_end 先于
+//      runLoop → streamAssistantResponse 首次模型请求；直达链锚 PS-08，
+//      verifiedWith 以 pi-semantics.json 为准）⇒ 同步 registerProvider 覆写当前 provider 的 streamSimple；
 //   ③ 我们的 streamSimple 被调用 ⇒ 返回 stream 之前同步注销覆写（one-shot 自撤），
 //      本轮内被 steer/followUp drain 出的后续请求与后续轮次全部走真实 provider；
 //   ④ turn_end / session 边界 ⇒ 安全网注销（幂等）。
@@ -344,9 +344,9 @@ export function createAckTurnController(deps: AckTurnDeps): AckTurnController {
 /**
  * 落盘判据①：会话内已有 assistant 消息 ⇒ pi 已 flush，任务必然已落盘。
  *
- * 反向推论承重锚（语义登记 docs/pi-semantics.json PS-14）：pi _appendEntry 先 push 进
- * fileEntries 再同步 _persist（dist/core/session-manager.js:757-762），assistant 在列时
- * hasAssistant 命中即走同步 wx 全量补写分支（:741-752，0.84.4 无异步 flush）——getEntries
+ * 反向推论承重锚（语义登记 docs/pi-semantics.json PS-14，verifiedWith 以该登记为准）：
+ * pi _appendEntry 先 push 进 fileEntries 再同步 _persist，assistant 在列时
+ * hasAssistant 命中即走同步 wx 全量补写分支（0.84.4 无异步 flush）——getEntries
  * 读到 assistant 的时刻磁盘必已含全部内存 entry，无异步窗口。
  *
  * entry 形状来自 replay 的 SchedulerEntryLike（无 role 字段声明），故用 `in` 收窄到

package/src/index.ts

@@ -7,7 +7,6 @@ import { createAckTurnController, type AckTurnController } from './ack-turn.js'
 import { PiSchedulerBackend } from './backend.js'
 import { registerScheduleCommand } from './commands.js'
 import { formatSchedule } from './format.js'
-import { MS_PER_MINUTE } from './parsing.js'
 import { readUiLocale, t } from './i18n.js'
 import { importLegacyStore } from './importer.js'
 import { abortPendingScheduleForms } from './interaction.js'
@@ -40,26 +39,14 @@ import type { ScheduledTask } from './types.js'
 // 绑定，永不再递增 → 其 isCtxStale 恒 false。该盲区由两道既有防线覆盖：pi 在替换前 await
 // fire session_shutdown（F1 stopScheduler 主防线，teardownCurrent）+ runtime 侧
 // STALE_CTX_MARKER 文案兜底（F2 catch 分诊）。
+// 绑定，永不再递增 → 其 isCtxStale 恒 false。该盲区由两道既有防线覆盖：pi 在替换前 await
+// fire session_shutdown（F1 stopScheduler 主防线，teardownCurrent）+ runtime 侧
+// STALE_CTX_MARKER 文案兜底（F2 catch 分诊）。
 let sessionGeneration = 0
 
 /** 包内既有 logger（ack 编排的日志面与其它模块同源）。 */
 const logger = getLogger('scheduler')
 
-/**
- * D2 保活底线帧间隔（10min）：任务集静态期间每 ≥10min 强制推一帧（内容与上一帧相同，
- * 纯粹为维持 rpc-client 入站全帧 touch `_lastActivityAt` 的心跳），防 idle reaper
- * （DEFAULT_PI_RECLAIM_IDLE_MS，生产 2h，5min 一拍、严格大于判定）回收挂有定时任务的
- * 会话——定时任务跨空闲期不停摆（G3）。
- *
- * **方案不变量：保活间隔 ≪ idle 回收阈值，须维持 ≥3 倍余量。** 生产 10min vs 2h = 12 倍；
- * 保活帧实际到达受 tick（TICK_INTERVAL_MS=30s）驱动波动（+0~30s），余量须覆盖 tick 波动
- * 与 reaper 拍相位。未来调整本值、idle 阈值或 tick 间隔任一侧，须重验 ≥3 倍余量并重跑
- * C-场景（真机加速验收的加速值也须 ≥3 倍保活间隔，防零余量竞态随机误回收）。
- */
-/** 保活间隔的分钟数（语义单位，避免裸魔数；乘 MS_PER_MINUTE 得毫秒间隔）。 */
-const WIDGET_KEEPALIVE_MINUTES = 10
-const WIDGET_KEEPALIVE_INTERVAL_MS = WIDGET_KEEPALIVE_MINUTES * MS_PER_MINUTE
-
 /**
  * pi-scheduler extension factory。
  * 注册 schedule + schedule_control 两个 tool、/schedule command、session 事件。
@@ -89,7 +76,6 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
   // 空窗；模块级 vs 闭包级的语义差异在本包有实证（见上方 sessionGeneration 注释）。
   // 生命周期：session_start 装配新会话实例时重置（refreshWidgetState 调用点）。
   let lastWidgetFingerprint: string | null = null
-  let lastWidgetPushedAt = 0
 
   const getService = (): SchedulerService => {
     if (!service) throw new Error('Scheduler not initialized: session not started')
@@ -184,17 +170,17 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     })
 
     // 注册 widget（SDK setWidget 第一重载：直接传 string[]）。初始渲染一次，
-    // 后续随每次 tickScheduler 末尾的 onAfterTick 回调刷新（推送频率由指纹跳推 +
-    // 保活底线帧判定，见 refreshWidget）。
+    // 后续随每次 tickScheduler 末尾的 onAfterTick 回调刷新（推送频率由指纹跳推判定，
+    // 见 refreshWidget）。
     // 新会话实例起点重置推送状态：首帧（含空任务清屏帧）必推，不继承前代指纹/时间戳。
     lastWidgetFingerprint = null
-    lastWidgetPushedAt = 0
     refreshWidget(ctx)
   })
 
   // U6c：树回退（撤回 __taiji_nav__ → navigateTree / 用户树跳转）后重折叠任务集。
   // 注册在 factory 顶层而非 PiSchedulerBackend 构造函数：pi 的 on 是追加语义（loader.js
-  // on 实现 list.push，无去重无 off，0.84.4 实装核对），且 RPC 模式下每次 session 替换
+  // on 实现 list.push，无去重——0.84.4 连 off 都没有，1.0.0 起返回 unsubscribe 但本处
+  // 不消费，handler 生命周期随 factory 代际收敛），且 RPC 模式下每次 session 替换
   // session_start 在同一代内触发两次（agent-session-runtime finishSessionReplacement
   // 内部 rebindSession 一路 + RPC handler 再 rebindSession 一路，均经 bindExtensions
   // emit session_start）——构造函数注册会同代线性累积 handler（残留旧代 backend 在旧
@@ -263,8 +249,9 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
   // 注册 schedule tool（触发反转：直建，不再弹确认表单——人侧表单入口在 /schedule 命令）。
   // execute 内联闭包：从 SDK 全签名 (toolCallId, params, signal, onUpdate, ctx) 提取
   // 转调 handleSchedule 直建流（预校验 → abort 检查 → service.create）。
-  // 错误路径 throw（W4）：pi 只对 execute throw 置 isError:true（返回值里的
-  // isError 被 agent-loop 丢弃）；getService() 未初始化异常穿透到这里，包装
+  // 错误路径 throw（W4）：pi 对 execute throw 置 isError:true（agent-loop.js:581-588；
+  // 1.0.0 起返回值 isError:true 也被尊重，本工具恒走 throw 路径两版语义等价）；
+  // getService() 未初始化异常穿透到这里，包装
   // 'Error: Scheduler not initialized' 格式（R3 格式保持）。
   pi.registerTool({
     name: 'schedule',
@@ -325,14 +312,11 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
    * `ctx as GuiContext`：pi 的 `ExtensionContext` 与协议包最小结构（mode/hasUI/ui.setWidget）
    * 静态不完全兼容，先例见 todo/src/index.ts makeRefreshDisplay。
    *
-   * 推送频率判定（scheduler widget 推送修正设计 D1-b / D2）：
+   * 推送频率判定（scheduler widget 推送修正设计 D1-b；原 D2 保活底线帧随 idle reaper
+   * 退役一并删除——其存在理由唯一指向 reaper 回收防御）：
    * - D1 指纹跳推：任务集稳定指纹（computeTasksFingerprint，字段集含 kind/locale）与上次
-   *   实际推送相同且保活未到期 → 跳过推送。时间流逝不是状态变化，任务集不变期间零推送
+   *   实际推送相同 → 跳过推送。时间流逝不是状态变化，任务集不变期间零推送
    *   （rpc/tui 两模式同效——判定在 setWidgetDual 之前）。
-   * - D2 保活底线帧：有任务（任务集非空，含全部 disabled——任务存在即调度意图，re-enable
-   *   后须可执行）且距上次实际推送超过 WIDGET_KEEPALIVE_INTERVAL_MS → 强制推一帧（内容
-   *   与上帧相同，纯粹为维持心跳防 idle reaper 回收）。空任务集不发保活帧：清屏后任务集
-   *   保持空 → 无帧 → 会话按 idle 规则正常回收（保活与任务存在性绑定）。
    * - fail-open：指纹计算异常即推送（宁可多推不可漏显，设计 §3.1 失败路径）。
    */
   function refreshWidget(ctx: ExtensionContext): void {
@@ -347,22 +331,16 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
       fingerprint = computeTasksFingerprint(tasks, locale)
     } catch (err) {
       // fail-open（辅助显示面的降级 ≠ 吞错）：指纹异常说明序列化路径有 bug，跳推判定不可信
-      // → 直接推送保显示正确；缓存失效（null）使下一帧也必推，保活计时照常刷新。
+      // → 直接推送保显示正确；缓存失效（null）使下一帧也必推。
       logger.warn('widget fingerprint computation failed, pushing anyway', { error: toErrorMessage(err) })
       lastWidgetFingerprint = null
-      lastWidgetPushedAt = Date.now()
       setSchedulerWidget(ctx as GuiContext, tasks)
       return
     }
 
-    const nowMs = Date.now()
-    // D2 双条件：任务存在（含 disabled）+ 距上次实际推送超时。跳推不刷新 lastWidgetPushedAt
-    // ——保活计时只从「实际推送」起算。
-    const keepaliveDue = tasks.length > 0 && nowMs - lastWidgetPushedAt >= WIDGET_KEEPALIVE_INTERVAL_MS
-    if (fingerprint === lastWidgetFingerprint && !keepaliveDue) return
+    if (fingerprint === lastWidgetFingerprint) return
 
     setSchedulerWidget(ctx as GuiContext, tasks)
     lastWidgetFingerprint = fingerprint
-    lastWidgetPushedAt = nowMs
   }
 }

package/src/runtime.ts

@@ -23,22 +23,14 @@ const RATE_LIMIT_PER_MINUTE = 6
 export const TICK_INTERVAL_MS = 30_000
 const DEFAULT_EXPIRY_DAYS = 7
 const DEFAULT_EXPIRY_MS = DEFAULT_EXPIRY_DAYS * MS_PER_DAY // 7 days
-// U4 dispatch 模型切换（设计 D3 修订版 + D1 归属简化）：
+// U4 dispatch 模型切换（设计 D3 修订版 + D1 归属简化 + ADR-0122 事实查询翻转）：
 // - dispatch 注入消息的 customType 标记前缀（sendMessage 的消息标记，供运维从 session 流
 //   识别 scheduler dispatch 注入；与 ack 触发器前缀 pi-scheduler-ack: 避让）
+// - 恢复判定锚点 = isIdle() 同步事实查询（判定层级最高）：agent_settled 确定性事件是
+//   提前触发的加速器（事件到达即查询并兑现）；每 tick 开头对未决记录做一次同步事实
+//   查询兜正确性（事件丢失时由查询收敛——拉保证正确、事件只优化延迟）。原 2-tick
+//   计数对账（时间窗猜测事件丢失）已按 ADR-0122 删除。
 const DISPATCH_CUSTOM_TYPE_PREFIX = 'pi-scheduler:'
-// - 在途标记强制开放的 tick 计数：超过本计数的 tick 数未关闭即视为恢复事件丢失
-// [时间平抑红线登记]（30s tick 周期对账 = 用时间换一致的兜底）：
-//   补偿根因：agent_settled 恢复事件丢失（pi 事件通道无送达保证）时，未决记录无事件通道
-//   复位，会话停留在任务模型上不被切回。
-//   量级/形态：TICK_INTERVAL_MS=30s 周期 tick 对账；in-flight 标记超本计数（2 tick ≈ 60s，
-//   强制开放的最坏恢复延迟 ≈ 3 tick ≈ 90s）未关闭即视为事件丢失、强制开放转移。
-//   恢复路径：reconcileModelSwitch 强制开放 → idle 即 restoreExpectedModel 切回期望模型 /
-//   非 idle 转 awaiting-restore（tick 重入 idle 兑现）；恢复失败落 warn 日志（含
-//   "manual switch back required" 恢复动作）。
-//   重审触发（退役条件）：恢复事件闭环已由 agent_settled 单点达成（D1 归属简化）；待批次 5
-//   W2 通道可观测（事件丢失可报警）落地后，本对账强制开放分支删除（设计 §3.3 D-B4-4）。
-const MODEL_SWITCH_RECONCILE_TICKS = 2
 
 /**
  * 模型控制面（U4 dispatch 模型切换，依赖反转）：runtime 只见 'provider/id' 字符串 ref
@@ -60,24 +52,19 @@ export interface SchedulerModelOps {
 }
 
 /**
- * 未决模型切换记录（模型状态机，纯内存态）。模型语义异常不进持久化词表
+ * 未决模型切换记录（纯内存态）。模型语义异常不进持久化词表
  * （replay 守卫对 advance.status 硬校验 'success'，旁路字段会炸重放推进）。
  *
- * phase 生命周期（D1 归属简化后二态；恢复事件 = agent_settled 单点）：
- * - 'in-flight'：dispatch 受理后等待 run 落定（agent_settled）兑现恢复；ticksOpen 计数超过
- *   MODEL_SWITCH_RECONCILE_TICKS → 恢复事件丢失，tick 对账强制开放
- * - 'awaiting-restore'：settled 到达时非 idle（与用户新 run 交错）/ 对账强制开放时非 idle
- *   的推迟态；比对决策已在窗口内锁定，执行不受窗口过期限制——tick 重入 idle 即兑现
- *   （不设墙钟上界）
- * - 恢复成功 / restore-failed（setModel(原) false）→ 记录清除（终态只留日志）
+ * 生命周期（ADR-0122 事实查询翻转后）：dispatch 受理 → 记录创建（in-flight 等价语义：
+ * 等 run 落定）；恢复兑现锚点 = isIdle() 同步事实查询（agent_settled 事件提前触发 +
+ * tick 每轮查询兜正确性）→ 恢复成功 / restore-failed（setModel(原) false）→ 记录清除
+ * （终态只留日志）。记录存在 + idle 即恢复，无 phase 区分、无时间窗计数。
  */
 interface PendingModelSwitch {
   taskId: string
   /** 会话期望模型（dispatch 切换前抓取的原模型 'provider/id'） */
   expectedModelRef: string
   targetModelRef: string
-  phase: 'in-flight' | 'awaiting-restore'
-  ticksOpen: number
 }
 
 // HISTORY_LIMIT 单点在 types.ts（ext-simplify-08 L5）——与 replay.ts 的 advance 折叠共用
@@ -305,15 +292,15 @@ export class SchedulerRuntime {
   }
 
   async tickScheduler(): Promise<void> {
-    // U4 对账兜底（设计 D3）：严格先于本 tick 的 dispatch 循环。顺序约束：否则出现
-    // 「B dispatch 先切 Y → 对账持 A 旧记录把 Y 静默切回」的交错（Y 从未生效、全序列
-    // 无报错，G4 被绕过）。恢复执行时 await 完成，保证恢复 setModel 完成后 dispatch 循环
-    // 才开 setModel；更广的「任意两个 setModel 不并发」由模型 op 串行队列（modelOpChain）
+    // U4 未决模型切换记录的事实查询结算（严格先于本 tick 的 dispatch 循环）。顺序约束：
+    // 否则出现「B dispatch 先切 Y → 结算持 A 旧记录把 Y 静默切回」的交错（Y 从未生效、
+    // 全序列无报错，G4 被绕过）。恢复执行时 await 完成，保证恢复 setModel 完成后 dispatch
+    // 循环才开 setModel；更广的「任意两个 setModel 不并发」由模型 op 串行队列（modelOpChain）
     // 结构保证——含 agent_settled 恢复 fire-and-forget 挂点，dispatch 模型分支排在其后。
-    // 无未决记录的绝大多数 tick 同步返回、不引入 microtask 断点——dispatch 的同步段
-    // 契约（in-flight 守卫在 tickScheduler() 未 await 时同步可见）保持不变。
-    const reconciling = this.reconcileModelSwitch()
-    if (reconciling) await reconciling
+    // 无未决记录（或非 idle）的绝大多数 tick 同步返回、不引入 microtask 断点——dispatch
+    // 的同步段契约（in-flight 守卫在 tickScheduler() 未 await 时同步可见）保持不变。
+    const settling = this.settlePendingIfIdle('tick-reconcile')
+    if (settling) await settling
 
     const now = this.backend.now()
 
@@ -392,8 +379,8 @@ export class SchedulerRuntime {
    * 按序执行「互斥校验 → setModel(task.model) → 记未决切换记录 → sendMessage」，切换段
    * 整体入模型 op 串行队列（modelOpChain——与恢复 setModel 互斥，MF-2）。busy 亦照常 setModel
    * （P-MODEL-② 证伪「busy 切换不生效」——steer 消息消费时在同一 run 内开新 turn，turn
-   * 开始从 ctx.model 取当前模型，setModel 对 steer turn 生效。pi 实装锚点（0.84.4）：
-   * dist/core/agent-session.js:1258 setModel 同步写 agent.state.model + :304 每个 turn
+   * 开始从 ctx.model 取当前模型，setModel 对 steer turn 生效。pi 实装锚点（1.0.0 复核）：
+   * dist/core/agent-session.js setModel 同步写 agent.state.model + 每个 turn
    * 准备时从 agent.state.model 取模型快照——setModel 先于下一 turn 准备即生效）。
    * 失败降级（分级，不阻塞核心
    * 调度）：modelOps 缺省 / 会话无当前模型 / setModel false → 日志 + 放弃切换，照常 dispatch。
@@ -414,14 +401,14 @@ export class SchedulerRuntime {
       if (this.pendingModelSwitch) {
         // 互斥窗口（设计 D3，理由 = 切换秩序）：未决记录未关闭时，其他需切模型任务命中即
         // skip 本轮 + pending 留待下 tick 重试（复用现状 skip 语义，不建真队列；不需切模型
-        // 的任务不受互斥影响——检查只在本分支）。「dispatch 写新记录前先强制结算旧记录」
-        // 的落地：本分支结构性永不写新记录（杜绝新旧叠写），同时把已过窗口的 in-flight
-        // 残留先强制开放转移，保证新任务在旧记录结算后 ≤1 tick 内接管、不被过期残留无限阻塞。
-        // 强制结算的恢复必须 await（顺序约束，与 tickScheduler 的对账 await 同构）：恢复
+        // 的任务不受互斥影响——检查只在本分支）。「dispatch 写新记录前先结算旧记录」
+        // 的落地：本分支结构性永不写新记录（杜绝新旧叠写），skip 前做一次 isIdle() 事实
+        // 查询结算（idle 即恢复收口），保证新任务不被旧记录无限阻塞。
+        // 结算的恢复必须 await（顺序约束，与 tickScheduler 的结算 await 同构）：恢复
         // setModel(原) 完成后才放行 skip——恢复与紧随的需切模型任务 setModel(目标) 不得
         // 并发（串行由模型 op 队列结构保证，本 await 是调用方顺序语义：skip 放行前恢复
         // 已收口）；本分支随后即 skip，await 无额外延迟代价。
-        await this.forceSettleExpiredInFlight()
+        await this.settlePendingIfIdle('mutex-settle')
         skipped = true
       } else {
         // 模型 op 串行段（MF-2 收口，互斥窗口全程覆盖「setModel 起步 → 记录创建」）：
@@ -459,8 +446,6 @@ export class SchedulerRuntime {
               taskId: task.id,
               expectedModelRef: currentNow,
               targetModelRef,
-              phase: 'in-flight',
-              ticksOpen: 0,
             }
           } else {
             // setModel false（无可用 API key 等）→ 按「恢复失败」同族处理：日志 + 放弃本次
@@ -554,23 +539,23 @@ export class SchedulerRuntime {
     return this.dispatchTimestamps.length < RATE_LIMIT_PER_MINUTE
   }
 
-  // ── 模型切换：agent_settled 恢复与 tick 对账兜底（U4，D3 修订版 + D1 归属简化）──
+  // ── 模型切换：agent_settled 恢复与 tick 事实查询（U4，D3 修订版 + D1 归属简化
+  //    + ADR-0122 事实查询翻转）──
 
   /**
-   * 未决模型切换记录的对账探测（tickScheduler 开头调用，严格先于 dispatch 循环）。
-   * 同步推进状态机，仅在需要执行恢复时返回 Promise（调用方 await——顺序约束）。
-   * 对账守卫前置：仅当存在未决记录才比对恢复——无记录时「模型 ≠ 期望」是用户自主行为，
-   * 不动作（否则用户在任务间隙手动切模型会被静默回滚）。
-   * - in-flight：ticksOpen 计数超 MODEL_SWITCH_RECONCILE_TICKS → agent_settled 恢复事件
-   *   丢失，强制开放：idle 即恢复（返回恢复 Promise）；非 idle 转 awaiting-restore
-   *   （P-MODEL-② 证实 setModel 不影响 in-flight turn，但保守口径维持非 idle 推迟。
-   *   pi 实装锚点（0.84.4）：dist/core/agent-session.js:304 turn 模型在准备时一次性
-   *   快照，setModel 只写 state 不回写已在途 turn 的已快照模型）。
-   *   窗口内继续等事件。
-   * - awaiting-restore：比对决策已在窗口内锁定，执行不受窗口过期限制——idle 重入即兑现
-   *   （tick 为天然重入点，不设墙钟上界：任务级正常路径无墙钟超时）。
+   * 未决模型切换记录的事实查询结算：记录存在 + 会话 idle（isIdle() 同步查询，
+   * 判定层级最高的事实来源）→ 兑现恢复；非 idle → 不动作（不能把在途 run 的模型
+   * 换掉），记录保留等下一查询点。无记录时同步返回 undefined（调用方跳过 await，
+   * 保住 tick 无记录路径的同步契约——dispatch 的 in-flight 守卫在 tickScheduler()
+   * 未 await 时同步可见）。
+   *
+   * 调用点两处：① tickScheduler 开头（严格先于 dispatch 循环——顺序约束：否则
+   * 「B dispatch 先切 Y → 对账持 A 旧记录把 Y 静默切回」；agent_settled 事件丢失时
+   * 本查询点是正确性兜底，事件只作提前触发加速器）；② dispatchTaskInner 互斥分支
+   * （skip 前尽量把旧记录收口，恢复 setModel 与后续新任务的 setModel(目标) 不得并发
+   * ——串行由模型 op 队列结构保证，本 await 是调用方顺序语义）。
    */
-  private reconcileModelSwitch(): Promise<void> | undefined {
+  private settlePendingIfIdle(reason: string): Promise<void> | undefined {
     const ps = this.pendingModelSwitch
     if (!ps) return undefined
     if (this.isCtxStale?.()) {
@@ -580,44 +565,8 @@ export class SchedulerRuntime {
     }
     const ops = this.modelOps
     if (!ops) return undefined
-    if (ps.phase === 'in-flight') {
-      ps.ticksOpen += 1
-      if (ps.ticksOpen <= MODEL_SWITCH_RECONCILE_TICKS) return undefined
-      logger.warn('model switch in-flight mark expired, forcing reconciliation', {
-        taskId: ps.taskId,
-        expectedModelRef: ps.expectedModelRef,
-        targetModelRef: ps.targetModelRef,
-      })
-      if (!ops.isIdle()) {
-        ps.phase = 'awaiting-restore'
-        return undefined
-      }
-      return this.restoreExpectedModel('reconcile-forced')
-    }
     if (!ops.isIdle()) return undefined
-    return this.restoreExpectedModel('reconcile-idle')
-  }
-
-  /**
-   * 互斥命中时对已过窗口的 in-flight 残留做强制开放转移（idle 恢复 / 非 idle 转
-   * awaiting-restore）；未过窗口或已在 awaiting-restore 的记录不动（其结算由事件与
-   * tick 对账通道负责）。
-   *
-   * 返回 Promise 而非 fire-and-forget：idle 恢复路径透传 restoreExpectedModel，调用方
-   * （dispatchTaskInner 互斥分支）必须 await——恢复 setModel(原) 与后续新任务的
-   * setModel(目标) 不得并发（runTaskNow 直连路径下完成顺序不定，恢复后完成则该任务
-   * turn 用错模型；串行由模型 op 队列结构保证，本 await 是调用方顺序语义：skip 放行前
-   * 恢复已收口）；本分支随后即 skip，await 无额外延迟代价。
-   */
-  private forceSettleExpiredInFlight(): Promise<void> {
-    const ps = this.pendingModelSwitch
-    if (!ps || !this.modelOps) return Promise.resolve()
-    if (ps.phase !== 'in-flight' || ps.ticksOpen <= MODEL_SWITCH_RECONCILE_TICKS) return Promise.resolve()
-    if (this.modelOps.isIdle()) {
-      return this.restoreExpectedModel('mutex-forced')
-    }
-    ps.phase = 'awaiting-restore'
-    return Promise.resolve()
+    return this.restoreExpectedModel(reason)
   }
 
   /**
@@ -671,27 +620,22 @@ export class SchedulerRuntime {
   // 不执行恢复）。
 
   /**
-   * agent_settled：模型恢复的唯一事件通道（D1 归属简化，审计裁决「agent_settled + isIdle
-   * 复核拆 turnIndex 状态机」——原 turnIndex 归属：4 状态字段 + 6 事件挂点 + customType
-   * 前缀匹配，绕路自造对 2-tick 对账的依赖）。settled = run 完全落定（无 retry/compaction/
-   * queued continuation；pi 实装 agent-session.js _emitAgentSettled 先置 _isAgentRunActive
-   * = false 再 emit），dispatched turn 必已结束，无需 turnIndex 归属识别——isIdle 复核：
-   * - idle → 兑现恢复（in-flight / awaiting-restore 均结算；恢复延迟从「最长 1 tick（30s）」
-   *   收敛到事件即时）
-   * - 非 idle（settled 与用户新 run 交错）→ 转 awaiting-restore 推迟（不能切：会把新 run
-   *   的模型换掉，P-MODEL-② 同族形态），tick 重入 idle 兑现
+   * agent_settled：模型恢复的事件触发点（D1 归属简化——原 turnIndex 归属：4 状态字段 +
+   * 6 事件挂点 + customType 前缀匹配，绕路自造对 2-tick 对账的依赖）。settled = run
+   * 完全落定（无 retry/compaction/queued continuation；pi 实装 agent-session.js
+   * _emitAgentSettled 先置 _isAgentRunActive = false 再 emit），dispatched turn 必已
+   * 结束，无需 turnIndex 归属识别——事件到达即做 isIdle() 事实查询：
+   * - idle → 兑现恢复（事件是提前触发的加速器，恢复延迟 = 事件即时）
+   * - 非 idle（settled 与用户新 run 交错）→ 不能切：会把新 run 的模型换掉
+   *   （P-MODEL-② 同族形态）。记录保留，由 tick 的 isIdle() 查询在 idle 重入时兑现。
    * 不挂 agent_end 恢复：end 后仍可能有自动续跑 turn，此时切回会把续跑 turn 的模型换掉
-   * （P-MODEL-② 同族形态）——恢复只认 settled。agent_settled 丢失（事件通道无送达保证）
-   * → 30s tick 对账强制开放兜底（见 MODEL_SWITCH_RECONCILE_TICKS 红线登记）。
+   * （P-MODEL-② 同族形态）——恢复只认 settled。
    */
   handleRunSettled(): void {
     if (this.isCtxStale?.()) return
-    const ps = this.pendingModelSwitch
-    if (!ps || !this.modelOps) return
+    if (!this.pendingModelSwitch || !this.modelOps) return
     if (this.modelOps.isIdle()) {
       void this.restoreExpectedModel('agent-settled')
-    } else {
-      ps.phase = 'awaiting-restore'
     }
   }