dsh-code 0.4.0 → 0.6.0

package/lib/rolldown-runtime-CMFfr-1z.mjs

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/lib/startup.mjs

@@ -3,7 +3,7 @@ import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
 //#region src/startup.ts
 /**
 * The interactive terminal app's command-line provider: parses `--resume`,
-* `--continue`, `--session`, and `--help`, then publishes
+* `--continue`, `--session`, `--mode`, and `--help`, then publishes
 * {@link TUI_STARTUP_SERVICE} for the runner to consume lazily. Follows the
 * headless bundle's startup shape (a commander action publishing a service
 * through {@link parseCmdline}).
@@ -26,17 +26,41 @@ const name = "tui-startup";
 const inject = ["cmdlineArgs"];
 /** Service provided by this plugin and injected by the terminal runner. */
 const TUI_STARTUP_SERVICE = "tuiStartup";
+/** Pure option policy shared by Commander and tests. */
+function resolveTuiStartup(options) {
+	if ([
+		options.resume !== void 0,
+		options.continue === true,
+		options.session !== void 0
+	].filter(Boolean).length > 1) throw new Error("--resume, --continue, and --session are mutually exclusive");
+	if (options.session === "") throw new Error("--session needs an id");
+	if (options.resume === "") throw new Error("--resume needs a session id or id prefix");
+	if (options.mode === "") throw new Error("--mode needs a preset id");
+	if (options.mode !== void 0 && (options.resume !== void 0 || options.continue === true)) throw new Error("--mode applies only to a new session; it cannot be combined with --resume or --continue");
+	return options.resume !== void 0 ? {
+		kind: "resume",
+		sessionId: options.resume
+	} : options.continue === true ? { kind: "latest" } : options.session !== void 0 ? {
+		kind: "named",
+		sessionId: options.session,
+		...options.mode === void 0 ? {} : { mode: options.mode }
+	} : {
+		kind: "fresh",
+		...options.mode === void 0 ? {} : { mode: options.mode }
+	};
+}
 /**
 * This app's command: the launcher's flags this app owns, its description,
 * and its help text.
 * @returns a fresh program, so one process can parse more than once (tests).
 */
 function tuiCommand() {
-	return new Command().name("dsh --profile cli").description("Claude-Code-style interactive terminal for DeepSeek Harness.").helpOption("-h, --help", "show this help").option("-r, --resume <session>", "resume the persisted session with this id (or unique id prefix)").option("-c, --continue", "resume the most recent persisted session for this working directory").option("--session <id>", "create a new session under this explicit id").addHelpText("after", `
+	return new Command().name("dsh --profile cli").description("Claude-Code-style interactive terminal for DeepSeek Harness.").helpOption("-h, --help", "show this help").option("-r, --resume <session>", "resume the persisted session with this id (or unique id prefix)").option("-c, --continue", "resume the most recent persisted session for this working directory").option("--session <id>", "create a new session under this explicit id").option("--mode <preset>", "agent preset for a newly created session").addHelpText("after", `
 Examples:
   dsh --profile cli                       fresh session, minted id
   dsh --profile cli --resume abc123       resume session by id prefix
   dsh --profile cli --continue            resume the latest local session
+  dsh --profile cli --mode minimal        fresh session using the minimal preset
 `);
 }
 /**
@@ -48,23 +72,16 @@ function apply(ctx) {
 	const program = tuiCommand();
 	program.action(() => {
 		const options = program.opts();
-		if ([
-			options.resume !== void 0,
-			options.continue === true,
-			options.session !== void 0
-		].filter(Boolean).length > 1) program.error("error: --resume, --continue, and --session are mutually exclusive");
-		if (options.session !== void 0 && options.session === "") program.error("error: --session needs an id");
-		if (options.resume !== void 0 && options.resume === "") program.error("error: --resume needs a session id or id prefix");
-		const startup = options.resume !== void 0 ? {
-			kind: "resume",
-			sessionId: options.resume
-		} : options.continue === true ? { kind: "latest" } : options.session !== void 0 ? {
-			kind: "named",
-			sessionId: options.session
-		} : { kind: "fresh" };
+		let startup;
+		try {
+			startup = resolveTuiStartup(options);
+		} catch (error) {
+			program.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (startup === void 0) return;
 		ctx.provide(TUI_STARTUP_SERVICE, { startup });
 	});
 	parseCmdline(ctx, program);
 }
 //#endregion
-export { TUI_STARTUP_SERVICE, apply, inject, name };
+export { TUI_STARTUP_SERVICE, apply, inject, name, resolveTuiStartup };

package/lib/types/app.d.ts

@@ -21,6 +21,11 @@ import type { ModelDirectory, ModelRow } from './models.ts';
 import type { QuestionStore } from './questions.ts';
 import type { SkillsView } from './skills.ts';
 import type { MentionCandidate } from './mentions.ts';
+import type { PresetRow } from './presets.ts';
+import type { PluginRow } from './plugin-inventory.ts';
+import type { SessionDirectoryOptions, SessionRow } from './session-directory.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. */
 export interface AppProps {
     /** Event-fed transcript store for the live session. */
@@ -37,12 +42,16 @@ export interface AppProps {
     model: string;
     /** Working-directory basename the session serves. */
     cwd: string;
+    /** Absolute working directory used by session filters and references. */
+    workspaceRoot: string;
     /** Git branch name, empty outside a repository. */
     branch: string;
     /** Short session identifier. */
     sessionId: string;
     /** Whether this session was resumed from persistence. */
     resumed: boolean;
+    /** Agent preset currently composing the session. */
+    mode: string;
     /** Submit one line: slash commands to the registry, other text to the agent. */
     dispatch(text: string): void;
     /** Submit steering: consumed at the running turn's next step boundary. */
@@ -63,10 +72,29 @@ export interface AppProps {
     exportTranscript(argument: string): Promise<void>;
     /** Rename the session (/title <text>); returns the outcome line for the notice. */
     renameTitle(argument: string): string;
+    /** Preset/session/plugin kernel operations. */
+    loadPresets(): Promise<readonly PresetRow[]>;
+    switchMode(id: string): Promise<string>;
+    createSession(mode?: string): void;
+    loadSessions(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
+    loadSessionTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    switchSession(row: SessionRow): void;
+    cancelSessionSwitch(): boolean;
+    loadPlugins(): readonly PluginRow[];
     /** Registers the app's notice channel with the runner (called once on mount). */
     onBridgeReady(bridge: {
-        notify(text: string): void;
+        notify(text: string, tone?: NoticeTone): void;
     }): void;
+    /** Ordered enabled status items (/statusline config); the runner owns persistence. */
+    statusline: readonly string[];
+    /** Persist a new statusline item set; the runner surfaces IO failures as notices. */
+    saveStatusline(items: readonly string[]): 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. */
+    recordHistory(text: string): void;
+    /** Cancel one queued inbox message by identity (Delete on the empty composer). */
+    cancelQueued(messageId: string): void;
 }
 /** The whole terminal app; state arrives via the store, output via Ink. */
 export declare function App(props: AppProps): ReactElement;

package/lib/types/commands.d.ts

@@ -14,6 +14,8 @@ import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
 export interface CommandsView {
     /** Name-sorted descriptors after scoped shadowing. */
     readonly descriptors: readonly CommandDescriptor[];
+    /** Latest descriptor-read failure; the help panel exposes it in place. */
+    readonly error?: string;
     /** Subscribe to list changes (`commands/change`); returns the unsubscribe function. */
     subscribe(listener: () => void): () => void;
     /** Retarget the agent whose scoped view the list is read through. */

package/lib/types/history.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Global input recall: persistent cross-session entries plus this process's
+ * submissions, with Codex `ChatComposerHistory` semantics — empty submissions
+ * are ignored, adjacent duplicates collapse, the recall space skips
+ * persistent entries that duplicate a local one (local wins), and Up/Down
+ * navigation is gated so interior cursor movement never hijacks the draft.
+ *
+ * @module @deepseek-ai/dsh-tui/history
+ */
+/** Maximum entries retained in the persistent history file. */
+export declare const HISTORY_MAX_ENTRIES = 500;
+/** Encode one entry for the history file (JSON keeps multi-line drafts intact). */
+export declare function serializeHistoryEntry(text: string): string;
+/**
+ * Parse a persisted history file (one JSON entry per line): invalid lines
+ * drop out, empty entries are ignored, adjacent duplicates collapse, and the
+ * result keeps only the newest `max` entries.
+ * @param raw - file content, empty for a missing file.
+ * @param max - entry cap.
+ * @returns persistent entries, oldest first.
+ */
+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.
+ */
+export declare function appendHistoryContent(current: string, text: string, max?: number): string;
+/**
+ * Record one in-session submission: empty text is ignored and an adjacent
+ * duplicate collapses (Codex `record_local_submission` semantics).
+ * @param local - current in-session entries, oldest first.
+ * @param text - the submitted prompt.
+ * @returns the updated local list.
+ */
+export declare function recordLocalEntry(local: readonly string[], text: string): readonly string[];
+/**
+ * Build the recall space, newest first: local entries, then persistent
+ * entries whose text is not duplicated locally (the local copy wins and the
+ * persistent twin is skipped — Codex's replay-seed dedup, applied to the
+ * whole local set).
+ * @param persistent - cross-session entries, oldest first.
+ * @param local - this process's submissions, oldest first.
+ * @returns recall entries, newest first.
+ */
+export declare function recallEntries(persistent: readonly string[], local: readonly string[]): readonly string[];
+/** Shell-style recall navigation over a fixed recall space. */
+export interface RecallState {
+    /** Recall entries, newest first (frozen at navigation start). */
+    entries: readonly string[];
+    /** Current recall index; null when not browsing. */
+    index: number | null;
+    /** Draft saved when browsing started; restored on Down past the newest. */
+    savedDraft: string;
+    /** The recalled text currently in the composer (the boundary gate's anchor). */
+    lastRecalled: string | null;
+}
+/** Fresh navigation state over one recall space. */
+export declare function beginRecall(entries: readonly string[], draft: string): RecallState;
+/** The outcome of one recall step. */
+export interface RecallStep {
+    state: RecallState;
+    /** The text to place in the composer; undefined means "no movement". */
+    entry: string | undefined;
+}
+/**
+ * Move one entry older (Up, toward index +1 in the newest-first space). The
+ * first Up saves the current draft so Down past the newest can restore it
+ * (Claude-Code shell recall — the draft is never lost); the oldest entry
+ * stays put.
+ * @param state - current navigation state.
+ * @param draft - the composer text to preserve when browsing starts.
+ */
+export declare function recallOlder(state: RecallState, draft: string): RecallStep;
+/** Move one entry newer (Down, toward index 0); past the newest, browsing ends and the saved draft returns. */
+export declare function recallNewer(state: RecallState): RecallStep;

package/lib/types/index.d.ts

@@ -1,11 +1,10 @@
 /**
  * @deepseek-ai/dsh-code — the interactive terminal driver. The bundle patch
  * rides over dsh-base without Host, HTTP, or browser plugins; this runner
- * creates (or resumes) one Agent through the core registry, mounts the Ink
- * app (DeepSeek blue, whale wordmark), folds submitted prompts into the same
- * durable session, answers approval asks with a y/n bar, dispatches slash
- * commands through the shared registry, and on quit flushes and requests
- * process exit.
+ * creates or resumes preset-composed Agents through the core registry, keeps
+ * one Ink owner while the active session changes, folds submitted prompts
+ * into the selected durable session, answers approval asks with a y/n bar,
+ * dispatches slash commands, and on quit flushes and requests process exit.
  *
  * @module @deepseek-ai/dsh-code
  */
@@ -21,6 +20,7 @@ export interface Config {
     startup: {
         kind: string;
         sessionId?: string;
+        mode?: string;
     };
 }
 export declare const Config: z<Config>;

package/lib/types/internals.d.ts

@@ -8,6 +8,8 @@
 import type { ReactElement } from 'react';
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
+    /** Replace the root element while preserving Ink's single terminal owner. */
+    rerender(element: ReactElement): void;
     /** Tear the terminal app down before flush and exit. */
     unmount(): void;
 }

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

@@ -0,0 +1,48 @@
+/** Bounded, composer-safe panels for preset, session, and plugin kernel views. */
+import { type ReactElement } from 'react';
+import type { PresetRow } from './presets.ts';
+import type { PluginRow } from './plugin-inventory.ts';
+import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
+import { type StatusItemId } from './render/status.ts';
+export declare function ModePanel({ current, load, select, close }: {
+    current: string;
+    load(): Promise<readonly PresetRow[]>;
+    select(id: string): void;
+    close(): void;
+}): ReactElement;
+export declare function PluginPanel({ load, close, initialQuery }: {
+    load(): readonly PluginRow[];
+    close(): void;
+    initialQuery?: string;
+}): ReactElement;
+export declare function ResumePanel({ currentCwd, load, readTranscript, select, close }: {
+    currentCwd: string;
+    load(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
+    readTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    select(row: SessionRow): void;
+    close(): void;
+}): ReactElement;
+/**
+ * The /history recall panel (Codex composer-history search, bounded): one
+ * query line over the newest-first recall space, filtered by substring, with
+ * arrow selection and enter to fill the composer. Editing the query restarts
+ * from the newest match; Esc closes without touching the draft.
+ */
+export declare function HistoryPanel({ entries, fill, close }: {
+    /** Newest-first recall entries (persistent + in-session, deduped). */
+    entries: readonly string[];
+    /** Accept one entry: its text plus its recall-space index (browsing resumes there). */
+    fill(text: string, index: number): void;
+    close(): void;
+}): ReactElement;
+/**
+ * The /statusline picker (the Codex setup-view contract): one bounded list
+ * of every status item with its enabled mark, arrow reordering, and a
+ * live preview — the real status line under the composer updates as you
+ * edit, so the panel itself carries no duplicate preview row.
+ */
+export declare function StatuslinePanel({ enabled, change, close }: {
+    enabled: readonly StatusItemId[];
+    change(items: readonly StatusItemId[]): void;
+    close(): void;
+}): ReactElement;

package/lib/types/plugin-inventory.d.ts

@@ -0,0 +1,11 @@
+/** Read-only projection of Cordis Loader entries for /plugin. */
+import type { Context } from '@deepseek-ai/cordis';
+export type PluginPhase = 'pending' | 'loading' | 'active' | 'failed' | 'unloading' | null;
+export interface PluginRow {
+    readonly entryId: string;
+    readonly moduleName: string;
+    readonly enabled: boolean;
+    readonly phase: PluginPhase;
+}
+/** Snapshot the live Loader; group-only rows are composition containers, not plugins. */
+export declare function listPluginRows(ctx: Context): PluginRow[];

package/lib/types/presets.d.ts

@@ -0,0 +1,32 @@
+/** Agent-preset policy kept independent from the Ink surface. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, AgentHandle } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
+/** One discoverable agent composition. */
+export interface PresetRow {
+    readonly id: string;
+    readonly trust: 'system' | 'user';
+    readonly name?: string;
+    readonly description?: string;
+    readonly order?: number;
+    readonly broken?: string;
+}
+/** Structural boundary for the optional upstream AgentPresets service. */
+export interface AgentPresetsService {
+    readonly defaultId: string;
+    list(): Promise<PresetRow[]>;
+    resolve(id?: string): Promise<PresetRow>;
+    mount(agentCtx: Context, id?: string): Promise<PresetRow>;
+    recompose(agentCtx: Context, id: string): Promise<PresetRow>;
+    composedPreset(agentCtx: Context): string | undefined;
+}
+/** Read an optional Cordis service without requiring its package at build time. */
+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;
+/** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
+export declare function resolvePreset(session: Pick<Session, 'header' | 'events'>): string;
+/** Recompose atomically from the caller's perspective, logging only success. */
+export declare function switchPreset(service: AgentPresetsService, agent: Agent, presetId: string): Promise<PresetRow>;
+/** Minimal handle shape used by lifecycle tests without exposing Agent internals. */
+export type OwnedAgent = Pick<AgentHandle, 'agent' | 'dispose'>;

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

@@ -1,7 +1,8 @@
 /**
  * Terminal animation frame tables derived from the web design language:
  * the StateDot "ongoing" pixel chase (3×3 ring, 125ms flat-hold brightness
- * steps, 1s cycle) becomes the single-cell stepped pulse below, and the
+ * steps, 1s cycle) becomes the single-cell stepped pulse below and the
+ * full-ring clockwise braille chase in {@link BUSY_CHASE_FRAMES}, and the
  * streaming caret blink is the Claude-Code convention. Pure functions only —
  * the Ink layer owns timers and colors.
  *
@@ -11,5 +12,13 @@
 export declare const PULSE_FRAMES: readonly ["█", "█", "▆", "▃", "▁", "▃", "▆", "█"];
 /** Pulse frame for a monotonic tick. */
 export declare function pulseFrame(tick: number): string;
+/**
+ * The web StateDot "ongoing" chase in terminal form: three cells of the 3×3
+ * ring trail clockwise around the eight outer positions, one braille glyph
+ * per step — 8 frames × 125ms = the web's 1s cycle.
+ */
+export declare const BUSY_CHASE_FRAMES: readonly ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+/** Chase frame for a monotonic tick (the busy composer/Deep-diving marker). */
+export declare function busyChaseFrame(tick: number): string;
 /** Caret visibility: half the ticks on, half off (530ms blink). */
 export declare function caretVisible(tick: number): boolean;

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

@@ -5,11 +5,17 @@ export interface InspectorViewport {
     maxHeight: number;
     /** Rows available to the selected entry after border, title, and footer. */
     bodyRows: number;
+    /** Optional blank rows separating title/body/footer on roomy terminals. */
+    gapRows: 0 | 2;
     /** Columns available inside the horizontal border and padding. */
     contentColumns: number;
+    /** Safe outer width for a bordered dynamic panel; never writes column N. */
+    outerColumns: number;
     /** Tiny terminals use a borderless one-line close hint. */
     compact: boolean;
 }
+/** One transcript-to-composer gutter, collapsed on short terminals. */
+export declare function layoutGutterRows(rows: number): 0 | 1;
 /**
  * Keep the inspector plus its persistent status/composer chrome below
  * `stdout.rows`: at equality Ink clears the terminal and rewrites all

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

@@ -6,6 +6,7 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
+import { type MessageId } from '@deepseek-ai/dsh-llm';
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session';
 import { type ToolDetail } from './tool-detail.ts';
 /** One user prompt line. */
@@ -17,6 +18,16 @@ export interface UserEntry {
      * the renderer marks with a dim ↳ instead of the user ❯ prompt. */
     notice: boolean;
 }
+/** One user message waiting in the agent inbox (the web's queued-message row). */
+export interface PendingEntry {
+    kind: 'pending';
+    /** Stable message identity shared with the durable `user/message` that retires it. */
+    messageId: MessageId;
+    /** Which inbox list holds the message: steering is consumed at the next step boundary. */
+    target: 'next-turn' | 'next-step';
+    /** Full message text — Codex PendingSteer renders queued prompts exactly like user rows. */
+    text: string;
+}
 /** One assembled assistant reply. */
 export interface AssistantEntry {
     kind: 'assistant';
@@ -105,7 +116,7 @@ export interface FilesEntry {
     paths: readonly string[];
 }
 /** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry;
+export type TranscriptEntry = UserEntry | PendingEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry;
 /** The live goal the status line badges, folded from `goal/change`. */
 export interface GoalFold {
     /** Human-requested completion objective. */
@@ -185,6 +196,15 @@ export interface TranscriptView {
     sandbox: string;
     /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
     goal: GoalFold | undefined;
+    /**
+     * Ordered live message ids per inbox target, mirrored from
+     * `agent/inbox/spliced` exactly like the upstream Inbox projection — the
+     * coordinates later removals resolve against.
+     */
+    pending: {
+        'next-turn': readonly string[];
+        'next-step': readonly string[];
+    };
     /**
      * Fold-internal timing anchors, never rendered: open step and tool-call
      * start timestamps the next `assistant/message` / `tool/result` resolves