feat(schedule): add durable after reminders

packages/client/runtime/README.md

@@ -40,6 +40,8 @@ SlotsService gives the renderer separate bare observables for `useSessions` and
 
 Because the projection is log-ordered, the node array is seq-monotonic by construction: log-only `command/run` / `command/done` nodes splice in by seq, `Session` merges interrupted frozen nodes by their fractional seqs, and a window whose checkpoint cites a shadowed range outside it renders the marker with nothing logged. The marker's summary text, replaced-item count, and estimated shadowed-token count come from the checkpoint's cited `compact/summary` event; a window cut that left that event outside makes those fields unavailable, and a later page that supplies it resolves them. `CommandNode.outcome.sourceEventSeq` preserves a successful command's explicit reference to that summary event, allowing the presentation layer to pair `/compact` with its checkpoint without parsing settlement copy or assuming the two rows are adjacent. Performance contract: one append materializes at most one node and copies the projection only when it adds that node; an event that changes no node keeps the previous array reference (a chunk storm costs nothing), and unchanged nodes keep their object identity.
 
+A Host may redeliver the same Session event seq with a new or changed non-persistent view after the event reaches its presentation commit point. `Session` first requires deep event identity, then upgrades only the sidecar; a generic event view becomes one `PresentedEventNode` keyed by its `presentationKey`. The existing `liveBuffer` is the sole rendezvous during tail loading, gap stitching, and `loadOlder`. One merge path upgrades overlaps, consumes covered entries, and attaches only a contiguous suffix on every current-generation settlement, including rejected, empty, and discontinuous page responses. Reconnect advances the generation and clears its loading ownership, so an older request's result or `finally` cannot mutate or block the rebuilt window.
+
 ## Request inspection
 
 `SessionHistoryInspection.requests` is one chronological, purpose-discriminated provider-request stream. Assistant requests always carry their numeric `turn` and `step`; compaction requests carry `step: 0` and a `turn` owner that may be `null`. That null owner means a manual compaction ran standalone between turns, not that it belongs to either adjacent turn. A `session/end-seed` boundary closes an unmatched compaction request as an error at the boundary time with `Compaction was interrupted before completion.`; a later start projects as an independent request instead of overwriting the orphan.

packages/client/runtime/README.zh.md

@@ -40,6 +40,8 @@ SlotsService 分别为 renderer 提供 `useSessions` 与 `useWorkspaces` 的裸
 
 由于投影按日志顺序，节点数组天然按 seq 单调：仅日志的 `command/run` / `command/done` 节点按 seq 插入，`Session` 按分数 seq 归并被打断的冻结节点，而检查点所引范围落在窗口之外的窗口会渲染出标记且不打印任何日志。标记的摘要文本、被替换条目数量和估算的被遮蔽 token 数量都来自检查点引用的 `compact/summary` 事件；窗口切分把该事件留在窗口外时这些字段不可用，后续包含该事件的分页会解析出它们。`CommandNode.outcome.sourceEventSeq` 保留成功命令对该摘要事件的显式引用，使呈现层能够配对 `/compact` 与其检查点，而无须解析结算文案或假定两行相邻。性能约定：一次追加最多物化一个节点，并且仅在加入该节点时复制投影；不改变任何节点的事件保持上一次的数组引用（分片风暴零成本），未变化的节点保持其对象标识。
 
+一个 Session event 到达其 presentation 提交点后，Host 可以用同一 seq 重新投递完全相同的事件，并携带新增或变化的非持久 view。`Session` 会先要求事件深度一致，再只升级 sidecar；通用 event view 会按 `presentationKey` 形成一个 `PresentedEventNode`。既有 `liveBuffer` 是尾部加载、gap stitching 与 `loadOlder` 期间唯一的汇合点。每个当前 generation 的结算出口都使用同一条 merge 路径升级窗口重叠项、消费已覆盖项，并只接入连续后缀；RPC 拒绝、空页和不连续页同样如此。重连会推进 generation 并清除其 loading 所有权，因此旧请求的结果或 `finally` 既不能改写，也不能阻塞重建后的窗口。
+
 ## 请求检查
 
 `SessionHistoryInspection.requests` 是一条按时间顺序排列、以用途为判别字段的提供方请求流。助手请求始终携带数值型 `turn` 与 `step`；压缩请求携带 `step: 0`，其 `turn` 所有者可以是 `null`。这个 null 所有者表示手动压缩独立运行在两个轮次之间，并不表示它属于任一相邻轮次。`session/end-seed` 边界会在边界时刻将未匹配的压缩请求以错误状态结束，错误固定为 `Compaction was interrupted before completion.`；后续 start 会投影为独立请求，而不会覆盖这项遗留的未匹配请求。

packages/client/runtime/src/client/index.ts

