dsh-code 0.9.1 → 1.0.0

package/lib/types/render/animations.d.ts

@@ -1,9 +1,9 @@
 /**
  * Terminal animation frame tables derived from the web design language:
  * the StateDot "ongoing" pixel chase (3×3 ring, 125ms flat-hold brightness
- * steps, 1s cycle) becomes the single-cell stepped pulse below and the
- * full-ring clockwise braille chase in {@link BUSY_CHASE_FRAMES}, and the
- * streaming caret blink is the Claude-Code convention.
+ * steps, 1s cycle) becomes the full-ring clockwise braille chase in
+ * {@link BUSY_CHASE_FRAMES}, and the streaming caret blink is the
+ * Claude-Code convention.
  *
  * The DeepSeek model-switch easter egg ports Codex's effort-ignition "Wave"
  * style (`codex-rs/tui/src/bottom_pane/effort_ignition_styles.rs`): switching
@@ -17,10 +17,6 @@
  * @module @deepseek-ai/dsh-code/render/animations
  */
 import type { RgbTriple } from '../theme.ts';
-/** Single-cell stepped pulse: flat holds mirroring the web's 125ms keyframes. */
-export declare const PULSE_FRAMES: readonly ["█", "█", "▆", "▃", "▁", "▃", "▆", "█"];
-/** Pulse frame for a monotonic tick. */
-export declare function pulseFrame(tick: number): string;
 /**
  * The web StateDot "ongoing" chase in terminal form: three cells of the 3×3
  * ring trail clockwise around the eight outer positions, one braille glyph
@@ -59,15 +55,8 @@ export type DeepseekWaveTier = 'flash' | 'deepseek' | 'unknown';
  * One style is picked at random per trigger and never repeats the previous.
  */
 export type DeepseekWaveStyle = 'wave' | 'aurora' | 'pulse';
-/** All styles in canonical order, for random selection and tests. */
-export declare const DEEPSEEK_WAVE_STYLES: readonly DeepseekWaveStyle[];
 /** Wave half-width in columns — Codex WAVE_HALF_WIDTH (9). */
 export declare const WAVE_HALF_WIDTH = 9;
-/** Pulse ring half-width in columns — Codex PULSE_HALF_WIDTH (4.5). */
-export declare const PULSE_HALF_WIDTH = 4.5;
-/** Sparkle start and frame cadence — Codex SPARK_START / SPARK_FRAME. */
-export declare const SPARK_START_MS = 900;
-export declare const SPARK_FRAME_MS = 100;
 /** Sparkle glyphs in frame order — Codex SPARK_GLYPHS (`· ✦ ✧`). */
 export declare const SPARK_GLYPHS: readonly ["·", "✦", "✧"];
 /**
@@ -77,8 +66,6 @@ export declare const SPARK_GLYPHS: readonly ["·", "✦", "✧"];
  */
 export type DeepseekWaveBand = readonly [number, number, number];
 export declare const DEEPSEEK_WAVE_BANDS: Readonly<Record<DeepseekWaveStyle, Readonly<Record<DeepseekWaveTier, readonly DeepseekWaveBand[]>>>>;
-/** Extra display time applied to every Codex ignition style. */
-export declare const DEEPSEEK_WAVE_DURATION_EXTENSION_MS = 200;
 /**
  * Total visible duration: the Codex ignition duration plus 200ms so its motion
  * remains readable in a busy terminal.
@@ -94,14 +81,6 @@ export declare function deepseekWaveDuration(tier: DeepseekWaveTier, style?: Dee
  * @returns a style different from `previous`.
  */
 export declare function deepseekWaveStyleRandom(previous: DeepseekWaveStyle | undefined): DeepseekWaveStyle;
