dsh-code 1.0.4 → 1.0.6

package/lib/types/app.d.ts

@@ -15,7 +15,7 @@
  */
 import { type ReactElement } from 'react';
 import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
-import type { ImageBlock } from '@deepseek-ai/dsh-llm';
+import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
 import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
 import { type ThemeName } from './theme.ts';
 import type { TranscriptStore } from './store.ts';
@@ -35,7 +35,7 @@ import type { PluginRow } from './plugin-inventory.ts';
 import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
 import type { GitDiffView } from './git-workflow.ts';
 import { type ProviderAuthorizationDirectory, type ProviderAuthorizationRow } from './authorization.ts';
-import { type ImagePathInspection } from './attachments.ts';
+import { type FilePathInspection, type ImagePathInspection } from './attachments.ts';
 /** Visual priority for one bounded local notice. */
 export type NoticeTone = 'info' | 'warning' | 'error';
 /** Props the runner hands the app; callbacks stay owned by the runner. */
@@ -70,10 +70,20 @@ export interface AppProps {
     mode: string;
     /** Permission preset selected for the current or pending first session. */
     permission: string;
-    /** Submit one line: slash commands to the registry, other text to the agent. */
-    dispatch(text: string, images?: readonly ImageBlock[]): void;
-    /** Submit steering: consumed at the running turn's next step boundary. */
-    steer(text: string, images?: readonly ImageBlock[]): void;
+    /**
+     * Submit one line: slash commands to the registry, other text to the agent.
+     * The optional origin names the session the submission was composed for —
+     * an attachment prepare resolves after the app remounted onto another
+     * session, and the runner drops the stale delivery then.
+     */
+    dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
+    /** Submit steering, with the same stale-delivery guard as {@link dispatch}. */
+    steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
+    /**
+     * The FULL current session identity ('' while the first session is pending)
+     * — the stale-delivery origin above. Distinct from the short display id.
+     */
+    sessionKey: string;
     /** Interrupt the running turn (Esc); true when a turn was cancelled. */
     interrupt(): boolean;
     /** Quit: unmount, flush, and request process exit. */
@@ -86,6 +96,10 @@ export interface AppProps {
     inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>;
     /** Validate, normalize and persist images immediately before submission. */
     prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>;
+    /** Validate draft non-image file paths without committing attachment objects. */
+    inspectFiles(paths: readonly string[]): Promise<readonly FilePathInspection[]>;
+    /** Persist non-image files immediately before submission as durable file blocks. */
+    prepareFiles(paths: readonly string[], signal?: AbortSignal): Promise<readonly FileBlock[]>;
     /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
     selectModel(row: ModelRow, effortId?: string): string;
     /** The /subagent override label, '' when delegated agents follow the current model. */
@@ -166,6 +180,11 @@ export interface AppProps {
     saveStatusline(items: readonly string[]): void;
     /** Apply and persist one /theme selection; the runner owns the theme.json file. */
     saveTheme?(name: ThemeName): void;
+    /** Whether timed animations run at startup (animations.json; on by default
+     * — like parseAnimationsPref, only an explicit false disables them). */
+    animations?: boolean;
+    /** Apply and persist one /animation toggle; the runner owns the file. */
+    saveAnimations?(enabled: boolean): 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. */

package/lib/types/attachments.d.ts

@@ -1,6 +1,6 @@
-/** Terminal image-file adapter over the Harness durable attachment service. */
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
 import type { AttachmentStore, ImageMediaType } from '@deepseek-ai/dsh-attachment';
-import type { ImageBlock } from '@deepseek-ai/dsh-llm';
+import type { FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
 /** A validated path retained in the editor until submission persists it. */
 export interface ImagePathInspection {
     readonly path: string;
@@ -8,13 +8,45 @@ export interface ImagePathInspection {
     readonly mediaType: ImageMediaType;
     readonly bytes: number;
 }
+/** A validated non-image file path retained the same way (0.1.5 file blocks). */
+export interface FilePathInspection {
+    readonly path: string;
+    readonly name: string;
+    readonly bytes: number;
+}
+/**
+ * Terminal-side file admission bounds. Upstream exposes image limits through
+ * the attachment service but no file limits (files ride verbatim storage);
+ * these keep a dragged file from silently ingesting a disk-sized blob and
+ * bound one message the way the image batch is bounded.
+ */
+export declare const MAX_FILE_BYTES: number;
+export declare const MAX_FILES_PER_MESSAGE = 8;
 /** Detect the supported encoded raster formats from bytes, never from a path suffix. */
 export declare function detectImageMediaType(data: Uint8Array): ImageMediaType | undefined;
 /** Whether a path-like token is worth probing as an image attachment. */
 export declare function looksLikeImagePath(path: string): boolean;
-/** Parse a terminal paste/drop containing only one or more image paths. */
-export declare function parsePastedImagePaths(input: string): readonly string[];
+/**
+ * Parse a paste/drop into its image and file paths: image-suffixed tokens
+ * stay images, other path-shaped tokens ride as file attachments (0.1.5
+ * file blocks), and anything that is neither leaves both empty — the caller
+ * then treats the paste as plain text.
+ *
+ * File tokens are held to an absolute-path-with-shape bar (drive/backslash
+ * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * carries one of those, while prose, slash commands, and option flags never
+ * do. A POSIX absolute path without any dot-suffixed leaf falls through as
+ * text — the @ mention route still attaches such files deliberately.
+ */
+export declare function parsePastedAttachmentPaths(input: string): {
+    readonly images: readonly string[];
+    readonly files: readonly string[];
+};
 /** Validate path, byte size and encoded signature without writing an attachment object. */
 export declare function inspectImagePaths(paths: readonly string[], attachments: AttachmentStore | undefined, cwd?: string): Promise<readonly ImagePathInspection[]>;
 /** Read, validate, and persist an ordered image path list as model content blocks. */
 export declare function saveImagePaths(paths: readonly string[], attachments: AttachmentStore | undefined, signal?: AbortSignal): Promise<readonly ImageBlock[]>;
+/** Validate path and byte size for non-image file attachments without writing. */
+export declare function inspectFilePaths(paths: readonly string[], attachments: AttachmentStore | undefined, cwd?: string): Promise<readonly FilePathInspection[]>;
+/** Read and persist an ordered non-image file path list as model file blocks. */
+export declare function saveFilePaths(paths: readonly string[], attachments: AttachmentStore | undefined, signal?: AbortSignal): Promise<readonly FileBlock[]>;

package/lib/types/git-workflow.d.ts

@@ -1,4 +1,9 @@
-/** Read-only Git inspection used by /diff and /review. */
+/**
+ * Read-only Git inspection used by /diff and /review. Every diff
+ * invocation carries --no-ext-diff and --no-textconv, so configured
+ * external diff drivers and text converters can never execute as a
+ * side effect of reading a diff.
+ */
 export interface GitDiffSpec {
     readonly label: string;
     readonly args: readonly string[];
@@ -18,7 +23,7 @@ export declare function parseGitDiffFiles(text: string): readonly GitDiffFile[];
 /** Parse the intentionally small, option-safe /diff argument vocabulary. */
 export declare function parseGitDiffSpec(argument: string): GitDiffSpec;
 /**
- * Load one complete textual diff without invoking external diff drivers.
+ * Load one complete textual diff without invoking external programs.
  * @param signal - aborted by the caller on session switches/quit, killing the
  * git subprocess instead of letting a stale repository's diff land later.
  */

package/lib/types/history.d.ts

@@ -21,14 +21,21 @@ export declare function serializeHistoryEntry(text: string): string;
  */
 export declare function parseHistoryFile(raw: string, max?: number): readonly string[];
 /**
- * Append one entry to the persistent file content: JSON line, capped to the
- * newest `max` entries with a trailing newline.
- * @param current - existing file content.
- * @param text - submission to persist.
- * @param max - entry cap.
- * @returns the new file content.
+ * The append unit for the persistent file: one JSON line, so a multi-line
+ * draft still occupies exactly one physical line. Each submission appends
+ * this unit at the end of the file, so concurrent terminals add entries
+ * after each other. Node chunks one append at 512 KiB: a pasted entry
+ * beyond that size could interleave mid-line with another writer's
+ * chunks, and the damaged line then drops out at the next parse —
+ * recall tolerates the loss by design.
+ */
+export declare function historyLine(text: string): string;
+/**
+ * Whether the file on disk differs from its canonical form (deduped and
+ * capped). True means stale lines have accumulated and the next boot
+ * should rewrite it once, atomically.
  */
-export declare function appendHistoryContent(current: string, text: string, max?: number): string;
+export declare function needsCompaction(raw: string, max?: number): boolean;
 /**
  * Record one in-session submission: empty text is ignored and an adjacent
  * duplicate collapses (Codex `record_local_submission` semantics). The local
@@ -40,10 +47,10 @@ export declare function appendHistoryContent(current: string, text: string, max?
  */
 export declare function recordLocalEntry(local: readonly string[], text: string, max?: number): readonly string[];
 /**
- * Serialize a capped entry list to the history file format (one JSON line per
- * entry, trailing newline). The runner writes the in-memory list as the whole
- * file, so rapid same-process submissions cannot lose entries to a
- * read-modify-write race (the file is never read back before writing).
+ * Serialize a capped entry list to the history file format (one JSON line
+ * per entry, trailing newline). The boot-time compaction writes this
+ * canonical form once when stale lines have accumulated; submissions
+ * themselves only ever append a single line.
  * @param entries - the entries to persist, oldest first.
  * @returns the file content, '' for an empty list.
  */

package/lib/types/index.d.ts

@@ -10,7 +10,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import { type ImageBlock } from '@deepseek-ai/dsh-llm';
+import { type ContentBlock } from '@deepseek-ai/dsh-llm';
 import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session';
 import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
 import type { TuiStartup } from './startup.ts';
@@ -74,8 +74,17 @@ export declare function runQuitSequence(steps: readonly QuitCleanupStep[], exit:
 export interface QueuedSubmission {
     readonly text: string;
     readonly mode: 'followup' | 'steer';
-    readonly images: readonly ImageBlock[];
+    readonly images: readonly ContentBlock[];
 }
+/**
+ * Whether a tagged submission still belongs to the active session. Attachment
+ * prepares resolve on the microtask timeline, while a queued session switch
+ * remounts the app asynchronously — the composing instance's unmount cleanup
+ * runs too late to abort, so the delivery itself carries the composing
+ * session's full id and the runner drops it here when the world moved on.
+ * An untagged (synchronous) or pending-session ('') submission always passes.
+ */
+export declare function submissionBelongsToSession(origin: string | undefined, activeSessionId: string | undefined): boolean;
 /**
  * Order-preserving gate for composer input while the startup prompt/images
  * are still preparing. Anything submitted before the startup delivery settles

package/lib/types/presets.d.ts

@@ -11,8 +11,11 @@ export type AgentPresetsService = AgentPresets;
 export declare function agentPresetsFrom(ctx: Context): AgentPresetsService | undefined;
 /** A preset may change only before the first durable turn begins. */
 export declare function isBlankSession(events: readonly SessionEvent[]): boolean;
+/** Translate a preset id recorded before an upstream rename to its current id. */
+export declare function normalizePresetId(id: string): string;
+export declare function normalizePresetId(id: string | undefined): string | undefined;
 /** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
-export declare function resolvePreset(session: Pick<Session, 'header' | 'events'>): string;
+export declare function resolvePreset(session: Pick<Session, 'header' | 'snapshotEvents'>): string;
 /** Resolve a pre-session choice, or recompose an active blank Agent. */
 export declare function selectPreset(service: AgentPresetsService, agent: Agent | undefined, presetId: string): Promise<PresetRow>;
 /** Recompose atomically from the caller's perspective, logging only success. */

package/lib/types/provider-settings.d.ts

@@ -78,17 +78,6 @@ export interface DiscoveredModelView {
     /** Output cap when disclosed. */
     readonly maxTokens?: number;
 }
-/** One model an endpoint reported about itself (mirrors LlmDiscoveredModel). */
-export interface DiscoveredModelView {
-    /** Model id the endpoint accepts. */
-    readonly id: string;
-    /** Human-readable name when the endpoint supplies one. */
-    readonly name?: string;
-    /** Context window when disclosed; adoption still owes it if absent. */
-    readonly contextWindow?: number;
-    /** Output cap when disclosed. */
-    readonly maxTokens?: number;
-}
 /**
  * The seven canonical reasoning levels a reasoningEfforts key may name -
  * pi-ai's THINKING_LEVELS. A pi-ai upgrade that adds or removes one fails
@@ -153,6 +142,12 @@ export interface ProviderTargetView {
     readonly configuration: ProviderConfiguration;
     /** The owning adapter reports this route as hand-declared (absent when it draws no distinction). */
     readonly declared?: boolean;
+    /**
+     * Configuration diagnostic the adapter reported for this route (catalog or
+     * profile damage): the row stays listed and repairable instead of the whole
+     * provider vanishing; absent when the route reads clean.
+     */
+    readonly diagnostic?: string;
 }
 /** The resolved provider/settings/credential join. */
 export interface ProviderSettingsDirectory {

package/lib/types/questions.d.ts

@@ -1,18 +1,19 @@
 /**
- * The terminal ask_user_question provider: registers the single UI provider
- * on `ctx.userQuestions` and drives it with a FIFO queue — one question
- * request on screen at a time, everything else waiting — then resolves the
- * collected answers back into the tool's promise. The community TUI proved
- * this exact pipeline shape; here the dialog is an Ink bar instead of a
- * pi-tui inline modal.
+ * The terminal ask_user_question answerer: one `user-questions/request`
+ * waterfall listener that drives a FIFO queue — one question request on
+ * screen at a time, everything else waiting — then resolves the collected
+ * answers back into the waterfall. Mirrors the approval answerer's claim/
+ * defer split: only agents this TUI owns are answered, every other request
+ * falls through to the next answerer.
  *
- * Plan reviews (`exit_plan_mode`) arrive through the same service with an
+ * Plan reviews (`exit_plan_mode`) arrive through the same waterfall with an
  * `intent: { kind: 'plan-review' }` — the renderer highlights the approve
  * option; the answer encoding is identical either way.
  *
  * @module @deepseek-ai/dsh-code/questions
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
 import { type AskUserQuestionAnswer, type AskUserQuestionRequest } from '@deepseek-ai/dsh-user-questions';
 /** One question request waiting on the human, with its settle channels. */
 export interface PendingQuestion {
@@ -42,9 +43,12 @@ export interface QuestionStore {
     cancel(pending: PendingQuestion): void;
 }
 /**
- * Mount the single `ctx.userQuestions` UI provider over a FIFO queue.
- * @param ctx - context carrying the `userQuestions` service (dsh-base).
- * @returns the store the renderer subscribes to; a context without the
- * service yields a permanently empty store.
+ * Mount the `user-questions/request` answerer over a FIFO queue.
+ * @param ctx - plugin context whose event bus carries the waterfall.
+ * @param owns - agents this terminal answers for; every other request is
+ * deferred back into the waterfall (`next()`), so sibling answerers stay
+ * usable. Agent-less asks are claimed: this TUI is the only human surface
+ * in the process.
+ * @returns the store the renderer subscribes to.
  */
-export declare function mountQuestionProvider(ctx: Context): QuestionStore;
+export declare function mountQuestionProvider(ctx: Context, owns: (agent: Agent) => boolean): QuestionStore;

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

@@ -13,6 +13,19 @@
  * marker keeps the tier accent afterwards (persistent, like Codex's prompt
  * charge). Pure functions only — the Ink layer owns timers and colors.
  *
+ * Wave and Pulse deliberately extend the Codex port after in-terminal
+ * testing: the per-row phase cascade was removed (Codex tints each column
+ * across the whole band), Wave became a WATER SURFACE — one continuous sine
+ * swell spanning the band, mirror-symmetric about the center column, its
+ * crests flowing outward from the center with a symmetric fade envelope
+ * (the deepseek tier adds one faster harmonic crossing it), painted with
+ * Aurora's recipe: wide soft gradients, mirrored second-hue mixing, and a
+ * low alpha cap — no hard core line — while Pulse became true
+ * two-dimensional, cell-aspect-corrected detonations: soft wide rings whose
+ * color grades across their width, expanding outward through a symmetric
+ * fade envelope and each trailing an echo ripple in the next blue. Aurora
+ * keeps Codex's geometry verbatim.
+ *
  * @module @deepseek-ai/dsh-code/render/animations
  */
 import type { RgbTriple } from '../theme.ts';
@@ -41,6 +54,8 @@ export declare function deepDivingGradientColor(index: number, tick: number, gra
 export declare function deepDivingSparkIntensity(tick: number): number;
 /** Blue RGB color for the breathing Deep diving sparkle. */
 export declare function deepDivingSparkColor(tick: number, base: RgbTriple, highlight: RgbTriple): RgbTriple;
+/** Caret blink cadence: one blink step (on or off) per tick. */
+export declare const CARET_BLINK_TICK_MS = 530;
 /** Caret visibility: half the ticks on, half off (530ms blink). */
 export declare function caretVisible(tick: number): boolean;
 /**
@@ -71,8 +86,34 @@ 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';
-/** Wave half-width in columns — Codex WAVE_HALF_WIDTH (9). */
-export declare const WAVE_HALF_WIDTH = 9;
+/**
+ * The water surface: ONE continuous sine line spanning the whole band,
+ * mirror-symmetric about the center column, its crests flowing OUTWARD from
+ * the center (phase k·|x − center| − ω·t). No sweep window, no return trip —
+ * the surface fades in, flows, and fades out, symmetric in both space and
+ * time. The deepseek tier adds one faster, finer HARMONIC line whose crests
+ * cross the fundamental's: interleaved richness with both lines still
+ * symmetric and still only ever flowing outward.
+ */
+export declare const WAVE_SURFACE_AMPLITUDE = 0.8;
+export declare const WAVE_SURFACE_HARMONIC = 0.45;
+export declare const WAVE_SURFACE_WAVELENGTH = 40;
+export declare const WAVE_SURFACE_OMEGA = 9;
+/** Vertical thickness in lane units — Aurora-wide: soft gradients, no hard edges. */
+export declare const WAVE_SURFACE_THICKNESS = 1.2;
+/**
+ * The mirrored second-hue profile: the space BELOW the surface carries a
+ * second blue at this strength, so color (not just brightness) varies
+ * continuously across the wave — Aurora-style hue mixing instead of a
+ * single flat tint.
+ */
+export declare const WAVE_SURFACE_MIRROR = 0.6;
+/** Aurora-style soft alpha: low gain, capped well under the pulse ring's. */
+export declare const WAVE_SURFACE_ALPHA_GAIN = 0.45;
+export declare const WAVE_SURFACE_ALPHA_CAP = 0.68;
+/** Aurora-grade soft alpha for the detonation — a notch above the swell. */
+export declare const PULSE_ALPHA_GAIN = 0.45;
+export declare const PULSE_ALPHA_CAP = 0.72;
 /** Sparkle glyphs in frame order — Codex SPARK_GLYPHS (`· ✦ ✧`). */
 export declare const SPARK_GLYPHS: readonly ["·", "✦", "✧"];
 /**
@@ -98,9 +139,11 @@ export declare function deepseekWaveDuration(tier: DeepseekWaveTier, style?: Dee
  */
 export declare function deepseekWaveStyleRandom(previous: DeepseekWaveStyle | undefined): DeepseekWaveStyle;
 /**
- * Tier for a `provider/model` label: a model id containing `flash` runs the
+ * 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.
+ * dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping. Only the model
+ * segment (after the `/`) is matched, so a provider whose name contains
+ * `flash` cannot flip an unrelated model onto the flash tier.
  * @param model - the `provider/model` label of the applied model.
  * @returns the wave tier for that model.
  */
@@ -139,9 +182,13 @@ export declare function envelope(elapsed: number, total: number, fadeIn: number,
  * 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. 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.
+ * both ends. With `rows > 1`: Wave is a water surface — every column
+ * lights the row nearest the surface's current height, so the light reads
+ * as ONE continuous wavy line spanning the band, symmetric about the center
+ * column and flowing outward (a single-row band falls back to a flat glow);
+ * Pulse rings in two dimensions around the band's center cell with trailing
+ * echo ripples; only Aurora samples the timeline shifted by a per-row phase
+ * offset.
  * @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.
@@ -196,3 +243,23 @@ export declare function isOfficialDeepSeekLabel(label: string): boolean;
  * @returns whether the effort ranks above high.
  */
 export declare function effortAboveHigh(effort: string | undefined): boolean;
+/**
+ * Parse a persisted animations preference (`animations.json`): timed
+ * animations are on by default and only an explicit `false` disables them —
+ * a missing key, corrupt value, or absent file all mean enabled, so the
+ * /animation toggle degrades exactly like every other user preference.
+ * @param value - the raw parsed JSON value (expected boolean).
+ * @returns whether timed animations should run.
+ */
+export declare function parseAnimationsPref(value: unknown): boolean;
+/**
+ * One parsed `/animation` argument: '' toggles, `on|true|1` enables,
+ * `off|false|0` disables (case-insensitive, surrounding whitespace ignored),
+ * and anything else is a usage error the caller surfaces. Kept pure so the
+ * command's entire decision table is unit-testable.
+ * @param argument - the raw text after `/animation`.
+ * @returns `{ enabled }`, `'toggle'`, or `'usage'`.
+ */
+export declare function parseAnimationsArgument(argument: string): {
+    enabled: boolean;
+} | 'toggle' | 'usage';

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

@@ -6,10 +6,4 @@
  * @module @deepseek-ai/dsh-code/render/export
  */
 import { type TranscriptView } from './projection.ts';
-/**
- * Render the transcript as a standalone markdown document.
- * @param view - the folded transcript view to export.
- * @param sessionId - the full session identity for the header.
- * @returns the complete markdown text.
- */
 export declare function buildExportMarkdown(view: TranscriptView, sessionId: string): string;

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

@@ -0,0 +1,21 @@
+/**
+ * Shared fuzzy ranking for `/` and `@` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name. Prefix hits
+ * rank first, then the strongest alignment score, then the source order of
+ * the input. Ported from the upstream web client's ui-primitives
+ * (rank-by-name.ts) so the terminal matches the web menu's discovery feel;
+ * the algorithm is unchanged, only the module's home moved.
+ *
+ * @module @deepseek-ai/dsh-code/render/fuzzy
+ */
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (the caller's composition order
+ * is the final tie-breaker, e.g. local commands before registry entries).
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export declare function rankByName<T extends {
+    readonly name: string;
+}>(items: readonly T[], rawQuery: string): readonly T[];

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

@@ -6,8 +6,10 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
-import { type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm';
-import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session';
+import { type ImageBlock, type MessageId, type StreamChunk } from '@deepseek-ai/dsh-llm';
+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 { type ToolDetail } from './tool-detail.ts';
 /** One user prompt line. */
 export interface UserEntry {
@@ -19,6 +21,8 @@ export interface UserEntry {
     notice: boolean;
     /** Durable image references carried by this prompt. */
     images?: readonly ImageBlock['attachment'][];
+    /** Durable file references carried by this prompt (0.1.5 file blocks). */
+    files?: readonly FileAttachmentRef[];
 }
 /** One user message waiting in the agent inbox (the web's queued-message row). */
 export interface PendingEntry {
@@ -31,6 +35,8 @@ export interface PendingEntry {
     text: string;
     /** Durable image references queued with this prompt. */
     images?: readonly ImageBlock['attachment'][];
+    /** Durable file references queued with this prompt (0.1.5 file blocks). */
+    files?: readonly FileAttachmentRef[];
 }
 /** One authoritative assembled assistant reply. */
 export interface AssistantEntry {
@@ -217,7 +223,7 @@ export interface TranscriptStats {
 export interface TranscriptView {
     /** Settled entries in log order. */
     entries: readonly TranscriptEntry[];
-    /** Bounded text tail accumulated from `assistant/chunk` deltas since the last flush. */
+    /** Bounded text tail accumulated from live stream frames since the last settlement. */
     streaming: string;
     /** Bounded thinking tail accumulated from reasoning deltas since the last flush. */
     streamingReasoning: string;
@@ -248,6 +254,13 @@ export interface TranscriptView {
     permission: string;
     /** Latest session title folded from the last `session/title` event, empty before one. */
     title: string;
+    /**
+     * Effective system prompt assembled from `system/message` surface nodes
+     * (v3): the head node's text joined with every later non-empty node, blank
+     * lines between. Empty before the first system node or when every node is
+     * empty ("no system prompt").
+     */
+    systemPrompt: string;
     /** Sandbox-mode override folded from the last `sandbox/mode` event, empty when never switched. */
     sandbox: string;
     /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
@@ -278,12 +291,16 @@ export interface TranscriptView {
         turnFiles: Map<number, Set<string>>;
         turnSteps: Map<number, string>;
         turnTools: Map<number, Set<string>>;
+        /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
+        systemNodes: Map<number, 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;
+/** Human-readable bounded file labels for the same surfaces (0.1.5 file blocks). */
+export declare function fileLabels(files: readonly FileAttachmentRef[] | undefined): string;
+/** Prompt text with its durable image and file labels, without exposing local paths or bytes. */
+export declare function promptDisplayText(entry: Pick<UserEntry | PendingEntry, 'text' | 'images' | 'files'>): string;
 /** A fresh, empty transcript view. */
 export declare function createTranscriptView(): TranscriptView;
 /**
@@ -340,6 +357,7 @@ export interface ReplayAccumulator {
     plan: boolean;
     permission: string;
     title: string;
+    systemPrompt: string;
     sandbox: string;
     goal: GoalFold | undefined;
     stats: TranscriptStats;
@@ -351,6 +369,8 @@ export interface ReplayAccumulator {
     turnFiles: Map<number, Set<string>>;
     turnSteps: Map<number, string>;
     turnTools: Map<number, Set<string>>;
+    /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
+    systemNodes: Map<number, string>;
     /** Entry-level container operations performed so far (test instrumentation). */
     ops: number;
 }
@@ -399,6 +419,28 @@ export declare function snapshotReplayView(acc: ReplayAccumulator): TranscriptVi
  * @returns the folded view.
  */
 export declare function projectEvents(events: readonly SessionEvent[]): TranscriptView;
+/**
+ * Fold one process-local assistant-stream chunk frame (session-log v2+ keeps
+ * durable logs settlement-only; live typing rides the `agent/assistant-stream`
+ * agent event). Same first-token anchoring the durable `assistant/chunk` event
+ * used to carry: the first non-empty delta anchors the TTFT and empty
+ * keep-alive deltas do not count. The caller maps the frame's attempt to the
+ * `turn:step` key (the start frame owns turn/step; chunk frames do not).
+ * @param acc - the live replay accumulator.
+ * @param key - the `turn:step` key the attempt's start frame declared.
+ * @param time - the frame's safe-integer timestamp.
+ * @param chunk - the model chunk the frame carries.
+ * @returns whether the accumulator changed (the store stays silent otherwise).
+ */
+export declare function applyAssistantStreamChunk(acc: ReplayAccumulator, key: string, time: number, chunk: StreamChunk): boolean;
+/**
+ * Drop the live streaming tails without a settlement (an `agent/assistant-stream`
+ * end frame with an `abandoned` outcome, or a session switch). The next start
+ * frame rebuilds from scratch.
+ * @param acc - the live replay accumulator.
+ * @returns whether any tail text was discarded.
+ */
+export declare function clearAssistantStream(acc: ReplayAccumulator): boolean;
 /**
  * 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