@@ -50,7 +50,7 @@ export type {
 export type {
   AssistantBlock, AssistantMessageNode, AssistantProvenanceView, AssistantRequestConfig,
   AssistantTiming, CommandNode, CompactionSummaryNode, ComposerPhase,
-  ContextMessageNode, ConversationNode, ConversationSnapshot, ModelRetryNode, QueuedMessage,
+  ContextMessageNode, ConversationNode, ConversationSnapshot, ModelRetryNode, PresentedEventNode, QueuedMessage,
   RunningToolCall,
   SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, UnknownSurfaceNode, UserMessageNode,
 } from './sessions/conversation.ts'

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

@@ -252,6 +252,23 @@ export interface CommandNode {
   } | null
 }
 
+/**
+ * Host-computed presentation for one durable non-surface event. The generic
+ * runtime carries the keyed JSON-compatible payload without importing the
+ * producing domain; a client plugin owns the keyed renderer.
+ */
+export interface PresentedEventNode {
+  kind: 'presented-event'
+  /** Seq of the durable event whose sidecar produced this node. */
+  seq: number
+  /** Unix epoch ms from the source Session event. */
+  time: number
+  /** Open runtime key selecting an optional domain renderer. */
+  presentationKey: string
+  /** Domain-owned JSON-compatible presentation payload. */
+  view: unknown
+}
+
 /** Finalized conversation node union (kind discriminates; seq is the React key). */
 export type ConversationNode =
   | UserMessageNode
@@ -262,6 +279,7 @@ export type ConversationNode =
   | TurnErrorNode
   | ToolResultNode
   | CommandNode
+  | PresentedEventNode
   | CompactionSummaryNode
   | UnknownSurfaceNode
 

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

@@ -6,7 +6,7 @@ import type { LlmRetryEventData } from '@deepseek-ai/dsh-llm-retry/types'
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
 import type {
   HistoryEntry, IApiClient, MessageId, MuxFrame, QueueAction, RpcError,
-  RpcId, RpcResponse, RpcResult, SessionId, SubagentAddress, ToolEventView,
+  RpcId, RpcResponse, RpcResult, SessionEventView, SessionId, SubagentAddress,
 } from '@deepseek-ai/dsh-client-connection/client'
 // Value import from the inline-safe wire layer (not the connection plugin):
 // plugin-to-plugin value imports are a bundle purity error.
@@ -74,6 +74,30 @@ function queueTextOf(content: readonly ContentBlock[]): string | null {
   return content.map(block => block.text).join('')
 }
 
+/** Browser-safe structural equality for JSON-compatible wire values. */
+function sameWireValue(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true
+  if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object') return false
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false
+    return left.every((value, index) => sameWireValue(value, right[index]))
+  }
+  const leftRecord = left as Record<string, unknown>
+  const rightRecord = right as Record<string, unknown>
+  const leftKeys = Object.keys(leftRecord).sort()
+  const rightKeys = Object.keys(rightRecord).sort()
+  return leftKeys.length === rightKeys.length
+    && leftKeys.every((key, index) =>
+      key === rightKeys[index] && sameWireValue(leftRecord[key], rightRecord[key]))
+}
+
+/** Same-seq deliveries may add a sidecar, but must carry the identical durable event. */
+function assertSameEvent(left: SessionEvent, right: SessionEvent): void {
+  if (!sameWireValue(left, right)) {
+    throw new Error(`session event identity mismatch at seq ${left.seq}`)
+  }
+}
+
 /**
  * Owns a session's event window, derived conversation state, and observable
  * snapshot. React bindings remain outside this data layer. Features see only
@@ -85,7 +109,7 @@ export class Session implements SessionFace {
   private events: SessionEvent[] = []
   /** Wire views aligned with `events` by index (envelope-level annotations; undefined = no view).
    *  Kept parallel rather than merged so `events` stays the raw log slice (model-visible ⟺ logged). */
-  private views: (ToolEventView | undefined)[] = []
+  private views: (SessionEventView | undefined)[] = []
   private baseSeq = 0
   private hasMore = false
   private openState: OpenState = 'cold'
