feat: implement todo plan clearance on turn start

packages/client/connection/src/client/fixture.ts

@@ -316,11 +316,16 @@ function pageOf(
   return { events, hasMore: start > 0 }
 }
 
-/** Current todo projection over the full log (host parallel: latest todo/write, last write wins). */
+/**
+ * Current plan projection over the full log (host parallel: latest todo/write
+ * with no later turn/start; a new turn retires the previous plan).
+ */
 function backscanTodos(log: readonly SessionEvent[]): TodoItem[] | undefined {
   for (let i = log.length - 1; i >= 0; i--) {
     const event = log[i]
-    if (event !== undefined && event.type === 'todo/write') return event.data.todos
+    if (event === undefined) continue
+    if (event.type === 'turn/start') return undefined
+    if (event.type === 'todo/write') return event.data.todos
   }
   return undefined
 }

packages/client/runtime/src/client/sessions/session.ts

@@ -99,8 +99,9 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   private queueCache: { rev: number; value: QueuedMessage[] } | null = null
   private frozenRev = 0
   private nodesCache: { folded: readonly ConversationNode[]; frozenRev: number; value: readonly ConversationNode[] } | null = null
-  /** Current whole-list todo/write projection: each tail history response replaces it (an omitted
-   *  field is the authoritative empty list) and every live write overwrites it. */
+  /** Current plan strip: the latest `todo/write` not followed by a later `turn/start`. Tail history
+   *  responses replace it (an omitted field is the authoritative empty list); live writes overwrite
+   *  it; each new `turn/start` clears it so a finished plan does not linger into the next turn. */
   private todos: readonly TodoItem[] = []
   /** `run_code` sub-dispatches by parent callId (window-derived, like openCalls). Appends
    *  copy-on-write the per-parent array so published snapshot references never mutate. */
@@ -511,13 +512,13 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     this.views = entries.map(e => e.view)
     this.baseSeq = this.events[0]?.seq ?? 0
     this.hasMore = hasMore
-    // Session-level projection from the tail page (full-log latest todo/write,
-    // independent of the window); an in-window write below re-derives the same
-    // value, and later live events keep overwriting it. Every caller here is a
-    // tail request (no beforeSeq), which the host answers with the projection
-    // or omits it only when the full log holds no todo/write — so an absent
-    // field is the authoritative empty list, not a missing carrier. Assigning
-    // it clears a plan the log never kept (a write lost to a host crash).
+    // Tail-page projection (full-log current plan, independent of the window);
+    // an in-window write or turn/start below re-derives the same value, and later
+    // live events keep overwriting or clearing it. Every caller here is a tail
+    // request (no beforeSeq), which the host answers with the projection or omits
+    // it when the log has no standing plan — so an absent field is the
+    // authoritative empty list, not a missing carrier. Assigning it clears a plan
+    // the log never kept (a write lost to a host crash).
     this.todos = todos ?? []
     this.foldAdapter.reset(this.events, this.baseSeq, this.views)
     this.rebuildDerivedFromWindow()
@@ -693,6 +694,13 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
         this.todos = event.data.todos
         return
       }
