dsh-code 1.0.6 → 1.2.0

package/src/render/projection.ts

@@ -23,6 +23,7 @@ import type {} from '@deepseek-ai/dsh-goal'
 import type {} from '@deepseek-ai/dsh-llm-retry'
 import type {} from '@deepseek-ai/dsh-plan-mode'
 import type {} from '@deepseek-ai/dsh-permission-presets'
+import type {} from '@deepseek-ai/dsh-schedule'
 import type {} from '@deepseek-ai/dsh-sandbox-policy'
 import type {} from '@deepseek-ai/dsh-session-title'
 // The subagent package's durable catalog event joins the union the same way
@@ -62,6 +63,12 @@ export interface UserEntry {
   images?: readonly ImageBlock['attachment'][]
   /** Durable file references carried by this prompt (0.1.5 file blocks). */
   files?: readonly FileAttachmentRef[]
+  /**
+   * How the prompt reached the agent, when it did not arrive as an ordinary
+   * submission: `queued` waited for this turn, `steered` joined it mid-flight.
+   * Absent for a prompt typed straight into an idle composer.
+   */
+  delivery?: 'queued' | 'steered'
 }
 
 /** One user message waiting in the agent inbox (the web's queued-message row). */
@@ -121,6 +128,169 @@ export interface ToolEntry {
    * result lands and only when something renderable exists.
    */
   detail: ToolDetail | undefined
+  /**
+   * Nested PTC sub-dispatches (`run_code`) in start order, bounded to the
+   * newest {@link MAX_TOOL_SUB_DISPATCHES} rows.
+   */
+  subs: readonly ToolSubDispatch[]
+  /** Sub-dispatches evicted from the bounded window. */
+  subsDropped: number
+}
+
+/**
+ * One nested PTC sub-dispatch under a `run_code` parent call: the durable
+ * `tool/ptc-dispatch-start`/`tool/ptc-dispatch` pair folded to one bounded
+ * row (upstream contract: pair by `subCallId`, every start settles, and the
+ * settle carries `tool/result`'s own vocabulary).
+ */
+export interface ToolSubDispatch {
+  /** Opaque sub-call id pairing the start with its settle. */
+  subCallId: string
+  /** Sub-call tool name. */
+  name: string
+  /** Bounded arguments preview. */
+  preview: string
+  /** Lifecycle; `running` until the paired settle lands. */
+  state: 'running' | 'done' | 'error'
+  /** Bounded first text block of the settle content, '' until it lands. */
+  summary: string
+  /** Wall-clock duration (settle − start), 0 while running. */
+  durationMs: number
+}
+
+/** Bounded sub-dispatch window per tool card (display budget only). */
+export const MAX_TOOL_SUB_DISPATCHES = 12
+
+/** Bounded member window per workflow run card (display budget only). */
+export const MAX_WORKFLOW_MEMBERS = 12
+
+/** One workflow member (an `agent()` call inside a `workflow` script). */
+export interface WorkflowMember {
+  /** Member sequence within the run (the agent-start/agent-end pairing key). */
+  seq: number
+  /** Display label. */
+  label: string
+  /** Declared phase title, '' when none. */
+  phase: string
+  /** Child session id (cross-links the subagent feed's rows). */
+  childId: string
+  /** Settlement; `running` until the paired `tool-workflow/agent-end`. */
+  outcome: 'running' | 'completed' | 'failed' | 'cancelled'
+}
+
+/**
+ * One durable workflow run (the `tool-workflow/*` record a `workflow` or
+ * `ralph` tool appends to the parent session): run identity plus its
+ * bounded member list, live until `tool-workflow/run-end` settles.
+ */
+export interface WorkflowEntry {
+  kind: 'workflow'
+  /** Stable run identity shared by every event of the run. */
+  runId: string
+  /** Display name of the run. */
+  name: string
+  /** Members in sequence order, bounded to the newest window. */
+  members: readonly WorkflowMember[]
+  /** Members evicted from the bounded window. */
+  membersDropped: number
+  /** Run settlement; `running` until `tool-workflow/run-end`. */
+  state: 'running' | 'completed' | 'cancelled' | 'error'
+}
+
+/** Payload of `tool-workflow/run-start` (dsh-tool-workflow's map merge). */
+interface WorkflowRunStartData {
+  runId: string
+  name: string
+}
+
+/** Payload of `tool-workflow/agent-start`. */
+interface WorkflowAgentStartData {
+  runId: string
+  seq: number
+  label: string
+  phase?: string
+  childId: string
+}
+
+/** Payload of `tool-workflow/agent-end`. */
+interface WorkflowAgentEndData {
+  runId: string
+  seq: number
+  outcome: 'completed' | 'failed' | 'cancelled'
+}
+
+/** Payload of `tool-workflow/run-end`. */
+interface WorkflowRunEndData {
+  runId: string
+  stopReason: 'completed' | 'cancelled' | 'error'
+}
+
+/** Append one member to a run entry, evicting past the bounded window. */
+function pushWorkflowMember(entry: WorkflowEntry, member: WorkflowMember): WorkflowEntry {
+  if (entry.members.length >= MAX_WORKFLOW_MEMBERS) {
+    return { ...entry, members: [...entry.members.slice(1), member], membersDropped: entry.membersDropped + 1 }
+  }
+  return { ...entry, members: [...entry.members, member] }
+}
+
+/** Settle one member by its sequence number (pure; unmatched stays a no-op). */
+function settleWorkflowMember(entry: WorkflowEntry, data: WorkflowAgentEndData): WorkflowEntry {
+  let paired = false
+  const members = entry.members.map(member => {
+    if (member.seq !== data.seq) return member
+    paired = true
+    return { ...member, outcome: data.outcome }
+  })
+  return paired ? { ...entry, members } : entry
+}
+
+/**
+ * Payload of `tool/ptc-dispatch-start` (`@deepseek-ai/dsh-tools`'s
+ * SessionEventMap merge — the bundle does not depend on that package, so
+ * the fold guards the discriminator by string instead of by type).
+ */
+interface PtcDispatchStartData {
+  rootCallId: string
+  subCallId: string
+  name: string
+  arguments: unknown
+}
+
+/** Payload of `tool/ptc-dispatch` (a start plus its settled outcome). */
+interface PtcDispatchData extends PtcDispatchStartData {
+  isError: boolean
+  content: readonly ContentBlock[]
+}
+
+/** JSON-stringify one sub-dispatch argument value for the preview helper. */
+function subDispatchArguments(arguments_: unknown): string {
+  if (typeof arguments_ === 'string') return arguments_
+  try {
+    return JSON.stringify(arguments_) ?? ''
+  } catch {
+    return ''
+  }
+}
+
+/** Append one running sub-dispatch under its parent, evicting past the cap. */
+function pushSubDispatch(entry: ToolEntry, sub: ToolSubDispatch): ToolEntry {
+  if (entry.subs.length >= MAX_TOOL_SUB_DISPATCHES) {
+    return { ...entry, subs: [...entry.subs.slice(1), sub], subsDropped: entry.subsDropped + 1 }
+  }
+  return { ...entry, subs: [...entry.subs, sub] }
+}
+
+/** Fold one settled sub-dispatch into its matching row (pure). */
+function settleSubDispatch(entry: ToolEntry, data: PtcDispatchData, summary: string, durationMs: number): ToolEntry {
+  let paired = false
+  const subs = entry.subs.map(sub => {
+    if (sub.subCallId !== data.subCallId) return sub
+    paired = true
+    return { ...sub, state: data.isError === true ? 'error' as const : 'done' as const, summary, durationMs }
+  })
+  // A settle without a live row (the sub left the bounded window, or the
+  // parent entry was never seen) stays a provable no-op.
+  return paired ? { ...entry, subs } : entry
 }
 
 /** One slash-command execution dispatched through `ctx.commands`. */