@@ -147,7 +171,7 @@ export class Session implements SessionFace {
   private promptError: PromptError | null = null
   private lastAgentError: string | null = null
   /** Live events buffered during open/resync and stitched by sequence once history lands. */
-  private liveBuffer: { event: SessionEvent; view: ToolEventView | undefined }[] = []
+  private liveBuffer: { event: SessionEvent; view: SessionEventView | undefined }[] = []
   /** Gap repair in flight; live events detour to the buffer until the tail page lands. */
   private stitching = false
   /** subscribed.lastSeq baseline (gap detection; null when no subscribed frame arrived — degrade to the liveBuffer dedup path). */
@@ -367,10 +391,12 @@ export class Session implements SessionFace {
   /** Page up: pull one earlier page with the window's first seq as beforeSeq and prepend (§D.2). */
   async loadOlder(): Promise<void> {
     if (this.openState !== 'open' || !this.hasMore || this.loadingOlder) return
+    const generation = this.openGeneration
     this.loadingOlder = true
     this.notifier.markDirty()
     try {
       const { result } = await this.history({ beforeSeq: this.baseSeq, maxMessages: PAGE_MESSAGES })
+      if (generation !== this.openGeneration) return
       if (!result.ok) return // keep the window as-is; do not overwrite openError (open already succeeded)
       const older = result.value.events
       if (older.length === 0) {
@@ -384,18 +410,30 @@ export class Session implements SessionFace {
         this.hasMore = false
         return
       }
-      this.events = [...older.map(e => e.event), ...this.events]
-      this.views = [...older.map(e => e.view), ...this.views]
-      /* v8 ignore next -- the ?? arm needs older[0] undefined, but the empty-page branch above already returned. */
-      this.baseSeq = older[0]?.event.seq ?? this.baseSeq
-      this.hasMore = result.value.hasMore
-      this.transcript.reset(this.events, this.views) // prepend forces a rebuild (the window grew at the head)
-      this.rebuildDerivedFromWindow()
+      this.installWindow([
+        ...older,
+        ...this.events.map((event, index): HistoryEntry => {
+          const view = this.views[index]
+          return view === undefined ? { event } : { event, view }
+        }),
+      ], result.value.hasMore)
     } catch (error) {
-      console.error('[web-runtime] loadOlder failed:', error)
+      if (generation === this.openGeneration) {
+        console.error('[web-runtime] loadOlder failed:', error)
+      }
     } finally {
-      this.loadingOlder = false
-      this.notifier.markDirty()
+      if (generation === this.openGeneration) {
+        try {
+          const { hasGap } = this.mergeWindow()
+          // oxlint-disable-next-line typescript/no-unnecessary-condition -- resync can close the window while the page request is awaited.
+          if (hasGap && this.openState === 'open') void this.repairGap()
+        } catch (error) {
+          console.error('[web-runtime] loadOlder buffer merge failed:', error)
+          void this.resync()
+        }
+        this.loadingOlder = false
+        this.notifier.markDirty()
+      }
     }
   }
 
@@ -423,6 +461,8 @@ export class Session implements SessionFace {
     this.pendingRev++
     this.subscribedLastSeq = null
     this.liveBuffer = []
+    this.loadingOlder = false
+    this.stitching = false
     this.notifier.markDirty()
     await this.open()
   }
@@ -627,7 +667,9 @@ export class Session implements SessionFace {
         if (generation !== this.openGeneration) return
         if (result.ok) this.installWindow(result.value.events, result.value.hasMore, result.value.projections)
       }
+      const { hasGap } = this.mergeWindow()
       this.openState = 'open'
+      if (hasGap) void this.repairGap()
     } catch (error) {
       if (generation !== this.openGeneration) return
       this.openState = 'error'
@@ -639,29 +681,132 @@ export class Session implements SessionFace {
     }
   }
 
-  /** Install the history window + stitch the liveBuffer (seq is the sole dedup key).
-   *  Stitching MUST NOT route through acceptLiveEvent: openState is still 'loading' here
-   *  (doOpen flips it after install), so recursing would push every buffered event straight
-   *  back into liveBuffer where nothing ever drains it — a silent drop loop (audit S1).
-   *  A carried projections block seeds the value store (higher seq wins, so a stale
-   *  baseline cannot overwrite a newer push frame); the window events themselves are
-   *  never folded — the host is the only computation site. */
+  /**
+   * Install one history window and settle every buffered overlap or safe
+   * contiguous suffix through {@link mergeWindow}. A carried projections
+   * block seeds the value store (higher seq wins, so a stale baseline cannot
+   * overwrite a newer push frame); the window events themselves are never
+   * folded — the host is the only computation site.
+   */
   private installWindow(entries: HistoryEntry[], hasMore: boolean, projections?: ProjectionsBaseline): void {
-    this.events = entries.map(e => e.event)
-    this.views = entries.map(e => e.view)
-    this.baseSeq = this.events[0]?.seq ?? 0
+    this.mergeWindow(entries)
     this.hasMore = hasMore
-    this.transcript.reset(this.events, this.views)
-    this.rebuildDerivedFromWindow()
     if (projections !== undefined) this.projections.seed(projections)
-    const buffered = this.liveBuffer
-    this.liveBuffer = []
-    for (const item of buffered) this.appendLive(item.event, item.view)
     this.notifier.markDirty()
   }
 
+  /**
+   * Reconcile a history snapshot (when supplied), the current window, and
+   * buffered live deliveries by seq. Same-seq events must be identical;
+   * defined late sidecars upgrade but an absent sidecar never erases an
+   * existing one. Only the contiguous suffix joins the window, leaving a real
+   * gap buffered for the existing repair path.
+   * @param entries - replacement/prepended history window, or undefined to
+   *   settle the current window after an RPC failure or empty page.
+   * @returns whether the visible window changed and whether a true gap remains.
+   */
+  private mergeWindow(entries?: readonly HistoryEntry[]): { changed: boolean; hasGap: boolean } {
+    const current = new Map<number, { event: SessionEvent; view: SessionEventView | undefined }>()
+    for (let index = 0; index < this.events.length; index++) {
+      const event = this.events[index]
+      /* v8 ignore next -- dense-array guard: index stays within events.length. */
+      if (event !== undefined) current.set(event.seq, { event, view: this.views[index] })
+    }
+
+    const events: SessionEvent[] = []
+    const views: (SessionEventView | undefined)[] = []
+    if (entries === undefined) {
+      events.push(...this.events)
+      views.push(...this.views)
+    } else {
+      let previousSeq: number | undefined
+      for (const entry of entries) {
+        if (previousSeq !== undefined && entry.event.seq !== previousSeq + 1) {
+          throw new Error(`history window is not contiguous at seq ${entry.event.seq}`)
+        }
+        previousSeq = entry.event.seq
+        const retained = current.get(entry.event.seq)
+        if (retained !== undefined) assertSameEvent(retained.event, entry.event)
+        events.push(entry.event)
+        views.push(entry.view ?? retained?.view)
+      }
+    }
+
+    const buffered = new Map<number, { event: SessionEvent; view: SessionEventView | undefined }>()
+    for (const item of this.liveBuffer) {
+      const retained = buffered.get(item.event.seq)
+      if (retained !== undefined) {
+        assertSameEvent(retained.event, item.event)
+        if (item.view !== undefined) retained.view = item.view
+      } else {
+        buffered.set(item.event.seq, { ...item })
+      }
+    }
+
+    const bySeq = new Map<number, number>()
+    for (let index = 0; index < events.length; index++) {
+      const event = events[index]
+      /* v8 ignore next -- dense-array guard: index stays within events.length. */
+      if (event !== undefined) bySeq.set(event.seq, index)
+    }
+    const consumed = new Set<number>()
+    let viewChanged = false
+    const baseSeq = events[0]?.seq
+    const tailSeq = events.at(-1)?.seq
+    for (const [seq, item] of buffered) {
+      const index = bySeq.get(seq)
+      if (index !== undefined) {
+        const event = events[index]
+        /* v8 ignore next -- bySeq indexes the dense events array. */
+        if (event === undefined) continue
+        assertSameEvent(event, item.event)
+        if (item.view !== undefined && !sameWireValue(views[index], item.view)) {
+          views[index] = item.view
+          viewChanged = true
+        }
+        consumed.add(seq)
+        continue
+      }
+      // A replay older than the retained tail window is irrelevant to this
+      // page and cannot become a future suffix.
+      if (baseSeq !== undefined && seq < baseSeq) {
+        consumed.add(seq)
+        continue
+      }
+      if (tailSeq !== undefined && seq <= tailSeq) {
+        throw new Error(`history window is missing buffered seq ${seq}`)
+      }
+    }
+
+    const appended: SessionEvent[] = []
+    let expectedSeq = tailSeq === undefined ? 0 : tailSeq + 1
+    for (let item = buffered.get(expectedSeq); item !== undefined; item = buffered.get(++expectedSeq)) {
+      events.push(item.event)
+      views.push(item.view)
+      appended.push(item.event)
+      consumed.add(expectedSeq)
+    }
+
+    const remaining = [...buffered.entries()]
+      .filter(([seq]) => !consumed.has(seq))
+      .sort(([left], [right]) => left - right)
+      .map(([, item]) => item)
+    this.liveBuffer = remaining
+
+    const changed = entries !== undefined || viewChanged || appended.length > 0
+    if (changed) {
+      this.events = events
+      this.views = views
+      this.baseSeq = events[0]?.seq ?? 0
+      this.transcript.reset(events, views)
+      this.rebuildDerivedFromWindow()
+      for (const event of appended) this.handoffPendingSteering(event)
+    }
+    return { changed, hasGap: remaining.length > 0 }
+  }
+
   /** Seq-guarded append shared by stitching and the open-state live path. */
-  private appendLive(event: SessionEvent, view?: ToolEventView): void {
+  private appendLive(event: SessionEvent, view?: SessionEventView): void {
     const tailSeq = this.windowTailSeq()
     if (tailSeq !== null && event.seq <= tailSeq) return // replay overlap, drop
     this.events.push(event)
@@ -687,18 +832,34 @@ export class Session implements SessionFace {
    *  expected reconnect-window artifact, repaired by refetch). The window stays one contiguous
    *  raw range, which is what lets the transcript render every event between its ends and lets a
    *  compaction checkpoint find its cited summary event. */
-  private acceptLiveEvent(event: SessionEvent, view?: ToolEventView): void {
+  private acceptLiveEvent(event: SessionEvent, view?: SessionEventView): void {
     if (this.openState === 'loading' || this.stitching) {
       this.liveBuffer.push({ event, view })
       return
     }
     if (this.openState !== 'open') return // cold/error: no window upkeep (history fully backfills on open)
     const tailSeq = this.windowTailSeq()
+    if (tailSeq !== null && event.seq <= tailSeq) {
+      this.liveBuffer.push({ event, view })
+      try {
+        const { changed } = this.mergeWindow()
+        if (changed) this.notifier.markDirty()
+      } catch (error) {
+        console.error('[web-runtime] duplicate session event failed identity validation:', error)
+        void this.resync()
+      }
+      return
+    }
     if (tailSeq !== null && event.seq > tailSeq + 1) {
       this.liveBuffer.push({ event, view })
       void this.repairGap()
       return
     }
+    if (tailSeq === null && event.seq !== 0) {
+      this.liveBuffer.push({ event, view })
+      void this.repairGap()
+      return
+    }
     this.appendLive(event, view)
     if (event.type === 'assistant/chunk') {
       if (isVisibleAssistantChunk(event.data.chunk.type)) this.notifier.markFrameDirty()
@@ -717,20 +878,33 @@ export class Session implements SessionFace {
     const generation = this.openGeneration
     try {
       const { result } = await this.history({ maxMessages: PAGE_MESSAGES })
-      // Failure or superseded by a full resync: drop — the resync path rebuilds and clears the buffer itself.
-      if (result.ok && generation === this.openGeneration && this.openState === 'open') {
+      if (generation !== this.openGeneration || this.openState !== 'open') return
+      if (result.ok) {
         this.installWindow(result.value.events, result.value.hasMore, result.value.projections)
+      } else {
+        this.mergeWindow()
       }
     } catch (error) {
-      console.error('[web-runtime] gap repair failed:', error)
+      if (generation === this.openGeneration) {
+        console.error('[web-runtime] gap repair failed:', error)
+        try {
+          this.mergeWindow()
+        } catch (mergeError) {
+          console.error('[web-runtime] gap repair buffer merge failed:', mergeError)
+          void this.resync()
+        }
+      }
     } finally {
-      this.stitching = false
+      if (generation === this.openGeneration) {
+        this.stitching = false
+        this.notifier.markDirty()
+      }
     }
   }
 
   /** Per-event side effects (right column of the §A.9 dispatch table):
    *  chunk/retry projection and openCalls add-remove. */
-  private applyEventSideEffects(event: SessionEvent, view?: ToolEventView): void {
+  private applyEventSideEffects(event: SessionEvent, view?: SessionEventView): void {
     const eventType = event.type as string
     if (eventType === 'llm/retry') {
       const data = parseRetryEventData(event.data)

packages/client/runtime/src/client/sessions/transcript-adapter.ts

@@ -19,7 +19,9 @@ import type { CommandId } from '@deepseek-ai/dsh-commands/brand'
 // `sessions: ISessions` (TS2717, the one-program-per-side rule in
 // docs/development.md).
 import type { COMPACT_CHECKPOINT_SOURCE } from '@deepseek-ai/dsh-compact/checkpoint'
-import type { ToolCallView, ToolEventView, ToolResultView } from '@deepseek-ai/dsh-client-connection/client'
+import type {
+  PresentedEventView, SessionEventView, ToolCallView, ToolResultView,
+} from '@deepseek-ai/dsh-client-connection/client'
 import type { CommandNode, CompactionSummaryNode, ConversationNode } from './conversation.ts'
 import { toAssistantBlocks } from './conversation.ts'
 import { contextForm, contextProvenance } from './context-provenance.ts'
@@ -48,7 +50,7 @@ interface CallIndexEntry {
   callView: ToolCallView | null
 }
 
-/** One event -> UI node (pure function; the ten-variant ConversationNode union). */
+/** One ordinary surface event -> UI node. */
 function materializeNode(
   event: SessionEvent,
   callIndex: ReadonlyMap<string, CallIndexEntry>,
@@ -117,6 +119,17 @@ function materializeNode(
   }
 }
 
+/** One host-presented non-surface event -> generic keyed conversation node. */
+function materializePresented(event: SessionEvent, sidecar: PresentedEventView): ConversationNode {
+  return {
+    kind: 'presented-event',
+    seq: event.seq,
+    time: event.time,
+    presentationKey: sidecar.presentationKey,
+    view: sidecar.view,
+  }
+}
+
 /**
  * Whether an event is a landed compaction checkpoint — all three conditions,
  * matching the terminal's `isCompactCheckpoint`: a `user/message`, carrying the
@@ -255,7 +268,7 @@ export class TranscriptAdapter {
    * @param events - the new window contents (seq-ascending).
    * @param views - per-event wire views aligned with `events` by index (undefined slots for view-less events).
    */
-  reset(events: readonly SessionEvent[], views?: readonly (ToolEventView | undefined)[]): void {
+  reset(events: readonly SessionEvent[], views?: readonly (SessionEventView | undefined)[]): void {
     this.rev++
     this.eventIndex = new Map()
     this.callIdx = new Map()
@@ -277,8 +290,13 @@ export class TranscriptAdapter {
     // Indexes first, then project: a tool/result materializes against the
     // complete call index, and a checkpoint against the complete event index.
     const projected: ConversationNode[] = []
-    for (const event of events) {
-      if (isTranscriptEvent(event)) projected.push(this.materialize(event, steeringSeqs.has(event.seq)))
+    for (let index = 0; index < events.length; index++) {
+      const event = events[index]
+      /* v8 ignore next -- dense-array guard: index stays within events.length. */
+      if (event === undefined) continue
+      const view = views?.[index]
+      if (view?.for === 'event') projected.push(materializePresented(event, view))
+      else if (isTranscriptEvent(event)) projected.push(this.materialize(event, steeringSeqs.has(event.seq)))
     }
     this.projected = projected
   }
@@ -292,12 +310,17 @@ export class TranscriptAdapter {
    * @param event - the live event (seq = window tail + 1).
    * @param view - host-computed tool view paired with the event when it is a tool call/result; indexed for card rendering.
    */
-  append(event: SessionEvent, view?: ToolEventView): void {
+  append(event: SessionEvent, view?: SessionEventView): void {
     this.eventIndex.set(event.seq, event)
     this.indexCall(event, view)
     const steering = this.steeringHistory.apply(event)
     indexAssistantStepTiming(this.stepTimings, event)
     if (this.indexCommand(event)) this.rev++
+    if (view?.for === 'event') {
+      this.projected = [...this.projected, materializePresented(event, view)]
+      this.rev++
+      return
+    }
     if (!isTranscriptEvent(event)) return
     this.projected = [...this.projected, this.materialize(event, steering)]
     this.rev++
@@ -392,7 +415,7 @@ export class TranscriptAdapter {
     return true
   }
 
-  private indexCall(event: SessionEvent, view?: ToolEventView): void {
+  private indexCall(event: SessionEvent, view?: SessionEventView): void {
     if (event.type === 'tool/result') {
       if (view?.for === 'result') this.resultViews.set(event.seq, view.view)
       return

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

@@ -33,6 +33,23 @@ function histResponse(events: SessionEvent[], hasMore = false) {
   return Promise.resolve(ok({ events: entries(events) as never[], hasMore }))
 }
 
+function logRange(start: number, end: number, label = 'fixture/log'): SessionEvent[] {
+  return Array.from({ length: end - start }, (_value, offset) =>
+    at(start + offset, { type: label, data: { index: start + offset } }))
+}
+
+function reminderEvent(seq: number, id: string): SessionEvent {
+  return at(seq, { type: 'schedule/change', data: { version: 1, operation: 'dispatch', id } })
+}
+
+function reminderView(id: string, prompt = '检查日志') {
+  return {
+    for: 'event' as const,
+    presentationKey: 'schedule/reminder',
+    view: { id, prompt },
+  }
+}
+
 describe('open', () => {
   it('installs the tail page: cold → loading → open with window and nodes in place', async () => {
     const { api, session } = makeSession()
@@ -82,9 +99,9 @@ describe('open', () => {
     const gate = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
     api.onHistory = () => gate.promise
     const opening = session.open()
-    // Three live frames land mid-open; seq 15 overlaps the page tail (page covers 10..15).
     const page = plainTurn(10, 0, '早', '安')
-    session.handleMuxEnvelope('r1' as never, { type: 'session/event', sessionId: SID, event: ev.turnStart(15, 1) })
+    // Three live frames land mid-open; seq 15 overlaps the page tail (page covers 10..15).
+    session.handleMuxEnvelope('r1' as never, { type: 'session/event', sessionId: SID, event: page[5]! })
     session.handleMuxEnvelope('r2' as never, { type: 'session/event', sessionId: SID, event: ev.user(16, '插进来的') })
     gate.resolve(ok({
       events: entries(page) as never[],
@@ -98,6 +115,117 @@ describe('open', () => {
   })
 })
 
+describe('late event views', () => {
+  it('upgrades an already-open raw event without duplicating it or letting an absent sidecar erase it', async () => {
+    const { api, session } = makeSession()
+    const event = reminderEvent(0, 'schedule-1')
+    api.onHistory = () => histResponse([event])
+    await session.open()
+    expect(session.getSnapshot().nodes).toEqual([])
+
+    session.handleMuxEnvelope('rv1' as never, {
+      type: 'session/event', sessionId: SID, event, view: reminderView('schedule-1'),
+    })
+    expect(session.getSnapshot().nodes).toMatchObject([{
+      kind: 'presented-event', seq: 0, presentationKey: 'schedule/reminder',
+      view: { id: 'schedule-1', prompt: '检查日志' },
+    }])
+
+    session.handleMuxEnvelope('rv2' as never, {
+      type: 'session/event', sessionId: SID, event,
+    })
+    expect(session.getSnapshot().nodes).toMatchObject([{
+      kind: 'presented-event', view: { prompt: '检查日志' },
+    }])
+
+    session.handleMuxEnvelope('rv3' as never, {
+      type: 'session/event', sessionId: SID, event, view: reminderView('schedule-1', '检查发布'),
+    })
+    expect(session.getSnapshot().nodes).toMatchObject([{
+      kind: 'presented-event', view: { prompt: '检查发布' },
+    }])
+  })
+
+  it('merges a view delivered while the tail history is loading', async () => {
+    const { api, session } = makeSession()
+    const event = reminderEvent(0, 'schedule-loading')
+    const gate = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => gate.promise
+    const opening = session.open()
+    session.handleMuxEnvelope('rv' as never, {
+      type: 'session/event', sessionId: SID, event, view: reminderView('schedule-loading'),
+    })
+    gate.resolve(ok({ events: [{ event }] as never[], hasMore: false }))
+    await opening
+    expect(session.getSnapshot().nodes).toMatchObject([{
+      kind: 'presented-event', seq: 0, view: { id: 'schedule-loading' },
+    }])
+  })
+
+  it('merges a late view buffered behind a gap repair snapshot', async () => {
+    const { api, session } = makeSession()
+    const first = logRange(0, 6)
+    api.onHistory = () => histResponse(first)
+    await session.open()
+
+    const due = reminderEvent(9, 'schedule-gap')
+    const full = [...first, ...logRange(6, 9), due]
+    const gate = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => gate.promise
+    session.handleMuxEnvelope('raw' as never, {
+      type: 'session/event', sessionId: SID, event: due,
+    })
+    session.handleMuxEnvelope('late' as never, {
+      type: 'session/event', sessionId: SID, event: due, view: reminderView('schedule-gap'),
+    })
+    gate.resolve(ok({ events: entries(full) as never[], hasMore: false }))
+
+    await vi.waitFor(() => {
+      expect(session.getSnapshot().nodes).toMatchObject([{
+        kind: 'presented-event', seq: 9, view: { id: 'schedule-gap' },
+      }])
+    })
+  })
+
+  it.each(['success', 'rejection', 'empty', 'discontinuous'] as const)(
+    'settles a late overlap after loadOlder %s',
+    async (outcome) => {
+      const { api, session } = makeSession()
+      const newer = logRange(6, 12)
+      const target = newer[3]!
+      api.onHistory = () => histResponse(newer, true)
+      await session.open()
+
+      const gate = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+      api.onHistory = () => gate.promise
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+      try {
+        const loading = session.loadOlder()
+        session.handleMuxEnvelope('late' as never, {
+          type: 'session/event', sessionId: SID, event: target,
+          view: reminderView(`schedule-${outcome}`),
+        })
+        if (outcome === 'success') {
+          gate.resolve(ok({ events: entries(logRange(0, 6)) as never[], hasMore: false }))
+        } else if (outcome === 'rejection') {
+          gate.resolve(err({ code: 'internal', message: 'page rejected', details: {} }))
+        } else if (outcome === 'empty') {
+          gate.resolve(ok({ events: [], hasMore: false }))
+        } else {
+          gate.resolve(ok({ events: entries(logRange(0, 2)) as never[], hasMore: true }))
+        }
+        await loading
+        expect(session.getSnapshot().nodes).toMatchObject([{
+          kind: 'presented-event', seq: target.seq,
+          view: { id: `schedule-${outcome}` },
+        }])
+      } finally {
+        errorSpy.mockRestore()
+      }
+    },
+  )
+})
+
 
 describe('live event path', () => {
   async function opened(events: SessionEvent[] = plainTurn(0, 0, 'a', 'b')) {
@@ -548,11 +676,12 @@ describe('live event path', () => {
   })
 
   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')]
+    const first = plainTurn(0, 0, 'a', 'b')
+    const { api, session } = await opened(first) // tail seq = 5
+    const repaired = [...first, ...plainTurn(6, 1, 'c', 'd')]
     api.onHistory = () => histResponse(repaired)
     // seq 9 with tail 5 → gap; the event detours to the buffer and one history refetch fires.
-    session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: ev.assistant(9, 1, 'd') })
+    session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: repaired[9]! })
     await vi.waitFor(() => {
       expect(api.callsOf('session.history').length).toBe(2)
     })
@@ -883,11 +1012,12 @@ describe('remaining branches', () => {
 
   it('subscribed baseline past the window tail triggers the second stitch pull in doOpen', async () => {
     const { api, session } = makeSession()
-    const full = [...plainTurn(0, 0, 'a', 'b'), ...plainTurn(6, 1, 'c', 'd')]
+    const first = plainTurn(0, 0, 'a', 'b')
+    const full = [...first, ...plainTurn(6, 1, 'c', 'd')]
     let call = 0
     api.onHistory = () => {
       call++
-      return histResponse(call === 1 ? plainTurn(0, 0, 'a', 'b') : full)
+      return histResponse(call === 1 ? first : full)
     }
     // Baseline arrives before open: lastSeq 11 > first page tail 5 → doOpen repulls once.
     session.handleMuxEnvelope('rs' as never, { type: 'session/subscribed', sessionId: SID, lastSeq: 11 })
@@ -1175,6 +1305,107 @@ describe('resync', () => {
     expect(snapshot.nodes.map(n => n.seq)).toEqual([7, 9])
   })
 
+  it('a stale loadOlder success and finally cannot mutate or clear a fresh-generation page request', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(logRange(6, 12), true)
+    await session.open()
+
+    const stale = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => stale.promise
+    const staleLoad = session.loadOlder()
+
+    api.onHistory = () => histResponse(logRange(12, 18), true)
+    await session.resync()
+    const fresh = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => fresh.promise
+    const freshLoad = session.loadOlder()
+    expect(session.getSnapshot()).toMatchObject({ loadingOlder: true, hasMore: true })
+
+    stale.resolve(ok({ events: entries(logRange(0, 6)) as never[], hasMore: false }))
+    await staleLoad
+    expect(session.getSnapshot()).toMatchObject({ loadingOlder: true, hasMore: true })
+
+    fresh.resolve(ok({ events: entries(logRange(6, 12)) as never[], hasMore: false }))
+    await freshLoad
+    expect(session.getSnapshot()).toMatchObject({ loadingOlder: false, hasMore: false })
+  })
+
+  it('a stale rejected or never-settled loadOlder cannot freeze the new generation', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(logRange(6, 12), true)
+    await session.open()
+
+    const stale = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => stale.promise
+    const staleLoad = session.loadOlder()
+    api.onHistory = () => histResponse(logRange(12, 18), false)
+    await session.resync()
+    expect(session.getSnapshot()).toMatchObject({ openState: 'open', loadingOlder: false })
+
+    stale.reject(new Error('old page connection closed'))
+    await staleLoad
+    expect(session.getSnapshot()).toMatchObject({ openState: 'open', loadingOlder: false })
+
+    const never = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    // Re-open a pageable generation and park a request that never settles.
+    api.onHistory = () => histResponse(logRange(18, 24), true)
+    await session.resync()
+    api.onHistory = () => never.promise
+    void session.loadOlder()
+    expect(session.getSnapshot().loadingOlder).toBe(true)
+    api.onHistory = () => histResponse(logRange(24, 30), false)
+    await session.resync()
+    expect(session.getSnapshot()).toMatchObject({ openState: 'open', loadingOlder: false })
+  })
+
+  it('stale gap success, rejection, and finally cannot clear a fresh repair owner', async () => {
+    const { api, session } = makeSession()
+    const initial = logRange(0, 6)
+    api.onHistory = () => histResponse(initial)
+    await session.open()
+
+    const staleRepair = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    api.onHistory = () => staleRepair.promise
+    session.handleMuxEnvelope('old-gap' as never, {
+      type: 'session/event', sessionId: SID, event: reminderEvent(9, 'old-gap'),
+    })
+
+    const freshBase = logRange(10, 16)
+    api.onHistory = () => histResponse(freshBase)
+    await session.resync()
+
+    const freshRepair = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
+    let freshRepairCalls = 0
+    api.onHistory = () => {
+      freshRepairCalls++
+      return freshRepair.promise
+    }
+    const due = reminderEvent(18, 'fresh-gap')
+    session.handleMuxEnvelope('fresh-gap' as never, {
+      type: 'session/event', sessionId: SID, event: due, view: reminderView('fresh-gap'),
+    })
+    expect(freshRepairCalls).toBe(1)
+
+    staleRepair.reject(new Error('stale gap connection closed'))
+    await Promise.resolve()
+    await Promise.resolve()
+    const trailing = at(19, { type: 'fixture/log', data: { index: 19 } })
+    session.handleMuxEnvelope('fresh-trailing' as never, {
+      type: 'session/event', sessionId: SID, event: trailing,
+    })
+    expect(freshRepairCalls).toBe(1)
+
+    freshRepair.resolve(ok({
+      events: entries([...freshBase, ...logRange(16, 18), due, trailing]) as never[],
+      hasMore: false,
+    }))
+    await vi.waitFor(() => {
+      expect(session.getSnapshot().nodes).toMatchObject([{
+        kind: 'presented-event', seq: 18, view: { id: 'fresh-gap' },
+      }])
+    })
+  })
+
 })
 
 describe('nested run_code sub-dispatches', () => {

packages/client/runtime/tests/transcript-adapter.spec.ts

@@ -434,6 +434,34 @@ describe('TranscriptAdapter', () => {
     })
   })
 
+  it('materializes generic presented-event nodes on replay and live append', () => {
+    const replayed = at(0, { type: 'schedule/change', data: { operation: 'dispatch', id: 'schedule-1' } })
+    const live = at(1, { type: 'schedule/change', data: { operation: 'dispatch', id: 'schedule-2' } })
+    const adapter = new TranscriptAdapter()
+    adapter.reset([replayed], [{
+      for: 'event',
+      presentationKey: 'schedule/reminder',
+      view: { id: 'schedule-1', prompt: '检查日志' },
+    }])
+    adapter.append(live, {
+      for: 'event',
+      presentationKey: 'schedule/reminder',
+      view: { id: 'schedule-2', prompt: '检查发布' },
+    })
+    expect(adapter.nodes()).toEqual([
+      {
+        kind: 'presented-event', seq: 0, time: 1_700_000_000_000,
+        presentationKey: 'schedule/reminder',
+        view: { id: 'schedule-1', prompt: '检查日志' },
+      },
+      {
+        kind: 'presented-event', seq: 1, time: 1_700_000_000_001,
+        presentationKey: 'schedule/reminder',
+        view: { id: 'schedule-2', prompt: '检查发布' },
+      },
+    ])
+  })
+
   it('leaves callView null when the paired call fell outside the window (cross-page break)', () => {
     const adapter = new TranscriptAdapter()
     const resultView = { for: 'result' as const, view: { card: 'generic' as const, title: '孤儿' } }