dsh-code 1.0.5 → 1.0.7

package/lib/session-query.mjs

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import SqliteSessionQueryEngine from "@deepseek-ai/dsh-session-query-sqlite";
+import { SessionQueryError, assertSessionHeadersCompatible, buildSessionEventSearchDocuments, readColdSessionLog } from "@deepseek-ai/dsh-session-query";
+//#region src/session-query.ts
+/**
+* Skip-tolerant session-query engine for this terminal.
+*
+* The upstream SqliteSessionQueryEngine reconciliation observes EVERY
+* persisted session before each search, and ONE unreadable source (for
+* example a pre-release session artifact the frozen format codecs reject)
+* fails the whole pass with SESSION_QUERY_PERSISTENCE_FAILED — every
+* cross-session search dies because of a single old file nobody opened
+* otherwise. This subclass overrides only the observation loop so an
+* unreadable source is skipped with a warning and the rest of the corpus
+* indexes normally; skipped sessions are retried on later reconciliations
+* and rejoin automatically once a host that can read them is installed.
+*
+* Vendored surface note: `_observeStable` and its module-local helpers are
+* private upstream; this file re-declares the observation loop against the
+* pinned @deepseek-ai line (see package.json peers) and must be re-checked
+* whenever that line moves. The engine class and the tool boundary also
+* share ONE physical parent-package instance through this bundle, which
+* restores instanceof-based typed error messages on the search path.
+*/
+const STABLE_OBSERVATION_ATTEMPTS = 2;
+function assertNotAborted(signal) {
+	if (signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED");
+}
+function isAbort(error) {
+	return error instanceof SessionQueryError && error.code === "SESSION_QUERY_ABORTED";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "unknown error";
+}
+function observeSession(header, inheritedEventCount, events) {
+	const detachedHeader = structuredClone(header);
+	const detachedEvents = events.map((event) => structuredClone(event));
+	return {
+		header: detachedHeader,
+		inheritedEventCount,
+		documents: buildSessionEventSearchDocuments(detachedHeader.id, detachedEvents),
+		fingerprint: createHash("sha256").update(JSON.stringify({
+			header: detachedHeader,
+			inheritedEventCount,
+			events: detachedEvents
+		})).digest("base64url")
+	};
+}
+function sameHeader(a, b) {
+	return a.id === b.id && a.createdAt === b.createdAt && a.cwd === b.cwd && a.parentSession === b.parentSession && a.isSeeded === b.isSeeded && (a.delegationDepth ?? 0) === (b.delegationDepth ?? 0) && a.agentPreset === b.agentPreset;
+}
+function materializePersistenceSnapshots(snapshots) {
+	if (!Array.isArray(snapshots)) throw new Error("persistence snapshots must be an array");
+	const result = /* @__PURE__ */ new Map();
+	for (const snapshot of snapshots) {
+		if (typeof snapshot.revision !== "string") throw new Error("persistence snapshot revision must be a string");
+		const header = structuredClone(snapshot.header);
+		if (result.has(header.id)) throw new Error(`persistence listed duplicate session "${header.id}"`);
+		result.set(header.id, {
+			header,
+			revision: snapshot.revision
+		});
+	}
+	return result;
+}
+function samePersistenceSnapshots(before, after) {
+	if (before.size !== after.size) return false;
+	for (const [id, first] of before) {
+		const second = after.get(id);
+		if (second === void 0 || first.revision !== second.revision || !sameHeader(first.header, second.header)) return false;
+	}
+	return true;
+}
+/**
+* The skip-tolerant observation pass: structurally the upstream loop, with
+* the per-source cold read wrapped so one unreadable session degrades to a
+* warning instead of failing every search. Exported for unit tests with an
+* injectable cold reader.
+*/
+async function observeStableWithSkip(engine, indexed, signal, readCold = readColdSessionLog) {
+	for (let attempt = 0; attempt < STABLE_OBSERVATION_ATTEMPTS; attempt += 1) {
+		assertNotAborted(signal);
+		const persistenceBinding = engine._persistenceBinding;
+		const persistence = persistenceBinding.service;
+		const initiallyLive = new Set(engine.ctx.sessions.list().map((session) => session.id));
+		let persisted = /* @__PURE__ */ new Map();
+		if (persistence !== void 0) try {
+			const canReuseIndexed = engine._lastPersistenceIdentity === void 0 || engine._lastPersistenceIdentity === persistenceBinding.identity;
+			const listOptions = signal === void 0 ? void 0 : { signal };
+			const before = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			persisted = materializePersistenceSnapshots(before);
+			for (const entry of persisted.values()) {
+				if (canReuseIndexed && indexed.get(entry.header.id)?.revision === entry.revision) continue;
+				if (initiallyLive.has(entry.header.id) || engine.ctx.sessions.get(entry.header.id) !== void 0) continue;
+				assertNotAborted(signal);
+				try {
+					const loaded = await readCold(persistence, entry.header.id, signal);
+					assertNotAborted(signal);
+					assertSessionHeadersCompatible(entry.header, loaded.header);
+					entry.loaded = observeSession(loaded.header, loaded.inheritedEventCount, loaded.events);
+				} catch (error) {
+					if (isAbort(error) || signal?.aborted) throw error;
+					if (engine._persistenceBinding !== persistenceBinding) break;
+					entry.unreadable = errorMessage(error);
+					engine.ctx.logger?.warn("session-search skipped unreadable session %s: %s", entry.header.id, entry.unreadable);
+				}
+			}
+			assertNotAborted(signal);
+			const afterSnapshots = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			const after = materializePersistenceSnapshots(afterSnapshots);
+			if (!samePersistenceSnapshots(persisted, after)) continue;
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+		} catch (error) {
+			if (isAbort(error) || signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED", { cause: error });
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+			if (error instanceof SessionQueryError) throw error;
+			throw new SessionQueryError(`session-search persistence observation failed: ${errorMessage(error)}`, "SESSION_QUERY_PERSISTENCE_FAILED", { cause: error });
+		}
+		const live = /* @__PURE__ */ new Map();
+		for (const session of engine.ctx.sessions.list()) {
+			const observed = observeSession(session.header, session.inheritedEventCount, session.snapshotEvents());
+			const durable = persisted.get(session.id);
+			if (durable !== void 0 && durable.loaded === void 0) {
+				live.set(session.id, observed);
+				continue;
+			}
+			if (durable !== void 0) assertSessionHeadersCompatible(observed.header, durable.header);
+			live.set(session.id, observed);
+		}
+		if (!(initiallyLive.size === live.size && [...initiallyLive].every((id) => live.has(id)))) continue;
+		return {
+			persistenceBinding,
+			persisted,
+			live
+		};
+	}
+	throw new SessionQueryError("session-search persistence observation did not stabilize after one retry", "SESSION_QUERY_PERSISTENCE_FAILED");
+}
+const EngineBase = SqliteSessionQueryEngine;
+/** The engine this bundle mounts in place of the base `session-query-sqlite` row. */
+var SkipTolerantSessionQueryEngine = class extends EngineBase {
+	async _observeStable(indexed, signal) {
+		return await observeStableWithSkip(this, indexed, signal);
+	}
+};
+//#endregion
+export { SkipTolerantSessionQueryEngine, SkipTolerantSessionQueryEngine as default, observeStableWithSkip };

package/lib/types/app.d.ts

@@ -15,9 +15,10 @@
  */
 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 { LauncherUpdateStatus } from './update.ts';
 import type { TranscriptStore } from './store.ts';
 import { type TranscriptEntry } from './render/projection.ts';
 import type { ApprovalStore } from './approval.ts';
@@ -35,7 +36,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 +71,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 +97,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. */
@@ -125,8 +140,10 @@ export interface AppProps {
     logoutProviderAuthorization?(row: ProviderAuthorizationRow): Promise<void>;
     openAuthorizationUrl?(url: string): boolean;
     copyTextValue?(text: string): Promise<void>;
-    /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
-    cyclePermission(): string;
+    /** Cycle to the next mode station (Shift+Tab): a permission preset or a plan switch; returns the notice label. */
+    cycleMode(): string;
+    /** Pre-session plan choice: shows the plan badge before the first session exists. */
+    pendingPlan?: boolean;
     /** Select or inspect a permission preset without requiring a pre-existing session. */
     setPermission(id: string): string;
     /** Export the transcript to a markdown file (/export [path]); reports via notices. */
@@ -156,6 +173,10 @@ export interface AppProps {
     loadPlugins(): readonly PluginRow[];
     /** Caller-visible background jobs (the host jobs registry, read-only). */
     loadJobs(): readonly JobRow[];
+    /** Probe the launcher's aligned update plan (read-only; never installs). */
+    probeUpdate(): Promise<LauncherUpdateStatus>;
+    /** Run the launcher's aligned update; streams sanitized lines; resolves with the exit code. */
+    applyUpdate(onLine: (line: string) => void): Promise<number>;
     /** Registers the app's notice channel with the runner (called once on mount). */
     onBridgeReady(bridge: {
         notify(text: string, tone?: NoticeTone): void;
@@ -166,6 +187,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,44 @@ 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;
+/** One Shift+Tab station decision for the mode cycle. */
+export type ModeCycleDecision = {
+    readonly kind: 'permission';
+    readonly preset: string;
+} | {
+    readonly kind: 'plan-on';
+} | {
+    readonly kind: 'plan-off';
+    readonly preset: string;
+};
+/**
+ * Decide the next Shift+Tab station. The cycle keeps the preset table's
+ * own order (most restrictive first) and inserts ONE plan station between
+ * the most restrictive preset and the wrap target: with the shipped three
+ * presets the user sees workspace-write → danger-full-access → read-only
+ * → plan → workspace-write. Plan IS the most restrictive preset plus the
+ * plan prompt layer — entering it switches nothing (the cycle is already
+ * parked on read-only), and leaving it lands on the next preset after the
+ * most restrictive one. Without the /plan command the cycle is exactly the
+ * preset table.
+ */
+export declare function planCycleDecision(input: {
+    readonly names: readonly string[];
+    readonly current: string;
+    readonly inPlan: boolean;
+    readonly planAvailable: boolean;
+}): ModeCycleDecision | undefined;
 /**
  * Order-preserving gate for composer input while the startup prompt/images
  * are still preparing. Anything submitted before the startup delivery settles

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

@@ -2,6 +2,7 @@
 import { type ReactElement } from 'react';
 import type { ModelDirectory, ModelRow } from './models.ts';
 import type { SubagentRow } from './subagents.ts';
+import type { ScheduleRow } from './render/projection.ts';
 import type { PermissionRow } from './permissions.ts';
 import type { PresetRow } from './presets.ts';
 import type { PluginRow } from './plugin-inventory.ts';
@@ -165,3 +166,25 @@ export declare function SubagentPanel({ current, load, pick, inherit, close }: {
     inherit(): void;
     close(): void;
 }): ReactElement;
+/**
+ * The /schedule panel: the read-only catalog of active reminders folded from
+ * durable schedule/change events (the web ui-schedule contract: overdue
+ * first, then ascending target; the model creates and cancels through its
+ * schedule_* tools, the panel only shows state). A local second-hand keeps
+ * the relative labels live while the panel is open.
+ */
+export interface ScheduleDisplayRow {
+    readonly key: string;
+    readonly text: string;
+    readonly tone?: 'error';
+}
+/** Human frequency label: one-shot kinds read as Once, every rows carry the interval. */
+export declare function scheduleFrequency(row: ScheduleRow): string;
+/** Relative label for the next target: in N unit, or N unit overdue. */
+export declare function scheduleRelative(targetAt: number, now: number): string;
+/** Ordered display rows: overdue first (error tone), then ascending target. */
+export declare function scheduleDisplayRows(rows: readonly ScheduleRow[], now: number): readonly ScheduleDisplayRow[];
+export declare function SchedulePanel({ rows, close }: {
+    rows(): readonly ScheduleRow[];
+    close(): void;
+}): ReactElement;

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/editor.d.ts

@@ -155,8 +155,9 @@ export declare function replaceRangePreservingCursor(value: string, cursor: numb
  */
 export declare function composerMaxRows(terminalRows: number): number;
 /**
- * History navigation starts with Up on an empty draft, or after visual
- * movement has reached the directional text edge of an unchanged recalled
- * entry. Every other position remains under textarea movement.
+ * History navigation starts with Up on an empty draft, or continues from an
+ * unchanged recalled entry whenever the caret sits on either text edge
+ * (start or end) - moving the caret into the interior returns the keys to
+ * ordinary editing until an edge is reached again.
  */
 export declare function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean;

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/ime-cursor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * IME cursor anchoring for the composer.
+ *
+ * Ink keeps the real terminal cursor hidden and parks it just below the
+ * dynamic tree (after the status row). IME composition text and candidate
+ * windows anchor to that real cursor cell - VS Code's integrated terminal
+ * positions its hidden IME textarea there, and Windows consoles behave the
+ * same - so CJK input appeared at the bottom of the screen instead of at the
+ * caret. The anchor moves the real cursor onto the caret cell without
+ * touching Ink's relative erase ledger:
+ *
+ * - the displacement is owned: before any foreign write or re-anchor, the
+ *   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+ *   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+ *   the cursor exactly where it was left;
+ * - log-update frame chunks (which start with the erase-line sequence) get
+ *   the anchor re-appended inside the same write, so a repaint can never
+ *   leave the cursor behind - in particular the caret blink keeps the anchor
+ *   stable while an IME composition is open, because the terminal parses the
+ *   rewrite and the re-anchor as one atomic update.
+ *
+ * @module @deepseek-ai/dsh-code/render/ime-cursor
+ */
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+export declare function imeCursorRestore(rows: number): string;
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+export declare function imeCursorMove(rows: number, column: number): string;
+/**
+ * Rows between the caret cell and Ink's parked cursor row: the band's bottom
+ * blank row, the editor window rows below the caret, the status footer, and
+ * Ink's own below-frame row. Rows above the composer (gutter, live content)
+ * never enter this distance.
+ */
+export declare function imeCursorRowsUp(input: {
+    editorWindowRows: number;
+    caretRowInWindow: number;
+    rowsBelowComposer: number;
+}): number;
+/** The installed anchor handle. */
+export interface ImeCursorAnchor {
+    /** Anchor on the caret cell: `rows` above Ink's parked row at the 0-based
+     * `column`; `rows <= 0` releases the anchor. */
+    anchor(rows: number, column: number): void;
+    /** Cancel the displacement, restore the original write path, and detach. */
+    release(): void;
+}
+/**
+ * Take over `stream.write` so the anchor displacement stays invisible to every
+ * other writer. Idempotent per stream: a second install returns the live
+ * handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+ */
+export declare function installImeCursorAnchor(stream: NodeJS.WriteStream): ImeCursorAnchor | undefined;
+/**
+ * Keep the real terminal cursor on the composer's caret cell while `active`
+ * (the editable composer). The second effect runs after every commit without
+ * a dep list: frame rewrites restore the anchor themselves, but any other
+ * write (protocol push, resize replay) leaves the cursor at Ink's parked
+ * position, and the next commit re-anchors it.
+ */
+export declare function useImeCursorAnchor(active: boolean, rows: number, column: number): void;