@@ -193,7 +363,7 @@ export interface FilesEntry {
 }
 
 /** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | PendingEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry
+export type TranscriptEntry = UserEntry | PendingEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry | WorkflowEntry
 
 /** The live goal the status line badges, folded from `goal/change`. */
 export interface GoalFold {
@@ -208,14 +378,21 @@ export interface GoalFold {
   blocked: string
 }
 
-/** Cumulative token accounting folded from `assistant/message` usage reports. */
+/**
+ * Cumulative token accounting folded from `assistant/message` usage reports.
+ * The buckets are disjoint and mirror the provider's report, so the prompt
+ * side is never double counted: reasoning tokens are already inside
+ * `outputTokens`, and cache reads are never folded into the uncached input.
+ */
 export interface UsageTotals {
-  /** Prompt-side billed tokens: `inputTokens` plus both cache buckets. */
-  inputTokens: number
+  /** Prompt-side tokens billed outside the cache. */
+  uncachedInputTokens: number
   /** Completion-side tokens over the whole log. */
   outputTokens: number
   /** Cache-read tokens over the whole log (0 when the adapter reports none). */
   cacheReadTokens: number
+  /** Cache-write tokens over the whole log (0 when the adapter reports none). */
+  cacheWriteTokens: number
 }
 
 /**
@@ -273,6 +450,86 @@ export interface TranscriptStats {
   reasoningEffort: string
 }
 
+/** One active reminder folded from durable `schedule/change` events. */
+export interface ScheduleRow {
+  readonly id: string
+  readonly kind: 'after' | 'at' | 'every'
+  readonly prompt: string
+  /** Next due time (epoch ms); the /schedule panel derives overdue/relative labels. */
+  readonly targetAt: number
+  /** Recurrence seconds for 'every' rows, undefined otherwise. */
+  readonly everySeconds?: number
+}
+
+/**
+ * The durable `schedule/change` payload shape this fold consumes. Upstream
+ * strict-decodes the whole transition stream before appending, so unknown
+ * ids here are corrupt-input edges that degrade to a no-op.
+ */
+export interface ScheduleChangeLike {
+  readonly operation: 'create' | 'delete' | 'dispatch'
+  readonly schedule?: {
+    readonly id: string
+    readonly kind: 'after' | 'at' | 'every'
+    readonly prompt: string
+    readonly afterSeconds?: number
+    readonly everySeconds?: number
+    readonly scheduledAt: string
+  }
+  readonly id?: string
+  readonly acceptedAt?: string
+}
+
+/*
+ * Upstream record semantics (dsh-schedule types): `scheduledAt` is ALREADY
+ * the due instant — AfterScheduleRecord carries the RFC 3339 UTC target
+ * (delay included), EveryScheduleRecord carries the earliest anchor-aligned
+ * occurrence not yet dispatched. No kind ever adds its own interval on top.
+ */
+
+/** Fold one `schedule/change` into the active-reminder list (create/delete/dispatch). */
+export function applyScheduleChange(rows: readonly ScheduleRow[], data: ScheduleChangeLike): readonly ScheduleRow[] {
+  if (data.operation === 'create' && data.schedule !== undefined) {
+    const schedule = data.schedule
+    const row: ScheduleRow = {
+      id: schedule.id,
+      kind: schedule.kind,
+      prompt: schedule.prompt,
+      targetAt: Date.parse(schedule.scheduledAt),
+      ...(schedule.kind === 'every' ? { everySeconds: schedule.everySeconds ?? 0 } : {}),
+    }
+    return [...rows.filter(existing => existing.id !== schedule.id), row]
+  }
+  if (data.operation === 'delete' && data.id !== undefined) {
+    return rows.filter(existing => existing.id !== data.id)
+  }
+  if (data.operation === 'dispatch' && data.id !== undefined) {
+    // A dispatched one-shot reminder is finished. An 'every' reminder
+    // advances PAST every missed occurrence in one step: the next target is
+    // the first anchor-aligned instant strictly after acceptedAt, stepping
+    // from the previous aligned target (upstream advances the same way).
+    if (data.acceptedAt === undefined) return rows.filter(existing => existing.id !== data.id)
+    const accepted = Date.parse(data.acceptedAt)
+    return rows.map(existing => existing.id === data.id
+      ? { ...existing, targetAt: nextEveryTarget(existing.targetAt, accepted, existing.everySeconds ?? 0) }
+      : existing)
+  }
+  return rows
+}
+
+/** First anchor-aligned target after `acceptedAt`, stepping from the previous aligned target. */
+export function nextEveryTarget(previousTarget: number, acceptedAt: number, everySeconds: number): number {
+  const interval = Math.max(1, everySeconds) * 1000
+  if (acceptedAt <= previousTarget) return previousTarget + interval
+  const missed = Math.ceil((acceptedAt - previousTarget + 1) / interval)
+  return previousTarget + missed * interval
+}
+
+/** Plugin snapshot sources folded into token stats but never rendered as rows. */
+const HIDDEN_SNAPSHOT_PLUGINS = new Set(['time-context', 'tmux-context'])
+/** Plugin prompt sources rendered as full user rows (they ARE the conversation). */
+const REMINDER_PLUGINS = new Set(['schedule'])
+
 /** The complete TUI transcript view for one session. */
 export interface TranscriptView {
   /** Settled entries in log order. */
@@ -319,12 +576,22 @@ export interface TranscriptView {
   sandbox: string
   /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
   goal: GoalFold | undefined
+  /** Active reminders folded from `schedule/change` events, oldest target first at render. */
+  schedules: readonly ScheduleRow[]
   /**
    * Ordered live message ids per inbox target, mirrored from
    * `agent/inbox/spliced` exactly like the upstream Inbox projection — the
    * coordinates later removals resolve against.
    */
   pending: { 'next-turn': readonly string[]; 'next-step': readonly string[] }
+  /**
+   * In-flight inbox messages by the list they were inserted into, kept until
+   * the durable user message that claims them lands. The claim itself is a
+   * plain splice that empties the pending row first, so this map — not
+   * {@link pending} — is what lets a settled prompt say it was queued or
+   * steered rather than typed into an idle composer.
+   */
+  claimOrigin: ReadonlyMap<string, 'next-turn' | 'next-step'>
   /**
    * Fold-internal timing anchors, never rendered: open step and tool-call
    * start timestamps the next `assistant/message` / `tool/result` resolves
@@ -336,6 +603,8 @@ export interface TranscriptView {
   readonly anchors: {
     stepStart: Map<string, number>
     toolStart: Map<string, number>
+    /** Open PTC sub-dispatch starts by `subCallId` (duration anchors). */
+    subStart: Map<string, number>
     firstChunkAt: Map<string, number>
     compactionTokens: Map<string, number>
     lastPruneTokens: number
@@ -399,6 +668,7 @@ function cloneViewAnchors(anchors: TranscriptView['anchors']): TranscriptView['a
   return {
     stepStart: new Map(anchors.stepStart),
     toolStart: new Map(anchors.toolStart),
+    subStart: new Map(anchors.subStart),
     firstChunkAt: new Map(anchors.firstChunkAt),
     compactionTokens: new Map(anchors.compactionTokens),
     lastPruneTokens: anchors.lastPruneTokens,
@@ -491,9 +761,11 @@ export function createTranscriptView(): TranscriptView {
     systemPrompt: '',
     sandbox: '',
     goal: undefined,
+    schedules: [],
     pending: { 'next-turn': [], 'next-step': [] },
-    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
-    anchors: { stepStart: new Map(), toolStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map(), turnSteps: new Map(), turnTools: new Map(), systemNodes: new Map() },
+    claimOrigin: new Map(),
+    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
+    anchors: { stepStart: new Map(), toolStart: new Map(), subStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map(), turnSteps: new Map(), turnTools: new Map(), systemNodes: new Map() },
   }
 }
 
@@ -538,6 +810,18 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         pending = { ...pending, [target]: pending[target].filter((_, i) => i !== index) }
         entries = entries.filter(entry => !(entry.kind === 'pending' && entry.messageId === message.id))
       }
+      // How this message reached the agent. The claim that precedes this event
+      // is a plain splice (no `canceled` outcome), so it has already emptied
+      // the pending row above; `claimOrigin` is what survives to say whether
+      // the prompt was queued for this turn or steered into it.
+      const origin = view.claimOrigin.get(message.id)
+      let claimOrigin = view.claimOrigin
+      if (origin !== undefined) {
+        const next = new Map(claimOrigin)
+        next.delete(message.id)
+        claimOrigin = next
+      }
+      const delivery = origin === undefined ? {} : { delivery: origin === 'next-turn' ? 'queued' as const : 'steered' as const }
       // Injected context (plugin/model-continuation sources) stays collapsed
       // to a bounded notice row, exactly like collapsed transcript context
       // elsewhere in the product; only direct human prompts render in full.
@@ -548,7 +832,41 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         return {
           ...view,
           pending,
-          entries: [...entries, { kind: 'user', text, notice: false, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) }],
+          claimOrigin,
+          entries: [...entries, { kind: 'user', text, notice: false, ...delivery, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) }],
+          stats: {
+            ...view.stats,
+            contextSegments: {
+              ...view.stats.contextSegments,
+              prompt: view.stats.contextSegments.prompt + estimateTokens(text),
+            },
+          },
+        }
+      }
+      // Snapshot injections (time/tmux context) still spend model context but
+      // render nothing; the schedule reminder is a real prompt and renders in
+      // full — the model acts on it, so the transcript must show it.
+      if (message.source.kind === 'plugin' && HIDDEN_SNAPSHOT_PLUGINS.has(message.source.plugin)) {
+        return {
+          ...view,
+          pending,
+          claimOrigin,
+          entries,
+          stats: {
+            ...view.stats,
+            contextSegments: {
+              ...view.stats.contextSegments,
+              system: view.stats.contextSegments.system + estimateTokens(text),
+            },
+          },
+        }
+      }
+      if (message.source.kind === 'plugin' && REMINDER_PLUGINS.has(message.source.plugin)) {
+        return {
+          ...view,
+          pending,
+          claimOrigin,
+          entries: [...entries, { kind: 'user', text, notice: false, ...delivery, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) }],
           stats: {
             ...view.stats,
             contextSegments: {
@@ -560,11 +878,14 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
-        : message.source.kind
+        : message.source.kind === 'plugin'
+          ? message.source.plugin
+          : message.source.kind
       const summary = boundContextSummary(notice)
       return {
         ...view,
         pending,
+        claimOrigin,
         entries: [...entries, { kind: 'user', text: summary, notice: true }],
         stats: {
           ...view.stats,
@@ -579,9 +900,29 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       // The durable inbox mutation (web queue-mirror contract, event-sourced):
       // removals drop the projected rows at their inbox coordinates, inserted
       // messages gain a pending row at their log position.
-      const { target, start, removedCount = 0, inserted } = event.data
+      const { target, start, removedCount = 0, inserted, outcome } = event.data
       const ids = view.pending[target]
       const removed = ids.slice(start, start + removedCount)
+      // Which list each in-flight message came from, so the durable user
+      // message it later becomes can say how it was delivered. Only messages
+      // that arrived while a turn was already running count: `followup` is
+      // the ordinary submission path too, so an idle submission lands in
+      // next-turn exactly like a queued one and must stay unmarked. A claim
+      // (no `outcome`) keeps the entry because the user message is still
+      // coming; a real cancellation retires it.
+      const inFlight = view.busy
+      let claimOrigin: ReadonlyMap<string, 'next-turn' | 'next-step'> = view.claimOrigin
+      let mutableOrigins: Map<string, 'next-turn' | 'next-step'> | undefined
+      const remember = (id: string): void => {
+        mutableOrigins ??= new Map(claimOrigin)
+        mutableOrigins.set(id, target)
+        claimOrigin = mutableOrigins
+      }
+      if (outcome === 'canceled' && removed.length > 0) {
+        const next = new Map(claimOrigin)
+        for (const id of removed) next.delete(id)
+        claimOrigin = next
+      }
       // In-place upstream semantics: the kernel's authoritative fold is
       // `inbox.splice(start, removedCount, ...inserted)` — inserted ids land
       // AT the splice position (prepend/replace shapes), never at the tail.
@@ -600,6 +941,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           !(entry.kind === 'pending' && entry.target === target && removedSet.has(entry.messageId)))
       }
       for (const message of inserted) {
+        if (inFlight) remember(message.id)
         entries = [...entries, {
           kind: 'pending',
           messageId: message.id,
@@ -609,7 +951,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           ...filesOf(message.content).length === 0 ? {} : { files: filesOf(message.content) },
         }]
       }
-      return { ...view, entries, pending: { ...view.pending, [target]: nextIds } }
+      return { ...view, entries, claimOrigin, pending: { ...view.pending, [target]: nextIds } }
     }
     case 'system/message': {
       // Session-log v3 carries the system prompt as surface nodes (the
@@ -693,18 +1035,25 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const totals = stats.usage
       const text = textOf(event.data.message.content)
       const reasoning = reasoningOf(event.data.message.content)
+      // A tool-only step settles with no text, no reasoning, and (unless the
+      // attempt was interrupted) nothing to render: appending an entry would
+      // create an invisible zero-line card that pads the inspector's ←→
+      // walk and an empty block in /export. The event still updates timing
+      // and usage above; only the transcript entry is skipped.
+      const renderable = text !== '' || reasoning !== '' || event.data.interrupted === true
       return {
         ...view,
         streaming: '',
         streamingReasoning: '',
-        entries: [...view.entries, { kind: 'assistant', text, reasoning, interrupted: event.data.interrupted === true ? true : undefined }],
+        ...(renderable ? { entries: [...view.entries, { kind: 'assistant', text, reasoning, interrupted: event.data.interrupted === true ? true : undefined }] } : {}),
         stats: {
           ...stats,
           llmMs: stats.llmMs + (started === undefined ? 0 : Math.max(0, event.time - started)),
           usage: usage === undefined ? totals : {
-            inputTokens: totals.inputTokens + usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+            uncachedInputTokens: totals.uncachedInputTokens + usage.inputTokens,
             outputTokens: totals.outputTokens + usage.outputTokens,
             cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
+            cacheWriteTokens: totals.cacheWriteTokens + (usage.cacheWriteTokens ?? 0),
           },
           lastPromptTokens: usage === undefined ? stats.lastPromptTokens
             : usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
@@ -745,6 +1094,8 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           state: 'running',
           summary: '',
           detail: undefined,
+          subs: [],
+          subsDropped: 0,
         }],
         stats: {
           ...view.stats,
@@ -963,6 +1314,11 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         entries: line === undefined ? view.entries : [...view.entries, { kind: 'turn-marker', text: line }],
       }
     }
+    case 'schedule/change':
+      // Non-conversational catalog state: the /schedule panel renders the
+      // active list, the transcript shows only the reminder prompts
+      // (handled at user/message above).
+      return { ...view, schedules: applyScheduleChange(view.schedules, event.data) }
     case 'session/title':
       // Latest-wins title snapshot, log-only; the status line prefers it.
       return { ...view, title: event.data.title }
@@ -1043,8 +1399,86 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       })
       return { ...view, entries }
     }