-/**
- * Blank-cell background the wave tint blends toward — fixed approximations
- * of the terminal's default background, mirroring Codex's
- * `user_message_bg_rgb` (which derives a near-black / near-white bubble tint
- * from the terminal background). The Ink layer picks the active theme's one.
- */
-export declare const WAVE_BASE_DARK: RgbTriple;
-export declare const WAVE_BASE_LIGHT: RgbTriple;
 /**
  * Tier for a `provider/model` label: a model id containing `flash` runs the
  * single-band flash tier; everything else (pro/reasoner/chat) runs the
@@ -137,14 +116,16 @@ export declare function easeInOut(progress: number): number;
  */
 export declare function envelope(elapsed: number, total: number, fadeIn: number, fadeOut: number): number;
 /**
- * The background color for one composer-row column at a tick — Codex
+ * The background color for one composer-band column at a tick — Codex
  * `paint_bands` + `Canvas::tint` for all three styles. Bands overlap with a
  * max for Wave/Pulse and a SUM for Aurora (Codex differs by style), the
  * weighted hues mix per column (Wave/Pulse always end on hue 0), the tint
  * blends the mixed hue toward the blank-cell base at the style's alpha cap,
  * and Aurora applies its own fade envelope. Returns `null` when the column
  * should stay transparent, so the row returns to no `backgroundColor` on
- * both ends.
+ * both ends. With `rows > 1` each row samples the same timeline shifted by a
+ * per-row phase offset, so the crest cascades down the band instead of
+ * painting every row identically.
  * @param tick - wave frame (0, 1, … at DEEPSEEK_WAVE_TICK_MS).
  * @param column - column index in the content row (0..width-1).
  * @param width - content-row width in columns.
@@ -152,9 +133,11 @@ export declare function envelope(elapsed: number, total: number, fadeIn: number,
  * @param style - the ignition style.
  * @param hues - the tier's three hues.
  * @param base - the blank-cell base color the tint blends toward.
+ * @param row - row index in the band (0..rows-1; default 0 = old single-row).
+ * @param rows - band height in rows (default 1).
  * @returns the blended RGB background, or null for transparent.
  */
-export declare function deepseekWaveColumnBg(tick: number, column: number, width: number, tier: DeepseekWaveTier, style: DeepseekWaveStyle, hues: readonly [RgbTriple, RgbTriple, RgbTriple], base: RgbTriple): RgbTriple | null;
+export declare function deepseekWaveColumnBg(tick: number, column: number, width: number, tier: DeepseekWaveTier, style: DeepseekWaveStyle, hues: readonly [RgbTriple, RgbTriple, RgbTriple], base: RgbTriple, row?: number, rows?: number): RgbTriple | null;
 /**
  * The sparkle glyph for a tick — Codex `spark_frame`, sampled on the same
  * proportionally slowed DeepSeek Wave timeline as the composer background.
@@ -163,18 +146,6 @@ export declare function deepseekWaveColumnBg(tick: number, column: number, width
  * @returns the sparkle glyph, or null outside the stretched tail window.
  */
 export declare function deepseekWaveSpark(tick: number): string | null;
