dsh-code 1.3.0 → 1.5.0

package/src/{theme-panel.ts → panels/theme-panel.ts}

@@ -9,11 +9,11 @@
 
 import { createElement, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import { clampScroll, panelViewport } from './render/inspector.ts'
-import { truncateColumns } from './render/text.ts'
-import { panelAccent } from './panel-accent.ts'
-import { getPalette, inkColor, THEMES, type ThemeName } from './theme.ts'
-import { t } from './i18n.ts'
+import { clampScroll, panelViewport } from '../render/inspector.ts'
+import { truncateColumns } from '../render/text.ts'
+import { panelAccent } from '../ui/panel-accent.ts'
+import { getPalette, inkColor, THEMES, type ThemeName } from '../theme.ts'
+import { t } from '../i18n.ts'
 
 /**
  * The /theme list: one row per theme, the current one marked with ●, the

package/src/{update-panel.ts → panels/update-panel.ts}

@@ -11,12 +11,12 @@
 
 import { createElement, useEffect, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import type { LauncherUpdatePlan, LauncherUpdateStatus } from './update.ts'
-import { clampScroll, panelViewport } from './render/inspector.ts'
-import { singleLineText, truncateColumns } from './render/text.ts'
-import { panelAccent } from './panel-accent.ts'
-import { getPalette, inkColor } from './theme.ts'
-import { t } from './i18n.ts'
+import type { LauncherUpdatePlan, LauncherUpdateStatus } from '../update.ts'
+import { clampScroll, panelViewport } from '../render/inspector.ts'
+import { singleLineText, truncateColumns } from '../render/text.ts'
+import { panelAccent } from '../ui/panel-accent.ts'
+import { getPalette, inkColor } from '../theme.ts'
+import { t } from '../i18n.ts'
 
 /** Retained apply-progress lines (ring tail; npm output is ephemeral). */
 export const UPDATE_OUTPUT_CAP = 800

package/src/provider-settings.ts

@@ -666,6 +666,44 @@ export async function saveProviderConfiguration(
   }
 }
 
+/**
+ * Switch one provider route to its subscription (plan sign-in) channel: the
+ * profile keeps neither a key reference nor an explicit model list, so the
+ * official catalog endpoint serves requests and the stored OAuth record — not
+ * a settings-named key override — authenticates them. Enabling a route that
+ * has no profile yet creates the empty profile that registers it.
+ * @param ctx - context carrying the `settings` service.
+ * @param target - provider row whose settings namespace owns the profile.
+ * @throws when the route is unmanaged or settings are read-only.
+ */
+export async function enableProviderSubscription(ctx: Context, target: ProviderTargetView): Promise<void> {
+  if (target.settingsNs.length === 0) {
+    throw new ProviderSettingsError(`provider "${target.provider}" has no managed settings namespace; configure it in settings.yaml`)
+  }
+  const settings = ctx.get('settings') as SettingsFace | undefined
+  if (settings === undefined || settings.writable !== true) {
+    throw new ProviderSettingsError('settings are read-only; provider configuration cannot be changed here')
+  }
+  const root = target.settingsPath
+  const ops: SettingsPathOpFace[] = target.configured
+    ? [
+      // The key reference would resolve as a request-level override BEFORE
+      // the stored sign-in record, so the subscription channel must drop it;
+      // the endpoint and the explicit model list belong to the key channel.
+      { op: 'unset', path: [...root, 'apiKeyEnv'] },
+      { op: 'unset', path: [...root, 'baseURL'] },
+      { op: 'unset', path: [...root, 'models'] },
+    ]
+    // A route with no profile stays dormant: an empty profile registers it
+    // with the catalog endpoint and every catalog model.
+    : [{ op: 'set', path: [...root], value: {} }]
+  try {
+    await settings.mutate(target.settingsNs, ops, target.settingsRevision)
+  } catch (error) {
+    throw new ProviderSettingsError(singleLine(messageOf(error)))
+  }
+}
+
 /**
  * Interrogate a provider endpoint for the models it really serves, through
  * the model-discovery capability the provider's settings namespace

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. */
@@ -99,6 +111,29 @@ export function panelViewport(columns: number, rows: number): InspectorViewport
   }
 }
 
+/**
+ * Viewport for an expanded (near-fullscreen) document overlay: the document
+ * replaces the transcript area entirely, so the half-screen overlay cap and
+ * the inter-section gaps drop away while the bottom live region (composer,
+ * status) and the Static-rewrite margin stay reserved. The result stays
+ * below terminal height, which is what keeps Ink off its full-rewrite path.
+ */
+export function expandedDocumentViewport(columns: number, rows: number): InspectorViewport {
+  const safeColumns = Math.max(1, Math.floor(columns))
+  const safeRows = Math.max(1, Math.floor(rows))
+  const maxHeight = Math.max(0, safeRows - 2 - INSPECTOR_CHROME_ROWS - layoutGutterRows(safeRows))
+  const compact = maxHeight < 5 || safeColumns < 8
+  const outerColumns = compact ? safeColumns : Math.max(1, safeColumns - 1)
+  return {
+    maxHeight,
+    bodyRows: compact ? 0 : maxHeight - 4,
+    gapRows: 0,
+    contentColumns: compact ? Math.max(1, safeColumns - 1) : Math.max(1, outerColumns - 4),
+    outerColumns,
+    compact,
+  }
+}
+
 /** Backward-compatible name for the Ctrl+O-specific caller and tests. */
 export function inspectorViewport(columns: number, rows: number): InspectorViewport {
   return panelViewport(columns, rows)

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/text.ts

@@ -14,6 +14,8 @@
 
 import { graphemeWidth, splitGraphemes, stringWidth } from './width.ts'
 
+export { stringWidth }
+
 /**
  * Compact token count: exact below 1K, then one-decimal-ish K/M.
  * @param n - token count.
@@ -84,6 +86,12 @@ export function truncateColumns(text: string, columns: number): string {
   return `${result}…`
 }
 
+/** Sanitize, clip, and right-pad one cell to an exact terminal-column width. */
+export function padColumns(text: string, columns: number): string {
+  const clipped = truncateColumns(singleLineText(text), columns)
+  return clipped + ' '.repeat(Math.max(0, columns - stringWidth(clipped)))
+}
+
 /** A display-safe suffix bounded by terminal rows and columns. */
 export interface DisplayTail {
   /** Sanitized suffix suitable for direct terminal rendering. */

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 {