-    default:
+    default: {
+      // `tool/ptc-dispatch*` live in @deepseek-ai/dsh-tools' map merge,
+      // which this bundle does not depend on; the string guards keep the
+      // fold decoupled while following the upstream contract exactly (pair
+      // by subCallId; every start settles; settle speaks tool/result's own
+      // vocabulary). Log-only upstream: deriveMessages ignores them, so the
+      // sub rows are pure display state on the parent run_code card.
+      const type = event.type as string
+      if (type === 'tool/ptc-dispatch-start') {
+        const data = event.data as PtcDispatchStartData
+        view.anchors.subStart.set(data.subCallId, event.time)
+        const entries = view.entries.map(entry => entry.kind !== 'tool' || entry.callId !== data.rootCallId
+          ? entry
+          : pushSubDispatch(entry, {
+            subCallId: data.subCallId,
+            name: data.name,
+            preview: toolArgumentsPreview(subDispatchArguments(data.arguments), data.name),
+            state: 'running',
+            summary: '',
+            durationMs: 0,
+          }))
+        return { ...view, entries }
+      }
+      if (type === 'tool/ptc-dispatch') {
+        const data = event.data as PtcDispatchData
+        const started = view.anchors.subStart.get(data.subCallId)
+        view.anchors.subStart.delete(data.subCallId)
+        const summary = boundContextSummary(textOf(data.content))
+        const durationMs = started === undefined ? 0 : Math.max(0, event.time - started)
+        const entries = view.entries.map(entry => entry.kind !== 'tool' || entry.callId !== data.rootCallId
+          ? entry
+          : settleSubDispatch(entry, data, summary, durationMs))
+        return { ...view, entries }
+      }
+      // The durable workflow record (`tool-workflow/*`, appended by the
+      // workflow/ralph tools): one bounded card per run, members paired by
+      // their sequence number, the run settling on run-end.
+      if (type === 'tool-workflow/run-start') {
+        const data = event.data as WorkflowRunStartData
+        return {
+          ...view,
+          entries: [...view.entries, {
+            kind: 'workflow',
+            runId: data.runId,
+            name: data.name,
+            members: [],
+            membersDropped: 0,
+            state: 'running',
+          }],
+        }
+      }
+      if (type === 'tool-workflow/agent-start') {
+        const data = event.data as WorkflowAgentStartData
+        const entries = view.entries.map(entry => entry.kind !== 'workflow' || entry.runId !== data.runId
+          ? entry
+          : pushWorkflowMember(entry, {
+            seq: data.seq,
+            label: data.label,
+            phase: data.phase ?? '',
+            childId: data.childId,
+            outcome: 'running',
+          }))
+        return { ...view, entries }
+      }
+      if (type === 'tool-workflow/agent-end') {
+        const data = event.data as WorkflowAgentEndData
+        const entries = view.entries.map(entry => entry.kind !== 'workflow' || entry.runId !== data.runId
+          ? entry
+          : settleWorkflowMember(entry, data))
+        return { ...view, entries }
+      }
+      if (type === 'tool-workflow/run-end') {
+        const data = event.data as WorkflowRunEndData
+        const entries = view.entries.map(entry => entry.kind !== 'workflow' || entry.runId !== data.runId
+          ? entry
+          : { ...entry, state: data.stopReason })
+        return { ...view, entries }
+      }
       return view
+    }
   }
 }
 