-/**
- * The composer BORDER color at a tick: the frame breathes with the wave —
- * the palette's static dim blends toward the tier accent as the crest is
- * alive and back, so the frame glows up while the wave sweeps and settles to
- * dim on both ends (first==last frame==dim, no hard jump).
- * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
- * @param tier - the wave tier.
- * @param hues - the tier's three hues; the border blends toward hues[0].
- * @param dim - the palette's static dim RGB (the resting border color).
- * @returns the blended border RGB.
- */
-export declare function deepseekWaveBorderColor(tick: number, tier: DeepseekWaveTier, style: DeepseekWaveStyle, hues: readonly [RgbTriple, RgbTriple, RgbTriple], dim: RgbTriple): RgbTriple;
 /**
  * Whether the `deepseek` wordmark rides the wave at this tick: it fades in
  * shortly after the first crest launches and out before the wave settles,

package/lib/types/render/editor.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Pure composer editor model with Codex textarea semantics: a grapheme
+ * cursor over a column-safe multiline layout, word/piece motion, single-entry
+ * kill + yank, and the shell-recall boundary gate that keeps Up/Down usable
+ * inside a multiline draft.
+ *
+ * The model is intentionally string-offset based (UTF-16 indices clamped to
+ * grapheme boundaries) so the React state stays two primitives
+ * (value, cursor) and every operation here stays pure and testable.
+ *
+ * Word motion deviates from Codex's UAX#29 segmentation in one deliberate
+ * way: a run of same-class characters is ONE piece, so a CJK run moves as a
+ * single word (two hanzi are one Alt+B step, not two).
+ *
+ * @module @deepseek-ai/dsh-code/render/editor
+ */
+/** One grapheme cluster with its source span and display width in cells. */
+export interface GraphemeSpan {
+    text: string;
+    start: number;
+    end: number;
+    width: number;
+}
+/**
+ * Split text into grapheme clusters. Falls back to code points when
+ * Intl.Segmenter is unavailable; the fallback still keeps surrogate pairs
+ * (emoji) atomic so the cursor can never split one.
+ */
+export declare function splitGraphemes(text: string): readonly GraphemeSpan[];
+/** Clamp a cursor offset to the nearest grapheme boundary (surrogates, ZWJ, marks stay whole). */
+export declare function clampCursor(value: string, offset: number): number;
+/**
+ * Delete the final grapheme cluster (append-only drafts without a cursor).
+ * Surrogate pairs and multi-codepoint emoji stay whole instead of leaving a
+ * lone trailing code unit behind.
+ */
+export declare function deleteLastGrapheme(text: string): string;
+/**
+ * Step the cursor by whole graphemes (negative steps left). The cursor is
+ * assumed to sit on a boundary; any drift is clamped first.
+ */
+export declare function moveCursorBy(value: string, offset: number, delta: number): number;
+/**
+ * Normalize text entering the draft: CRLF/CR become LF, tabs become two
+ * spaces (terminal tab stops are contextual and cannot join a deterministic
+ * row budget), and every other C0 control byte plus DEL is REMOVED — the
+ * draft is data, so a stray ESC (Windows Terminal file drops) disappears
+ * instead of rendering as literal backslash-x-1-b text. Newlines survive.
+ */
+export declare function sanitizeDraftText(text: string): string;
+/** One physical editor row: wrapped text plus its boundary map. */
+export interface EditorRowModel {
+    /** Display text of the row (never contains `\n`; sanitized upstream). */
+    readonly text: string;
+    /** Source offset of the first grapheme on the row. */
+    readonly start: number;
+    /** Source offset just past the last grapheme on the row (before its newline). */
+    readonly end: number;
+    /** Boundary offsets on the row, start to end inclusive. */
+    readonly offsets: readonly number[];
+    /** Display column of each boundary; `columns[i]` pairs with `offsets[i]`. */
+    readonly columns: readonly number[];
+    /** Code-unit cut in `text` at each boundary; `cuts[i]` pairs with `offsets[i]`. */
+    readonly cuts: readonly number[];
+}
+/** The wrapped physical-row model of one draft. */
+export interface EditorModel {
+    readonly rows: readonly EditorRowModel[];
+    readonly length: number;
+}
+/**
+ * Hard-wrap the draft into column-safe physical rows. Wide graphemes never
+ * split across rows (a grapheme that does not fit flushes the row first) and
+ * explicit newlines end their row without occupying a cell.
+ */
+export declare function editorModel(value: string, columns: number): EditorModel;
+/** Where a cursor offset renders: the physical row and its display column. */
+export interface CaretSite {
+    row: number;
+    column: number;
+}
+/** Map a cursor offset to its caret site on the wrapped rows. */
+export declare function caretSite(model: EditorModel, offset: number): CaretSite;
+/**
+ * Move the caret across physical rows keeping a preferred display column
+ * (Codex `preferred_col`): horizontal moves reset the preference, vertical
+ * moves reuse it, clamped to each row's width.
+ */
+export declare function moveCursorVertically(model: EditorModel, offset: number, preferredColumn: number, delta: number): number;
+/** The start/end offsets of the logical line containing the cursor. */
+export declare function lineBounds(value: string, offset: number): {
+    start: number;
+    end: number;
+};
+/**
+ * Codex `beginning_of_previous_word`: skip whitespace left, then land on the
+ * START of the trailing non-space piece (extending over separator pieces).
+ */
+export declare function moveWordLeft(value: string, offset: number): number;
+/**
+ * Codex `end_of_next_word`: skip whitespace right, then land on the END of
+ * the leading non-space piece (extending over separator pieces).
+ */
+export declare function moveWordRight(value: string, offset: number): number;
+/** One edit outcome: the next draft value, cursor, and killed span (if any). */
+export interface EditResult {
+    value: string;
+    cursor: number;
+    /** Text removed into the kill buffer; undefined when nothing was killed. */
+    killed: string | undefined;
+}
+/** Delete the grapheme cluster before the cursor. */
+export declare function deleteBackward(value: string, cursor: number): EditResult;
+/** Delete the grapheme cluster at the cursor. */
+export declare function deleteForward(value: string, cursor: number): EditResult;
+/** Delete back to the start of the previous word (fills the kill buffer). */
+export declare function deleteWordBackward(value: string, cursor: number): EditResult;
+/** Delete forward to the end of the next word (fills the kill buffer). */
+export declare function deleteWordForward(value: string, cursor: number): EditResult;
+/** Ctrl+U: kill from the line start to the cursor; at BOL, kill the newline. */
+export declare function killToLineStart(value: string, cursor: number): EditResult;
+/** Ctrl+K: kill from the cursor to the line end; at EOL, kill the newline. */
+export declare function killToLineEnd(value: string, cursor: number): EditResult;
+/** Insert sanitized text at the cursor. */
+export declare function insertText(value: string, cursor: number, text: string): EditResult;
+/**
+ * Composer editor row budget: the editor itself never grows past this many
+ * physical rows; deeper drafts scroll internally to keep the caret visible.
+ * Short terminals collapse toward one row so the live transcript keeps room.
+ */
+export declare function composerMaxRows(terminalRows: number): number;
+/**
+ * Codex `should_handle_navigation`: Up/Down walk history only from an empty
+ * draft, or from a boundary of a draft that still exactly matches the last
+ * recalled entry. Any interior cursor position keeps vertical caret movement.
+ */
+export declare function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null): boolean;

