dsh-code 0.6.0 → 0.7.0

package/lib/types/app.d.ts

@@ -14,12 +14,14 @@
  * @module @deepseek-ai/dsh-code/app
  */
 import { type ReactElement } from 'react';
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+import { type ThemeName } from './theme.ts';
 import type { TranscriptStore } from './store.ts';
 import type { ApprovalStore } from './approval.ts';
 import type { CommandsView } from './commands.ts';
 import type { ModelDirectory, ModelRow } from './models.ts';
 import type { QuestionStore } from './questions.ts';
-import type { SkillsView } from './skills.ts';
+import type { SkillsView, SkillRow } from './skills.ts';
 import type { MentionCandidate } from './mentions.ts';
 import type { PresetRow } from './presets.ts';
 import type { PluginRow } from './plugin-inventory.ts';
@@ -40,6 +42,8 @@ export interface AppProps {
     skills: SkillsView;
     /** `provider/model` selection serving this session (updated on /model). */
     model: string;
+    /** Effective reasoning effort in force ('' when none), for the /model picker mark. */
+    effort?: string;
     /** Working-directory basename the session serves. */
     cwd: string;
     /** Absolute working directory used by session filters and references. */
@@ -64,8 +68,8 @@ export interface AppProps {
     loadModels(): Promise<ModelDirectory>;
     /** Load @mention candidates for the typed query (files + sessions). */
     loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
-    /** Apply one /model selection; returns the display label. */
-    selectModel(row: ModelRow): string;
+    /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
+    selectModel(row: ModelRow, effortId?: string): string;
     /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
     cyclePermission(): string;
     /** Export the transcript to a markdown file (/export [path]); reports via notices. */
@@ -89,6 +93,8 @@ export interface AppProps {
     statusline: readonly string[];
     /** Persist a new statusline item set; the runner surfaces IO failures as notices. */
     saveStatusline(items: readonly string[]): void;
+    /** Apply and persist one /theme selection; the runner owns the theme.json file. */
+    saveTheme?(name: ThemeName): void;
     /** Persistent cross-session input history (oldest first); the runner owns the file. */
     history: readonly string[];
     /** Persist one submitted prompt to the global history file. */
@@ -96,5 +102,27 @@ export interface AppProps {
     /** Cancel one queued inbox message by identity (Delete on the empty composer). */
     cancelQueued(messageId: string): void;
 }
+/** One completion candidate row. */
+interface CompletionCandidate {
+    /** Insertion text for the command name (with leading slash). */
+    label: string;
+    /** Human-readable description shown beside the label. */
+    description: string;
+    /** Candidate origin; skills land the same literal text but route through the prompt. */
+    origin: 'command' | 'skill' | 'mention' | 'path';
+}
+/**
+ * Resolve completion candidates for the current input: TUI-local commands,
+ * the live registry descriptors, and user-invocable skills, filtered by the
+ * typed prefix. Command names win collisions (the dispatch tries the
+ * registry first and only then falls through to the skill gesture), and a
+ * later duplicate name never renders twice.
+ *
+ * A bare `/` returns the FULL merged list — Codex's command popup shows every
+ * command inside a scroll window on an empty filter, and the menu's own
+ * selection window bounds the visible rows, so no slice cap is needed.
+ */
+export declare function completionCandidates(value: string, descriptors: readonly CommandDescriptor[], skills: readonly SkillRow[]): readonly CompletionCandidate[];
 /** The whole terminal app; state arrives via the store, output via Ink. */
 export declare function App(props: AppProps): ReactElement;
+export {};

package/lib/types/index.d.ts

@@ -21,6 +21,7 @@ export interface Config {
         kind: string;
         sessionId?: string;
         mode?: string;
+        theme?: string;
     };
 }
 export declare const Config: z<Config>;

package/lib/types/kernel-panels.d.ts

@@ -1,5 +1,6 @@
 /** Bounded, composer-safe panels for preset, session, and plugin kernel views. */
 import { type ReactElement } from 'react';
+import type { ModelRow } from './models.ts';
 import type { PresetRow } from './presets.ts';
 import type { PluginRow } from './plugin-inventory.ts';
 import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
@@ -46,3 +47,23 @@ export declare function StatuslinePanel({ enabled, change, close }: {
     change(items: readonly StatusItemId[]): void;
     close(): void;
 }): ReactElement;
+/**
+ * The `/model` reasoning-effort stage (the Codex model → reasoning popup
+ * contract): one bounded list over the selected model's adapter-advertised
+ * effort levels, with the effective effort and the model default marked.
+ * A model WITHOUT an adapter-declared default leads with a "Default"
+ * (provider-default) row — the web effort pane's first entry — so the user
+ * can clear a picked level back to provider behavior instead of being forced
+ * to choose an advertised one. Enter applies one level; Esc returns to the
+ * model list without applying.
+ */
+export declare function EffortPanel({ row, current, select, back }: {
+    /** The model row whose advertised levels this stage lists. */
+    row: ModelRow;
+    /** Effective effort currently in force ('' when none), for the ● mark. */
+    current: string | undefined;
+    /** Accept one advertised effort id, or '' for the provider default. */
+    select(effortId: string): void;
+    /** Return to the model list without applying. */
+    back(): void;
+}): ReactElement;

package/lib/types/mentions.d.ts

@@ -1,12 +1,17 @@
 /**
- * Workspace @mention support: file candidates from a bounded async scan of
- * the session cwd, session candidates from the opt-in `sessionReferenceResolver`
- * service, and submission preparation through its `prepare()` API. Picked
- * session mentions land as canonical `@[label](dsh-session:…)` tokens; on
- * submit the text is parsed back into readable `@label` text plus structured
- * references, snapshots are injected via `agent.inject()` before the readable
- * message wakes the driver (`followup` idle, `steer` running) — exactly the
- * upstream README's wiring.
+ * Workspace @mention support: file and directory candidates from a bounded
+ * async scan of the session cwd, session candidates from the opt-in
+ * `sessionReferenceResolver` service, and submission preparation through its
+ * `prepare()` API. Picked session mentions land as canonical
+ * `@[label](dsh-session:…)` tokens; on submit the text is parsed back into
+ * readable `@label` text plus structured references, snapshots are injected
+ * via `agent.inject()` before the readable message wakes the driver
+ * (`followup` idle, `steer` running) — exactly the upstream README's wiring.
+ *
+ * Harness exposes no workspace-file mention service (only session references
+ * plus a post-hoc produced-file linker), so the file index is the lightweight
+ * bounded scan below, kept deliberately smaller than Codex's streaming
+ * gitignore-aware walker.
  *
  * @module @deepseek-ai/dsh-code/mentions
  */
@@ -40,11 +45,17 @@ export interface PreparedMention {
     /** Aggregated snapshot for `agent.inject()`, undefined without references. */
     additionalContext?: import('@deepseek-ai/dsh-session').UserMessage;
 }
-/** Bounded async BFS scan of a workspace; unreadable entries are skipped. */
+/**
+ * Bounded async BFS scan of a workspace; unreadable entries are skipped.
+ * Both files and directories are indexed (directories insert with a trailing
+ * slash), mirroring Codex's `MatchType::{File,Directory}` index. Dotfiles and
+ * the {@link SKIP_DIRS} list are excluded, which is a coarser filter than
+ * Codex's gitignore-aware walker but stays dependency-free and bounded.
+ */
 export declare function scanWorkspaceFiles(root: string, signal?: AbortSignal): Promise<readonly FileCandidate[]>;
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
-    /** Scanned workspace files, cached across one session. */
+    /** Scanned workspace files and directories, cached across one session. */
     files(): Promise<readonly FileCandidate[]>;
     /** Ranked menu candidates for the typed `@` query. */
     candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
@@ -61,10 +72,16 @@ export interface MentionsApi {
 /**
  * Create the mention API for one agent's workspace. A missing
  * session-reference service degrades to file mentions only (the scan still
- * works); `prepare` then passes text through untouched.
+ * works); `prepare` then passes text through untouched. An undefined agent
+ * (a bare launch before any session exists) also degrades to file-only
+ * mentions, so `@` file completion works before the first message.
+ *
+ * `files` is hoisted into the closure so `candidates` never reaches for
+ * `this` — the runner hands `mentions.candidates` to the input editor as a
+ * detached callback, and a `this`-bound method would throw on every `@` key.
  * @param ctx - context carrying the optional `sessionReferenceResolver`.
  * @param agent - the session owner; excluded from its own candidates.
  * @param cwd - workspace root to scan.
  */
-export declare function createMentions(ctx: Context, agent: Agent, cwd: string): MentionsApi;
+export declare function createMentions(ctx: Context, agent: Agent | undefined, cwd: string): MentionsApi;
 export {};

package/lib/types/models.d.ts

@@ -8,6 +8,24 @@
  * @module @deepseek-ai/dsh-tui/models
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { ModelSelection } from '@deepseek-ai/dsh-agent';
+import { type LlmModelReasoningInfo } from '@deepseek-ai/dsh-llm';
+/** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
+export interface ModelReasoningEffort {
+    /** Opaque value accepted by the model's `GenerateOptions.reasoningEffort`. */
+    id: string;
+    /** Human-readable effort name for selectors. */
+    name: string;
+    /** Optional user-facing distinction from otherwise similar efforts. */
+    description?: string;
+}
+/** Selectable reasoning efforts for one model (mirrors `LlmModelReasoningInfo`). */
+export interface ModelReasoning {
+    /** Supported efforts in adapter-preferred display order. */
+    efforts: readonly ModelReasoningEffort[];
+    /** Adapter-configured default materialized when callers omit an effort. */
+    defaultEffort?: string;
+}
 /** One selectable row in the `/model` panel. */
 export interface ModelRow {
     /** Registered provider route. */
@@ -18,6 +36,8 @@ export interface ModelRow {
     model: string;
     /** Human-readable model name. */
     modelName: string;
+    /** Adapter-owned selectable reasoning levels when the model exposes any. */
+    reasoning?: ModelReasoning;
 }
 /** The resolved directory: rows plus per-provider discovery failures. */
 export interface ModelDirectory {
@@ -25,12 +45,58 @@ export interface ModelDirectory {
     rows: readonly ModelRow[];
     /** Provider ids whose model listing failed; those providers contribute no rows. */
     failures: readonly string[];
+    /**
+     * `provider/model` labels whose per-model capability lookup failed. Those
+     * rows still appear (advisory degrade, mirroring the web catalog), but
+     * without an effort picker — a picker caller must not misread the absence
+     * as "this model exposes no reasoning" (e.g. deepseek-v4-flash always
+     * advertises off/high/max unless thinking is disabled). Optional for
+     * callers that shape a directory by hand; {@link loadModelDirectory}
+     * always populates it (empty when nothing failed).
+     */
+    reasoningFailures?: readonly string[];
 }
+/** Map an adapter's reasoning capability onto the panel's plain-id shape. */
+export declare function mapReasoning(reasoning: LlmModelReasoningInfo): ModelReasoning;
+/**
+ * Resolve the effective model selection for one live session, in the
+ * documented precedence: the in-process explicit pick, then the session's
+ * last `request/header` config, then the deployment default.
+ * @param picked - the explicit selection made in this process, when any.
+ * @param logged - the last logged request header config, when any.
+ * @param defaults - the deployment default selection.
+ * @returns the effective selection, carrying a reasoning effort when one is in force.
+ */
+export declare function resolveEffectiveSelection(picked: ModelSelection | undefined, logged: {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+} | undefined, defaults: ModelSelection): ModelSelection;
+/**
+ * Build the selection one `/model` pick applies, rejecting an effort the
+ * row does not advertise. The row is the picker's source of truth, so a
+ * stale directory cannot smuggle an unsupported effort into the next step
+ * (the request pipeline would reject it before network I/O regardless). The
+ * empty string is the picker's "provider default" sentinel — an explicit
+ * choice to leave the effort to the model's own default, exactly like an
+ * absent effort.
+ * @param row - the picked model row.
+ * @param effortId - the chosen advertised effort, '' or undefined for the model default.
+ * @returns the selection the runner records for the next assembled step.
+ */
+export declare function buildModelSelection(row: ModelRow, effortId?: string): ModelSelection;
+/** Display label for one applied selection: `provider/model` or `provider/model@effort`. */
+export declare function modelSelectionLabel(selection: ModelSelection): string;
 /**
  * Load the selectable model directory from the live `ctx.llm` registry.
  * Providers are listed synchronously; each provider's models are discovered
  * with a bounded parallel fan-out whose failures degrade to that provider
  * contributing no rows (mirrors the web catalog's per-provider failures).
+ * Each row's reasoning levels are resolved per exact model like the web
+ * catalog (`buildModelCatalog`); a single model's capability lookup failure
+ * degrades to that row having no effort picker rather than hiding the model,
+ * and the failure rides `reasoningFailures` so the caller can tell "no
+ * advertised reasoning" from "capability lookup failed".
  * @param ctx - context carrying the `llm` service.
  * @returns the resolved directory; empty rows when `llm` is unavailable.
  */

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

@@ -3,11 +3,20 @@
  * 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. Pure functions only —
- * the Ink layer owns timers and colors.
+ * 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
+ * INTO an official DeepSeek route sweeps a blue wave across the composer's
+ * input row — one column per cell, `backgroundColor` = the sampled wave
+ * color — then, on the deepseek (Ultra-equivalent) tier, drops the `· ✦ ✧`
+ * sparkle sequence into the rightmost blank cell before fading. The prompt
+ * marker keeps the tier accent afterwards (persistent, like Codex's prompt
+ * charge). Pure functions only — the Ink layer owns timers and colors.
  *
  * @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. */
@@ -22,3 +31,167 @@ export declare const BUSY_CHASE_FRAMES: readonly ["⣾", "⣽", "⣻", "⢿", "
 export declare function busyChaseFrame(tick: number): string;
 /** Caret visibility: half the ticks on, half off (530ms blink). */
 export declare function caretVisible(tick: number): boolean;
+/**
+ * The one-shot DeepSeek model-switch easter egg: when the status bar model
+ * label switches to an official DeepSeek route, the composer's input row
+ * plays Codex's effort-ignition "Wave" — a blue crest sweeping the content
+ * row column by column (background tint ≤ 0.55 under the draft), plus the
+ * Ultra-style `· ✦ ✧` sparkles on the deepseek tier — and the prompt marker
+ * keeps the tier accent afterwards. The Ink layer owns the timer and reads
+ * the ACTIVE palette anchors (`getPalette`); everything below is pure
+ * interpolation over the colors it is given.
+ */
+/** Frame cadence of the DeepSeek wave: Codex's IGNITION_FRAME_TICK (33ms ≈ 30fps). */
+export declare const DEEPSEEK_WAVE_TICK_MS = 33;
+/**
+ * The two DeepSeek wave tiers. The concept maps Codex's reasoning tiers to
+ * model ids: `flash` runs the Max parameters, `deepseek` (pro models) runs
+ * the Ultra parameters (dual band + tail sparkles on the Wave style).
+ */
+export type DeepseekWaveTier = 'flash' | 'deepseek';
+/**
+ * The three ignition styles — Codex `IgnitionStyle`: a traveling crest
+ * (Wave), a drifting multi-hue band (Aurora), and an expanding ring (Pulse).
+ * 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 ["·", "✦", "✧"];
+/**
+ * Band tables — Codex `bands(style, tier)`. Each entry is a triple whose
+ * meaning depends on the style: Wave/Pulse use `(launch, travel, strength)`;
+ * Aurora uses `(speed, phase, hueIndex)`.
+ */
+export type DeepseekWaveBand = readonly [number, number, number];
+export declare const DEEPSEEK_WAVE_BANDS: Readonly<Record<DeepseekWaveStyle, Readonly<Record<DeepseekWaveTier, readonly DeepseekWaveBand[]>>>>;
+/**
+ * Total animation duration — Codex `IgnitionStyle::total_duration`: three
+ * styles × two tiers.
+ * @param tier - the active wave tier.
+ * @param style - the active ignition style.
+ * @returns the duration in milliseconds.
+ */
+export declare function deepseekWaveDuration(tier: DeepseekWaveTier, style?: DeepseekWaveStyle): number;
+/**
+ * Pick one ignition style at random, never repeating the previous one —
+ * Codex `IgnitionStyle::random`. Falls back to the remaining styles.
+ * @param previous - the style of the last trigger, if any.
+ * @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
+ * dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping.
+ * @param model - the `provider/model` label of the applied model.
+ * @returns the wave tier for that model.
+ */
+export declare function deepseekWaveTier(model: string): DeepseekWaveTier;
+/**
+ * Cosine window — Codex `crest`: 1 exactly under the wave center, 0 from
+ * one half-width away.
+ * @param distance - distance from the crest center in half-widths.
+ * @returns the crest strength in 0..1.
+ */
+export declare function crest(distance: number): number;
+/**
+ * Cubic ease-in-out — Codex `ease_in_out`: flat at both ends, steepest in
+ * the middle, so the crest accelerates and eases instead of sliding linearly.
+ * @param progress - raw progress (clamped to 0..1).
+ * @returns the eased progress in 0..1.
+ */
+export declare function easeInOut(progress: number): number;
+/**
+ * Fade-in/fade-out envelope — Codex `envelope`: linear ramp over `fadeIn`
+ * at the start and `fadeOut` at the end, plateau at 1 between, 0 outside the
+ * total. The Wave style keeps the envelope at 1 (Codex paints Wave without
+ * an envelope); exported for the Aurora-style fades and for tests.
+ * @param elapsed - seconds since the animation started.
+ * @param total - total duration in seconds.
+ * @param fadeIn - seconds of fade-in.
+ * @param fadeOut - seconds of fade-out.
+ * @returns the envelope value in 0..1.
+ */
+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
+ * `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.
+ * @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.
+ * @param tier - the wave tier (flash = Max, deepseek = Ultra parameters).
+ * @param style - the ignition style.
+ * @param hues - the tier's three hues.
+ * @param base - the blank-cell base color the tint blends toward.
+ * @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;
+/**
+ * The sparkle glyph for a tick — Codex `spark_frame`: from 900ms on, one
+ * glyph every 100ms through `· ✦ ✧`, then silent. The deepseek (Ultra) tier
+ * only; the Ink layer still must skip occupied cells.
+ * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
+ * @returns the sparkle glyph, or null outside the 900..1200ms 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,
+ * so the brand name surfaces through the sweep's middle. The Ink layer
+ * places it in the row's blank mid-section (never over real draft text).
+ * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
+ * @param tier - the wave tier.
+ * @returns true while the wordmark should be visible.
+ */
+export declare function deepseekWaveWordVisible(tick: number, tier: DeepseekWaveTier, style?: DeepseekWaveStyle): boolean;
+/**
+ * The per-character color for the `deepseek` wordmark: the tier's hues
+ * cycled per character (d→hue0, e→hue1, e→hue2, …), a brand-gradient text.
+ * @param index - character index in the wordmark.
+ * @param hues - the tier's three hues.
+ * @returns the hue for that character.
+ */
+export declare function deepseekWaveWordHue(index: number, hues: readonly [RgbTriple, RgbTriple, RgbTriple]): RgbTriple;
+/**
+ * True when a `provider/model` status label addresses the official DeepSeek
+ * route: either segment contains `deepseek` (case-insensitive), covering the
+ * `deepseek-official` provider route and its `deepseek-*` model ids.
+ * @param label - the status bar model label (`provider/model`).
+ * @returns whether the label names an official DeepSeek model.
+ */
+export declare function isOfficialDeepSeekLabel(label: string): boolean;

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

@@ -138,6 +138,24 @@ export interface UsageTotals {
     /** Cache-read tokens over the whole log (0 when the adapter reports none). */
     cacheReadTokens: number;
 }
+/**
+ * Estimated used tokens per context content type, folded from transcript
+ * events via {@link estimateTokens}. The segmented context bar's composition
+ * source: proportions across types are meaningful, absolute values are not
+ * (they never touch billing or the reported `lastPromptTokens`).
+ */
+export interface ContextSegments {
+    /** Rendered system-prompt text (latest `request/header`) plus injected-context notices. */
+    system: number;
+    /** Direct human prompts (durable `user/message` rows). */
+    prompt: number;
+    /** Assistant text blocks (visible replies). */
+    assistant: number;
+    /** Assistant reasoning blocks (hidden thinking). */
+    thinking: number;
+    /** Tool call arguments plus result text. */
+    tools: number;
+}
 /** Window-scoped figures the status line shows; timing uses event timestamps. */
 export interface TranscriptStats {
     /** Durable turns opened (`turn/start` events). */
@@ -154,6 +172,8 @@ export interface TranscriptStats {
     lastPromptTokens: number;
     /** Newest advertised route capacity, 0 when no adapter ever advertised one. */
     contextWindow: number;
+    /** Estimated used tokens per content type (the segmented bar's composition). */
+    contextSegments: ContextSegments;
     /** Summed first-token waits: `step/start` → first non-empty chunk, in ms. */
     ttftMs: number;
     /** Steps that produced a first chunk (the TTFT average's denominator). */
@@ -162,6 +182,14 @@ export interface TranscriptStats {
     decodeMs: number;
     /** Completion tokens over timed decode spans (the tok/s numerator). */
     decodeTokens: number;
+    /**
+     * Adapter-owned reasoning effort of the latest `request/header` config —
+     * the EFFECTIVE effort the session actually uses (a materialized model
+     * default is included, exactly as the adapter resolved it). Empty when the
+     * header carried none (provider-default behavior). The status line appends
+     * it to the model segment as `provider/model@effort`.
+     */
+    reasoningEffort: string;
 }
 /** The complete TUI transcript view for one session. */
 export interface TranscriptView {
@@ -235,13 +263,16 @@ export declare function projectEvent(view: TranscriptView, event: SessionEvent):
  */
 export declare function projectEvents(events: readonly SessionEvent[]): TranscriptView;
 /**
- * How many leading transcript entries can never change again: only a
- * `running` tool or retry can still mutate in place — everything before the
- * first one (including a completed tail: later events only APPEND new rows)
- * is final. The renderer currently draws the whole transcript dynamically
- * (a `<Static>` flush proved unstable with CJK wrapping on real terminals);
- * this boundary stays as the append-only contract for when flushing is
- * reintroduced.
+ * The append-only flush boundary for a transcript view: the count of entries
+ * no later event can remove. Entries at or beyond this index are mutable and
+ * must stay in the live tree.
+ *
+ * `pending` rows are excluded even though they are not a running tool/retry:
+ * the inbox claims or cancels them durably (`agent/inbox/spliced` removals,
+ * `user/message` retirement), and an append-only `<Static>` flush cannot
+ * erase a row that vanishes from the view — the retired row would ghost on
+ * screen until the next source-backed replay. Everything else (including a
+ * completed tail) is final: later events only APPEND new rows.
  * @param entries - the view's transcript entries in order.
  * @returns the count of entries safe to flush (0 for an empty transcript).
  */

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

@@ -9,7 +9,7 @@
  *
  * @module @deepseek-ai/dsh-tui/render/status
  */
-import type { TranscriptStats } from './projection.ts';
+import type { ContextSegments, TranscriptStats } from './projection.ts';
 /**
  * Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three
  * digits), mirroring the web composer's StatsLine format.
@@ -40,7 +40,7 @@ export declare function cacheHitPercent(usage: TranscriptStats['usage']): number
  * Presentation tones for status spans; the footer maps each to a theme color
  * (Codex status-line accents: model/path/branch/state/usage categories).
  */
-export type StatusTone = 'model' | 'live' | 'path' | 'branch' | 'value' | 'label' | 'meta' | 'accent' | 'success' | 'warn' | 'error';
+export type StatusTone = 'model' | 'live' | 'path' | 'branch' | 'value' | 'label' | 'meta' | 'accent' | 'success' | 'warn' | 'error' | 'ctxSystem' | 'ctxPrompt' | 'ctxAssistant' | 'ctxThinking' | 'ctxTools';
 /** One colored run inside the status bar. */
 export interface StatusSpan {
     text: string;
@@ -80,21 +80,42 @@ export declare const STATUS_GROUP_SEPARATOR = " | ";
 export declare const STATUS_ITEM_SEPARATOR = " \u00B7 ";
 /** The Codex-style mode cycle hint appended to the permission badge. */
 export declare const STATUS_CYCLE_HINT = " (shift+tab to cycle)";
-/** Cells in the context-occupancy progress bar (block glyphs count two columns in the budget). */
-export declare const CONTEXT_BAR_CELLS = 10;
-/** Occupancy at which the bar switches from brand blue to a single amber warning. */
+/**
+ * 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.
+ */
+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;
+/** One content-type segment of the context bar (pure data; colors live in app.ts). */
+export interface ContextSegmentSpec {
+    key: keyof ContextSegments;
+    /** Tone the footer maps to a DeepSeek blue shade. */
+    tone: StatusTone;
+    /** Labels longest → shortest; the first one fitting the segment width wins. */
+    labels: readonly string[];
+}
+/** The five content types in conversation order, dark → light blue. */
+export declare const CONTEXT_SEGMENTS: readonly ContextSegmentSpec[];
 /**
- * Render a context-occupancy percent as a bracketed fixed-width progress bar
- * plus the percentage: `[▰▰▰▱▱▱▱▱▱▱] 25%`. Filled cells and the percent read
- * in brand blue (accent), empty cells and the brackets read dim (label), and
- * the whole meter flips to one amber warning once occupancy reaches the
- * warning threshold. The bar fill clamps to 100 while the printed percent
- * keeps the raw value so an over-budget session reads as such.
- * @param percent - occupancy percent (may exceed 100).
+ * Render context occupancy as a segmented bar: one DeepSeek-blue run per
+ * content type (system/prompt/assistant/thinking/tools), column widths
+ * proportional to their estimated token share, each with a centered label
+ * that shortens to fit (system→sys→s). The remaining free tail is a dim
+ * track whose right edge carries the usage readout (`12.3K/1.0M 25%`,
+ * shrinking to the bare percent as the tail narrows). The readout flips to
+ * amber once occupancy reaches the warning threshold; the segment blues stay
+ * untouched so the composition remains readable at full context. The used
+ * total comes from the reported `lastPromptTokens`, never from the estimates.
+ * @param segments - estimated used tokens per content type.
+ * @param usedTokens - reported used tokens (drives the readout and percent).
+ * @param contextWindow - route capacity.
+ * @param width - total bar interior columns.
  * @returns tone-split spans for the footer to paint.
  */
-export declare function contextBar(percent: number): readonly StatusSpan[];
+export declare function contextBar(segments: ContextSegments, usedTokens: number, contextWindow: number, width: number): readonly StatusSpan[];
 /**
  * One customizable status item (the Codex /statusline picker contract).
  * 'left' items render as pipe-separated clusters after the identity dot;