dsh-code 0.1.0 → 0.3.0

package/lib/invariant.mjs

@@ -1,5 +1,5 @@
 //#region src/invariant.ts
-const PACKAGE_NAME = "@deepseek-ai/dsh-tui";
+const PACKAGE_NAME = "dsh-code";
 /** Cordis companion plugin name. */
 const name = "tui-invariant";
 /** Service required before the companion can register. */

package/lib/startup.mjs

@@ -0,0 +1,70 @@
+import { Command } from "commander";
+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
+* {@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}).
+*
+* Semantics:
+* - `--resume <id|prefix>` — continue the persisted session whose id or unique
+*   id-prefix matches; the TUI replays its transcript and appends to the same
+*   durable log.
+* - `--continue` / `-c` — resume the most recently modified persisted session
+*   whose project directory matches the current working directory.
+* - `--session <id>` — create a new session under an explicit identity (the
+*   id must not exist yet).
+* - no flags — a fresh session with a minted id.
+*
+* @module @deepseek-ai/dsh-tui/startup
+*/
+/** Stable Cordis plugin name. */
+const name = "tui-startup";
+/** Services required before the invocation can be resolved. */
+const inject = ["cmdlineArgs"];
+/** Service provided by this plugin and injected by the terminal runner. */
+const TUI_STARTUP_SERVICE = "tuiStartup";
+/**
+* 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", `
+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
+`);
+}
+/**
+* Parse the invocation and publish the startup service. Mutual exclusions are
+* usage errors rejected from the action before anything is provided.
+* @param ctx - plugin context carrying the command line and exit request.
+*/
+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" };
+		ctx.provide(TUI_STARTUP_SERVICE, { startup });
+	});
+	parseCmdline(ctx, program);
+}
+//#endregion
+export { TUI_STARTUP_SERVICE, apply, inject, name };

package/lib/types/app.d.ts

@@ -1,23 +1,39 @@
 /**
  * The Ink terminal app: whale-and-wordmark header in DeepSeek blue, the live
- * transcript, the streaming line, local notices, and the input box. All state
- * arrives through the transcript store (derived from the durable session log)
- * plus local input state; the app owns no session mutation of its own.
+ * transcript, the todo panel, the streaming line, the approval bar, the model
+ * panel, local notices, and the input box with history and slash-command
+ * completion. All state arrives through the transcript store (derived from
+ * the durable session log) plus local input state; the app owns no session
+ * mutation of its own.
  *
  * Element construction uses `createElement` (not JSX): the `dsh` source launch
  * compiles this file through tsx's ESM-only hook, which does not adopt this
  * package's `jsx: react-jsx` compiler option, and the classic JSX runtime
  * would demand a React global.
  *
- * @module @deepseek-ai/dsh-tui/app
+ * @module @deepseek-ai/dsh-code/app
  */
 import { type ReactElement } from 'react';
 import type { TranscriptStore } from './store.ts';