@@ -1079,11 +1513,15 @@ export interface ReplayAccumulator {
   retryIndex: Map<string, number[]>
   /** messageId → every index into `entries` holding a `pending` row with that id. */
   pendingIndex: Map<string, number[]>
+  /** runId → every index into `entries` holding a `workflow` row with that id. */
+  workflowIndex: Map<string, number[]>
   /** Tombstone count; zero means `entries` is already the final array. */
   removedCount: number
   /** Mutable inbox id lists, mirroring `view.pending` order per target. */
   pendingTurn: string[]
   pendingStep: string[]
+  /** Mutable mirror of `view.claimOrigin` (see the reducer's field doc). */
+  claimOrigin: Map<string, 'next-turn' | 'next-step'>
   streaming: string
   streamingReasoning: string
   todos: readonly TodoItem[]
@@ -1098,9 +1536,12 @@ export interface ReplayAccumulator {
   systemPrompt: string
   sandbox: string
   goal: GoalFold | undefined
+  schedules: readonly ScheduleRow[]
   stats: TranscriptStats
   stepStart: Map<string, number>
   toolStart: Map<string, number>
+  /** Open PTC sub-dispatch starts by `subCallId` (duration anchors). */
+  subStart: Map<string, number>
   firstChunkAt: Map<string, number>
   compactionTokens: Map<string, number>
   lastPruneTokens: number
@@ -1121,9 +1562,11 @@ export function createReplayAccumulator(): ReplayAccumulator {
     commandIndex: new Map(),
     retryIndex: new Map(),
     pendingIndex: new Map(),
+    workflowIndex: new Map(),
     removedCount: 0,
     pendingTurn: [],
     pendingStep: [],
+    claimOrigin: new Map(),
     streaming: '',
     streamingReasoning: '',
     todos: [],
@@ -1137,9 +1580,11 @@ export function createReplayAccumulator(): ReplayAccumulator {
     systemPrompt: '',
     sandbox: '',
     goal: undefined,
-    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
+    schedules: [],
+    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
     stepStart: new Map(),
     toolStart: new Map(),
+    subStart: new Map(),
     firstChunkAt: new Map(),
     compactionTokens: new Map(),
     lastPruneTokens: 0,
@@ -1270,8 +1715,14 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       const text = textOf(message.content)
       const images = imagesOf(message.content)
       const files = filesOf(message.content)
-      if (message.source.kind === 'user') {
-        appendReplayEntry(acc, { kind: 'user', text, notice: false, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) })
+      // Same delivery-origin rule as the reducer: the claim splice that
+      // precedes this event never carried the origin, so `claimOrigin` is the
+      // only surviving record of how the prompt was submitted.
+      const origin = acc.claimOrigin.get(message.id)
+      const delivery = origin === undefined ? {} : { delivery: origin === 'next-turn' ? 'queued' as const : 'steered' as const }
+      acc.claimOrigin.delete(message.id)
+      if (message.source.kind === 'user' || (message.source.kind === 'plugin' && REMINDER_PLUGINS.has(message.source.plugin))) {
+        appendReplayEntry(acc, { kind: 'user', text, notice: false, ...delivery, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) })
         acc.stats = {
           ...acc.stats,
           contextSegments: {
@@ -1281,9 +1732,21 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         }
         return true
       }
+      if (message.source.kind === 'plugin' && HIDDEN_SNAPSHOT_PLUGINS.has(message.source.plugin)) {
+        acc.stats = {
+          ...acc.stats,
+          contextSegments: {
+            ...acc.stats.contextSegments,
+            system: acc.stats.contextSegments.system + estimateTokens(text),
+          },
+        }
+        return true
+      }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
-        : message.source.kind
+        : message.source.kind === 'plugin'
+          ? message.source.plugin
+          : message.source.kind
       const summary = boundContextSummary(notice)
       appendReplayEntry(acc, { kind: 'user', text: summary, notice: true })
       acc.stats = {
@@ -1296,12 +1759,15 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       return true
     }
     case 'agent/inbox/spliced': {
-      const { target, start, removedCount = 0, inserted } = event.data
+      const { target, start, removedCount = 0, inserted, outcome } = event.data
       const ids = target === 'next-turn' ? acc.pendingTurn : acc.pendingStep
       const removed = ids.slice(start, start + removedCount)
       acc.ops += removed.length
       ids.splice(start, removedCount)
       acc.ops += removed.length
+      // A claim keeps the origin for the user message still to come; a real
+      // cancellation retires it with the row.
+      if (outcome === 'canceled') for (const id of removed) acc.claimOrigin.delete(id)
       for (const id of removed) {
         const list = acc.pendingIndex.get(id)
         if (list === undefined) continue
@@ -1318,6 +1784,9 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       // later inbox event.
       ids.splice(start, 0, ...inserted.map(message => message.id))
       for (const message of inserted) {
+        // Same rule as the reducer: only a submission that arrived while a
+        // turn was running is "queued"/"steered" rather than ordinary.
+        if (acc.busy) acc.claimOrigin.set(message.id, target)
         const images = imagesOf(message.content)
         const files = filesOf(message.content)
         appendReplayEntry(acc, { kind: 'pending', messageId: message.id, target, text: pendingText(message.content), ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) })
@@ -1394,14 +1863,19 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       const reasoning = reasoningOf(event.data.message.content)
       acc.streaming = ''
       acc.streamingReasoning = ''
-      appendReplayEntry(acc, { kind: 'assistant', text, reasoning, interrupted: event.data.interrupted === true ? true : undefined })
+      // Same zero-line guard as the live fold: tool-only settlements carry
+      // timing/usage but no renderable transcript entry.
+      if (text !== '' || reasoning !== '' || event.data.interrupted === true) {
+        appendReplayEntry(acc, { kind: 'assistant', text, reasoning, interrupted: event.data.interrupted === true ? true : undefined })
+      }
       acc.stats = {
         ...acc.stats,
         llmMs: acc.stats.llmMs + (started === undefined ? 0 : Math.max(0, event.time - started)),
         usage: usage === undefined ? totals : {
-          inputTokens: totals.inputTokens + usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+          uncachedInputTokens: totals.uncachedInputTokens + usage.inputTokens,
           outputTokens: totals.outputTokens + usage.outputTokens,
           cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
+          cacheWriteTokens: totals.cacheWriteTokens + (usage.cacheWriteTokens ?? 0),
         },
         lastPromptTokens: usage === undefined ? acc.stats.lastPromptTokens
           : usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
@@ -1433,6 +1907,8 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         state: 'running',
         summary: '',
         detail: undefined,
+        subs: [],
+        subsDropped: 0,
       })
       indexList(acc.toolIndex, data.callId).push(acc.entries.length - 1)
       acc.stats = {
@@ -1603,6 +2079,10 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       if (line !== undefined) appendReplayEntry(acc, { kind: 'turn-marker', text: line })
       return true
     }
+    case 'schedule/change':
+      acc.schedules = applyScheduleChange(acc.schedules, event.data)
+      acc.ops += 1
+      return true
     case 'session/title':
       acc.title = event.data.title
       return true
@@ -1664,8 +2144,75 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       updateReplayById<CommandEntry>(acc, acc.commandIndex, data.commandId, entry => entry.commandId === data.commandId, update)
       return true
     }
-    default:
+    default: {
+      // PTC sub-dispatch pair, string-guarded like the live fold above; the
+      // parent run_code row is addressed through the same call-id index the
+      // tool/result case uses.
+      const type = event.type as string
+      if (type === 'tool/ptc-dispatch-start') {
+        const data = event.data as PtcDispatchStartData
+        acc.subStart.set(data.subCallId, event.time)
+        updateReplayById<ToolEntry>(acc, acc.toolIndex, data.rootCallId, entry => entry.callId === data.rootCallId, entry =>
+          pushSubDispatch(entry, {
+            subCallId: data.subCallId,
+            name: data.name,
+            preview: toolArgumentsPreview(subDispatchArguments(data.arguments), data.name),
+            state: 'running',
+            summary: '',
+            durationMs: 0,
+          }))
+        return true
+      }
+      if (type === 'tool/ptc-dispatch') {
+        const data = event.data as PtcDispatchData
+        const started = acc.subStart.get(data.subCallId)
+        acc.subStart.delete(data.subCallId)
+        const summary = boundContextSummary(textOf(data.content))
+        const durationMs = started === undefined ? 0 : Math.max(0, event.time - started)
+        updateReplayById<ToolEntry>(acc, acc.toolIndex, data.rootCallId, entry => entry.callId === data.rootCallId, entry =>
+          settleSubDispatch(entry, data, summary, durationMs))
+        return true
+      }
+      // Durable workflow record, string-guarded like the live fold above.
+      if (type === 'tool-workflow/run-start') {
+        const data = event.data as WorkflowRunStartData
+        appendReplayEntry(acc, {
+          kind: 'workflow',
+          runId: data.runId,
+          name: data.name,
+          members: [],
+          membersDropped: 0,
+          state: 'running',
+        })
+        indexList(acc.workflowIndex, data.runId).push(acc.entries.length - 1)
+        return true
+      }
+      if (type === 'tool-workflow/agent-start') {
+        const data = event.data as WorkflowAgentStartData
+        updateReplayById<WorkflowEntry>(acc, acc.workflowIndex, data.runId, entry => entry.runId === data.runId, entry =>
+          pushWorkflowMember(entry, {
+            seq: data.seq,
+            label: data.label,
+            phase: data.phase ?? '',
+            childId: data.childId,
+            outcome: 'running',
+          }))
+        return true
+      }
+      if (type === 'tool-workflow/agent-end') {
+        const data = event.data as WorkflowAgentEndData
+        updateReplayById<WorkflowEntry>(acc, acc.workflowIndex, data.runId, entry => entry.runId === data.runId, entry =>
+          settleWorkflowMember(entry, data))
+        return true
+      }
+      if (type === 'tool-workflow/run-end') {
+        const data = event.data as WorkflowRunEndData
+        updateReplayById<WorkflowEntry>(acc, acc.workflowIndex, data.runId, entry => entry.runId === data.runId, entry =>
+          ({ ...entry, state: data.stopReason }))
+        return true
+      }
       return false
+    }
   }
 }
 
@@ -1715,13 +2262,16 @@ function materializeReplayView(acc: ReplayAccumulator, copy: boolean): Transcrip
     systemPrompt: acc.systemPrompt,
     sandbox: acc.sandbox,
     goal: acc.goal,
+    schedules: acc.schedules,
     pending: { 'next-turn': [...acc.pendingTurn], 'next-step': [...acc.pendingStep] },
+    claimOrigin: new Map(acc.claimOrigin),
     stats: acc.stats,
     // Handed-out views get their own anchors snapshot: the accumulator keeps
     // folding its live containers, and no consumer may observe that.
     anchors: {
       stepStart: new Map(acc.stepStart),
       toolStart: new Map(acc.toolStart),
+      subStart: new Map(acc.subStart),
       firstChunkAt: new Map(acc.firstChunkAt),
       compactionTokens: new Map(acc.compactionTokens),
       lastPruneTokens: acc.lastPruneTokens,
@@ -1828,6 +2378,7 @@ export function settledEntryCount(entries: readonly TranscriptEntry[]): number {
     if (entry.kind === 'tool' && entry.state === 'running') return index
     if (entry.kind === 'retry' && entry.state === 'running') return index
     if (entry.kind === 'command' && entry.state === 'running') return index
+    if (entry.kind === 'workflow' && entry.state === 'running') return index
   }
   return entries.length
 }