package/lib/types/render/export.d.ts

@@ -5,7 +5,7 @@
  *
  * @module @deepseek-ai/dsh-code/render/export
  */
-import type { TranscriptView } from './projection.ts';
+import { type TranscriptView } from './projection.ts';
 /**
  * Render the transcript as a standalone markdown document.
  * @param view - the folded transcript view to export.

package/lib/types/render/lines.d.ts

@@ -1,5 +1,5 @@
 /** Width-safe styled physical rows for bounded terminal panels. */
-import type { TranscriptEntry } from './projection.ts';
+import { type TranscriptEntry } from './projection.ts';
 import { type MdStyle } from './markdown.ts';
 /** Presentation classes mapped to Ink colors by the app boundary. */
 export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic';
@@ -33,5 +33,9 @@ export declare function reasoningLines(text: string, columns: number): readonly
 /**
  * Convert one durable transcript entry to its complete scrollable row model.
  * The source entry stays intact; only the caller's visible slice is rendered.
+ * Wrapped continuations keep a hanging indent aligned under each row's
+ * content (Codex history-cell alignment) instead of resetting to column 0.
  */
-export declare function transcriptEntryLines(entry: TranscriptEntry, columns: number): readonly StyledLine[];
+export declare function transcriptEntryLines(entry: TranscriptEntry, columns: number, showReasoning?: boolean, reasoningToggleHint?: boolean): readonly StyledLine[];
+/** Settled-history variant carrying the Ctrl+R reasoning fold. */
+export declare function settledEntryLines(entry: TranscriptEntry, columns: number, showReasoning: boolean): readonly StyledLine[];

package/lib/types/render/markdown.d.ts