+import type { ApprovalStore } from './approval.ts';
+import type { CommandsView } from './commands.ts';
+import type { ModelDirectory, ModelRow } from './models.ts';
+import type { QuestionStore } from './questions.ts';
+import type { SkillsView } from './skills.ts';
+import type { MentionCandidate } from './mentions.ts';
 /** Props the runner hands the app; callbacks stay owned by the runner. */
 export interface AppProps {
     /** Event-fed transcript store for the live session. */
     store: TranscriptStore;
-    /** `provider/model` selection serving this session. */
+    /** Approval-question store fed by the answerer listener. */
+    approval: ApprovalStore;
+    /** ask_user_question store fed by the single UI provider. */
+    questions: QuestionStore;
+    /** Live slash-command descriptor list (completion candidates). */
+    commands: CommandsView;
+    /** Live user-invocable skill catalog (completion candidates). */
+    skills: SkillsView;
+    /** `provider/model` selection serving this session (updated on /model). */
     model: string;
     /** Working-directory basename the session serves. */
     cwd: string;
@@ -25,10 +41,49 @@ export interface AppProps {
     branch: string;
     /** Short session identifier. */
     sessionId: string;
-    /** Submit one human prompt; the runner folds it into the session. */
-    onSubmit(text: string): void;
+    /** Whether this session was resumed from persistence. */
+    resumed: boolean;
+    /** 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. */
+    steer(text: string): void;
+    /** Interrupt the running turn (Esc); true when a turn was cancelled. */
+    interrupt(): boolean;
     /** Quit: unmount, flush, and request process exit. */
-    onQuit(): void;
+    quit(): void;
+    /** Load the selectable model directory (called when /model opens). */
+    loadModels(): Promise<ModelDirectory>;
+    /** Load @mention candidates for the typed query (files + sessions). */
+    loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
+    /** Apply one /model selection; returns the display label. */
+    selectModel(row: ModelRow): string;
+    /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
+    cyclePermission(): string;
+    /** Registers the app's notice channel with the runner (called once on mount). */
+    onBridgeReady(bridge: {
+        notify(text: string): void;
+    }): void;
+}
+/** One completion candidate row. */
+interface CompletionCandidate {
+    /** Insertion text for the command name (with leading slash). */
+    label: string;
+    /** Human-readable description shown beside the label. */
+    description: string;
+    /** Candidate origin; skills land the same literal text but route through the prompt. */
+    origin: 'command' | 'skill' | 'mention';
+}
+/** The completion menu snapshot the input editor publishes to the app. */
+export interface MenuState {
+    /** Whether the menu is on screen (slash or @mention). */
+    active: boolean;
+    /** Whether the menu is driven by an @mention token. */
+    mention: boolean;
+    /** Highlighted candidate index (wraps by row count). */
+    index: number;
+    /** Rendered rows in display order. */
+    rows: readonly CompletionCandidate[];
 }
 /** The whole terminal app; state arrives via the store, output via Ink. */
-export declare function App({ store, model, cwd, branch, sessionId, onSubmit, onQuit }: AppProps): ReactElement;
+export declare function App(props: AppProps): ReactElement;
+export {};

package/lib/types/approval.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The terminal approval answerer: one `approval/request` waterfall listener
+ * that renders the pending question as a y/n bar and resolves the decision
+ * back into the waterfall. Mirrors the web host's composer takeover — the
+ * service (audit pair, policy gate, fail-closed defaults) all live in
+ * dsh-base; this module only answers for agents this TUI owns.
+ *
+ * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
+ * or `'rejected'`; `'cancelled'` belongs to the request signal and
+ * `'unavailable'` to the fail-closed waterfall default.
+ *
+ * @module @deepseek-ai/dsh-code/approval
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ApprovalRequest } from '@deepseek-ai/dsh-user-approval';
+/** The answer values a client answerer may resolve with. */
+export type ApprovalAnswer = 'allowed-once' | 'rejected';
+/** One pending approval question, derived from the request for rendering. */
+export interface PendingApproval {
+    /** The asker's human-readable explanation, or a generic fallback. */
+    headline: string;
+    /** The tool the question is about. */
+    toolName: string;
+    /** Command-line preview resolved from the paired streaming tool call. */
+    command: string;
+    /** Resolve the ask; calling twice is inert (one-shot latch). */
+    answer(outcome: ApprovalAnswer): void;
+}
+/** The pending-question snapshot the renderer subscribes to. */
+export interface ApprovalSnapshot {
+    /** The pending question, or undefined when none is being asked. */
+    pending: PendingApproval | undefined;
+    /** Presentational: an answer was submitted, the ask has not settled yet. */
+    answered: boolean;
+}
+/** Store the pending question lands in; the renderer reads, the answerer writes. */
+export interface ApprovalStore {
+    /** Subscribe to pending-state changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Read the current snapshot (identity-stable between changes). */
+    getSnapshot(): ApprovalSnapshot;
+}
+/**
+ * Create the approval store and mount the answerer listener on the context.
+ * The listener claims only requests for `owns`-owned agents and defers every
+ * other request back into the waterfall (`next()`), so sibling answerers stay
+ * usable. An aborted ask never reaches the human. Plugin teardown removes the
+ * listener; the service then fails its own question closed.
+ * @param ctx - plugin context whose event bus carries `approval/request`.
+ * @param owns - agents this terminal answers for.
+ * @param preview - resolves a tool-call preview for a pending request (the
+ * request contract carries no arguments; the UI self-serves from the
+ * transcript projection via `callId`).
+ * @returns the store the renderer subscribes to.
+ */
+export declare function mountApprovalAnswerer(ctx: Context, owns: (agent: Agent) => boolean, preview: (request: ApprovalRequest) => string): ApprovalStore;

