@zhushanwen/pi-scheduler 0.11.0 → 0.11.1

package/README.md

@@ -208,7 +208,7 @@ pi -p "/schedule 5m 'check build'"
 | 默认过期 | **7 天**（`DEFAULT_EXPIRY_MS`） | recurring 任务缺省 `expires` 时；`expires: 'never'` 关闭 |
 | once 任务 | 触发后自动删除 | 不参与后续调度 |
 | cron 失效 | 任务停用 + `lastStatus=failed` + `lastError='cron expression invalid'` | 不会用 `now()` 兜底导致每 tick 重触发死循环 |
-| 忙时 dispatch | steer 直投（scheduler-steer-direct-dispatch） | busy 时消息插入当前 turn、idle 时开新 turn（`{deliverAs:'steer', triggerTurn:true}`），受理即记账不排队；同任务 in-flight 守卫防双投 |
+| 忙时 dispatch | steer 直投（scheduler-steer-direct-dispatch） | busy 时消息插入当前 turn、idle 时开新 turn（`{deliverAs:'steer', triggerTurn:true}`），受理即记账不排队；同任务 in-flight 检查防双投 |
 | history | 保留最近 **20** 条执行记录 | 超出丢弃最旧；重放折叠时同样裁剪 |
 | 持久化 | custom entry append 到 session JSONL（dispatch 成功后立即 append advance 记录执行） | 任务随 owner session 持久化，resume 后重放恢复，无需额外写盘 |
 | 交付语义 | **at-least-once**（至少一次） | dispatch 成功后内存更新 nextRunAt 并 append advance；append 之前若进程崩溃可能重复注入一次（无精确一次保证，可接受） |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-scheduler",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "type": "module",
   "main": "index.ts",
   "taiji": {
@@ -51,10 +51,10 @@
   },
   "dependencies": {
     "croner": "^9.0.0",
-    "@zhushanwen/extension-protocol": "0.21.0",
+    "@zhushanwen/extension-protocol": "0.23.0",
     "@zhushanwen/pi-ext-guards": "0.5.0",
     "@zhushanwen/pi-extension-logger": "0.6.2",
-    "@zhushanwen/pi-llm-shared": "0.11.3",
+    "@zhushanwen/pi-llm-shared": "0.12.0",
     "@zhushanwen/pi-session-path": "0.1.0"
   },
   "scripts": {

package/skills/scheduler-ext-config/SKILL.md

@@ -35,7 +35,7 @@ description: "使用或排查 @zhushanwen/pi-scheduler（定时任务调度）
 - **`schedule_control`**（管理）：`action` = `list`/`toggle`/`delete`/`run`，`id`（toggle/delete/run 必填），`enabled`（toggle 必填）。
 - 两个工具的返回都是结构化 `{content: [{type:'text', text}], details}`；业务失败以异常抛出（pi 只对 execute throw 置 `isError:true`，错误 message 作为 toolResult content 返回），不通过返回值表达失败。
 
-> 创建/管理操作不受 agent 运行状态约束；**到期 dispatch** 也不等待 agent idle（steer 直投，busy 时插入当前 turn），仅受速率限制/同任务 in-flight 守卫约束（见「运行限制与 dispatch 行为」）。
+> 创建/管理操作不受 agent 运行状态约束；**到期 dispatch** 也不等待 agent idle（steer 直投，busy 时插入当前 turn），仅受速率限制/同任务 in-flight 检查约束（见「运行限制与 dispatch 行为」）。
 
 ### 3. 创建方式（触发反转）
 
@@ -127,7 +127,7 @@ dispatch 行为（`dispatchTask`，scheduler-steer-direct-dispatch 直投模型
 
 - **steer 直投**：到期任务 `backend.sendMessage(..., {deliverAs: 'steer', triggerTurn: true})` 直接投递——agent busy 时消息插入当前 turn（立即被模型看到）、idle 时开新 turn。不排队、不等 idle、不丢弃。
 - **受理即记账**：`sendMessage` 是 fire-and-forget（返回 void），await 立即通过，`nextRunAt` 调用即推进——无「入队未终态」窗口。
-- **同任务 in-flight 守卫**：该任务 dispatch 在途（如 `/schedule run` 与 tick dispatch 并发）时本 tick 跳过，防双投。
+- **同任务 in-flight 检查**：该任务 dispatch 在途（如 `/schedule run` 与 tick dispatch 并发）时本 tick 跳过，防双投。
 - **模型切换**（`task.model` 设定且 ≠ 会话当前模型）：sendMessage 前 `setModel` 切到目标任务模型、记未决切换记录，事件恢复（turn_end + isIdle 复核）后切回原模型；切换失败降级——照常 dispatch（模型字段不阻塞核心调度）。
 - dispatch 成功后：recurring 推进 `nextRunAt` 并 append `advance`；once 删除任务并 append `delete`；失败（`sendMessage` 同步抛错，如 session 关闭）记 `lastStatus='failed'` 不 rethrow，下个 tick 重试（transient 失败重试语义，不 append advance）。
 - 注入的消息：`{content: task.prompt, customType: 'pi-scheduler:dispatched', display: true}`，投递选项 `{deliverAs: 'steer', triggerTurn: true}`。

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

@@ -14,7 +14,7 @@
  *   任务的 setModel 排队等前序模型 op 完成（任意两个 setModel 不并发、双记录不叠写）
  * - tick 事实查询兜正确性（原 2-tick 计数对账已按 ADR-0122 删除）：严格先于同 tick
  *   dispatch 循环；记录存在 + idle 即恢复（agent_settled 丢失时由查询收敛——拉保证
- *   正确、事件只优化延迟）；未决记录守卫（无记录时模型漂移 = 用户自主行为不动作）
+ *   正确、事件只优化延迟）；未决记录检查（无记录时模型漂移 = 用户自主行为不动作）
  * - 降级与接管副作用：setModel false 不阻塞 dispatch；sendMessage 抛错 catch 先恢复；
  *   模型语义异常只走日志（不进持久化词表）
  *
@@ -40,7 +40,7 @@ const ORIG = 'prov-a/model-1'
 const TASK_M = 'prov-b/model-2'
 const OTHER_M = 'prov-c/model-3'
 
-/** 模型控制面 mock：setModelCalls 记录调用序（切换/恢复时序断言的核心观测点） */
+/** 模型控制接口 mock：setModelCalls 记录调用序（切换/恢复时序断言的核心观测点） */
 class ModelOpsMock implements SchedulerModelOps {
   currentRef: string | undefined = ORIG
   idle = true

package/src/__tests__/ack-contract.test.ts

@@ -1,7 +1,7 @@
-// ack 契约面测试（dev-flow u-foundation 单元）。
+// ack 契约范围测试（dev-flow u-foundation 单元）。
 //
-// 本单元只交付「依赖反转契约面」，不含 ack 业务逻辑，故测试只证明三件事：
-//   1. SchedulerBackend 扩面（registerProvider/unregisterProvider/getEntries）后可被纯对象
+// 本单元只交付「依赖反转契约范围」，不含 ack 业务逻辑，故测试只证明三件事：
+//   1. SchedulerBackend 接口扩大（registerProvider/unregisterProvider/getEntries）后可被纯对象
 //      夹具实现（isIdle/getCurrentModel 是 PiSchedulerBackend 类方法、非接口成员）；
 //   2. PiSchedulerBackend 对 pi / ctx 的转发语义（含缺字段兜底）；
 //   3. ack 契约常量/判别值锚定（防后续单元依赖字符串时不发现改动）。
@@ -24,14 +24,14 @@ import {
   type SchedulerProviderOverride,
 } from '../types.js'
 
-// ── 1. 扩面可被纯对象夹具实现（类型闭合）──
+// ── 1. 接口扩大可被纯对象夹具实现（类型完备）──
 
 /**
  * 纯对象夹具：只实现接口成员（sendMessage/appendEntry/getSessionFile/now +
  * registerProvider/unregisterProvider/getEntries）。
  * `satisfies SchedulerBackend` 的**编译期**效力以「测试被 typecheck」为前提——
  * `extensions/tsconfig.json` 的 exclude 覆盖全部测试目录，常态 `extensions:typecheck`
- * 不覆盖本文件（若将来把测试纳入 typecheck，这行才是编译期契约闭合证据）；当前至少保证
+ * 不覆盖本文件（若将来把测试纳入 typecheck，这行才是编译期契约完备证据）；当前至少保证
  * 运行期结构契约。
  */
 function createFixtureBackend(): SchedulerBackend {
@@ -65,8 +65,8 @@ function createFixtureBackend(): SchedulerBackend {
   } satisfies SchedulerBackend
 }
 
-describe('SchedulerBackend ack 扩面（纯对象夹具）', () => {
-  it('夹具实现既有 + 新增全部方法且类型闭合', () => {
+describe('SchedulerBackend ack 接口扩大（纯对象夹具）', () => {
+  it('夹具实现既有 + 新增全部方法且类型完备', () => {
     const backend = createFixtureBackend()
 
     expect(backend.getEntries()).toHaveLength(1)
@@ -83,7 +83,7 @@ describe('SchedulerBackend ack 扩面（纯对象夹具）', () => {
 
 // ── 2. PiSchedulerBackend 转发 / 归一 / 兜底 ──
 
-/** 最小假 pi 的记录面。 */
+/** 最小假 pi 的记录侧。 */
 interface FakePi {
   pi: Pick<
     ExtensionAPI,
@@ -118,7 +118,7 @@ function createFakePi(): FakePi {
   }
 }
 
-describe('PiSchedulerBackend ack 扩面转发', () => {
+describe('PiSchedulerBackend ack 接口扩大转发', () => {
   it('registerProvider 转发 pi 并零转换透传 (providerId, config)', () => {
     const { pi, providerCalls } = createFakePi()
     const ctx: SchedulerBackendCtx = {
@@ -230,7 +230,7 @@ describe('ack 契约常量与类型', () => {
     expect<AckAvailability>({ available: true }).toEqual({ available: true })
 
     // 可通知形态只有两种：其余 E 形态（e1/e2/e4/e5/e6/e8b）不发用户通知——真实轮已
-    // 应答或与落盘无关，提示即反向撒谎（设计 §3.4）；它们在日志面用字符串标签。
+    // 应答或与落盘无关，提示即反向撒谎（设计 §3.4）；它们在日志侧用字符串标签。
     const notifyReasons: AckNotifyReason[] = ['e3-no-turn', 'e8-no-base']
     expect(notifyReasons).toHaveLength(2)
 

package/src/__tests__/ack-provider.test.ts

@@ -1,6 +1,6 @@
 // ack 合成流 + 可用性判据测试（dev-flow u-ack-provider 单元）。
 //
-// 本单元只交付三件事的纯函数面：
+// 本单元只交付三件事的纯函数部分：
 //   1. buildAckStreamSimple —— 零 token 合成流（字段 = 会话真实模型 / usage 全 0 /
 //      aborted 走 error 终止 / onCalled 返回前同步自撤）；
 //   2. computeAckAvailability —— 预计算 + fail-closed 的可用性判据（内置含 radius）；

package/src/__tests__/ack-turn.test.ts

@@ -322,11 +322,11 @@ it('session 边界：未启动 ack 轮且文件不存在 ⇒ 补发通知；ack
   expect(b.notifyCalls).toHaveLength(0)
 })
 
-it('E3 后同会话再次创建可重试（无定时器清 pending，守卫只认 window）', async () => {
+it('E3 后同会话再次创建可重试（无定时器清 pending，检查只认 window）', async () => {
   const h = makeHarness({ builtinIds: new Set(['anthropic']) })
   await startAck(h.controller)
   expect(h.captured.sent).toHaveLength(1)
-  // 触发器未启动轮次 ⇒ window 从未置位 ⇒ 守卫不挡，下一次创建重新注入。
+  // 触发器未启动轮次 ⇒ window 从未置位 ⇒ 检查不挡，下一次创建重新注入。
   await h.controller.maybeStartAck({
     task: { ...TASK, id: 't2' },
     model: MODEL,
@@ -399,9 +399,9 @@ it('E3 后同会话再次创建可重试（无定时器清 pending，守卫只
   })
 })
 
-// ── 回归用例（一致性审查 F2/F3 + 去定时器后的守卫语义）──
+// ── 回归用例（一致性审查 F2/F3 + 去定时器后的检查语义）──
 
-describe('ack-turn 守卫与归因回归', () => {
+describe('ack-turn 检查与归因回归', () => {
   beforeEach(() => {
     vi.useFakeTimers()
     resetAckState()

package/src/__tests__/active-path.test.ts

@@ -79,9 +79,9 @@ function makeCtx(initialEntries: BranchEntry[], initialLeafId: string | null) {
   }
 }
 
-/** 捕获 pi.on 注册的 handler + 副作用记录面（sendMessage / appendEntry vi.fn）。
- * on 字段仅满足 ExtensionAPI 结构完整性：session_tree 注册面已迁至 factory 顶层
- * （index.ts），backend 构造不再调 pi.on（注册面契约见 session-tree-registration.test.ts）。 */
+/** 捕获 pi.on 注册的 handler + 副作用记录侧（sendMessage / appendEntry vi.fn）。
+ * on 字段仅满足 ExtensionAPI 结构完整性：session_tree 注册点已迁至 factory 顶层
+ * （index.ts），backend 构造不再调 pi.on（注册点契约见 session-tree-registration.test.ts）。 */
 function makePi() {
   const handlers = new Map<string, (...args: unknown[]) => unknown>()
   const sendMessage = vi.fn(async () => {})
@@ -201,7 +201,7 @@ describe('session_tree 重折叠（U6c）', () => {
     expect(runtime.getTask('t2')).toBeDefined()
 
     // 撤回：树回退（label 锚落尾 + leafId 指向它）→ session_tree 事件 → 重折叠
-    // （生产注册面在 factory 顶层 index.ts，此处直接驱动委托体）
+    // （生产注册点在 factory 顶层 index.ts，此处直接驱动委托体）
     setTree([...preRevoke, labelEntry('L', 'e1')], 'L')
     backend.refoldSessionTree()
 

package/src/__tests__/create-form-component.test.ts

@@ -394,7 +394,7 @@ describe('ScheduleCreateComponent — Submit 确认门与回传', () => {
 		})
 	})
 
-	it('S-5: 终态后继续按键 no-op（resolved 守卫）', () => {
+	it('S-5: 终态后继续按键 no-op（resolved 检查）', () => {
 		const { c, result } = make()
 		fillRecurringToSubmit(c)
 		c.handleInput(ENTER)

package/src/__tests__/importer.test.ts

@@ -243,7 +243,7 @@ describe('importLegacyStore', () => {
     expect(fs.unlinkSync).not.toHaveBeenCalled()
   })
 
-  // ── TC8b：cleanup 幂等 + unlink ENOENT 守卫（MF-2，R2 修复）──
+  // ── TC8b：cleanup 幂等 + unlink ENOENT 检查（MF-2，R2 修复）──
   it('TC8b: cleanup 幂等（已删后 no-op）+ unlink 仅静默 ENOENT，其他 fs 错误向上抛', () => {
     const taskA = makeTask({ id: 'ffff' })
     vi.mocked(fs.readFileSync).mockReturnValue(

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

@@ -39,7 +39,7 @@ vi.mock('@zhushanwen/pi-extension-logger', () => ({
 vi.mock('../importer.js', () => ({ importLegacyStore: vi.fn(() => vi.fn()) }))
 
 // u-p2b 接线断言：index.ts 的 refreshWidget 必须走结构化/双模入口 `setSchedulerWidget`
-// （取代旧 `renderSchedulerWidget` TUI 单形态）——mock 捕获调用面（任务数组直传）。
+// （取代旧 `renderSchedulerWidget` TUI 单形态）——mock 捕获调用（任务数组直传）。
 const { setSchedulerWidgetMock } = vi.hoisted(() => ({ setSchedulerWidgetMock: vi.fn() }))
 vi.mock('../widget.js', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../widget.js')>()
@@ -55,7 +55,7 @@ const { isCtxStaleCaptures, runtimeInstances, stopSchedulerCalls } = vi.hoisted(
 
 // InstrumentedRuntime 继承真实实现（loadTasks/onAfterTick/startScheduler 均真实执行），
 // 仅捕获构造参（isCtxStale）并登记实例（afterEach 统一停 timer，避免真实 setInterval 残留）；
-// stopScheduler 调用按序记录（F1 验收断言面：新装配前旧实例必须被停）。
+// stopScheduler 调用按序记录（F1 验收断言范围：新装配前旧实例必须被停）。
 vi.mock('../runtime.js', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../runtime.js')>()
   const RealSchedulerRuntime = actual.SchedulerRuntime
@@ -210,7 +210,7 @@ describe('G1: index.ts 代际接线（S9）', () => {
 // 下一 tick 的 refreshWidget 访问 stale ctx.ui 抛错 → unhandledRejection → pi 主进程 exit 1。
 // F1 在 session_start 开头幂等 stopScheduler，从源头消灭。
 //
-// 行为断言口径（验收 U4）：观测面 = InstrumentedRuntime 的 stopScheduler 调用序列
+// 行为断言口径（验收 U4）：观测范围 = InstrumentedRuntime 的 stopScheduler 调用序列
 // （widget 推送是 D1 指纹跳推语义——任务集静态期间零推送，不能靠推送计数区分新旧 timer；
 // stopScheduler 白盒断言直接锁定「新装配前旧实例必须被停」的 F1 语义本身）。
 describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
@@ -294,7 +294,7 @@ describe('F1: session_start 停旧 runtime（crash-fix U4）', () => {
     expect(setSchedulerWidgetMock).toHaveBeenCalledTimes(2) // runtime2 初始渲染（实例态重置，首帧必推）
     expect(runtimeInstances).toHaveLength(2)
 
-    // 行为断言（验收口径）：stopScheduler 恰被调一次且命中 runtime1；
+    // 行为断言（验收标准）：stopScheduler 恰被调一次且命中 runtime1；
     // F1 缺失时旧 timer 不被停（数组为空或不含 runtime1）
     expect(stopSchedulerCalls).toEqual([runtimeInstances[0]])
   })

package/src/__tests__/mock-backend.ts

@@ -2,7 +2,7 @@ import type { SchedulerBackend, SchedulerProviderOverride } from '../backend.js'
 import { replayFoldEntries, type SchedulerEntryLike } from '../replay.js'
 import type { ScheduledTask, SchedulerEntryOp } from '../types.js'
 
-// 测试专用 mock（ext-simplify-08 L9：从 backend.ts 迁出——导出面即测试面的收敛，
+// 测试专用 mock（ext-simplify-08 L9：从 backend.ts 迁出——导出范围即测试范围的收敛，
 // 生产模块不再携带测试脚手架；MockSchedulerBackend/SentMessage 零生产引用）。
 
 export interface SentMessage {

package/src/__tests__/replay.test.ts

@@ -263,7 +263,7 @@ describe('replayFoldEntries', () => {
     expect(a.nextRunAt).toBe(100) // 保持 upsert 快照值
   })
 
-  // ── MF-2：守卫按变体校验必填字段——损坏 entry 只跳过该条，不清空全部任务 ──
+  // ── MF-2：检查按变体校验必填字段——损坏 entry 只跳过该条，不清空全部任务 ──
   it('MF-2: op 合法但缺必填字段的损坏 entry 被跳过，其余任务保留', () => {
     const session = '/s.json'
     loggerMock.warn.mockClear()

package/src/__tests__/runtime.test.ts

@@ -138,14 +138,14 @@ describe('SchedulerRuntime', () => {
     })
   })
 
-  // ── R3-S1：dispatchTask in-flight 守卫 ──
+  // ── R3-S1：dispatchTask in-flight 检查 ──
   // tick 为 fire-and-forget：tick1 的 await sendMessage 挂起超过 TICK_INTERVAL_MS（如 pi
   // 卡死）时，tick2 的 step2 再标 pending → step3 对同一 task 并发第二个 dispatch → 同一
-  // prompt 双注入。守卫：同任务在途（Set<taskId>）
+  // prompt 双注入。检查：同任务在途（Set<taskId>）
   // 时 skip 本轮并 warn；不同任务不受影响。
   // 末两条为调用方 API 层验收：不经 tick，直接并发/串行调 dispatchTask，
-  // 验证守卫在调用方入口同样拦截（warn + 第二次 false）与完成后放行。
-  describe('dispatchTask in-flight 守卫（R3-S1）', () => {
+  // 验证检查在调用方入口同样拦截（warn + 第二次 false）与完成后放行。
+  describe('dispatchTask in-flight 检查（R3-S1）', () => {
     beforeEach(() => {
       vi.useFakeTimers()
       vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
@@ -170,7 +170,7 @@ describe('SchedulerRuntime', () => {
       expect(task.pending).toBe(true) // dispatch 未完成，pending 未清
 
       // tick2（模拟 30s 后 pi 仍卡死）：同任务再标 pending → step3 dispatchTask 命中
-      // in-flight 守卫 → skip + warn（修复前：同一 prompt 双注入）
+      // in-flight 检查 → skip + warn（修复前：同一 prompt 双注入）
       await runtime.tickScheduler()
       expect(backend.sendMessage).toHaveBeenCalledTimes(1)
       const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
@@ -198,8 +198,8 @@ describe('SchedulerRuntime', () => {
       const tick1 = runtime.tickScheduler()
       expect(backend.sendMessage).toHaveBeenCalledTimes(1)
 
-      // tick2：task1 命中守卫跳过，task2 无在途 → 正常 dispatch（守卫按 taskId 粒度隔离）。
-      // 注：tick2 挂起在 task1 的 await dispatchTask（守卫命中即 resolved promise）与 task2
+      // tick2：task1 命中检查跳过，task2 无在途 → 正常 dispatch（检查按 taskId 粒度隔离）。
+      // 注：tick2 挂起在 task1 的 await dispatchTask（检查命中即 resolved promise）与 task2
       // 的 await sendMessage 上，先放行再 await，完成态统一断言
       const tick2 = runtime.tickScheduler()
       resolveSend!()
@@ -210,7 +210,7 @@ describe('SchedulerRuntime', () => {
     })
 
     // ── 调用方 API 层 ──
-    it('调用方守卫：同一 taskId 并发 dispatchTask → 第二次被拦截（send 只调 1 次 + warn）', async () => {
+    it('调用方检查：同一 taskId 并发 dispatchTask → 第二次被拦截（send 只调 1 次 + warn）', async () => {
       loggerMock.warn.mockClear()
       // 可控延迟的 sendMessage：让第一次 dispatch 挂起
       let resolveSend: (() => void) | undefined
@@ -239,7 +239,7 @@ describe('SchedulerRuntime', () => {
       await first
     })
 
-    it('调用方守卫：第一次完成后 → 第二次 dispatchTask 正常执行（send 调 2 次）', async () => {
+    it('调用方检查：第一次完成后 → 第二次 dispatchTask 正常执行（send 调 2 次）', async () => {
       const task = await runtime.addTask('serial-inflight', { mode: 'interval', intervalMs: 60_000 })
 
       // 第一次 dispatch（串行等待完成）

package/src/__tests__/sdk-contract.test.ts

@@ -5,9 +5,10 @@
 //   1. tool 注册名为 schedule / schedule_control
 //   2. tool 有 execute 函数字段（不是 handler/fn）
 //   3. execute 是 async function（SDK 期望返回 Promise）
-//   4. 错误路径 throw（W4：pi-agent-core 只对 execute throw 置 isError:true，
-//      返回值里的 isError 字段被 agent-loop 丢弃——错误轮曾被标成功；
-//      锚点 agent-loop.js:453-483/525-547）
+//   4. 错误路径 throw（W4：execute throw → pi-agent-core agent-loop catch 置 isError:true
+//      ——pi-agent-core dist/agent-loop.js executePreparedToolCall，1.0.0 实读 catch :581-588；
+//      1.0.0 起正常 return 的 isError 也被尊重——:579 isError: result.isError === true，
+//      0.84.4 才硬编码 false、return 的错误轮曾被标成功——本包失败恒走 throw，行为不变）
 //
 // 不导入 SchedulerRuntime 的内部：只通过 index.ts 的 default export 测，
 // 保证 tool 注册逻辑的入口契约。
@@ -203,7 +204,7 @@ describe('pi-scheduler SDK contract', () => {
     const cleanup = vi.mocked(importLegacyStore).mock.results[0]!.value
     expect(typeof cleanup).toBe('function')
 
-    // turn_end（首个 turn 完成，flush 已发生）→ cleanup 被调用——跨 session 双导入窗口闭合点
+    // turn_end（首个 turn 完成，flush 已发生）→ cleanup 被调用——跨 session 双导入窗口封住点
     await events.get('turn_end')!()
     expect(cleanup).toHaveBeenCalledTimes(1)
 

package/src/__tests__/service.test.ts

@@ -315,7 +315,7 @@ describe('SchedulerService', () => {
       if (result.params === undefined || !('tasks' in result.params)) throw new Error('expected list params')
       const line = renderResult('task.list', result.params, 'zh-CN').split('\n')[1]!
       expect(line).toContain('上次: 失败×2')
-      // 命令变体保留相对时间（设计 D1-a：命令层按需呈现面不变）
+      // 命令变体保留相对时间（设计 D1-a：命令层按需呈现侧不变）
       expect(line).toMatch(/分钟后|分钟前|\d+m ago|in \d+m/)
       // params 携带 locale-neutral 原始值（摘要不预渲染）
       expect(result.params.tasks[0]!.lastExec).toEqual({ lastStatus: 'failed', recentFailures: 2 })

package/src/__tests__/session-tree-registration.test.ts

@@ -1,6 +1,6 @@
 // src/__tests__/session-tree-registration.test.ts
 //
-// U6c session_tree 注册面契约：注册在 extension factory 顶层（每代恰一 handler），
+// U6c session_tree 注册点契约：注册在 extension factory 顶层（每代恰一 handler），
 // 同代 session_start 复发不累积。回归背景：注册曾在 PiSchedulerBackend 构造函数内，
 // 而 pi RPC 模式下每次 session 替换 session_start 在同一代内触发两次
 // （agent-session-runtime finishSessionReplacement 内部 rebindSession + RPC handler
@@ -79,7 +79,7 @@ function taskEntry(sessionFile: string, taskId: string) {
   }
 }
 
-/** fake ctx：entries 经容器可变（模拟撤回前后 swap）；ui.setWidget 观测面。 */
+/** fake ctx：entries 经容器可变（模拟撤回前后 swap）；ui.setWidget 观测范围。 */
 function createFakeCtx(sessionFile: string, entriesBox: { entries: unknown[] }): ExtensionContext {
   return {
     cwd: '/test-tree-reg',
@@ -93,7 +93,7 @@ function createFakeCtx(sessionFile: string, entriesBox: { entries: unknown[] }):
   } as unknown as ExtensionContext
 }
 
-describe('session_tree 注册面（factory 顶层恰一，同代 session_start 复发不累积）', () => {
+describe('session_tree 注册点（factory 顶层恰一，同代 session_start 复发不累积）', () => {
   it('factory 运行恰注册 1 个 session_tree handler', () => {
     const { pi, handlers } = createAppendPi()
     schedulerExtension(pi)

package/src/__tests__/types.test.ts

@@ -4,7 +4,7 @@ import { snapshotToTask, toTaskSnapshot } from '../types.js'
 import type { ScheduledTask, TaskSnapshot } from '../types.js'
 
 /**
- * B2 转换器收敛（ext-simplify-17）等价守卫：toTaskSnapshot canonical 取解构式，
+ * B2 转换器收敛（ext-simplify-17）等价检查：toTaskSnapshot canonical 取解构式，
  * 替换 importer 旧显式 14 字段式——期望值按旧显式式的输出形状逐字段锚定
  * （toEqual 严格比较键集合，解构式多带/漏带键即红），防字段演进中静默漂移。
  * 既有间接断言（importer/runtime 测试的 objectContaining）不覆盖键集合精确性与

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

@@ -2,7 +2,7 @@
 //
 // scheduler widget 推送（D1 指纹跳推）集成单测：
 // 走 index.ts 真实装配链（session_start → runtime.onAfterTick → refreshWidget），
-// 观测面 = ctx.ui.setWidget 调用序列（每个实际推送恰一次调用——跳推判定在
+// 观测范围 = ctx.ui.setWidget 调用序列（每个实际推送恰一次调用——跳推判定在
 // setSchedulerWidget 之前，setWidgetDual 的 TUI 分支与清屏分支都落 setWidget）。
 //
 // 行为契约（scheduler widget 推送修正设计 D1-b）：
@@ -79,7 +79,7 @@ function createMockPi(): { pi: ExtensionAPI; events: Map<string, (...args: unkno
   return { pi, events }
 }
 
-/** fake ctx：entries 注入任务（owner = sessionFile）；setWidget 独立导出作观测面。 */
+/** fake ctx：entries 注入任务（owner = sessionFile）；setWidget 独立导出作观测范围。 */
 function createFakeCtx(sessionFile: string, entries: unknown[] = []): {
   ctx: ExtensionContext
   setWidget: ReturnType<typeof vi.fn>
@@ -153,7 +153,7 @@ describe('widget 推送判定（D1 指纹跳推）', () => {
     stringifySpy.mockRestore()
 
     expect(setWidget).toHaveBeenCalledTimes(2) // fail-open：宁可多推不可漏显
-    // 用户可见面：fail-open 推出的帧内容正确（静态行完整，非空帧/异常串）
+    // 用户可见部分：fail-open 推出的帧内容正确（静态行完整，非空帧/异常串）
     const frame = String((setWidget.mock.calls[1]![1] as string[])[0] ?? '')
     expect(frame).toContain('keepalive probe')
     const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')

package/src/__tests__/widget.test.ts

@@ -26,7 +26,7 @@ const makeTask = (overrides: Partial<ScheduledTask> = {}): ScheduledTask => ({
   ...overrides,
 })
 
-describe('renderSchedulerWidgetTui（D1 静态面契约）', () => {
+describe('renderSchedulerWidgetTui（D1 静态范围契约）', () => {
   it('returns empty array when no tasks', () => {
     expect(renderSchedulerWidgetTui([], 'en-US')).toEqual([])
   })
@@ -37,7 +37,7 @@ describe('renderSchedulerWidgetTui（D1 静态面契约）', () => {
     expect(result[0]).toContain('2 scheduled')
   })
 
-  // 静态面：最近任务行 = 任务名 + 静态调度描述（formatSchedule），无相对时间
+  // 静态范围：最近任务行 = 任务名 + 静态调度描述（formatSchedule），无相对时间
   it('renders nearest task with static schedule description, no relative time', () => {
     const tasks = [makeTask({ name: 'check build' })]
     const result = renderSchedulerWidgetTui(tasks, 'en-US')
@@ -48,7 +48,7 @@ describe('renderSchedulerWidgetTui（D1 静态面契约）', () => {
     expect(result[0]).not.toContain('now')
   })
 
-  // 逾期标记整体移除：nextRunAt 在过去也不产生 [!] 段（now 派生显示不进静态面）
+  // 逾期标记整体移除：nextRunAt 在过去也不产生 [!] 段（now 派生显示不进静态范围）
   it('omits overdue marker even when nextRunAt is in the past', () => {
     const tasks = [makeTask({ nextRunAt: Date.now() - 1000 })]
     const result = renderSchedulerWidgetTui(tasks, 'en-US')
@@ -120,7 +120,7 @@ describe('renderSchedulerWidgetTui（D1 静态面契约）', () => {
   })
 })
 
-describe('buildSchedulerWidgetGui（D1 静态面契约）', () => {
+describe('buildSchedulerWidgetGui（D1 静态范围契约）', () => {
   it('emits structured meta with self-owned localized title (en-US)', () => {
     const tasks = [makeTask(), makeTask({ id: 'def67890', name: 'another' })]
     const gui = buildSchedulerWidgetGui(tasks, 'en-US')
@@ -219,7 +219,7 @@ describe('setSchedulerWidget', () => {
 
 // ── D1-b 任务集指纹（computeTasksFingerprint 纯函数契约）──
 // 维护不变量：指纹字段集 ⊇ widget 显示决定因素全集（scheduler widget 推送修正设计 D1-b）。
-// 显示面 = f(id, name, schedule, kind, enabled, nextRunAt, locale)——以下用例逐字段锁定：
+// 显示侧 = f(id, name, schedule, kind, enabled, nextRunAt, locale)——以下用例逐字段锁定：
 // 变更任一显示决定因素必变指纹，字段不变必同指纹。
 
 describe('computeTasksFingerprint（字段集契约）', () => {
@@ -259,13 +259,17 @@ describe('computeTasksFingerprint（字段集契约）', () => {
 
   it('non-display runtime state does NOT alter the fingerprint', () => {
     // runCount/history/lastStatus/pending 不在指纹字段集（非显示决定因素——执行摘要只进
-    // 命令查询面）。它们变化不触发推送，否则静态期零推送承诺被破坏。
-    const base = makeTask()
+    // 命令查询结果）。它们变化不触发推送，否则静态期零推送承诺被破坏。
+    // nextRunAt 显式固定（nextRunAt 在指纹字段集内）：makeTask 缺省 Date.now() 两次调用
+    // 跨毫秒边界时差 1ms → 指纹不同 → 断言测到时钟而非字段集（coverage-gate 实测实例）。
+    const now = Date.now()
+    const base = makeTask({ nextRunAt: now })
     const busy = makeTask({
       runCount: 7,
       history: [{ at: base.createdAt, status: 'failed' }],
       lastStatus: 'failed',
       pending: true,
+      nextRunAt: now,
     })
     expect(computeTasksFingerprint([base], 'en-US')).toBe(computeTasksFingerprint([busy], 'en-US'))
   })

package/src/ack-notify.ts

@@ -12,7 +12,7 @@
 // （`notify-toast.ts` 对非前台 session 的 info 不弹窗），用 `info` 等于静默撒谎。
 //
 // 反向撒谎禁令：e1/e2/e4/e5（真实模型已应答 ⇒ 任务其实已落盘）与 e8b（hybrid ⇒ 覆写照常
-// 发生）一律不发「未写入」文案；e6（注销失败）与落盘无关，只在日志面登记。这些形态在
+// 发生）一律不发「未写入」文案；e6（注销失败）与落盘无关，只在日志侧登记。这些形态在
 // 类型层就不可传入通知路径（`AckNotifyReason` 只含两种可通知形态）。
 
 /**

package/src/ack-provider.ts

@@ -228,7 +228,7 @@ export async function computeAckAvailability(deps: AckAvailabilityDeps): Promise
   }
 }
 
-// ── 小守卫（禁 any / 免断言）──
+// ── 小检查（禁 any / 免断言）──
 
 /** 是否为带 `code` 的 Node errno 异常（ENOENT 判别用）。 */
 function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
@@ -240,7 +240,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-/** 错误类型最小投影（name + 可选 code）——只取可安全入日志的字段。 */
+/** 错误类型最小派生视图（name + 可选 code）——只取可安全入日志的字段。 */
 function describeError(err: unknown): { name: string; code?: string } {
   if (err instanceof Error) {
     const code = isErrnoException(err) ? err.code : undefined

package/src/ack-turn.ts

@@ -78,7 +78,7 @@ export const ackState: AckState = getOrCreateAckState()
 /** 通知去重（模块级；resetAckState 全清——跨会话隔离）。 */
 const notifyDedup = createAckNotifyDedup()
 
-/** 编排依赖（注入面；backend 为 per-session 实例，状态经模块级单例跨代共享）。 */
+/** 编排依赖（注入点；backend 为 per-session 实例，状态经模块级单例跨代共享）。 */
 export interface AckTurnDeps {
   backend: SchedulerBackend
   log: {

package/src/backend.ts

@@ -72,7 +72,7 @@ export interface SchedulerBackend {
    */
   getEntries(): SchedulerEntryLike[]
   /**
-   * U6c：session_tree（树回退）重折叠订阅。生产注册面在 extension factory 顶层
+   * U6c：session_tree（树回退）重折叠订阅。生产注册点在 extension factory 顶层
    * （index.ts：pi.on('session_tree') 每代恰一，事件经 activeBackend 委托
    * PiSchedulerBackend.refoldSessionTree），事件到达时按活跃路径重折叠任务集并回调
    * listener——落点是 SchedulerRuntime 的内存任务 Map（runtime 构造时订阅，backend
@@ -107,7 +107,7 @@ export interface SchedulerBackendCtx {
    */
   isIdle?(): boolean
   /**
-   * 会话当前模型（真实 ExtensionContext.model: Model<any> | undefined，结构兼容此处最小投影）。
+   * 会话当前模型（真实 ExtensionContext.model: Model<any> | undefined，结构兼容此处最小派生视图）。
    * 可选 = 无模型会话（ExtensionContext.model 本身可为 undefined）。
    */
   model?: SchedulerCurrentModel
@@ -156,7 +156,7 @@ export class PiSchedulerBackend implements SchedulerBackend {
 
   /**
    * U6c：session_tree（树回退）事件委托体，由 extension factory 顶层注册的 handler
-   * 经 activeBackend 调用（index.ts；不在本类构造函数注册，注册面理由见该处注释）。
+   * 经 activeBackend 调用（index.ts；不在本类构造函数注册，注册点理由见该处注释）。
    * 纯重建体：只按活跃路径重折叠任务集（loadTasks）并回调 runtime 换 Map——不做
    * 任何 sendMessage / appendEntry / tickTimer 启停（tick 常驻循环照常消费新任务集，
    * 被撤子树任务不在集内即到点不触发，A14）。
@@ -215,14 +215,14 @@ export class PiSchedulerBackend implements SchedulerBackend {
    *
    * ctx.isIdle 缺失（最小 duck ctx）时保守返回 false（视作「有轮在跑」）：ack 机制的
    * fail-safe 方向是「不确定则不介入」——运行中的轮次会自然产出 assistant 消息、打开会话
-   * 落盘闸门（设计 §3.3 D4 / G4），而未知状态下注入合成轮反而可能吞掉用户消息。
+   * 落盘门禁（设计 §3.3 D4 / G4），而未知状态下注入合成轮反而可能吞掉用户消息。
    */
   isIdle(): boolean {
     return this.ctx.isIdle ? this.ctx.isIdle() : false
   }
 
   /**
-   * 会话当前模型的最小投影（**类方法，非接口成员**，理由同 isIdle）；ctx.model 缺失/
+   * 会话当前模型的最小派生视图（**类方法，非接口成员**，理由同 isIdle）；ctx.model 缺失/
    * undefined（无模型会话）时返回 undefined。
    */
   getCurrentModel(): SchedulerCurrentModel | undefined {

package/src/create-form-component.ts

@@ -991,7 +991,7 @@ export class ScheduleCreateComponent implements Component {
 		this.done(result)
 	}
 
-	/** 取消。public 供 signal abort 监听复用 resolved 守卫（abort 晚于用户操作时防二次 done）。 */
+	/** 取消。public 供 signal abort 监听复用 resolved 检查（abort 晚于用户操作时防二次 done）。 */
 	cancel(): void {
 		if (this.resolved) return
 		this.resolved = true

package/src/format.ts

@@ -1,6 +1,6 @@
 // 时间格式化器（r4 M1 locale 版）：formatSchedule / formatRelativeTime 是 locale 必填的
 // 本地实现（UiLocale 双语输出，i18n.ts / widget / service / commands 消费）；fix 轨 locale
-// 化与 U2 protocol 下沉（无 locale 面，服务 taiji plugin 管理面）暂双轨并存，收敛待后续
+// 化与 U2 protocol 下沉（无 locale 面，服务 taiji plugin 管理侧）暂双轨并存，收敛待后续
 // 把 locale 版提升进 @zhushanwen/extension-protocol。formatDuration / MS_PER_* 单源
 // @zhushanwen/extension-protocol（re-export 保持既有 import 路径）。
 import { formatDuration, MS_PER_DAY, MS_PER_HOUR, MS_PER_MINUTE, MS_PER_SECOND } from './parsing.js'

package/src/i18n.ts

@@ -19,12 +19,12 @@ export { readUiLocale }
  * - `t(key, params)`：单条词典模板
  * - `renderResult(messageKey, params, locale)`：toast / 命令反馈（12+ 条命令反馈）
  * - `renderTaskLine(taskParams, locale)`：**命令变体**任务行（状态●/○ + id + name + 摘要 +
- *   相对时间 + 执行状态摘要），调用面 = list 行 / toast 内部组合，`renderResult` 内部复用、
+ *   相对时间 + 执行状态摘要），调用点 = list 行 / toast 内部组合，`renderResult` 内部复用、
  *   不重实现
  * - `renderTaskLineStatic(taskParams, locale)`：**widget 静态变体**（状态●/○ + id + name +
  *   静态调度描述，无任何 now 派生段），仅供 widget GUI body——两变体拆分是 scheduler
- *   widget 推送修正设计 D1-a 的渲染单点裁决：命令层是按需呈现面（保留相对时间），widget
- *   显示面静态化是指纹跳推的前置
+ *   widget 推送修正设计 D1-a 的渲染单点裁决：命令层是按需呈现侧（保留相对时间），widget
+ *   显示侧静态化是指纹跳推的前置
  *
  * L4（模型可见的 tool result）**不**经本模块——`service.ts` 的 `message` 字段保留英文回退。
  */
@@ -74,9 +74,9 @@ export type TaskParams = TaskScheduleParams & {
   enabled: boolean
   /**
    * 执行状态摘要（可选；仅命令层 `task.list` 行尾消费，见 renderLastExecSummary）。
-   * widget 静态变体**不消费**本字段：摘要不在 widget 指纹字段集内，进显示面会造出
-   * 「显示已变、指纹未变」的冻结缺口（scheduler widget 推送修正设计 D1-a/被否③）；
-   * 失败可见性补偿只进命令查询面（按需呈现，零推送成本）。
+   * widget 静态变体**不消费**本字段：摘要不在 widget 指纹字段集内，进显示侧会造出
+   * 「显示已变、指纹未变」的冻结缺口（scheduler widget 推送修正设计 D1-a/不采用③）；
+   * 失败可见性补偿只进命令查询结果（按需呈现，零推送成本）。
    */
   lastExec?: { lastStatus: TaskStatus; recentFailures: number }
 }
@@ -136,7 +136,7 @@ export type ServiceMessage<K extends ServiceMessageKey = ServiceMessageKey> = {
 }[K]
 
 /**
- * messageKey 词表（机器化守卫用：`service.test.ts` 断言「词典 key 集合 ⊇ 本表 + tray.title」）。
+ * messageKey 词表（机器化检查用：`service.test.ts` 断言「词典 key 集合 ⊇ 本表 + tray.title」）。
  * RESULT_RENDERERS 的映射类型已提供编译期穷尽校验；本数组供测试与词典对账。
  */
 export const SERVICE_MESSAGE_KEYS: readonly ServiceMessageKey[] = [
@@ -192,7 +192,7 @@ const ZH_CN: Dictionary = {
   'task.notDispatched': '任务 {id} 未派发（已停用 / 触发受限 / 正在派发中）',
   'task.limit': '任务数已达上限（{max}），请先删除一个',
   'schedule.invalid': '无法解析的时间表达式：{input}',
-  // 执行状态摘要（task.list 行尾；widget 静态面不带——scheduler widget 推送修正设计 D1）
+  // 执行状态摘要（task.list 行尾；widget 静态范围不带——scheduler widget 推送修正设计 D1）
   // 失败可见性优先裁决：窗口内有失败即失败形态（n = 近期失败计数），否则成功形态
   'task.lastOk': '上次: 成功',
   'task.lastFailures': '上次: 失败×{n}',
@@ -212,14 +212,14 @@ const ZH_CN: Dictionary = {
 
   // ack 确认轮（合成确认行 + 落盘失败如实文案）
   // 措辞边界：只承诺「写入会话文件」（本机制的唯一保证），不得写「已持久化 / 已保存到磁盘」
-  // 之类存储级承诺——ack.notPersisted 是失败面，confirm 是成功面，两者都不越界。
+  // 之类存储级承诺——ack.notPersisted 是失败情形，confirm 是成功情形，两者都不越界。
   'ack.confirm': '已保存任务：{name}（{schedule}）。',
   'ack.notPersisted': '已创建任务 {name}，但未写入会话文件。在本会话说一句话即可保存。',
 
   // 托盘标题（扩展自产，宿主零改动）
   'tray.title': '定时任务',
 
-  // TUI widget 文本行（静态面：任务名 + 静态调度描述，无相对时间/逾期段——D1 静态化）
+  // TUI widget 文本行（静态范围：任务名 + 静态调度描述，无相对时间/逾期段——D1 静态化）
   'widget.title': '定时任务',
   'widget.count': '{n} 条',
   'widget.task': '{name} {schedule}',
@@ -264,7 +264,7 @@ const EN_US: Dictionary = {
   // 托盘标题（扩展自产，宿主零改动）
   'tray.title': 'Scheduled tasks',
 
-  // TUI widget 文本行（静态面：任务名 + 静态调度描述，无相对时间/逾期段——D1 静态化）
+  // TUI widget 文本行（静态范围：任务名 + 静态调度描述，无相对时间/逾期段——D1 静态化）
   'widget.title': 'scheduler',
   'widget.count': '{n} scheduled',
   'widget.task': '{name} {schedule}',
@@ -285,7 +285,7 @@ export function dictionaryKeys(locale: UiLocale): string[] {
 
 /**
  * 渲染词典模板。键缺失 → 回落 en 值 → 再回落键名本身（**禁返回空串**，设计 r4 S1）：
- * 所有经 `t()` 赋值的字段因此天然非空——防「空标题在 nullish 渲染面显示空白段头」
+ * 所有经 `t()` 赋值的字段因此天然非空——防「空标题在 nullish 渲染范围显示空白段头」
  * 从词典后门回潮（`meta.title` 依赖本保证）。占位符缺参时保留 `{name}` 原样（非空）。
  */
 export function t(key: string, params?: Record<string, string | number>, locale?: UiLocale): string {
@@ -302,10 +302,10 @@ function interpolate(template: string, params?: Record<string, string | number>)
   })
 }
 
-// ── 形状投影 ──
+// ── 形状映射 ──
 
 /**
- * 执行状态摘要投影（ScheduledTask.history/lastStatus → TaskParams.lastExec 单点）：
+ * 执行状态摘要派生视图（ScheduledTask.history/lastStatus → TaskParams.lastExec 单点）：
  * recentFailures = history 定长窗口（HISTORY_LIMIT=20）内失败计数；无任何执行记录
  * （history 空且 lastStatus 缺）→ undefined = 行尾不显示摘要段。
  * 失败记账为进程内存态（失败 dispatch 无 jsonl op），跨 resume/重启后计数归零、
@@ -317,7 +317,7 @@ function toLastExec(task: ScheduledTask): TaskParams['lastExec'] {
   return { lastStatus: task.lastStatus ?? 'success', recentFailures }
 }
 
-/** ScheduledTask → locale-neutral TaskParams（service 与 widget 共用同一投影，防双口径）。 */
+/** ScheduledTask → locale-neutral TaskParams（service 与 widget 共用同一派生视图，防双口径）。 */
 export function toTaskParams(task: ScheduledTask, now: number): TaskParams {
   const base = {
     id: task.id,
@@ -327,7 +327,7 @@ export function toTaskParams(task: ScheduledTask, now: number): TaskParams {
     now,
     expiresAt: task.expiresAt,
     enabled: task.enabled,
-    // 摘要随投影携带；仅命令变体消费（widget 静态变体忽略——不在指纹字段集内）
+    // 摘要随派生视图携带；仅命令变体消费（widget 静态变体忽略——不在指纹字段集内）
     lastExec: toLastExec(task),
   }
   return task.schedule.mode === 'interval'
@@ -345,7 +345,7 @@ function toScheduleSpec(task: TaskParams): ScheduleSpec {
 // ── 三个渲染入口 ──
 
 /**
- * 执行状态摘要段（task.list 行尾，D1 失败可见性补偿；widget 静态面不带）。
+ * 执行状态摘要段（task.list 行尾，D1 失败可见性补偿；widget 静态范围不带）。
  * 失败可见性优先：窗口内有失败即失败形态（`上次: 失败×n`，n = 近期失败计数——即使最近
  * 一次执行成功，窗口内存在失败也须让用户看见，否则静默失败不可发现与 G3 语义冲突）；
  * 无失败但有记录 → 成功形态；无任何记录 → 空串（行尾不追加段）。
@@ -362,7 +362,7 @@ function renderLastExecSummary(lastExec: TaskParams['lastExec'], locale: UiLocal
  * `{状态} {id} {name} · {摘要} · {相对时间}[ · {执行状态摘要}]`——状态由 `enabled` 在
  * **代码**派生（r5 追补：不得把 ●/○ 做成词典固定字面量，否则停用任务本地化后会显示为
  * 启用）；摘要/相对时间走带 locale 的格式化器现算（params 只携带原始值）。
- * 相对时间**保留**：命令层是按需呈现面（用户主动触发，无推送放大成本），schedule tool
+ * 相对时间**保留**：命令层是按需呈现侧（用户主动触发，无推送放大成本），schedule tool
  * 的「next run time」承诺依赖它（scheduler widget 推送修正设计 D1-a）。
  */
 export function renderTaskLine(taskParams: TaskParams, locale: UiLocale): string {
@@ -378,7 +378,7 @@ export function renderTaskLine(taskParams: TaskParams, locale: UiLocale): string
 /**
  * **widget 静态变体**任务行（仅供 widget GUI body，`buildSchedulerWidgetItems` 单点消费）：
  * `{状态} {id} {name} · {静态调度描述}`——无任何 now 派生段（相对时间/逾期标记/执行摘要
- * 都不进 widget 行），显示面 = f(稳定字段, locale)。这是 index.ts 任务集指纹跳推的完备性
+ * 都不进 widget 行），显示侧 = f(稳定字段, locale)。这是 index.ts 任务集指纹跳推的完备性
  * 前提（D1-a）：now 派生元素会造出「显示已变而指纹不变」的冻结缺口（P6 反例基线）。
  */
 export function renderTaskLineStatic(taskParams: TaskParams, locale: UiLocale): string {

package/src/importer.ts

@@ -117,7 +117,7 @@ function importFromFile(
   // appendMessage 触发 _persist 全量落盘）与 session_shutdown 时重复调用——flush 后 sessionFile
   // 出现 → 删；仍未 flush → 静默保留 .imported 供下次 session_start 的 handleImportedResidue
   // 崩溃恢复重导入。跨 session 重导入窗口 = session_start → 首个 turn_end（秒级）：turn_end 后
-  // .imported 已删，后续 session 启动看不到残留 → 双导入窗口闭合（R-CONCURRENT-IMPORT 已更新）
+  // .imported 已删，后续 session 启动看不到残留 → 双导入窗口封住（R-CONCURRENT-IMPORT 已更新）
   logger.warn('imported legacy tasks (session not flushed; deferring removal)', {
     count: tasks.length,
     path: importedPath,

package/src/index.ts

@@ -48,7 +48,7 @@ import type { ScheduledTask } from './types.js'
 // STALE_CTX_MARKER 文案兜底（F2 catch 分诊）。
 let sessionGeneration = 0
 
-/** 包内既有 logger（ack 编排的日志面与其它模块同源）。 */
+/** 包内既有 logger（ack 编排的日志侧与其它模块同源）。 */
 const logger = getLogger('scheduler')
 
 /**
@@ -62,7 +62,7 @@ const logger = getLogger('scheduler')
 export default function schedulerExtension(pi: ExtensionAPI): void {
   let service: SchedulerService | null = null
   // U6c：当代 backend（session_start 装配点更新）。factory 顶层 session_tree handler
-  // 经它委托当代重折叠（注册面理由见下方 session_tree 注册点注释）。
+  // 经它委托当代重折叠（注册点理由见下方 session_tree 注册点注释）。
   let activeBackend: PiSchedulerBackend | null = null
   // IMPORT-FLUSH-GUARD（MF-1）：importLegacyStore 对未 flush 的新 session 返回延迟删除 .imported
   // 的 cleanup——turn_end / session_shutdown 时执行：确认 flush（sessionFile 已出现）则删，
@@ -110,7 +110,7 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     // F2 catch 分诊判定 stale——不依赖 pi 错误文案。
     // 投递模型（scheduler-steer-direct-dispatch）：到期任务 steer 直投（backend.sendMessage），
     // 受理即记账，不经投递内核。
-    // U4 模型控制面（设计 D3）：runtime 只见 'provider/id' ref（与 task.model 同域），pi 的
+    // U4 模型控制接口（设计 D3）：runtime 只见 'provider/id' ref（与 task.model 同域），pi 的
     // Model 对象解析封在本闭包。setModelByRef 契约 = 不 throw、失败返回 false（ref 非法 /
     // modelRegistry.find 无命中 / pi setModel false / 意外异常统一折叠）。
     const modelOps: SchedulerModelOps = {
@@ -155,7 +155,7 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     ackController.handleSessionBoundary()
 
     service = new SchedulerService(runtime, () => backend.now(), (task) => {
-      // 创建汇聚点 → ack 触发器（fire-and-forget：回调不 await，失败仅日志面）。
+      // 创建汇聚点 → ack 触发器（fire-and-forget：回调不 await，失败仅日志侧）。
       // 唯一生产开关 TAIJI_SCHED_ACK_DISABLE 在此单点读取（fail-safe 方向：缺省不禁用）。
       const controller = ackController
       if (!controller) return
@@ -227,7 +227,7 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
   pi.on('agent_settled', () => service?.runtime.handleRunSettled())
 
   pi.on('session_shutdown', async () => {
-    // 命令路径挂起表单的收口（设计 §6.2 生命周期案 ①②③）：session_shutdown
+    // 命令路径挂起表单的收尾（设计 §6.2 生命周期案 ①②③）：session_shutdown
     //（reason ∈ quit/reload/new/resume/fork）→ abort 挂起的表单交互（不创建、不 toast）。
     // taiji 内「切到另一会话」不触发本事件，表单保留且仍有效（有意行为）。
     abortPendingScheduleForms()
@@ -349,7 +349,7 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     try {
       fingerprint = computeTasksFingerprint(tasks, locale)
     } catch (err) {
-      // fail-open（辅助显示面的降级 ≠ 吞错）：指纹异常说明序列化路径有 bug，跳推判定不可信
+      // fail-open（辅助显示侧的降级 ≠ 吞错）：指纹异常说明序列化路径有 bug，跳推判定不可信
       // → 直接推送保显示正确；缓存失效（null）使下一帧也必推。
       logger.warn('widget fingerprint computation failed, pushing anyway', { error: toErrorMessage(err) })
       lastWidgetFingerprint = null

package/src/interaction.ts

@@ -245,7 +245,7 @@ function parseScheduleFormAnswerValue(rawResult: unknown): ScheduleFormResult {
 // ── 命令路径入口（异步打开）──
 
 /**
- * 命令路径表单入口：打开创建表单，提交后经 service.create 落库。
+ * 命令路径表单入口：打开创建表单，提交后经 service.create 写入。
  *
  * **契约：返回的 Promise 永不 reject**（内部错误自 catch → `ctx.ui.notify(..., 'error')`；
  * 挂起期间 `session_shutdown` abort → 取消收尾）。因此调用点的 `void openScheduleFormAsync(...)`

package/src/runtime.ts

@@ -33,7 +33,7 @@ const DEFAULT_EXPIRY_MS = DEFAULT_EXPIRY_DAYS * MS_PER_DAY // 7 days
 const DISPATCH_CUSTOM_TYPE_PREFIX = 'pi-scheduler:'
 
 /**
- * 模型控制面（U4 dispatch 模型切换，依赖反转）：runtime 只见 'provider/id' 字符串 ref
+ * 模型控制接口（U4 dispatch 模型切换，依赖反转）：runtime 只见 'provider/id' 字符串 ref
  * （与 ScheduledTask.model 同域，tool.ts draft 组装 modelRef 的产出形态），pi 的 Model
  * 对象解析（modelRegistry.find → setModel）封在生产装配闭包（index.ts session_start）。
  *
@@ -53,7 +53,7 @@ export interface SchedulerModelOps {
 
 /**
  * 未决模型切换记录（纯内存态）。模型语义异常不进持久化词表
- * （replay 守卫对 advance.status 硬校验 'success'，旁路字段会炸重放推进）。
+ * （replay 检查对 advance.status 硬校验 'success'，旁路字段会炸重放推进）。
  *
  * 生命周期（ADR-0122 事实查询翻转后）：dispatch 受理 → 记录创建（in-flight 等价语义：
  * 等 run 落定）；恢复兑现锚点 = isIdle() 同步事实查询（agent_settled 事件提前触发 +
@@ -68,7 +68,7 @@ interface PendingModelSwitch {
 }
 
 // HISTORY_LIMIT 单点在 types.ts（ext-simplify-08 L5）——与 replay.ts 的 advance 折叠共用
-// STALE_CTX_MARKER（文案兜底分诊词）已迁移到 ext-guards 共享守卫（guardStaleCtx 内部
+// STALE_CTX_MARKER（文案兜底分诊词）已迁移到 ext-guards 共享检查（guardStaleCtx 内部
 // 引用，本文件不再直接持有）。语义：G1 模块级代际检测（isCtxStale）为主判；文案子串
 // 覆盖代际盲区——显式 reload / cwd 变化触发 clearExtensionCache 后 jiti 重新 import 产生
 // 全新模块环境，旧闭包引用的模块级代数冻结不再递增，isCtxStale 恒 false，只剩错误文案
@@ -85,14 +85,14 @@ export class SchedulerRuntime {
   private readonly isCtxStale: (() => boolean) | undefined
   // R3-S1：同任务 dispatch 在途标记（Set<taskId>），见 dispatchTask 注释
   private readonly dispatchesInFlight = new Set<string>()
-  // U4 dispatch 模型切换（设计 D3 修订版）：模型控制面（缺省 undefined = 无切换能力，降级）
+  // U4 dispatch 模型切换（设计 D3 修订版）：模型控制接口（缺省 undefined = 无切换能力，降级）
   private readonly modelOps: SchedulerModelOps | undefined
   // 未决模型切换记录（同时至多一条——互斥窗口 + 模型 op 串行队列共同保证「切换→dispatch→
   // 恢复」周期单在途、单 setModel 在途）
   private pendingModelSwitch: PendingModelSwitch | null = null
-  // 模型 op 串行队列尾（MF-2 收口）：调度器发起的全部 setModel（dispatch 切换 / 期望模型
+  // 模型 op 串行队列尾（MF-2 收敛）：调度器发起的全部 setModel（dispatch 切换 / 期望模型
   // 恢复 / 错误路径恢复）单点经 serializeModelOp 入队——「setModel 起步 → 记录创建 /
-  // 恢复收口」全程持队，任何后继 setModel 发起点先排队前置等待，两个 setModel 并发
+  // 恢复收尾」全程持队，任何后继 setModel 发起点先排队前置等待，两个 setModel 并发
   // 结构性不可能（完成顺序不定 → turn 静默跑错模型的交错被消除）。链条引用恒吞错
   // 自愈（见 serializeModelOp），前序 op 失败不阻断后继。
   private modelOpChain: Promise<void> = Promise.resolve()
@@ -105,7 +105,7 @@ export class SchedulerRuntime {
    * 替换。index.ts 装配点注入（模块级代数比对，R3-M1），使 stale 分诊不依赖 pi 错误文案；
    * 缺省（不注入）恒视为非 stale——纯 runtime 单测与旧装配路径行为不变。
    *
-   * modelOps（U4）：模型控制面，session_start 装配点注入；缺省 = 无模型切换能力
+   * modelOps（U4）：模型控制接口，session_start 装配点注入；缺省 = 无模型切换能力
    * （task.model 非空时降级照常 dispatch）。
    */
   constructor(backend: SchedulerBackend, isCtxStale?: () => boolean, modelOps?: SchedulerModelOps) {
@@ -240,13 +240,13 @@ export class SchedulerRuntime {
   startScheduler(): void {
     if (this.tickTimer) return
     this.tickTimer = setInterval(() => {
-      // 三件套语义等价迁移到共享守卫 guardStaleCtx（crash-resilience D1 / u1-ext-guard；
-      // 守卫语义 = 本处原地实现的泛化，迁移对照逐条可证）：
-      // 1. G1 前置检查（S9）：守卫的 isCtxStale 命中 → onStale（= retireStaleTimer）且
+      // 三件套语义等价迁移到共享检查 guardStaleCtx（crash-resilience D1 / u1-ext-guard；
+      // 检查语义 = 本处原地实现的泛化，迁移对照逐条可证）：
+      // 1. G1 前置检查（S9）：检查的 isCtxStale 命中 → onStale（= retireStaleTimer）且
       //    tickScheduler 不执行——与迁移前「前置分支 return」等价：本 runtime 所属 session
       //    已被替换 → timer 属泄漏资源自停退场，不触碰捕获的 stale ctx，不依赖 pi 错误文案。
       //    主防线仍是 F1（session_start 停旧 timer），此处覆盖 F1 未能触达的泄漏路径。
-      // 2. F2 catch 分诊（防御兜底）：守卫对 tickScheduler 的 rejection 挂同一分诊谓词
+      // 2. F2 catch 分诊（防御兜底）：检查对 tickScheduler 的 rejection 挂同一分诊谓词
       //    `isCtxStale() || 文案含 STALE_CTX_MARKER`（字面不变）——stale → retireStaleTimer；
       //    非 stale → 原样 reject，由下方 .catch 仅告警不终止调度（'tick error' 文案不变，
       //    U2/G1-c 锚定）。fire-and-forget 的 tick 链路必须自带 catch——tick 内任何异常
@@ -254,7 +254,7 @@ export class SchedulerRuntime {
       //    即 unhandledRejection，直接崩掉 pi 主进程（E1 同机制）。
       // 3. retireStaleTimer 自停：未改（'tick stopped' warn 口径与幂等 stopScheduler 原样，
       //    U1/G1-b/G1-d 锚定）。
-      // `?.catch`：前置检查命中时守卫返回 undefined（fn 未执行、无 Promise、无 rejection
+      // `?.catch`：前置检查命中时检查返回 undefined（fn 未执行、无 Promise、无 rejection
       // 可接——retire 已由 onStale 完成）；非 stale 时返回 Promise，非 stale rejection
       // 流到 .catch 仅告警。
       void guardStaleCtx(() => this.tickScheduler(), {
@@ -298,7 +298,7 @@ export class SchedulerRuntime {
     // 循环才开 setModel；更广的「任意两个 setModel 不并发」由模型 op 串行队列（modelOpChain）
     // 结构保证——含 agent_settled 恢复 fire-and-forget 挂点，dispatch 模型分支排在其后。
     // 无未决记录（或非 idle）的绝大多数 tick 同步返回、不引入 microtask 断点——dispatch
-    // 的同步段契约（in-flight 守卫在 tickScheduler() 未 await 时同步可见）保持不变。
+    // 的同步段契约（in-flight 检查在 tickScheduler() 未 await 时同步可见）保持不变。
     const settling = this.settlePendingIfIdle('tick-reconcile')
     if (settling) await settling
 
@@ -343,7 +343,7 @@ export class SchedulerRuntime {
    * dispatch 单个任务。返回 true 表示消息已发出（pi.sendMessage 受理），false 表示
    * no-op（task disabled / 已有同任务在途 / rate-limited）。
    *
-   * R3-S1 in-flight 守卫：tick 为 fire-and-forget，若 tick1 的 `await backend.sendMessage`
+   * R3-S1 in-flight 检查：tick 为 fire-and-forget，若 tick1 的 `await backend.sendMessage`
    * 挂起超过 TICK_INTERVAL_MS（如 pi 卡死），tick2 的 step2 会再标 pending、step3 对同一
    * task 并发第二个 dispatch → 同一 prompt 双注入。参照 subagent-workflow resumesInFlight
    * 模式：入口同步置位、finally 清除（覆盖 gate / rate-limit / sendMessage 抛错 / 成功推进
@@ -365,8 +365,8 @@ export class SchedulerRuntime {
   }
 
   /**
-   * dispatch 本体（dispatchTask 守卫置位后执行；runTaskNow 与 tick step3 共用入口，
-   * 手动 run-now 与挂起中的 tick dispatch 并发时同样被守卫拦截）。
+   * dispatch 本体（dispatchTask 检查置位后执行；runTaskNow 与 tick step3 共用入口，
+   * 手动 run-now 与挂起中的 tick dispatch 并发时同样被检查拦截）。
    * steer 直投（scheduler-steer-direct-dispatch 设计）：{deliverAs:'steer', triggerTurn:true}
    * 在 pi 侧的两分支——busy 时 steer 插入当前 turn（立即被模型看到）、idle 时开新 turn。
    * 受理即记账：pi extension API sendMessage 是 fire-and-forget（返回 void，错误走
@@ -403,15 +403,15 @@ export class SchedulerRuntime {
         // skip 本轮 + pending 留待下 tick 重试（复用现状 skip 语义，不建真队列；不需切模型
         // 的任务不受互斥影响——检查只在本分支）。「dispatch 写新记录前先结算旧记录」
         // 的落地：本分支结构性永不写新记录（杜绝新旧叠写），skip 前做一次 isIdle() 事实
-        // 查询结算（idle 即恢复收口），保证新任务不被旧记录无限阻塞。
+        // 查询结算（idle 即恢复收尾），保证新任务不被旧记录无限阻塞。
         // 结算的恢复必须 await（顺序约束，与 tickScheduler 的结算 await 同构）：恢复
         // setModel(原) 完成后才放行 skip——恢复与紧随的需切模型任务 setModel(目标) 不得
         // 并发（串行由模型 op 队列结构保证，本 await 是调用方顺序语义：skip 放行前恢复
-        // 已收口）；本分支随后即 skip，await 无额外延迟代价。
+        // 已收尾）；本分支随后即 skip，await 无额外延迟代价。
         await this.settlePendingIfIdle('mutex-settle')
         skipped = true
       } else {
-        // 模型 op 串行段（MF-2 收口，互斥窗口全程覆盖「setModel 起步 → 记录创建」）：
+        // 模型 op 串行段（MF-2 收敛，互斥窗口全程覆盖「setModel 起步 → 记录创建」）：
         // 前序模型 op（agent_settled 恢复 / 前序 dispatch 切换 / 错误路径恢复）可能仍在途——
         // 排队等待期间未决记录与当前模型均可能变化，禁止按排队前快照盲切（旧快照的
         // expectedModelRef 会把恢复锚点记错），串行段内重新校验后再切换。后来的需切模型
@@ -546,20 +546,20 @@ export class SchedulerRuntime {
    * 未决模型切换记录的事实查询结算：记录存在 + 会话 idle（isIdle() 同步查询，
    * 判定层级最高的事实来源）→ 兑现恢复；非 idle → 不动作（不能把在途 run 的模型
    * 换掉），记录保留等下一查询点。无记录时同步返回 undefined（调用方跳过 await，
-   * 保住 tick 无记录路径的同步契约——dispatch 的 in-flight 守卫在 tickScheduler()
+   * 保住 tick 无记录路径的同步契约——dispatch 的 in-flight 检查在 tickScheduler()
    * 未 await 时同步可见）。
    *
    * 调用点两处：① tickScheduler 开头（严格先于 dispatch 循环——顺序约束：否则
    * 「B dispatch 先切 Y → 对账持 A 旧记录把 Y 静默切回」；agent_settled 事件丢失时
    * 本查询点是正确性兜底，事件只作提前触发加速器）；② dispatchTaskInner 互斥分支
-   * （skip 前尽量把旧记录收口，恢复 setModel 与后续新任务的 setModel(目标) 不得并发
+   * （skip 前尽量把旧记录收尾，恢复 setModel 与后续新任务的 setModel(目标) 不得并发
    * ——串行由模型 op 队列结构保证，本 await 是调用方顺序语义）。
    */
   private settlePendingIfIdle(reason: string): Promise<void> | undefined {
     const ps = this.pendingModelSwitch
     if (!ps) return undefined
     if (this.isCtxStale?.()) {
-      // stale 代际失效（session 替换）：未决记录随代际丢弃，不触碰旧 ctx（同现有守卫路径）
+      // stale 代际失效（session 替换）：未决记录随代际丢弃，不触碰旧 ctx（同现有检查路径）
       this.pendingModelSwitch = null
       return undefined
     }
@@ -586,7 +586,7 @@ export class SchedulerRuntime {
   }
 
   /**
-   * 执行恢复（切回会话期望模型）并关闭未决记录（在途标记生命周期收口）：
+   * 执行恢复（切回会话期望模型）并关闭未决记录（在途标记生命周期收尾）：
    * 当前模型已等于期望（用户已手动切回）→ 清记录不动作；setModel(原) false →
    * restore-failed 终态（日志含恢复动作：会话停留在任务模型，需手动切回）+ 清记录。
    * 记录先关后恢复——防 await setModel 期间 agent_settled 与 tick 对账并发重入。

package/src/types.ts

@@ -1,6 +1,6 @@
 // entry 契约与折叠器单源于 @zhushanwen/extension-protocol（U2 折叠器下沉：扩展与 taiji plugin
 // 同源消费，杜绝双实现漂移）。本文件保持既有 import 路径不变（re-export），仅保留
-// 扩展侧写面私有物（toTaskSnapshot / 旧 store 形状 / 工具参数 / ack 机制类型）。
+// 扩展侧写侧私有物（toTaskSnapshot / 旧 store 形状 / 工具参数 / ack 机制类型）。
 
 // ack 覆写 config 类型同源自 pi（文件尾 SchedulerCurrentModel / SchedulerProviderOverride 消费）
 import type { ProviderConfig } from '@earendil-works/pi-coding-agent'
@@ -21,7 +21,7 @@ export type {
   TaskStatus,
 } from '@zhushanwen/extension-protocol'
 
-// 本地保留面（写侧 helper / 旧 store 形状 / 工具参数）签名引用的类型——re-export 不引入作用域，需显式 import
+// 本地保留范围（写侧 helper / 旧 store 形状 / 工具参数）签名引用的类型——re-export 不引入作用域，需显式 import
 import type { ScheduledTask, TaskKind, TaskSnapshot } from '@zhushanwen/extension-protocol'
 
 /**
@@ -44,7 +44,7 @@ export function toTaskSnapshot(task: ScheduledTask): TaskSnapshot {
 export interface SchedulerStore {
   /**
    * 形状忠实保留（ext-simplify-08 L8）：旧 store 文件（npm 0.1.1 store.ts）顶层携带
-   * version:1，importer 只读 tasks、version 零读点——字段是磁盘格式的文档而非消费面，
+   * version:1，importer 只读 tasks、version 零读点——字段是磁盘格式的文档而非消费方，
    * 删除会让类型与迁移源文件的真实形状静默漂移。
    */
   version: 1
@@ -102,7 +102,7 @@ export type AckUnavailableReason = 'no-base' | 'toggle-disabled' | 'check-failed
  *
  * 其余形态（e1-register / e2-not-hit / e4-provider-error / e5-interrupted /
  * e6-unregister / e8b-hybrid）**不发用户通知**——它们都意味着真实轮已应答或与落盘无关，
- * 发「未写入」即反向撒谎；可观测性由日志面承担（字符串标签，不实体化为类型成员）。
+ * 发「未写入」即反向撒谎；可观测性由日志侧承担（字符串标签，不实体化为类型成员）。
  * 把「可通知」收窄成类型本身，反向撒谎禁令就成了编译期约束：调用点无法传入不通知的形态。
  * 错误语义的完整 SSOT = 设计 scheduler-command-path-persistence §3.4。
  */
@@ -121,7 +121,7 @@ export interface AckState {
   window: { providerId: string } | null
   /** ack 轮是否已启动（session 边界写盘判定的判据之一：文件不存在且未启动才补发告警） */
   ackTurnStarted: boolean
-  /** 本次 ack 触发的任务 id（session 边界通知拼去重键用）；null = 未发起过 ack。注意：状态为模块级单例，session_start 时它可能是上一会话的残留——故所有读点都必须先过 taskId !== null 且由边界清理收口 */
+  /** 本次 ack 触发的任务 id（session 边界通知拼去重键用）；null = 未发起过 ack。注意：状态为模块级单例，session_start 时它可能是上一会话的残留——故所有读点都必须先过 taskId !== null 且由边界清理收尾 */
   taskId: string | null
   /** 本次 ack 触发的任务名（如实通知文案插值；taskId 为兜底） */
   taskName: string
@@ -144,7 +144,7 @@ export interface AckState {
 }
 
 /**
- * 会话当前模型的最小投影（`SchedulerBackend.getCurrentModel()` 返回值）。
+ * 会话当前模型的最小派生视图（`SchedulerBackend.getCurrentModel()` 返回值）。
  *
  * 只取 ack 合成轮所需三字段：`api`（registerProvider 覆写 config.api）、`provider`
  * （覆写目标 provider id）、`id`（合成 assistant 行的 model 字段）。`api` 用
@@ -158,7 +158,7 @@ export interface SchedulerCurrentModel {
 }
 
 /**
- * `registerProvider` 的覆写 config 最小面：ack 合成轮只带 `api` + `streamSimple`，不带
+ * `registerProvider` 的覆写 config 最小子集：ack 合成轮只带 `api` + `streamSimple`，不带
  * `models`（覆写不得改变 provider 的模型清单）。
  *
  * 不重定义字段——直接 Pick 自 pi 的 `ProviderConfig`，与 `pi.registerProvider` 的实参类型

package/src/widget.ts

@@ -22,9 +22,9 @@ const WIDGET_NAME_MAX_WIDTH = 20
  * `readUiLocale()` 解析后传入，再经 `setSchedulerWidget` 双模推送）。
  * 格式：[定时任务] 3 条 · check-build 每 5 分钟（en: [scheduler] 3 scheduled · …）
  *
- * 静态面契约（scheduler widget 推送修正设计 D1-a）：行内容只由任务集稳定字段 + locale
+ * 静态范围契约（scheduler widget 推送修正设计 D1-a）：行内容只由任务集稳定字段 + locale
  * 派生，**无任何 now 参与的元素**——相对时间与「[!] n 条已逾期」标记已整体移除（时间流逝
- * 不是状态变化，静态面恒定是 index.ts 指纹跳推「无变化零推送」的前提）。
+ * 不是状态变化，静态范围恒定是 index.ts 指纹跳推「无变化零推送」的前提）。
  * 「最近任务」= nextRunAt 升序首个**启用**任务、**不用 now 过滤**：若保留
  * `nextRunAt > now` 过滤，任务 dispatch 失败未推进 nextRunAt 时越过时间点后「最近任务」
  * 会切换——显示变化而指纹不变，重新引入冻结缺口（设计 D1-a 反例论证）。
@@ -58,7 +58,7 @@ export function renderSchedulerWidgetTui(tasks: ScheduledTask[], locale: UiLocal
 /**
  * GUI 臂结构化载荷（设计 §6.8 D8）：body = 逐任务 list-tree（行文本走 `renderTaskLineStatic`
  * 静态变体单点），head 元数据由宿主壳层渲染——**标题由扩展自产**（`meta.title = t('tray.title')`），
- * 宿主零改动（三处渲染面：前两面 trim / `TrayAggregatePanel` nullish，非空标题均正确）。
+ * 宿主零改动（三处渲染范围：前两面 trim / `TrayAggregatePanel` nullish，非空标题均正确）。
  *
  * icon 点名 lucide key 'clock'（与设计 §6.8 一致）；badge = 启用任务数；status 两态 =
  * 有启用任务 running / 空 idle（D1-a：「有逾期 → failed」翻牌已移除——逾期是 now 派生
@@ -82,7 +82,7 @@ export function buildSchedulerWidgetGui(tasks: ScheduledTask[], locale: UiLocale
 /**
  * GUI body 逐任务行（复用 renderTaskLineStatic 静态变体单点；导出供测试直接断言行文本）。
  * `now` 形参仅为满足 toTaskParams 的形状必填字段（命令变体的相对时间基准），静态变体
- * **不消费**它——保留形参以维持与命令投影同一形状来源，防双口径。
+ * **不消费**它——保留形参以维持与命令派生视图同一形状来源，防双口径。
  */
 export function buildSchedulerWidgetItems(
   tasks: ScheduledTask[],
@@ -108,7 +108,7 @@ function widgetStatus(enabledCount: number): WidgetMeta['status'] {
  * 否则冻结缺口静默回归。
  *
  * kind 显式入指纹：行文本含 `formatSchedule(spec, kind, locale)`，kind 是显示决定因素
- * （当前无 update op 不可变，by-construction 论证仍须显式闭合）；locale 显式入指纹：
+ * （当前无 update op 不可变，by-construction 论证仍须显式补全）；locale 显式入指纹：
  * 切语言一次推送自愈。
  */
 export function computeTasksFingerprint(tasks: ScheduledTask[], locale: UiLocale): string {