@@ -24,4 +24,6 @@ export interface MdLine {
 /** Visible width of a run in columns (CJK counts double). */
 export declare function visibleColumns(text: string): number;
 /** Render markdown text into styled lines of at most `width` columns. */
-export declare function renderMarkdown(text: string, width: number): readonly MdLine[];
+export declare function renderMarkdown(text: string, width: number, options?: {
+    physicalWrap?: boolean;
+}): readonly MdLine[];

package/lib/types/render/projection.d.ts

@@ -6,7 +6,7 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
-import { type MessageId } from '@deepseek-ai/dsh-llm';
+import { type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm';
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session';
 import { type ToolDetail } from './tool-detail.ts';
 /** One user prompt line. */
@@ -17,6 +17,8 @@ export interface UserEntry {
     /** True for collapsed injected context (plugin/continuation notices), which
      * the renderer marks with a dim ↳ instead of the user ❯ prompt. */
     notice: boolean;
+    /** Durable image references carried by this prompt. */
+    images?: readonly ImageBlock['attachment'][];
 }
 /** One user message waiting in the agent inbox (the web's queued-message row). */
 export interface PendingEntry {
@@ -27,20 +29,32 @@ export interface PendingEntry {
     target: 'next-turn' | 'next-step';
     /** Full message text — Codex PendingSteer renders queued prompts exactly like user rows. */
     text: string;
+    /** Durable image references queued with this prompt. */
+    images?: readonly ImageBlock['attachment'][];
 }
-/** One assembled assistant reply. */
+/** One authoritative assembled assistant reply. */
 export interface AssistantEntry {
     kind: 'assistant';
     /** Joined text blocks of the assistant message. */
     text: string;
-    /** Joined reasoning blocks of the same message, empty when the model thought out loud. */
+    /** Joined reasoning blocks from the same assembled message. */
     reasoning: string;
+    /** True when a cancelled stream's delivered prefix was finalized as this
+     * entry (rc.8 `assistant/message.interrupted`) — rendered with a marker. */
+    interrupted?: true;
 }
 /** One model-requested tool invocation and its settled state. */
 export interface ToolEntry {
     kind: 'tool';
     /** Correlation id shared with the matching `tool/result`. */
     callId: string;
+    /**
+     * Global tool-call ordinal across the whole transcript (1, 2, 3…, never
+     * reset between turns). The tool-card badge and every error line that
+     * references the failed call share this number, so "call N" in an error
+     * always names the exact card the badge shows.
+     */
+    ordinal: number;
     /** Tool name as the model addressed it. */
     name: string;
     /** Raw arguments JSON string exactly as the model produced it. */
@@ -203,6 +217,12 @@ export interface TranscriptView {
     streamingReasoning: string;
     /** Latest whole-list todo snapshot from `todo/write`, empty when none. */
     todos: readonly TodoItem[];
+    /**
+     * Global tool-call ordinal counter: the number the NEXT `tool/call` lands
+     * with (1-based). Never reset, so the counter and the badges/error lines
+     * stay consistent across turns and resumed sessions.
+     */
+    toolCallOrdinal: number;
     /** True while a durable turn is open (`turn/start` … `turn/end`). */
     busy: boolean;
     /** `turn/start` time of the open turn (0 while idle) — the web TurnStatus clock anchor. */
@@ -254,6 +274,10 @@ export interface TranscriptView {
         turnTools: Map<number, Set<string>>;
     };
 }
+/** Human-readable bounded image labels for transcript, inspector, and export surfaces. */
+export declare function imageLabels(images: readonly ImageBlock['attachment'][] | undefined): string;
+/** Prompt text with its durable image labels, without exposing local paths or bytes. */
+export declare function promptDisplayText(entry: Pick<UserEntry | PendingEntry, 'text' | 'images'>): string;
 /** A fresh, empty transcript view. */
 export declare function createTranscriptView(): TranscriptView;
 /**
@@ -302,6 +326,8 @@ export interface ReplayAccumulator {
     streaming: string;
     streamingReasoning: string;
     todos: readonly TodoItem[];
+    /** Global tool-call ordinal counter (see `TranscriptView.toolCallOrdinal`). */
+    toolCallOrdinal: number;
     busy: boolean;
     busySince: number;
     model: string;

package/lib/types/render/status.d.ts

@@ -23,13 +23,6 @@ export declare function formatTokens(n: number): string;
  * @returns display string.
  */
 export declare function formatDuration(ms: number): string;
-/**
- * Compact decode rate: one decimal under a hundred, whole below a thousand,
- * then thousands (15.3 / 124 / 1.2K).
- * @param n - tokens per second.
- * @returns display string.
- */
-export declare function formatRate(n: number): string;
 /**
  * Cache-hit share of billed prompt-side input.
  * @param usage - cumulative token totals.
@@ -80,13 +73,12 @@ export declare const STATUS_ITEM_SEPARATOR = " \u00B7 ";
 export declare const STATUS_CYCLE_HINT = " (shift+tab to cycle)";
 /**
  * Interior columns of the segmented context bar (content-type segments plus
- * the free tail whose right edge carries the usage readout). Fixed so the
- * row-2 drop ladder can pre-measure the group; the bar shrinks its labels and
- * readout inside this budget rather than asking the layout for more room.
+ * the free tail whose right edge carries the usage readout). The layout
+ * starts every bar at this width so the drop ladder can pre-measure the
+ * group, then shrinks the bar inside a tighter budget before dropping it
+ * (see CONTEXT_MIN_WIDTH) rather than asking the layout for more room.
  */
 export declare const CONTEXT_BAR_WIDTH = 24;
-/** Occupancy at which the usage readout flips from brand blue to amber. */
-export declare const CONTEXT_WARN_PERCENT = 90;
 /**
  * Render context occupancy as ONE stepless bar: a solid DeepSeek-blue fill
  * run, a dim dotted free track, and the usage readout riding the track's
@@ -193,4 +185,5 @@ export declare function permissionTone(permission: string): StatusTone;
 export declare function layoutStatusBar(facts: StatusFacts, stats: TranscriptStats, columns: number, options?: {
     busy?: boolean;
     items?: readonly string[];
+    contextWidth?: number;
 }): StatusLayout;

package/lib/types/session-directory.d.ts

@@ -50,10 +50,8 @@ export interface SessionRow {
     readonly preset: string;
     readonly title?: string;
 }
-/** True when the header describes a subagent conversation (durable lineage). */
+/** True only for delegated subagents; ordinary forks also carry lineage. */
 export declare function isSubagentSession(header: SessionHeader): boolean;
-/** Platform-consistent path equality for session cwd comparisons. */
-export declare function samePath(left: string | undefined, right: string): boolean;
 /**
  * Unique header match by exact id or unique id prefix (root and subagent
  * headers alike); the caller applies any lineage gate.

package/lib/types/startup.d.ts

@@ -1,6 +1,7 @@
 /**
  * The interactive terminal app's command-line provider: parses `--resume`,
- * `--continue`, `--session`, `--mode`, `--theme`, and `--help`, then
+ * `--continue`, `--session`, `--mode`, `--theme`, `--image`, an optional
+ * initial prompt, and `--help`, then
  * publishes {@link TUI_STARTUP_SERVICE} for the runner to consume lazily.
  * Follows the headless bundle's startup shape (a commander action publishing
  * a service through {@link parseCmdline}).
@@ -25,32 +26,33 @@ import { type ThemeName } from './theme.ts';
 export declare const name = "tui-startup";
 /** Services required before the invocation can be resolved. */
 export declare const inject: string[];
-/** Service provided by this plugin and injected by the terminal runner. */
-export declare const TUI_STARTUP_SERVICE = "tuiStartup";
 /** How the runner obtains its session identity. */
-export type TuiStartup = {
+export type TuiStartup = ({
     readonly kind: 'fresh';
     readonly mode?: string;
-    readonly theme?: ThemeName;
-} | {
+} & TuiStartupInput) | ({
     readonly kind: 'named';
     readonly sessionId: string;
     readonly mode?: string;
-    readonly theme?: ThemeName;
-} | {
+} & TuiStartupInput) | ({
     readonly kind: 'resume';
     readonly sessionId: string;
-    readonly theme?: ThemeName;
-} | {
+} & TuiStartupInput) | ({
     readonly kind: 'latest';
+} & TuiStartupInput);
+interface TuiStartupInput {
     readonly theme?: ThemeName;
-};
+    readonly prompt?: string;
+    readonly images?: readonly string[];
+}
 export interface TuiStartupOptions {
     readonly resume?: string;
     readonly continue?: boolean;
     readonly session?: string;
     readonly mode?: string;
     readonly theme?: ThemeName;
+    readonly prompt?: string;
+    readonly images?: readonly string[];
 }
 /** Pure option policy shared by Commander and tests. */
 export declare function resolveTuiStartup(options: TuiStartupOptions): TuiStartup;
@@ -60,3 +62,4 @@ export declare function resolveTuiStartup(options: TuiStartupOptions): TuiStartu
  * @param ctx - plugin context carrying the command line and exit request.
  */
 export declare function apply(ctx: Context): void;
+export {};

package/lib/types/store.d.ts

@@ -5,15 +5,17 @@
  *
  * Notification coalescing: the fold stays synchronous — `getView()` always
  * returns the latest state the moment `apply` returns — but listener
- * notification is scheduled on a microtask and deduplicated, so N events
- * delivered inside one synchronous drain (the zai/GLM adapter drains its
- * token buffer in sub-millisecond bursts) produce ONE React re-render.
- * Synchronous per-event notification instead cascades one
- * `useSyncExternalStore` force-update per token inside a single flush; the
- * reconciler counts those as nested passive updates and floods React's
- * "Maximum update depth exceeded" warning past 50 events, besides rendering
- * the whole live tree once per token. A microtask keeps latency within the
- * same macrotask, before Ink's throttled paint.
+ * notification is frame-throttled (~16ms) and deduplicated. The zai/GLM
+ * adapter delivers tokens as a sustained stream of sub-millisecond,
+ * microtask-spaced bursts: per-burst notification renders at microtask
+ * cadence, which chained SyncLane `useSyncExternalStore` rerenders past
+ * React's nested-update limit ("Maximum update depth exceeded"), while a
+ * bare `setImmediate` merges a whole macrotask turn's bursts into one
+ * chunky repaint (streaming text visibly staggers). The frame budget gives
+ * both: an event ≥16ms after the last paint notifies via `setImmediate`
+ * (sub-millisecond latency for sparse/first tokens), and anything denser
+ * defers to the next 16ms boundary — a 60fps render cap that also breaks
+ * the nesting chain by construction.
  *
  * @module @deepseek-ai/dsh-tui/store
  */

package/lib/types/subagents.d.ts

@@ -9,9 +9,9 @@
  * running state, bounded last-activity text), capped at
  * {@link MAX_SUBAGENT_ROWS}. Rows are advisory display state, rebuilt from
  * live events; nothing here persists or replays. Notification is coalesced
- * to one microtask per delivery burst, mirroring the transcript store's
- * contract (per-token synchronous notify once cascaded past React's nested
- * update limit on the GLM thinking path).
+ * by the same ~16ms frame throttle as the transcript store (per-burst
+ * microtask notify chained SyncLane rerenders past React's nested update
+ * limit; a bare macrotask merge repaints a whole turn's bursts at once).
  *
  * @module @deepseek-ai/dsh-code/subagents
  */

package/lib/types/theme.d.ts

@@ -17,7 +17,7 @@
 /** One RGB triple for a palette token. */
 export type RgbTriple = readonly [number, number, number];
 /** Palette token keys shared by every theme. */
-export type ThemeToken = 'brand' | 'brandBright' | 'brandMid' | 'brandDeep' | 'dim' | 'success' | 'error' | 'warn' | 'text' | 'code';
+export type ThemeToken = 'brand' | 'brandBright' | 'brandMid' | 'brandDeep' | 'dim' | 'success' | 'error' | 'warn' | 'text' | 'code' | 'composerBand';
 /** One full color palette: every token key mapped to an RGB triple. */
 export type ThemePalette = Readonly<Record<ThemeToken, RgbTriple>>;
 /** Selectable theme names: dark, light, or auto (terminal-sensed). */
@@ -50,6 +50,8 @@ export declare const DARK_PALETTE: {
     readonly text: readonly [236, 240, 246];
     /** Inline/fenced code — soft sky blue, distinct from brand accents. */
     readonly code: readonly [125, 211, 252];
+    /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+    readonly composerBand: readonly [46, 48, 52];
 };
 /**
  * Light palette tuned for white terminals: the same token keys as dark with
@@ -78,6 +80,8 @@ export declare const LIGHT_PALETTE: {
     readonly text: readonly [21, 21, 23];
     /** Inline/fenced code — Tailwind cyan-700, distinct from brand accents. */
     readonly code: readonly [14, 116, 144];
+    /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+    readonly composerBand: readonly [229, 231, 235];
 };
 /** Every palette by theme name; auto resolves through {@link resolveTheme}. */
 export declare const PALETTES: {
@@ -102,6 +106,8 @@ export declare const PALETTES: {
         readonly text: readonly [236, 240, 246];
         /** Inline/fenced code — soft sky blue, distinct from brand accents. */
         readonly code: readonly [125, 211, 252];
+        /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+        readonly composerBand: readonly [46, 48, 52];
     };
     readonly light: {
         /** Primary brand blue — unchanged, ≈4.9:1 AA on white. */
@@ -124,6 +130,8 @@ export declare const PALETTES: {
         readonly text: readonly [21, 21, 23];
         /** Inline/fenced code — Tailwind cyan-700, distinct from brand accents. */
         readonly code: readonly [14, 116, 144];
+        /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+        readonly composerBand: readonly [229, 231, 235];
     };
 };
 /**
@@ -131,6 +139,9 @@ export declare const PALETTES: {
  * two-palette switch keep compiling and painting identically (the default
  * theme IS dark). New code should read the active palette through
  * {@link getPalette} so a theme switch reaches it.
+ *
+ * @deprecated Read the active palette through {@link getPalette}; this
+ * compatibility alias is removed in the next minor release.
  */
 export declare const TUI_RGB: {
     /** Primary brand blue — `--dsw-static-deepseek-500`. */
@@ -153,6 +164,8 @@ export declare const TUI_RGB: {
     readonly text: readonly [236, 240, 246];
     /** Inline/fenced code — soft sky blue, distinct from brand accents. */
     readonly code: readonly [125, 211, 252];
+    /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+    readonly composerBand: readonly [46, 48, 52];
 };
 /**
  * Resolve a theme name to the palette actually in use. `auto` detection

package/lib/types/version.d.ts

@@ -1,5 +1,18 @@
 /** Installed dsh-code version exposed by the terminal header. */
-/** Read one package manifest version without making terminal startup depend on it. */
-export declare function readPackageVersion(manifest?: import("url").URL): string;
 /** Version of the installed dsh-code package. */
 export declare const DSH_CODE_VERSION: string;
+/**
+ * Resolve the running dsh CLI host's version from its entry file
+ * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js`). Only a manifest
+ * literally named `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a
+ * plain node script) resolves to undefined instead of faking a kernel version.
+ */
+export declare function resolveDshHostVersion(entry?: string | undefined): string | undefined;
+/**
+ * The dsh kernel version the TUI runs on, memoized after the first probe: the
+ * host process never changes within a run, and the header reads this on every
+ * Static replay.
+ */
+export declare function dshKernelVersion(): string | undefined;
+/** Test-only: forget the memoized kernel version so a new argv can be probed. */
+export declare function _resetDshKernelVersionForTests(): void;