dsh-code 1.0.5 → 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/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/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/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,7 +6,8 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
-import { type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm';
+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';
@@ -20,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 {
@@ -32,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 {
@@ -218,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;
@@ -249,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. */
@@ -279,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;
 /**
@@ -341,6 +357,7 @@ export interface ReplayAccumulator {
     plan: boolean;
     permission: string;
     title: string;
+    systemPrompt: string;
     sandbox: string;
     goal: GoalFold | undefined;
     stats: TranscriptStats;
@@ -352,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;
 }
@@ -400,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

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

@@ -1,5 +1,5 @@
 /** Lightweight session-directory projection for the /resume picker. */
-import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session';
+import { type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
 export interface SessionRecord {
     readonly header: SessionHeader;
     readonly live: boolean;
@@ -77,23 +77,58 @@ export declare function projectSessionRows(records: readonly SessionRecord[], op
 export declare function mergeSessionTitles(rows: readonly SessionRow[], observations: readonly TitleObservationResult[]): SessionRow[];
 /**
  * Encode a session id the way the JSONL backend does for its on-disk layout
- * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
- * validate that a `locate()` path really is this session's directory before
- * any deletion touches the filesystem — a local copy of the pure upstream
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used to
+ * validate and derive session directories — a local copy of the pure upstream
  * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
  */
 export declare function encodeSessionSegment(raw: string): string;
-/** The session-log artifact names the JSONL backend may create. */
-export declare const SESSION_ARTIFACT_NAMES: readonly string[];
 /**
- * Guard one `locate()` artifact path before deletion (codex's scoped-path
- * check, adapted to the JSONL layout): the file must be a `session.jsonl`
- * artifact sitting in the directory named exactly `encodeSegment(id)`.
- * @param artifact - the path the persistence backend located.
- * @param id - the session id the artifact claims to belong to.
- * @returns the owning session directory, or undefined when the layout is unexpected.
+ * Encode a project cwd the way the JSONL backend groups sessions on disk
+ * (`projectKey`: separators collapse to one `-`, everything else mirrors
+ * `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export declare function encodeProjectKey(cwd: string): string;
+/**
+ * Derive one session's artifact directory under the JSONL backend root,
+ * mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
+ * layout (0.1.5 `sessionDir`/`projectDir`).
+ * @param root - the JSONL backend's configured session root.
+ * @param cwd - the session's pinned working directory, when the header has one.
+ * @param id - the session id.
+ * @returns the absolute session directory path.
+ */
+export declare function sessionDirectoryFor(root: string, cwd: string | undefined, id: string): string;
+/**
+ * The canonical session-log artifact filenames the JSONL backend may create:
+ * format v0 writes the bare `session.jsonl` name; v1+ write
+ * `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
+ * immutable generations may coexist in one session directory (0.1.5). The
+ * range follows the installed session package's `SESSION_FORMAT_VERSION`, so
+ * a future generation joins the enumeration with the dependency bump.
+ */
+export declare function sessionArtifactNames(): readonly string[];
+/** True for one canonical session-log artifact filename the backend may own. */
+export declare function isSessionArtifactName(name: string): boolean;
+/**
+ * Guard a derived session directory before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the directory's base name must be
+ * exactly `encodeSegment(id)` beneath its project grouping.
+ * @param dir - the derived session artifact directory.
+ * @param id - the session id the directory claims to belong to.
+ * @returns the guarded directory, or undefined when the layout is unexpected.
+ */
+export declare function sessionArtifactDirectory(dir: string, id: string): string | undefined;
+/**
+ * The JSONL backend's configured session root, when the mounted backend
+ * exposes one. The upstream service contract dropped `locate()` in 0.1.5
+ * (artifact paths are backend-private; only refusal diagnostics carry them),
+ * so the TUI derives artifact paths from the backend's public plugin config.
+ * Backends without a JSONL-style config (or a foreign shape) yield undefined
+ * and callers degrade: mtime sorting falls back to createdAt and /delete
+ * refuses, exactly as before.
  */
-export declare function sessionArtifactDirectory(artifact: string, id: string): string | undefined;
+export declare function jsonlSessionRoot(persistence: unknown): string | undefined;
 /**
  * Collect one session's deletion subtree: the id plus every record whose
  * parent chain leads to it (codex deletes subagent threads with their root).

package/lib/types/store.d.ts

@@ -29,6 +29,7 @@
  *
  * @module @deepseek-ai/dsh-tui/store
  */
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
 import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import { type TranscriptView } from './render/projection.ts';
 /** The externally readable, event-fed transcript store for one session. */
@@ -39,6 +40,8 @@ export interface TranscriptStore {
     subscribe(listener: () => void): () => void;
     /** Fold one session event; ignored events change nothing and notify nobody. */
     apply(event: SessionEvent): void;
+    /** Fold one live assistant-stream frame; frames without visible deltas stay silent. */
+    applyStreamFrame(frame: AssistantStreamFrame): void;
     /** Drop the folded view entirely (/clear): the next event starts a fresh one. */
     reset(): void;
 }