+      case 'turn/start': {
+        // The plan strip is turn-scoped for display: a new turn retires the previous
+        // list until the model writes again. turn/end keeps it visible so the finished
+        // checklist remains while the user reads the answer.
+        this.todos = []
+        return
+      }
       case 'turn/end': {
         // Aborted turns never finalize. The accumulated partial is VALUE, not residue: freeze it
         // into an interrupted terminal node (pulse stops, text survives) instead of deleting it.
@@ -738,10 +746,12 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   /** Re-derive state (partial/openCalls/frozenNodes) from raw window events after a rebuild — keeps
    *  paging/stitching consistent, and makes the live freeze and the history replay converge on the
    *  same interrupted nodes (chunks are logged, so the replayed sweep re-freezes identical text).
-   *  todos is deliberately NOT reset: it is session-level (seeded by the tail page's full-log
-   *  projection, not derivable from an arbitrary window). The window always extends to the log
-   *  tail, so an in-window todo/write can only overwrite it with the same latest value. */
+   *  The standing plan starts empty for the sweep; when the window itself never determines it
+   *  (no todo/write and no turn/start — the write still precedes the page), the tail-page seed is
+   *  restored. A contiguous tail window that contains a turn/start after the standing write will
+   *  determine empty, matching the host projection. */
   private rebuildDerivedFromWindow(): void {
+    const seededTodos = this.todos
     this.partial = null
     this.openCalls.clear()
     this.callsRev++
@@ -749,11 +759,16 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     this.frozenRev++
     this.codeDispatches = new Map()
     this.dispatchesRev++
+    this.todos = []
+    let todosDetermined = false
     for (let i = 0; i < this.events.length; i++) {
       const event = this.events[i]
       /* v8 ignore next -- dense-array guard: i stays within events.length, so the undefined arm needs a sparse array no caller builds. */
-      if (event !== undefined) this.applyEventSideEffects(event, this.views[i])
+      if (event === undefined) continue
+      if (event.type === 'todo/write' || event.type === 'turn/start') todosDetermined = true
+      this.applyEventSideEffects(event, this.views[i])
     }
+    if (!todosDetermined) this.todos = seededTodos
   }
 
   private windowTailSeq(): number | null {

packages/client/runtime/tests/session.spec.ts

@@ -177,23 +177,62 @@ describe('live event path', () => {
 
   it('seeds todos from the tail page projection when the last write precedes the window', async () => {
     const list = [{ content: '窗口外的计划', status: 'in_progress' as const }]
-    // Cold open: the page window carries NO todo/write; the projection rides the response.
+    // Cold open: same-turn page with no todo/write and no turn/start (a later turn/start
+    // would mean the host projection is empty). The standing plan rides the response.
+    const tailPage = [
+      ev.user(100, '问'),
+      ev.stepStart(101, 9),
+      ev.assistant(102, 9, '答'),
+      ev.stepEnd(103, 9),
+      ev.turnEnd(104, 9),
+    ]
     const { api, session } = makeSession()
-    api.onHistory = () => histResponse(plainTurn(100, 9, '问', '答'), true, list)
+    api.onHistory = () => histResponse(tailPage, true, list)
     await session.open()
     expect(session.getSnapshot().todos).toEqual(list)
-    // Paging an older window in must not clear the session-level projection.
-    api.onHistory = () => histResponse(plainTurn(94, 8, '旧问', '旧答'), false)
+    // Older same-turn slice (still no determiner) must keep the seeded plan.
+    api.onHistory = () => histResponse([
+      ev.user(95, '旧问'),
+      ev.stepStart(96, 9),
+      ev.assistant(97, 9, '旧答'),
+      ev.stepEnd(98, 9),
+      ev.turnEnd(99, 9),
+    ], false)
     await session.loadOlder()
     expect(session.getSnapshot().todos).toEqual(list)
-    // A later live write still overrides the seeded projection.
+    // Contiguous live write (tail is 104) still overrides the seeded projection.
     session.handleMuxEnvelope('r' as never, {
       type: 'session/event', sessionId: SID,
-      event: ev.todoWrite(106, [{ content: '新计划', status: 'pending' as const }]),
+      event: ev.todoWrite(105, [{ content: '新计划', status: 'pending' as const }]),
     })
     expect(session.getSnapshot().todos).toEqual([{ content: '新计划', status: 'pending' }])
   })
 
+  it('clears the plan on turn/start (live and on window replay)', async () => {
+    const list = [{ content: '上一轮计划', status: 'completed' as const }]
+    const { session } = await opened()
+    const feed = (event: SessionEvent) => {
+      session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event })
+    }
+    feed(ev.todoWrite(6, list))
+    expect(session.getSnapshot().todos).toEqual(list)
+    // turn/end keeps the finished checklist visible while the user reads.
+    feed(ev.turnEnd(7, 0))
+    expect(session.getSnapshot().todos).toEqual(list)
+    feed(ev.turnStart(8, 1))
+    expect(session.getSnapshot().todos).toEqual([])
+    // Replay converges: a turn/start after the latest write yields an empty plan.
+    const replayed = makeSession()
+    replayed.api.onHistory = () => histResponse([
+      ...plainTurn(0, 0, 'a', 'b'),
+      ev.todoWrite(6, list),
+      ev.turnStart(7, 1),
+      ev.user(8, '下一问'),
+    ])
+    await replayed.session.open()
+    expect(replayed.session.getSnapshot().todos).toEqual([])
+  })
+
   it('repairs a seq gap by repulling the tail page instead of appending a hole', async () => {
     const { api, session } = await opened(plainTurn(0, 0, 'a', 'b')) // tail seq = 5
     const repaired = [...plainTurn(0, 0, 'a', 'b'), ...plainTurn(6, 1, 'c', 'd')]
@@ -211,11 +250,18 @@ describe('live event path', () => {
   it('gap repair adopts the repull response projection (a missed todo/write outside the new tail page)', async () => {
     const { api, session } = await opened(plainTurn(0, 0, 'a', 'b')) // tail seq = 5
     expect(session.getSnapshot().todos).toEqual([])
-    // The missed range contained a todo/write that the repulled page no longer
-    // covers; the response's session-level projection is the only carrier.
+    // Missed todo/write still stands (no later turn/start); the repulled tail page
+    // omits that write and any determiner, so the response projection is the carrier.
     const current = [{ content: '断线期间写的', status: 'in_progress' as const }]
-    api.onHistory = () => histResponse([...plainTurn(0, 0, 'a', 'b'), ...plainTurn(8, 1, 'c', 'd')], false, current)
-    session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: ev.assistant(11, 1, 'd') })
+    const tailPage = [
+      ev.user(8, 'c'),
+      ev.stepStart(9, 1),
+      ev.assistant(10, 1, 'd'),
+      ev.stepEnd(11, 1),
+      ev.turnEnd(12, 1),
+    ]
+    api.onHistory = () => histResponse(tailPage, false, current)
+    session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: ev.assistant(10, 1, 'd') })
     await vi.waitFor(() => {
       expect(api.callsOf('session.history').length).toBe(2)
     })

packages/client/ui-conversation/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-conversation/README.md
-README.md: a04c20f225c731581accbe8c12c52a5e7597029a
-README.zh.md: f9e6a635ea6090c87a66f029785af214025b9bda
+README.md: f343691d27993791f2264c4335c5cfa6a620851a
+README.zh.md: aebac5ca78da914af61f4be8001b47cd01628e1e

packages/client/ui-conversation/README.md

@@ -12,7 +12,7 @@ Generic tool rows classify the built-in bash, read, search, write, edit, and run
 
 Tool rows are slots too — the standalone tool ring (`ToolViewRegistry`/`ctx.toolviews`/outlet) is retired. The chat entry declares the keyed `'conversation.chat.toolview'` hole (session scope; the key space is runtime-open); its render site dispatches per row via `entryKey: toolName` with `GenericToolCard` as the call-site `fallback`. The owner payload is the uniform `ToolRowOwnerProps` (`callId`/`toolName`/`block`/`openFile`) and `ToolRowProps` pre-composes it with the session standard kit. A registrant is a plain plugin: `ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row)` with `inject: ['slots', 'conversation']` as the load-order seam (apply mounts ConversationService after the chat registration, so the service being present guarantees the slot is declared); session differentiation happens inside the component (`useSessions` reading `parentId` — the bash sample is the third-party-posture exemplar). Trajectory/waterfall toolview slots share this shape and land with their own render sites (RendersCheck rejects a declaration nobody renders).
 
-The todo surfaces are two registrations over that shape, both plain registrant plugins with `inject: ['slots', 'conversation']`. `TodoRow` takes the `'conversation.chat.toolview'` key `todo_write` and summarizes what the call attempted (`<done>/<total> 已完成 · <active item>` parsed from its args, falling back to the generic summary on malformed or wrongly-shaped model JSON, and keeping the generic dot for non-ok execution states so a cancelled call never reads as a completed update). `TodoDock` takes the `'conversation.input.dock'` list slot at `order: -1` — above the queue rows — and is the durable plan strip: it selects `todos` off the session snapshot and renders `TodoPanel`, which takes the plain list, hides itself while the list is empty, and collapses to a header of title plus `"<done>/<total> tasks · <n> in progress"` (status glyphs are the figma check / progress / dashed-pending set). The dock adapter owns the selection so the panel stays a pure function of its props; the persistent list lives here rather than in the row so the row stays one line. Anything the input-zone composer chain hides (a `conversation.composer` takeover such as ui-question's) hides the whole dock, this strip included.
+The todo surfaces are two registrations over that shape, both plain registrant plugins with `inject: ['slots', 'conversation']`. `TodoRow` takes the `'conversation.chat.toolview'` key `todo_write` and summarizes what the call attempted (`<done>/<total> 已完成 · <active item>` parsed from its args, falling back to the generic summary on malformed or wrongly-shaped model JSON, and keeping the generic dot for non-ok execution states so a cancelled call never reads as a completed update). `TodoDock` takes the `'conversation.input.dock'` list slot at `order: -1` — above the queue rows — and is the plan strip: it selects `todos` off the session snapshot (standing plan: latest `todo/write` with no later `turn/start`) and renders `TodoPanel`, which takes the plain list, hides itself while the list is empty, and collapses to a header of title plus `"<done>/<total> tasks · <n> in progress"` (status glyphs are the figma check / progress / dashed-pending set). The dock adapter owns the selection so the panel stays a pure function of its props; the standing list lives here rather than in the row so the row stays one line. Anything the input-zone composer chain hides (a `conversation.composer` takeover such as ui-question's) hides the whole dock, this strip included.
 
 Per-session UI state for selection and the active view lives in the declared chat store (`stores.ts` `createChatStore`); the InputHub owns the composer state machine and mirrors its draft into that store for persistence. Apply passes one store handle to the strict session subtree, chat view, and details registrations, so each session shares one instance and the framework owns its lifecycle. Components are pure: the framework standard kit supplies `useSession`/`sessionId`, global `useSessions`/`useWorkspaces`, and the input machine's `useInput`/`inputActions`; store faces and inject factories supply the remaining state and callbacks.
 

packages/client/ui-conversation/README.zh.md

@@ -12,7 +12,7 @@
 
 工具行同样是 slot：独立工具环（`ToolViewRegistry`／`ctx.toolviews`／outlet）已经退役。聊天配置项声明键控的 `'conversation.chat.toolview'` 空位（Session scope；key 空间在运行时开放）；其渲染点逐行通过 `entryKey: toolName` 分发，并以 `GenericToolCard` 作为调用点 `fallback`。owner 载荷是统一的 `ToolRowOwnerProps`（`callId`／`toolName`／`block`／`openFile`），`ToolRowProps` 则预先将其与 Session 标准工具包组合。注册方只是普通插件：`ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row)`，以 `inject: ['slots', 'conversation']` 作为加载顺序 seam（apply 在聊天注册后挂载 ConversationService，因此服务存在即可保证 slot 已声明）；Session 区分在组件内部完成（`useSessions` 读取 `parentId`，bash 示例是第三方姿态的范例）。Trajectory/waterfall 工具视图 slot 共享此形状，并随各自的渲染点落地（RendersCheck 会拒绝没有任何渲染方的声明）。
 
-todo 两个面就是在该形状上的两个注册项，都是普通注册方插件，`inject: ['slots', 'conversation']`。`TodoRow` 占用 `'conversation.chat.toolview'` 的 `todo_write` key，摘要该次调用「试图写入」的内容（从其 args 解析出 `<已完成>/<总数> 已完成 · <进行中条目>`；模型 JSON 残缺或形状不对时回落到通用摘要；非 ok 执行状态保留通用状态点，使被取消的调用绝不读成一次已完成的更新）。`TodoDock` 以 `order: -1` 占用 `'conversation.input.dock'` 列表 slot（位于队列行之上），是常驻的计划条：它从会话快照中选取 `todos` 并渲染 `TodoPanel`，后者接收纯列表，在列表为空时自我隐藏，折叠时收成标题加 `"<已完成>/<总数> tasks · <n> in progress"` 的表头（状态图标为 figma 的勾选／进行中／虚线未开始一组）。选取由 dock 适配器负责，因此面板保持为其 props 的纯函数；常驻列表放在此处而非行内，行才能保持单行。输入区 composer 链隐藏的一切（例如 ui-question 对 `conversation.composer` 的接管）也会隐藏整个 dock，包括这条计划条。
+todo 两个面就是在该形状上的两个注册项，都是普通注册方插件，`inject: ['slots', 'conversation']`。`TodoRow` 占用 `'conversation.chat.toolview'` 的 `todo_write` key，摘要该次调用「试图写入」的内容（从其 args 解析出 `<已完成>/<总数> 已完成 · <进行中条目>`；模型 JSON 残缺或形状不对时回落到通用摘要；非 ok 执行状态保留通用状态点，使被取消的调用绝不读成一次已完成的更新）。`TodoDock` 以 `order: -1` 占用 `'conversation.input.dock'` 列表 slot（位于队列行之上），是计划条：它从会话快照中选取 `todos`（站立计划：其后没有更晚 `turn/start` 的最近一次 `todo/write`）并渲染 `TodoPanel`，后者接收纯列表，在列表为空时自我隐藏，折叠时收成标题加 `"<已完成>/<总数> tasks · <n> in progress"` 的表头（状态图标为 figma 的勾选／进行中／虚线未开始一组）。选取由 dock 适配器负责，因此面板保持为其 props 的纯函数；站立列表放在此处而非行内，行才能保持单行。输入区 composer 链隐藏的一切（例如 ui-question 对 `conversation.composer` 的接管）也会隐藏整个 dock，包括这条计划条。
 
 逐 Session UI 状态中的选择与活跃视图位于已声明的聊天 store（`stores.ts` `createChatStore`）中；InputHub 拥有输入区状态机，并将草稿镜像到该 store 以便持久化。apply 将同一个 store handle 传给严格限定于会话的子树、聊天视图和详情注册，因此每个会话内共享一个实例，框架拥有其生命周期。组件保持纯粹：框架标准工具包提供 `useSession`／`sessionId`、全局 `useSessions`／`useWorkspaces`，以及输入状态机的 `useInput`／`inputActions`；store 表层与 inject factory 提供其余状态和回调。
 

packages/client/ui-conversation/src/client/skeleton/TodoPanel.tsx

@@ -1,9 +1,9 @@
-// TodoPanel: persistent plan strip above the composer (the web counterpart
-// of the TUI plan panel). Renders the latest todo/write whole-list snapshot —
-// no data of its own, hidden while the list is empty. Mounted through the
-// 'conversation.input.dock' slot (QueueDock posture): the dock adapter does
-// the selecting, so the panel takes the plain list and stays framework-free.
-// Visual: figma 772:51905 (states) / 772:52972 (collapsed) / 772:53419 (expanded).
+// TodoPanel: plan strip above the composer (the web counterpart of the TUI
+// plan panel). Renders the standing todo/write whole-list snapshot (cleared on
+// the next turn/start) — no data of its own, hidden while the list is empty.
+// Mounted through the 'conversation.input.dock' slot (QueueDock posture): the
+// dock adapter does the selecting, so the panel takes the plain list and stays
+// framework-free. Visual: figma 772:51905 / 772:52972 / 772:53419.
 
 import { useId, useState } from 'react'
 import type { Context } from 'cordis'