dsh-code 1.4.0 → 1.5.0

package/src/composer.ts

@@ -121,11 +121,11 @@ function deepseekWaveHues(tier: DeepseekWaveTier): readonly [RgbTriple, RgbTripl
     : [palette.brandBright, palette.code, palette.brandMid]
 }
 
-/** Original web StateDot chase used by the busy composer marker. */
+/** Functional busy chase; decorative color flow still follows the preference. */
 function BusyChase({ animated = true }: { animated?: boolean }): ReactElement {
-  const tick = useFrames(BUSY_CHASE_TICK_MS, animated)
-  // Flowing themes (prismatic, rainbow) ride their anchor walk while busy;
-  // every other theme (and the frozen state) keeps the palette's live accent.
+  const tick = useFrames(BUSY_CHASE_TICK_MS, true)
+  // Flowing themes (prismatic, rainbow) ride their anchor walk only when
+  // decorative animation is enabled; the activity glyph always advances.
   const flow = themeFlow()
   const marker = flow !== undefined && animated
     ? flowColor(tick * BUSY_CHASE_TICK_MS + flow.phaseMs, flow.anchors)
@@ -592,7 +592,7 @@ export function Composer({ active, frozen, frozenHint, busy, descriptors, skills
   historyFill: { text: string; index: number } | undefined
   /** Marks the accepted entry consumed (called after the fill is applied). */
   historyConsumed: () => void
-  /** Whether timed animations run (shimmer, chase, blink, wave). */
+  /** Whether decorative animations run; caret and busy activity stay live. */
   animations: boolean
   /** Apply and report one /animation toggle (App persists through the runner). */
   applyAnimations: (enabled: boolean) => void
@@ -647,7 +647,7 @@ export function Composer({ active, frozen, frozenHint, busy, descriptors, skills
   const [preparingImages, setPreparingImages] = useState(false)
   const prepareAbortRef = useRef<AbortController | undefined>(undefined)
   const prepareEpochRef = useRef(0)
-  const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages && animations)
+  const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages)
   useEffect(() => () => {
     prepareEpochRef.current += 1
     prepareAbortRef.current?.abort()

package/src/locales/en.ts

@@ -164,7 +164,7 @@ export const en = {
   'cmd.theme': 'switch the color theme',
   'cmd.language': 'switch the interface language (/language [en|zh])',
   'cmd.rainbow': 'reroll or pin the rainbow palette (/rainbow [seed])',
-  'cmd.animation': 'toggle timed animations (/animation [on|off])',
+  'cmd.animation': 'toggle decorative animations; shimmer and activity stay live (/animation [on|off])',
   'cmd.history': 'search and recall past prompts',
   'cmd.queue': 'manage messages queued for the next turn',
   'cmd.usage': 'show this session token usage',
@@ -312,12 +312,12 @@ export const en = {
   'notice.imageCancelled': 'image submission cancelled',
   'notice.themeConfigUnreadable': 'theme config unreadable, using dark: {message}',
   'notice.languageConfigUnreadable': 'language config unreadable, using english: {message}',
-  'notice.animationsConfigUnreadable': 'animations config unreadable, animations stay on: {message}',
+  'notice.animationsConfigUnreadable': 'decorative animation config unreadable, effects stay on: {message}',
   'notice.statuslineConfigUnreadable': 'statusline config unreadable, using defaults: {message}',
   'notice.sessionSearchUnavailable': 'session search is unavailable in this deployment',
   'notice.subagentsReadOnly': 'subagent conversations are read-only',
   'notice.statuslineSaveFailed': 'statusline save failed: {message}',
-  'notice.animationsSaveFailed': 'animations save failed: {message}',
+  'notice.animationsSaveFailed': 'decorative animation save failed: {message}',
   'notice.commandRegistryMissing': 'no command registry is mounted in this composition',
   'notice.commandFallbackFailed': 'command fallback failed: {message}',
   'notice.commandFailed': 'command failed: {message}',
@@ -368,7 +368,7 @@ export const en = {
   'notice.commandAttachments': 'commands cannot carry attachments; the line will be sent to the model as a prompt',
   'notice.copyFailed': 'copy failed: {message}',
   'notice.vscodeKeysFailed': 'vscode-keys failed: {message}',
-  'notice.animationState': 'animations {state}',
+  'notice.animationState': 'decorative animations {state}; activity indicators stay live',
   'notice.deleteFailed': 'delete failed: {message}',
   'notice.modelChangedPlaceholder': 'model → {model} · image history will be sent as text placeholders',
   'notice.modelNextStep': 'model → next step uses {model}',

package/src/locales/zh.ts

@@ -166,7 +166,7 @@ export const zh: MessageCatalog = {
   'cmd.theme': '切换配色主题',
   'cmd.language': '切换界面语言（/language [en|zh]）',
   'cmd.rainbow': '重掷或指定彩虹配色（/rainbow [seed]）',
-  'cmd.animation': '开关计时动画（/animation [on|off]）',
+  'cmd.animation': '开关装饰动画，shimmer 与活动指示始终保留（/animation [on|off]）',
   'cmd.history': '搜索并复用历史提示词',
   'cmd.queue': '管理等待下一轮的消息',
   'cmd.usage': '查看本会话的 token 用量',
@@ -314,12 +314,12 @@ export const zh: MessageCatalog = {
   'notice.imageCancelled': '图片提交已取消',
   'notice.themeConfigUnreadable': '主题配置无法读取，使用暗色：{message}',
   'notice.languageConfigUnreadable': '语言配置无法读取，使用英文：{message}',
-  'notice.animationsConfigUnreadable': '动画配置无法读取，保持开启：{message}',
+  'notice.animationsConfigUnreadable': '装饰动画配置无法读取，保持开启：{message}',
   'notice.statuslineConfigUnreadable': '状态栏配置无法读取，使用默认：{message}',
   'notice.sessionSearchUnavailable': '此部署未启用会话检索',
   'notice.subagentsReadOnly': '子代理会话为只读',
   'notice.statuslineSaveFailed': '状态栏保存失败：{message}',
-  'notice.animationsSaveFailed': '动画保存失败：{message}',
+  'notice.animationsSaveFailed': '装饰动画保存失败：{message}',
   'notice.commandRegistryMissing': '当前组合未加载命令注册表',
   'notice.commandFallbackFailed': '命令回退失败：{message}',
   'notice.commandFailed': '命令执行失败：{message}',
@@ -370,7 +370,7 @@ export const zh: MessageCatalog = {
   'notice.commandAttachments': '命令不能携带附件；该行将作为提示发送给模型',
   'notice.copyFailed': '复制失败：{message}',
   'notice.vscodeKeysFailed': 'vscode-keys 失败：{message}',
-  'notice.animationState': '动画{state}',
+  'notice.animationState': '装饰动画{state}；活动指示保持开启',
   'notice.deleteFailed': '删除失败：{message}',
   'notice.modelChangedPlaceholder': '模型 → {model} · 历史图片将以文本占位符发送',
   'notice.modelNextStep': '模型 → 下一步使用 {model}',

package/src/render/inspector.ts

@@ -1,5 +1,17 @@
 /** Pure viewport, selection, and scrolling rules for exclusive TUI panels. */
 
+import type { TranscriptEntry } from './projection.ts'
+
+/**
+ * Remove assistant settlements that contain reasoning but no final response.
+ * They remain in the durable transcript and in the Ctrl/Alt+R fold; excluding
+ * them only from Ctrl+O navigation prevents short progress thoughts from
+ * appearing as a long run of misleading `reply` entries.
+ */
+export function inspectableTranscriptEntries(entries: readonly TranscriptEntry[]): readonly TranscriptEntry[] {
+  return entries.filter(entry => !(entry.kind === 'assistant' && entry.text.trim() === '' && entry.reasoning.trim() !== ''))
+}
+
 /** Terminal-space allocation for the inspector's one dynamic screen. */
 export interface InspectorViewport {
   /** Maximum dynamic rows, kept strictly below the terminal height. */

package/src/render/lines.ts

@@ -243,7 +243,7 @@ export function reasoningLines(text: string, columns: number): readonly StyledLi
  * diff/read/web/raw rows align under them instead of floating two columns
  * shallower.
  */
-function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLine[] {
+function toolDetailLines(detail: ToolDetail, columns: number, rawStyle: LineStyle): readonly StyledLine[] {
   switch (detail.kind) {
     case 'diff':
       return detail.diffs.flatMap(diff => [
@@ -280,8 +280,8 @@ function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLi
       return prefixedTextLines(`${detail.url} · HTTP ${detail.statusCode}`, columns, '    ', 'dim')
     case 'raw':
       return [
-        ...prefixedTextLines(detail.text, columns, '    ', 'dim'),
-        ...prefixedTextLines(detail.truncated ? '… (output truncated)' : '(end of output)', columns, '    ', 'dim'),
+        ...prefixedTextLines(detail.text, columns, '    ', rawStyle),
+        ...prefixedTextLines(detail.truncated ? '… (output truncated)' : '(end of output)', columns, '    ', rawStyle),
       ]
     default: {
       const exhaustive: never = detail
@@ -410,12 +410,14 @@ function subDispatchLines(entry: ToolEntry, columns: number): readonly StyledLin
   const width = Math.max(1, Math.floor(columns))
   const rows = entry.subs.flatMap(sub => {
     const mark = sub.state === 'running' ? '●' : sub.state === 'error' ? '⨯' : '⏺'
-    const style: LineStyle = sub.state === 'running' ? 'brand' : sub.state === 'error' ? 'error' : 'dim'
-    const label = sub.preview === '' ? sub.name : `${sub.name} ${sub.preview}`
-    if (sub.state === 'error' && sub.summary !== '') {
-      return textLines(`  ┆ ${mark} ${label} · ${sub.summary}${subDispatchSeconds(sub.durationMs)}`, width, style)
-    }
-    return textLines(`  ┆ ${mark} ${label}${subDispatchSeconds(sub.durationMs)}`, width, style)
+    const markStyle: LineStyle = sub.state === 'running' ? 'brand' : sub.state === 'error' ? 'error' : 'success'
+    return hangingStyledLines([
+      lineSegment(`${mark} `, markStyle),
+      lineSegment(sub.name, 'brand'),
+      lineSegment(sub.preview === '' ? '' : ` ${sub.preview}`, 'dim'),
+      lineSegment(sub.state === 'error' && sub.summary !== '' ? ` · ${sub.summary}` : '', sub.state === 'error' ? 'error' : 'dim'),
+      lineSegment(subDispatchSeconds(sub.durationMs), 'dim'),
+    ], width, '  ┆ ', 'dim', '  ┆ ', 'dim')
   })
   if (entry.subsDropped === 0) return rows
   return [...rows, ...textLines(`  ┆ … ${entry.subsDropped} earlier dispatch${entry.subsDropped === 1 ? '' : 'es'}`, width, 'dim')]
@@ -491,7 +493,7 @@ export function transcriptEntryLines(
       const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
       const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
       const summaryStyle: LineStyle = entry.state === 'error' ? 'error' : 'dim'
-      const lines = [
+      const invocation = [
         // The invocation row hangs wrapped previews under the call badge.
         ...hangingStyledLines([
           // Global call ordinal — the same number an error line references.
@@ -505,13 +507,35 @@ export function transcriptEntryLines(
         // Nested PTC sub-dispatches (run_code): one bounded row per child
         // call, live while the parent card itself is still running.
         ...subDispatchLines(entry, width),
-        ...(entry.summary === '' ? [] : hangingTextLines(
-          entry.state === 'error' ? `call ${entry.ordinal}: ${entry.summary}` : entry.summary,
-          width, '  ⎿ ', summaryStyle, '    ', summaryStyle,
-        )),
-        ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
       ]
-      return showToolDetails ? lines : compactToolLines(lines, width)
+      const summary = entry.summary === '' ? [] : hangingTextLines(
+        entry.state === 'error' ? `call ${entry.ordinal}: ${entry.summary}` : entry.summary,
+        width, '  ⎿ ', summaryStyle, '    ', summaryStyle,
+      )
+      // Compact cards carry the bounded result summary only. Keep one fold
+      // hint when richer detail exists, but not when a complete one-line raw
+      // result is byte-for-byte the summary (that false hint was one symptom
+      // of rendering summary and detail together).
+      if (!showToolDetails) {
+        const rawFullySummarized = entry.detail?.kind === 'raw'
+          && !entry.detail.truncated
+          && entry.detail.text.trim() === entry.summary.trim()
+        const hiddenDetail = entry.detail !== undefined && !rawFullySummarized
+          ? textLines('    … output hidden · Ctrl/Alt+R', width, 'dim').slice(0, 1)
+          : []
+        return compactToolLines([...invocation, ...summary, ...hiddenDetail], width)
+      }
+
+      const detail = entry.detail === undefined
+        ? []
+        : toolDetailLines(entry.detail, width, entry.state === 'error' ? 'error' : 'dim')
+      // Raw output and structured read/diff views already contain the result
+      // represented by `summary`; web details are supplemental metadata, so
+      // those keep both the answer summary and their source/status rows.
+      const detailSupersedesSummary = entry.detail?.kind === 'raw'
+        || entry.detail?.kind === 'read'
+        || entry.detail?.kind === 'diff'
+      return [...invocation, ...(detailSupersedesSummary ? [] : summary), ...detail]
     }
     case 'command': {
       const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
@@ -537,9 +561,12 @@ export function transcriptEntryLines(
         // subagent feed's live rows for the same agent.
         ...entry.members.flatMap(member => {
           const state = member.outcome === 'running' ? '●' : member.outcome === 'failed' ? '⨯' : member.outcome === 'cancelled' ? '⏹' : '⏺'
-          const style: LineStyle = member.outcome === 'running' ? 'brand' : member.outcome === 'failed' ? 'error' : 'dim'
+          const stateStyle: LineStyle = member.outcome === 'running' ? 'brand' : member.outcome === 'failed' ? 'error' : member.outcome === 'cancelled' ? 'dim' : 'success'
           const phase = member.phase === '' ? '' : ` [${member.phase}]`
-          return textLines(`  ┆ ${state} ${member.label}${phase}`, width, style)
+          return hangingStyledLines([
+            lineSegment(`${state} `, stateStyle),
+            lineSegment(`${member.label}${phase}`, 'dim'),
+          ], width, '  ┆ ', 'dim', '  ┆ ', 'dim')
         }),
         ...(entry.membersDropped === 0 ? [] : textLines(`  ┆ … ${entry.membersDropped} earlier member${entry.membersDropped === 1 ? '' : 's'}`, width, 'dim')),
       ]

package/src/render/projection-events.ts

@@ -0,0 +1,109 @@
+/**
+ * Explicit compatibility policy for durable session events entering the TUI.
+ *
+ * The Harness event map is merge-extensible, so a reducer default branch is
+ * unavoidable: deployments may mount plugins this bundle does not know. The
+ * default must not, however, let a NEW first-party event silently bypass
+ * review. Tests compare this policy with `KNOWN_SESSION_EVENT_TYPES`; every
+ * kernel event must be deliberately classified before a Harness-line bump.
+ *
+ * @module @deepseek-ai/dsh-tui/render/projection-events
+ */
+
+/** How one durable event relates to the terminal transcript projection. */
+export type SessionEventDisposition =
+  | 'transcript'
+  | 'other-surface'
+  | 'ignored'
+  | 'unknown'
+
+/** Events folded directly into `TranscriptView`. */
+export const TRANSCRIPT_SESSION_EVENT_TYPES = [
+  'agent/inbox/spliced',
+  'assistant/attempt',
+  'assistant/message',
+  'command/done',
+  'command/run',
+  'compaction/end',
+  'compaction/prune',
+  'compaction/summary',
+  'goal/change',
+  'llm/retry',
+  'llm/retry-started',
+  'permission/preset',
+  'plan/mode',
+  'request/context',
+  'request/header',
+  'sandbox/mode',
+  'schedule/change',
+  'session/title',
+  'step/start',
+  'system/message',
+  'todo/write',
+  'tool-workflow/agent-end',
+  'tool-workflow/agent-start',
+  'tool-workflow/run-end',
+  'tool-workflow/run-start',
+  'tool/call',
+  'tool/ptc-dispatch',
+  'tool/ptc-dispatch-start',
+  'tool/result',
+  'turn/end',
+  'turn/start',
+  'user/message',
+] as const
+
+/**
+ * Events consumed by another TUI adapter rather than the transcript fold.
+ * Keeping these separate documents that they are visible behavior, not
+ * accidental no-ops.
+ */
+export const OTHER_SURFACE_SESSION_EVENT_TYPES = [
+  'agent-preset/selected',
+  'model/selection',
+  'subagent/catalog',
+] as const
+
+/**
+ * Kernel events deliberately omitted from terminal presentation. Their
+ * model-visible consequences arrive through projected message/tool/session
+ * events, while audit-only facts do not need a second transcript row.
+ */
+export const IGNORED_SESSION_EVENT_TYPES = [
+  'approval/asked',
+  'approval/decided',
+  'approval/policy',
+  'compaction/start',
+  'deliverables/presented',
+  'feedback/message-delete',
+  'feedback/message-put',
+  'feedback/record',
+  'hook/invoked',
+  'hook/result',
+  'session-log-deepseek/delivery-accepted',
+  'session/end-seed',
+  'session/title-llm-request',
+  'step/end',
+  'subagent/descriptor',
+  'subagent/model-selection-policy',
+  'team/member',
+  'team/message/delivered',
+  'team/message/queued',
+  'team/task',
+  'web/deepseek-search-llm-request',
+] as const
+
+const EVENT_DISPOSITIONS = new Map<string, Exclude<SessionEventDisposition, 'unknown'>>([
+  ...TRANSCRIPT_SESSION_EVENT_TYPES.map(type => [type, 'transcript'] as const),
+  ...OTHER_SURFACE_SESSION_EVENT_TYPES.map(type => [type, 'other-surface'] as const),
+  ...IGNORED_SESSION_EVENT_TYPES.map(type => [type, 'ignored'] as const),
+])
+
+/**
+ * Classify a durable event without rejecting merge-extensible plugin events.
+ * `unknown` remains a runtime no-op for forward/plugin compatibility; the
+ * known-event coverage test is what makes a first-party addition fail CI.
+ */
+export function sessionEventDisposition(type: string): SessionEventDisposition {
+  return EVENT_DISPOSITIONS.get(type) ?? 'unknown'
+}

package/src/render/projection.ts

@@ -12,6 +12,7 @@ import type { FileAttachmentRef } from '@deepseek-ai/dsh-attachment'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { TodoItem } from '@deepseek-ai/dsh-tool-todo'
 import { graphemeWidth, splitGraphemes } from './width.ts'
+import { sessionEventDisposition } from './projection-events.ts'
 // Type-only imports merge the plugin-owned SessionEventMap variants
 // (agent/inbox/spliced, command/*, compaction/*, goal/change, llm/retry*,
 // plan/mode, permission/preset, sandbox/mode, session/title) into the union
@@ -796,6 +797,10 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       stats: { ...view.stats, contextSegments: { ...view.stats.contextSegments, system: estimateTokens(shadow.prompt) } },
     }
   }
+  // Known non-transcript events are deliberate no-ops. Unknown plugin events
+  // remain tolerated at runtime, while the known-event coverage test makes a
+  // new first-party kernel event fail CI until its disposition is reviewed.
+  if (sessionEventDisposition(event.type) !== 'transcript') return view
   switch (event.type) {
     case 'user/message': {
       // A queued row retires when its durable user message lands (the agent
@@ -1477,7 +1482,10 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           : { ...entry, state: data.stopReason })
         return { ...view, entries }
       }
-      return view
+      // The policy classified this event as transcript-visible, so reaching
+      // the end means its reducer branch was omitted. Fail loudly instead of
+      // shipping a silently stale terminal projection.
+      throw new Error(`missing transcript projection for session event "${type}"`)
     }
   }
 }
@@ -1694,6 +1702,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
     acc.systemPrompt = shadow.prompt
     acc.stats = { ...acc.stats, contextSegments: { ...acc.stats.contextSegments, system: estimateTokens(shadow.prompt) } }
   }
+  if (sessionEventDisposition(event.type) !== 'transcript') return shadow.changed
   switch (event.type) {
     case 'user/message': {
       const message = event.data
@@ -2211,7 +2220,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           ({ ...entry, state: data.stopReason }))
         return true
       }
-      return false
+      throw new Error(`missing transcript replay projection for session event "${type}"`)
     }
   }
 }

package/src/render/tool-preview.ts

@@ -11,7 +11,7 @@
  */
 
 /** Keys searched in declaration order when building a preview. */
-const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'] as const
+const PREVIEW_KEYS = ['command', 'cmd', 'file_path', 'description', 'path', 'pattern', 'query', 'name'] as const
 
 /**
  * Raw arguments longer than this are skipped without parsing and fall back
@@ -25,6 +25,33 @@ function boundedRawPreview(args: string): string {
   return args.length > 80 ? `${args.slice(0, 77)}...` : args
 }
 
+/** Escape a fixed preview key before embedding it in a bounded regex. */
+function regexKey(key: string): string {
+  return key.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')
+}
+
+/**
+ * Recover one complete JSON string property from the bounded head/tail of a
+ * large argument object. Write/edit payloads commonly put a multi-kilobyte
+ * `content` first and `file_path` last; parsing the whole payload is forbidden
+ * on the render path, but the short trailing path is still safe to decode.
+ */
+function boundedStringProperty(args: string, key: string): string | undefined {
+  const slices = [args.slice(0, MAX_PARSE_CHARS), args.slice(-MAX_PARSE_CHARS)]
+  const pattern = new RegExp(`"${regexKey(key)}"\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`, 'u')
+  for (const slice of slices) {
+    const literal = pattern.exec(slice)?.[1]
+    if (literal === undefined) continue
+    try {
+      const value: unknown = JSON.parse(literal)
+      if (typeof value === 'string' && value !== '') return value
+    } catch {
+      // A property crossing the bounded slice edge is ignored.
+    }
+  }
+  return undefined
+}
+
 /**
  * Resolve one bounded preview for raw tool arguments.
  * @param args - raw JSON arguments string as the model produced it.
@@ -33,7 +60,13 @@ function boundedRawPreview(args: string): string {
  */
 export function toolArgumentsPreview(args: string, toolName: string): string {
   if (args === '') return toolName
-  if (args.length > MAX_PARSE_CHARS) return boundedRawPreview(args)
+  if (args.length > MAX_PARSE_CHARS) {
+    for (const key of PREVIEW_KEYS) {
+      const value = boundedStringProperty(args, key)
+      if (value !== undefined) return value
+    }
+    return boundedRawPreview(args)
+  }
   try {
     const parsed: unknown = JSON.parse(args)
     if (parsed !== null && typeof parsed === 'object') {

package/src/render/transcript-viewport.ts

@@ -0,0 +1,61 @@
+/** Physical-row viewport state for native scrollback plus a bottom-anchored tail. */
+
+export interface TranscriptViewportCursor {
+  readonly sessionKey: string
+  readonly epoch: number
+  readonly flushedRows: number
+}
+
+export interface TranscriptViewportInput {
+  readonly sessionKey: string
+  readonly epoch: number
+  /** Physical durable transcript rows in the current rendered-history window. */
+  readonly totalRows: number
+  /** Maximum durable rows retained outside Static for the live viewport. */
+  readonly retainedRows: number
+}
+
+export interface TranscriptViewportStep {
+  readonly cursor: TranscriptViewportCursor
+  /** Durable physical rows emitted through Static. */
+  readonly staticRows: number
+  /** Durable physical rows still available to the live viewport. */
+  readonly liveRows: number
+}
+
+/**
+ * Advance the monotonic physical-row flush cursor.
+ *
+ * Ordinary renders never pull a row back out of native scrollback. A source-
+ * backed replay (epoch change) flushes the complete durable window exactly
+ * once after the caller clears/remounts Static; subsequent durable rows start
+ * a fresh retained tail. Session/reset shrink starts from the new source.
+ */
+export function advanceTranscriptViewport(
+  previous: TranscriptViewportCursor,
+  input: TranscriptViewportInput,
+): TranscriptViewportStep {
+  const total = Math.max(0, Math.floor(input.totalRows))
+  const retained = Math.max(0, Math.floor(input.retainedRows))
+  const desiredStatic = Math.max(0, total - retained)
+  const staticRows = previous.sessionKey !== input.sessionKey
+    ? desiredStatic
+    : previous.epoch !== input.epoch
+      ? total
+      : total < previous.flushedRows
+        ? desiredStatic
+        : Math.max(previous.flushedRows, desiredStatic)
+  return {
+    cursor: { sessionKey: input.sessionKey, epoch: input.epoch, flushedRows: staticRows },
+    staticRows,
+    liveRows: total - staticRows,
+  }
+}
+
+/** Real history rows that fit beside the currently painted stream/tool rows. */
+export function visibleTranscriptRows(historyRows: number, occupiedRows: number, capacity: number): number {
+  const history = Math.max(0, Math.floor(historyRows))
+  const occupied = Math.max(0, Math.floor(occupiedRows))
+  const available = Math.max(0, Math.floor(capacity) - occupied)
+  return Math.min(history, available)
+}

package/src/render/usage.ts

@@ -15,8 +15,7 @@ import type { TokenUsageProjection, TurnTokenUsage } from '@deepseek-ai/dsh-toke
 import { t } from '../i18n.ts'
 import { lineSegment, type LineStyle, type StyledLine, type StyledSegment } from './lines.ts'
 import { visibleColumns } from './markdown.ts'
-import { formatTokens } from './status.ts'
-import { truncateColumns } from './text.ts'
+import { formatTokens, truncateColumns } from './text.ts'
 
 /** One completed turn's exact provider-reported accounting. */
 export interface UsageTurn {

package/src/runner/session-io.ts

@@ -61,6 +61,37 @@ export interface SessionIo {
   readonly loadSessionTranscript: (id: string, signal?: AbortSignal) => Promise<string>
 }
 
+/** Maximum session artifact directories inspected at once by the picker. */
+export const SESSION_ARTIFACT_READ_CONCURRENCY = 16
+
+/**
+ * Map a collection with a fixed worker count while preserving input order.
+ * The picker may own thousands of persisted sessions; an unbounded
+ * `Promise.all` turns those into one filesystem burst and can exhaust handles
+ * on Windows or remote filesystems.
+ *
+ * @internal Exported for the deterministic concurrency regression.
+ */
+export async function mapConcurrent<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  mapper: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  if (!Number.isSafeInteger(concurrency) || concurrency < 1) throw new RangeError('concurrency must be a positive safe integer')
+  const results = new Array<R>(items.length)
+  let next = 0
+  const worker = async (): Promise<void> => {
+    for (;;) {
+      const index = next
+      if (index >= items.length) return
+      next += 1
+      results[index] = await mapper(items[index], index)
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker))
+  return results
+}
+
 /**
  * Bind the session IO to one runner's services.
  * @param services - the query engine, persistence, and the live-session probe.
@@ -80,7 +111,8 @@ export function createSessionIo(services: SessionIoServices): SessionIo {
     const root = jsonlSessionRoot(persistence)
     const updated = new Map<string, number>()
     if (root !== undefined) {
-      await Promise.all(records.map(async record => {
+      const mtimes = await mapConcurrent(records, SESSION_ARTIFACT_READ_CONCURRENCY, async record => {
+        signal?.throwIfAborted()
         try {
           const dir = sessionDirectoryFor(root, record.header.cwd, record.header.id)
           const entries = await readdir(dir, { withFileTypes: true })
@@ -88,12 +120,19 @@ export function createSessionIo(services: SessionIoServices): SessionIo {
             entries.filter(entry => entry.isFile() && isSessionArtifactName(entry.name))
               .map(entry => stat(join(dir, entry.name))),
           )
+          signal?.throwIfAborted()
           const newest = Math.max(...stats.map(info => info.mtimeMs))
-          if (Number.isFinite(newest)) updated.set(record.header.id, newest)
+          return Number.isFinite(newest) ? [record.header.id, newest] as const : undefined
         } catch {
-          // Artifact gone or unreadable: the projection falls back to createdAt.
+          // Cancellation must stop the picker; only a missing/unreadable
+          // artifact degrades to createdAt.
+          signal?.throwIfAborted()
+          return undefined
         }
-      }))
+      })
+      for (const pair of mtimes) {
+        if (pair !== undefined) updated.set(...pair)
+      }
     }
     const projected = projectSessionRows(records, { ...options, query: '' }, updated)
     // Titles are the expensive fold. Fetch the first picker page when idle;

package/src/session-query.ts

@@ -224,6 +224,28 @@ export async function observeStableWithSkip(
   throw new SessionQueryError('session-search persistence observation did not stabilize after one retry', 'SESSION_QUERY_PERSISTENCE_FAILED')
 }
 
+/**
+ * Assert the private override seam this compatibility engine relies on.
+ * Harness keeps `_observeStable` private, so TypeScript cannot protect this
+ * subclass when upstream renames the method or changes its call signature.
+ * The exact-version launcher gate prevents unsupported hosts; this import-time
+ * check additionally prevents a newly built bundle from silently mounting an
+ * override the installed base will never call.
+ *
+ * @internal Exported for the compatibility regression.
+ */
+export function assertSessionQueryOverrideContract(candidate: unknown): void {
+  if (typeof candidate !== 'function') throw new TypeError('session-query sqlite engine must be a constructor')
+  const prototype = (candidate as { prototype?: object }).prototype
+  const descriptor = prototype === undefined ? undefined : Object.getOwnPropertyDescriptor(prototype, '_observeStable')
+  const method: unknown = descriptor?.value
+  if (typeof method !== 'function' || method.length !== 2) {
+    throw new Error('incompatible @deepseek-ai/dsh-session-query-sqlite: expected _observeStable(indexed, signal)')
+  }
+}
+
+assertSessionQueryOverrideContract(SqliteSessionQueryEngine)
+
 // The opaque-base cast keeps the private `_observeStable` override legal in
 // TypeScript while inheriting every runtime static (inject, Config, Service
 // metadata) from the real engine class.