package/lib/types/commands.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Slash-command bridge: forwards terminal command lines into the shared
+ * `ctx.commands` registry (the same surface the web composer dispatches
+ * through) and exposes the live descriptor list as completion candidates.
+ * The runner keeps only its own TUI-local commands (`/help`, `/quit`,
+ * `/clear`, `/model`) ahead of the registry dispatch.
+ *
+ * @module @deepseek-ai/dsh-tui/commands
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+/** Descriptor list snapshot the completion menu renders from. */
+export interface CommandsView {
+    /** Name-sorted descriptors after scoped shadowing. */
+    readonly descriptors: readonly CommandDescriptor[];
+    /** 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. */
+    setAgent(agent: Agent): void;
+}
+/**
+ * Watch the live command registry. Reads the current list immediately and
+ * re-reads on every registry mutation or agent retarget; notification
+ * failures are contained by the registry itself, so this watcher only ever
+ * re-reads. Without a `commands` service the view stays empty and all lines
+ * fall through to normal prompts.
+ * @param ctx - context carrying the `commands` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export declare function watchCommands(ctx: Context): CommandsView;
+/**
+ * Whether one command line is a syntactically valid slash command.
+ * @param line - the complete candidate line.
+ * @returns true when the line parses as `/name` or `/name input`.
+ */
+export declare function isSlashLine(line: string): boolean;

package/lib/types/index.d.ts

@@ -1,20 +1,32 @@
 /**
- * @deepseek-ai/dsh-tui — the interactive terminal driver. The bundle patch
+ * @deepseek-ai/dsh-code — the interactive terminal driver. The bundle patch
  * rides over dsh-base without Host, HTTP, or browser plugins; this runner
- * creates one Agent through the core registry, mounts the Ink app (DeepSeek
- * blue, whale wordmark), folds submitted prompts into the same durable
- * session, streams `session/event` into the transcript, and on quit flushes
- * and requests process exit.
+ * 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.
  *
- * @module @deepseek-ai/dsh-tui
+ * @module @deepseek-ai/dsh-code
  */
 import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
 /** Stable Cordis plugin name. */
 export declare const name = "tui-runner";
 /** Core services required before the interactive session can start. */
 export declare const inject: string[];
+/** Plugin config: the startup resolved from this app's injected provider service. */
+export interface Config {
+    /** How this invocation obtains its session identity (validated loosely; narrowed in {@link apply}). */
+    startup: {
+        kind: string;
+        sessionId?: string;
+    };
+}
+export declare const Config: z<Config>;
 /**
  * Mount the interactive terminal driver.
  * @param ctx - plugin context carrying core services and the launcher-provided exit request.
+ * @param config - validated startup config resolved from the tuiStartup provider.
  */
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/types/invariant.d.ts

@@ -1,6 +1,6 @@
 /**
- * Package-owned invariant companion for `@deepseek-ai/dsh-tui`.
- * @module @deepseek-ai/dsh-tui/invariant
+ * Package-owned invariant companion for `dsh-code`.
+ * @module dsh-code/invariant
  */
 import type { Context } from '@deepseek-ai/cordis';
 /** Cordis companion plugin name. */

package/lib/types/mentions.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Workspace @mention support: file candidates from a bounded async scan of
+ * the session cwd, session candidates from the opt-in `sessionReferenceResolver`
+ * service, and submission preparation through its `prepare()` API. Picked
+ * session mentions land as canonical `@[label](dsh-session:…)` tokens; on
+ * submit the text is parsed back into readable `@label` text plus structured
+ * references, snapshots are injected via `agent.inject()` before the readable
+ * message wakes the driver (`followup` idle, `steer` running) — exactly the
+ * upstream README's wiring.
+ *
+ * @module @deepseek-ai/dsh-code/mentions
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { parseSessionReferenceText, type SessionReferenceCandidate, type SessionReferenceInput } from '@deepseek-ai/dsh-session-reference';
+/** Parsed submission text: readable text plus structured references. */
+type ParsedSessionReferenceText = ReturnType<typeof parseSessionReferenceText>;
+/** One filesystem entry the @ menu can complete. */
+export interface FileCandidate {
+    /** Workspace-relative path with forward slashes. */
+    path: string;
+    /** Entry kind; directories insert with a trailing slash. */
+    kind: 'file' | 'directory';
+}
+/** One merged menu candidate (files and sessions, already ranked). */
+export interface MentionCandidate {
+    /** Text inserted after the `@` (directories carry a trailing slash). */
+    label: string;
+    /** Human-readable origin shown beside the label. */
+    description: string;
+    /** Origin kind for icon/coloring decisions. */
+    kind: 'file' | 'directory' | 'session';
+}
+/** Prepared submission: readable content plus optional injected context. */
+export interface PreparedMention {
+    /** Readable text with mention tokens normalized to `@label`. */
+    text: string;
+    /** Structured source sessions in appearance order (empty when none). */
+    references: SessionReferenceInput[];
+    /** Aggregated snapshot for `agent.inject()`, undefined without references. */
+    additionalContext?: import('@deepseek-ai/dsh-session').UserMessage;
+}
+/** Bounded async BFS scan of a workspace; unreadable entries are skipped. */
+export declare function scanWorkspaceFiles(root: string, signal?: AbortSignal): Promise<readonly FileCandidate[]>;
+/** The mention API the input editor and the runner share. */
+export interface MentionsApi {
+    /** Scanned workspace files, cached across one session. */
+    files(): Promise<readonly FileCandidate[]>;
+    /** Ranked menu candidates for the typed `@` query. */
+    candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
+    /** Parse submission text into readable text plus structured references. */
+    parse(text: string): ParsedSessionReferenceText;
+    /**
+     * Snapshot references and build the injected context. Throws the service's
+     * typed error on failure — the caller restores the draft and notifies.
+     */
+    prepare(parsed: ParsedSessionReferenceText, signal?: AbortSignal): Promise<PreparedMention>;
+    /** Canonical mention token for a picked session candidate. */
+    sessionMention(candidate: SessionReferenceCandidate): string;
+}
+/**
+ * Create the mention API for one agent's workspace. A missing
+ * session-reference service degrades to file mentions only (the scan still
+ * works); `prepare` then passes text through untouched.
+ * @param ctx - context carrying the optional `sessionReferenceResolver`.
+ * @param agent - the session owner; excluded from its own candidates.
+ * @param cwd - workspace root to scan.
+ */
+export declare function createMentions(ctx: Context, agent: Agent, cwd: string): MentionsApi;
+export {};

package/lib/types/models.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model directory for the `/model` panel: the in-process equivalent of the
+ * web host's model catalog (`buildModelCatalog`), reading the advisory
+ * `ctx.llm` registry directly. Catalog membership is advisory — a route
+ * serving a model it stopped advertising stays usable — so selection never
+ * fails on catalog absence alone.
+ *
+ * @module @deepseek-ai/dsh-tui/models
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** One selectable row in the `/model` panel. */
+export interface ModelRow {
+    /** Registered provider route. */
+    provider: string;
+    /** Display name of the provider route. */
+    providerName: string;
+    /** Provider-owned model id. */
+    model: string;
+    /** Human-readable model name. */
+    modelName: string;
+}
+/** The resolved directory: rows plus per-provider discovery failures. */
+export interface ModelDirectory {
+    /** Advisory rows, provider-major in registry order. */
+    rows: readonly ModelRow[];
+    /** Provider ids whose model listing failed; those providers contribute no rows. */
+    failures: readonly string[];
+}
+/**
+ * Load the selectable model directory from the live `ctx.llm` registry.
+ * Providers are listed synchronously; each provider's models are discovered
+ * with a bounded parallel fan-out whose failures degrade to that provider
+ * contributing no rows (mirrors the web catalog's per-provider failures).
+ * @param ctx - context carrying the `llm` service.
+ * @returns the resolved directory; empty rows when `llm` is unavailable.
+ */
+export declare function loadModelDirectory(ctx: Context): Promise<ModelDirectory>;

package/lib/types/questions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ *
+ * Plan reviews (`exit_plan_mode`) arrive through the same service 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 AskUserQuestionAnswer, type AskUserQuestionRequest } from '@deepseek-ai/dsh-user-questions';
+/** One question request waiting on the human, with its settle channels. */
+export interface PendingQuestion {
+    /** The request the renderer walks through question by question. */
+    request: AskUserQuestionRequest;
+    /** Resolve the provider promise with the collected answers. */
+    resolve(answers: AskUserQuestionAnswer): void;
+    /** Reject the provider promise as aborted (also used for Esc cancel). */
+    reject(error: Error): void;
+}
+/** The pending-question snapshot the renderer subscribes to. */
+export interface QuestionSnapshot {
+    /** The active request, or undefined when nothing is being asked. */
+    pending: PendingQuestion | undefined;
+}
+/** Store the pending question lands in; the renderer reads, the provider writes. */
+export interface QuestionStore {
+    /** Subscribe to pending-state changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Read the current snapshot (identity-stable between changes). */
+    getSnapshot(): QuestionSnapshot;
+    /** Submit the collected answers for the active request and advance the queue. */
+    submit(pending: PendingQuestion, answers: AskUserQuestionAnswer): void;
+    /** Cancel the active request (Esc) — rejects ASK_ABORTED and advances the queue. */
+    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.
+ */
+export declare function mountQuestionProvider(ctx: Context): QuestionStore;

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

@@ -0,0 +1,15 @@
+/**
+ * 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
+ * streaming caret blink is the Claude-Code convention. Pure functions only —
+ * the Ink layer owns timers and colors.
+ *
+ * @module @deepseek-ai/dsh-code/render/animations
+ */
+/** Single-cell stepped pulse: flat holds mirroring the web's 125ms keyframes. */
+export declare const PULSE_FRAMES: readonly ["█", "█", "▆", "▃", "▁", "▃", "▆", "█"];
+/** Pulse frame for a monotonic tick. */
+export declare function pulseFrame(tick: number): string;
+/** Caret visibility: half the ticks on, half off (530ms blink). */
+export declare function caretVisible(tick: number): boolean;

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

@@ -0,0 +1,27 @@
+/**
+ * Terminal markdown renderer for assistant replies: a pure GFM-subset
+ * block/inline parser producing styled line segments the Ink renderer maps
+ * to colored text. No ANSI here — the app owns color mapping, tests own the
+ * structure. The subset mirrors what agent replies actually emit: headings,
+ * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, and
+ * wrapped paragraphs. Unknown syntax degrades to plain text (never throws).
+ *
+ * @module @deepseek-ai/dsh-code/render/markdown
+ */
+/** Style classes the renderer emits; the app maps them to colors/props. */
+export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'dim' | 'strike';
+/** One styled run of text. */
+export interface MdSegment {
+    /** Visible text (no ANSI). */
+    text: string;
+    /** Presentation class for the app's color map. */
+    style: MdStyle;
+}
+/** One rendered line: a sequence of styled runs. */
+export interface MdLine {
+    segments: readonly MdSegment[];
+}
+/** Visible width of a run in columns (CJK counts double). */
+export declare function visibleColumns(text: string): number;
+/** Render markdown text into styled lines of at most `width` columns. */
+export declare function renderMarkdown(text: string, width: number): readonly MdLine[];

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

@@ -6,18 +6,23 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session';
 /** One user prompt line. */
 export interface UserEntry {
     kind: 'user';
     /** Joined text blocks of the user message. */
     text: string;
+    /** True for collapsed injected context (plugin/continuation notices), which
+     * the renderer marks with a dim ↳ instead of the user ❯ prompt. */
+    notice: boolean;
 }
 /** One assembled assistant reply. */
 export interface AssistantEntry {
     kind: 'assistant';
     /** Joined text blocks of the assistant message. */
     text: string;
+    /** Joined reasoning blocks of the same message, empty when the model thought out loud. */
+    reasoning: string;
 }
 /** One model-requested tool invocation and its settled state. */
 export interface ToolEntry {
@@ -28,11 +33,27 @@ export interface ToolEntry {
     name: string;
     /** Raw arguments JSON string exactly as the model produced it. */
     arguments: string;
+    /** Bounded human-meaningful arguments preview for the tool card. */
+    preview: string;
     /** Execution state; `running` until the paired result lands. */
     state: 'running' | 'done' | 'error';
     /** Bounded first text block of the result, empty until it lands. */
     summary: string;
 }
+/** One slash-command execution dispatched through `ctx.commands`. */
+export interface CommandEntry {
+    kind: 'command';
+    /** Pairing id shared with the matching `command/done`. */
+    commandId: string;
+    /** Lowercase command name without the leading slash. */
+    name: string;
+    /** Verbatim text following the command name. */
+    args: string;
+    /** Execution state; `running` until the paired lifecycle event lands. */
+    state: 'running' | 'done' | 'error';
+    /** Handler outcome text, empty until it lands. */
+    summary: string;
+}
 /** One turn-level failure surfaced from `turn/end`. */
 export interface ErrorEntry {
     kind: 'error';
@@ -40,7 +61,7 @@ export interface ErrorEntry {
     text: string;
 }
 /** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | ErrorEntry;
+export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry;
 /** Cumulative token accounting folded from `assistant/message` usage reports. */
 export interface UsageTotals {
     /** Prompt-side billed tokens: `inputTokens` plus both cache buckets. */
@@ -69,12 +90,25 @@ export interface TranscriptView {
     entries: readonly TranscriptEntry[];
     /** Text accumulated from `assistant/chunk` deltas since the last flush. */
     streaming: string;
+    /** Thinking accumulated from `assistant/chunk` reasoning deltas since the last flush. */
+    streamingReasoning: string;
     /** Latest whole-list todo snapshot from `todo/write`, empty when none. */
-    todos: SessionEvent<'todo/write'>['data']['todos'];
+    todos: readonly TodoItem[];
     /** True while a durable turn is open (`turn/start` … `turn/end`). */
     busy: boolean;
     /** Figures the status line renders. */
     stats: TranscriptStats;
+    /**
+     * The `provider/model` pair of the last `request/header` snapshot — the
+     * session's own model record, which a resumed TUI prefers over the
+     * deployment default (mirrors the web host's resume selection order).
+     * Empty before the session's first request.
+     */
+    model: string;
+    /** Plan mode state folded from the last `plan/mode` event. */
+    plan: boolean;
+    /** Active permission preset folded from the last `permission/preset` event, empty before one. */
+    permission: string;
     /**
      * Fold-internal timing anchors, never rendered: open step and tool-call
      * start timestamps the next `assistant/message` / `tool/result` resolves

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

@@ -37,6 +37,10 @@ export interface StatusFacts {
     branch: string;
     /** Short session identifier (last dash-separated segment or tail). */
     sessionId: string;
+    /** Whether plan mode is active (folded from `plan/mode`). */
+    plan: boolean;
+    /** Active permission preset (folded from `permission/preset`), empty when unknown. */
+    permission: string;
 }
 /**
  * Build the footer's display groups; a group with no data drops out whole.

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

@@ -0,0 +1,18 @@
+/**
+ * Display-boundary sanitization for externally sourced text (model output,
+ * tool payloads, skill descriptions). Control characters — including ANSI
+ * CSI/OSC escape sequences — would otherwise pass through Ink into the
+ * terminal, letting output rewrite the screen or inject prompts. Newlines
+ * and tabs survive; everything else in C0/C1 plus DEL becomes a visible
+ * `\xNN` escape.
+ *
+ * @module @deepseek-ai/dsh-code/render/text
+ */
+/**
+ * Escape control characters so externally sourced text cannot drive the
+ * terminal.
+ * @param text - raw text from a session event, tool payload, or catalog.
+ * @returns text with every control character (except `\n`, `\t`) rendered
+ * as a literal `\xNN` escape.
+ */
+export declare function displayText(text: string): string;