dsh-ssh-tui 0.5.9 → 0.6.0

package/lib/types/rows.d.ts

@@ -0,0 +1,69 @@
+import type { PlanTodoItem, Row, ToolDiffHunk } from './transcript-types.js';
+type ToolRow = Extract<Row, {
+    kind: 'tool';
+}>;
+type PlanRow = Extract<Row, {
+    kind: 'plan';
+}>;
+/** Long sessions keep the newest rows; older ones are dropped from the front. */
+export declare const MAX_TRANSCRIPT_ROWS = 5000;
+/**
+ * Drop the oldest rows past `max` and report how many went. The caller owns the
+ * things that point at rows (the focused card, clickable maps), so they can be
+ * invalidated with that count.
+ */
+export declare function boundTranscriptRows(rows: Row[], max?: number): number;
+export declare function findToolRowByCallId(rows: readonly Row[], callId: string): ToolRow | undefined;
+/** The card a repeated call of the same tool should merge into, if any. */
+export declare function findMergeableToolRow(rows: readonly Row[], next: {
+    name: string;
+    args: string;
+}): ToolRow | undefined;
+/**
+ * Fold a repeated call into the card that is already on screen: the card grows
+ * a repeat mark and starts over as `running`. `now` is passed in so the flip
+ * animation is testable.
+ */
+export declare function mergeToolCard(previous: ToolRow, next: {
+    callId: string;
+    name: string;
+    args: string;
+    title: string;
+    summary: string;
+    diff?: ToolDiffHunk[];
+}, now: number, replaying?: boolean): void;
+export declare function findLivePlanRow(rows: readonly Row[]): PlanRow | undefined;
+/** Whether the plan card should open on its own when it has work left. */
+export declare function planShouldDefaultExpand(plan: {
+    active?: boolean;
+    pending?: boolean;
+    todos: readonly PlanTodoItem[];
+}): boolean;
+/** Older / finished plans stay in the scrolling transcript, greyed out. */
+export declare function archiveStalePlans(rows: readonly Row[], keep?: PlanRow): void;
+export interface TranscriptWindow<T> {
+    /** Index of the first transcript line on screen; a fresh window means a repaint. */
+    start: number;
+    /** Clamped scroll offset; the caller stores it back for the next paint. */
+    scrollOffset: number;
+    visibleLines: string[];
+    visibleRefs: (T | undefined)[];
+    /** Blank lines added above so a short transcript sits against the chrome. */
+    padding: number;
+}
+/**
+ * Pick the slice of the transcript the terminal shows.
+ *
+ * `available` is the row budget the chrome left over; `reveal` is a row a fresh
+ * message wants on screen, which wins over the current scroll position. A
+ * transcript shorter than the budget is padded at the top so the prompt stays
+ * at the bottom instead of floating in the middle of the screen.
+ */
+export declare function windowTranscript<T>(input: {
+    lines: readonly string[];
+    refs: readonly (T | undefined)[];
+    available: number;
+    scrollOffset: number;
+    reveal?: T | undefined;
+}): TranscriptWindow<T>;
+export {};

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

@@ -34,16 +34,55 @@ export interface ResumableSession {
         sock: string;
         state?: string;
     };
+    /**
+     * `label` is a placeholder (the raw session id) because the log has not been
+     * inspected yet. The picker holds these back instead of painting an id that
+     * turns into a title two seconds later.
+     */
+    labelPending?: boolean;
 }
 /** `MM-DD HH:mm` local-time label for session lists. */
 export declare function formatSessionTime(timestamp: number): string;
-/** Incremental listing so the picker can paint before older logs are parsed. */
+/** Incremental listing so a caller can paint before older logs are parsed. */
 export interface ResumableSessionListing {
     /** Sessions already inspected (or restored from the disk cache). */
     sessions: ResumableSession[];
     /** Whether older logs are still being inspected. */
     pending: boolean;
 }
+/** One lazy page: everything read so far, plus what is still uninspected. */
+export interface ResumableSessionPage {
+    /** Resolved sessions in display order; a label here is never a placeholder. */
+    sessions: ResumableSession[];
+    /** Candidates not inspected yet (an upper bound on rows still to come). */
+    remaining: number;
+    /** No candidates are left to inspect. */
+    done: boolean;
+}
+/**
+ * A listing that grows on demand.
+ *
+ * The picker reads one page, paints it, and only reads on when the user reaches
+ * for older sessions. A launch used to inspect every log before the first
+ * frame, which is what made a large history feel like a hang; the first page
+ * alone also has every title resolved, so nothing on screen is ever a raw id
+ * that turns into a title a second later.
+ */
+export interface ResumableSessionPager {
+    /** Inspect onward until `size` more rows exist, or history runs out. */
+    page(size?: number): Promise<ResumableSessionPage>;
+    /** Read every remaining candidate (the `/resume` flow wants the whole list). */
+    complete(): Promise<ResumableSession[]>;
+}
+/** Sessions read before the picker's first paint, and per lazy page after it. */
+export declare const PICKER_PAGE_SIZE = 9;
+/**
+ * Open a pager over the store. Nothing is inspected until the first `page()`.
+ */
+export declare function openResumableSessionPager(persistence: object, currentId: string, options?: {
+    listHosts?: typeof listAttachableHosts;
+    indexPath?: string;
+}): Promise<ResumableSessionPager>;
 /**
  * List resumable top-level sessions, newest first.
  *
@@ -61,8 +100,9 @@ export declare function listResumableSessions(persistence: object, currentId: st
 /**
  * List resumable sessions, painting the recent page first.
  *
- * `onUpdate` fires after the priority page (cached + newest logs) and again
- * after each later inspect batch. Unchanged logs reuse `$DSH_HOME/tui-session-index.json`.
+ * `onUpdate` fires after the header sketch, after the first resolved title, and
+ * again after each later inspect batch. Unchanged logs reuse
+ * `$DSH_HOME/tui-session-index.json`.
  */
 export declare function listResumableSessionsProgressive(persistence: object, currentId: string, options?: {
     listHosts?: typeof listAttachableHosts;

package/lib/types/stats.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Session statistics: turns/steps, LLM and tool time, TTFT, decode rate, and
+ * token usage.
+ *
+ * `tui.ts` owns the rendering; this owns the arithmetic. The rules that used to
+ * live among the event handlers are what make the footer honest, so they live
+ * here with tests instead of inside a 7k-line class:
+ *
+ * - a repeated usage report for the same step replaces its sample (hosts report
+ *   usage per step more than once, and naive adding double counts),
+ * - TTFT latches on the *first* token delta of the open step,
+ * - the settled `assistant/message` packed stream wins over that latch (a
+ *   retried step would otherwise span both attempts and report a rate ~20x off),
+ * - decode rate needs a finite, non-negative output token count.
+ */
+import type { TokenUsage } from '@deepseek-ai/dsh-llm';
+export interface SessionUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export interface SessionStatsSnapshot {
+    turns: number;
+    steps: number;
+    llmMs: number;
+    toolMs: number;
+    ttftMs: number;
+    ttftSteps: number;
+    decodeMs: number;
+    decodeTokens: number;
+    usage: SessionUsage;
+}
+/** Flat view of the same numbers, for the footer's stats line. */
+export interface SessionStatsRow {
+    turns: number;
+    steps: number;
+    llmMs: number;
+    toolMs: number;
+    ttftMs: number;
+    ttftSteps: number;
+    decodeMs: number;
+    decodeTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export interface OpenStep {
+    turn: number;
+    step: number;
+}
+export declare function emptySessionUsage(): SessionUsage;
+export declare function emptySessionStats(): SessionStatsSnapshot;
+/** Flatten a snapshot into the footer's row shape. */
+export declare function statsRowOf(stats: SessionStatsSnapshot): SessionStatsRow;
+/**
+ * Accumulates the stats the footer and `/status` show as session events arrive.
+ * Every method is a no-op for events that do not apply, so callers can forward
+ * the raw event stream without checking.
+ */
+export declare class SessionStatsTracker {
+    private stats;
+    private openStep;
+    private readonly usageByStep;
+    private readonly pendingToolTimes;
+    private lastTurn;
+    /** The step a live chunk belongs to when the host frame carried none. */
+    currentStep(): OpenStep | undefined;
+    /** `step/start`: opens the clock LLM time, TTFT and decode are measured from. */
+    noteStepStart(turn: number, step: number, time: number): void;
+    /** The first token delta of the open step latches its TTFT clock. */
+    noteFirstToken(turn: number, step: number, time: number): void;
+    /** Replace one step's usage sample so a repeated report never double counts. */
+    recordUsage(turn: number, step: number, usage: TokenUsage): void;
+    /**
+     * `assistant/message`: settle the open step's LLM time, TTFT and decode rate.
+     * `firstTokenTime` is the settlement's own packed-stream answer when it has
+     * one; `undefined` falls back to the live latch.
+     */
+    settleMessage(input: {
+        turn: number;
+        step: number;
+        time: number;
+        firstTokenTime?: number | undefined;
+        outputTokens?: number | undefined;
+    }): void;
+    /** `tool/call`: start the tool clock for this call. */
+    noteToolStart(callId: string, time: number): void;
+    /** `tool/result`: add the elapsed tool time, once. */
+    noteToolEnd(callId: string, time: number): void;
+    /** `step/end`: count the step, and forget the step's usage dedupe key. */
+    noteStepEnd(turn: number, step: number): void;
+    /** `turn/end`: a tool whose result never arrived contributes nothing. */
+    noteTurnEnd(): void;
+    /** Current totals. A copy: callers cannot disturb the accumulator. */
+    snapshot(): SessionStatsSnapshot;
+}

package/lib/types/terminal-input.d.ts

@@ -0,0 +1,164 @@
+/** True when this process is talking to a terminal through SSH. */
+export declare function detectSshSession(env?: NodeJS.ProcessEnv): boolean;
+/** What a probe writes to ask the terminal where its cursor is. */
+export declare const CURSOR_POSITION_REQUEST = "\u001B[6n";
+/**
+ * How long a half-arrived reply is held before it is handed over as typing.
+ * A real sequence arrives within one read or the next; anything slower is
+ * either a very unlucky split or the start of a user's own escape key.
+ */
+export declare const INPUT_HOLD_MS = 30;
+/** A single probe answer that misses this window counts as "no reply". */
+export declare const RTT_SAMPLE_TIMEOUT_MS = 350;
+/** Wider window for the rest of the measurement once one has been missed. */
+export declare const RTT_SLOW_SAMPLE_TIMEOUT_MS = 800;
+/** Answers to collect before one is reported. */
+export declare const RTT_SAMPLE_COUNT = 3;
+/** Two answers this close already describe the link; the third is not needed. */
+export declare const RTT_AGREEMENT_MS = 6;
+/** Wall-clock ceiling for one measurement, however chatty the terminal is. */
+export declare const RTT_MEASURE_BUDGET_MS = 2500;
+/**
+ * An SSH answer that came back this much faster than the slowest sample cannot
+ * have made the round trip — it was already on the wire when we asked. Relative
+ * on purpose: `ssh localhost` honestly answers in about 2 ms.
+ */
+export declare const RTT_OUTLIER_RATIO = 0.25;
+/** Remove every complete cursor reply from `text`. */
+export declare function stripCursorReplies(text: string): {
+    text: string;
+    replies: number;
+};
+/**
+ * Drop cursor replies from a byte stream that is otherwise user input.
+ *
+ * Feed every read to `push()`; the bytes it returns are what the user actually
+ * typed. A read that ends in the middle of a possible reply is held back (see
+ * `flush()`) so `ESC [ 1` + `7;1R` cannot become visible digits either.
+ */
+export declare class TerminalInputFilter {
+    private held;
+    push(text: string): {
+        forward: string;
+        replies: number;
+    };
+    /** Release a held partial (its window passed, so it was not a reply). */
+    flush(): string;
+    /** Forget a held partial — used when the caller knows it must be stale. */
+    reset(): void;
+    get pending(): boolean;
+}
+/**
+ * The filter with the hold timer attached, for a caller that turns bytes into
+ * keystrokes (the TUI and the session picker) instead of forwarding them.
+ */
+export declare class TerminalInputGuard {
+    private readonly emit;
+    private readonly holdMs;
+    private readonly filter;
+    private timer;
+    constructor(emit: (text: string) => void, holdMs?: number);
+    /** Feed one decoded read; anything that is not a reply reaches `emit`. */
+    push(text: string): void;
+    /** Hand a half-arrived sequence over (its window passed; it is typing). */
+    release(): void;
+    /** Drop the timer and any held bytes (display detached, picker settled). */
+    stop(): void;
+}
+export interface TerminalInputPumpOptions {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+    /** Receives bytes that are real typing, never probe answers. */
+    onInput: (text: string) => void;
+    /** Link kind; defaults to the SSH environment of this process. */
+    ssh?: boolean;
+    holdMs?: number;
+    sampleTimeoutMs?: number;
+    samples?: number;
+    /** Give up sampling after this long; the attach must not wait forever. */
+    budgetMs?: number;
+    /** One line per probe attempt, for `DSH_TUI_DEBUG=1` troubleshooting. */
+    debug?: (message: string) => void;
+}
+/**
+ * stdin → replies (for the probe) + real input (for the caller).
+ *
+ * Long-lived on purpose: the relay keeps it running for the whole attachment,
+ * so a reply that arrives seconds late is dropped instead of reaching the Host.
+ */
+export declare class TerminalInputPump {
+    private readonly options;
+    private readonly filter;
+    private readonly decoder;
+    private readonly waiters;
+    /** When the last answer (accepted or not) arrived; drives the quiet wait. */
+    private lastAnswerAt;
+    /** When the last request went out; an answer may follow it for a window. */
+    private lastRequestAt;
+    /** Current answer window; widened once when the first one is missed. */
+    private windowMs;
+    /** Answers seen, used to tell "slow terminal" from "terminal never answers". */
+    private answersSeen;
+    /** Slowest sample so far; the quiet wait has to clear the worst of them. */
+    private slowestSampleMs;
+    private holdTimer;
+    private listening;
+    readonly ssh: boolean;
+    constructor(options: TerminalInputPumpOptions);
+    start(): void;
+    stop(): void;
+    /**
+     * Ask the terminal for its cursor a few times and report the round-trip that
+     * best describes the link. `undefined` means the terminal never answered in
+     * time (a dumb pipe), and the caller must not treat that as "0 ms".
+     */
+    measure(): Promise<number | undefined>;
+    /**
+     * Drop an answer that came back far too fast to have made the round trip —
+     * an answer to somebody else's request, still on the wire when we asked.
+     * Relative, not absolute (`ssh localhost` honestly answers in 2 ms), and
+     * measured against the *median*: comparing with the slowest sample would
+     * throw away three good answers because one request sat behind a repaint.
+     */
+    private dropFastOutliers;
+    /**
+     * How long the line must be quiet before the next request may go out.
+     *
+     * The only safe answer is the full sample window: a request we sent can be
+     * answered at any point inside it, so anything shorter can attribute that
+     * answer to the request that follows. Deriving it from the samples instead
+     * looks cheaper and is exactly what goes wrong — a leftover answer reports
+     * 1 ms, the window shrinks to the minimum, and the honest answer to the
+     * abandoned request lands in the *next* window (250 ms link reported as 1 ms
+     * and 0 ms, two "agreeing" samples, early stop, chip frozen on a wrong value).
+     */
+    private quietMs;
+    /**
+     * Wait until the line has been quiet for a full window, measured from the
+     * later of the last answer and the last request. An answer to a request we
+     * already gave up on lands in here and is thrown away, so it cannot be
+     * attributed to the request that follows it.
+     */
+    private quiet;
+    /**
+     * Consume what the kernel already holds, so an answer that was on its way
+     * before this request cannot be read as its answer.
+     *
+     * `read()` emits `data` for the chunk it returns whenever a listener is
+     * attached, and the listener path would then deliver the same bytes twice
+     * (a typed `hi` arrived at the Host as `hihi`). Detach for the duration of
+     * the loop: it is synchronous, so nothing can be lost in between.
+     */
+    private drain;
+    private ask;
+    private readonly onData;
+    private feed;
+    /**
+     * One reply: hand it to the oldest outstanding request. An answer that
+     * belongs to a request we already gave up on is simply dropped here — and
+     * its arrival time still restarts the quiet window, which is what keeps it
+     * from being attributed to the next request.
+     */
+    private answer;
+    private scheduleHold;
+}

package/lib/types/tui.d.ts

@@ -137,6 +137,9 @@ export declare class SshTui {
     private readonly headlessDisplay;
     private disconnectPolicy;
     private detachedIdleTimer;
+    /** Armed once an SSH drop left this Host alive with work still running. */
+    private hostKeptAlive;
+    private idleExitTimer;
     private displayDetached;
     private displayHost;
     private relayColumns;
@@ -179,17 +182,16 @@ export declare class SshTui {
     private openToolCalls;
     /** Survives result settlement so a card-less result can still be labelled. */
     private toolCallNames;
-    private readonly stats;
-    private openStepStats;
+    /** Session totals; the tracker owns the arithmetic (see `stats.ts`). */
+    private readonly statsTracker;
+    /** Snapshot of the session totals, for the footer and `/status`. */
+    private get stats();
     /** Attempt whose live `start` frame opened the current token stream. */
     private liveStreamOwner;
     /** Live events parked while the (yielding) history replay holds the floor. */
     private replayQueue;
     /** A relay claimed the display while a hangup was still cancelling/flushing. */
     private reattachedDuringHangup;
-    private readonly pendingToolTimes;
-    private readonly usageByStep;
-    private lastStatsTurn;
     private scrollOffset;
     private readonly clickableRows;
     private readonly paintedLinkHitsByRow;
@@ -201,6 +203,12 @@ export declare class SshTui {
     private streamingReasoning;
     private escapeBuffer;
     private escapeTimer;
+    /**
+     * Cursor-position replies removed from the relay's stdin stream. A launcher
+     * from an older release (or a reply that raced its own probe) would otherwise
+     * type `[17;1R` into the prompt or cancel a dialog with a bare ESC.
+     */
+    private readonly inputGuard;
     private thinkingStartedAt;
     private waitStartedAt;
     private completionSignaled;
@@ -256,6 +264,19 @@ export declare class SshTui {
     private detachedIdleMs;
     private clearDetachedIdleTimer;
     private armDetachedIdleTimer;
+    /**
+     * How long a leftover, finished Host may sit with no display before it exits
+     * and hands the session back. `0` disables the exit (legacy behavior).
+     */
+    private idleExitMs;
+    private clearIdleExitTimer;
+    /**
+     * Arm the exit for a Host a busy SSH drop left behind. Called when the agent
+     * goes idle — the reason the Host was kept is gone, and every second it stays
+     * is a second its `session.lock` keeps the browser surface from opening the
+     * session (`resume failed for session "…"`). A reattach cancels it.
+     */
+    private armIdleExitTimer;
     private isCompactView;
     /** Test helper: switch the workspace view without going through /view. */
     setWorkspaceView(view: WorkspaceView): void;
@@ -282,6 +303,12 @@ export declare class SshTui {
     detachDisplay(): void;
     /** Restore the terminal and drop event wiring. Does not flush or exit. */
     dispose(): Promise<void>;
+    /**
+     * `/diag`: collect the local facts about this session's channel, lock, and
+     * Host, then print the decision chain. Everything is local; nothing is sent
+     * anywhere (see the privacy note in the README).
+     */
+    private runDiagCommand;
     /** Human-facing exit with goodbye and flush; called from key handling. */
     requestExit(code: number): Promise<void>;
     /**
@@ -346,7 +373,6 @@ export declare class SshTui {
     private beginWait;
     private endWait;
     private waitCardSource;
-    private planShouldDefaultExpand;
     private findSubagentRow;
     private findLivePlanRow;
     /** Older / finished plans stay in the scrolling transcript. */
@@ -386,8 +412,6 @@ export declare class SshTui {
     private suggestionsVisible;
     private currentProviderId;
     private currentSelectionLabel;
-    /** Replace one step's usage sample so a repeated report never double counts. */
-    private recordUsage;
     /** Compact session stats groups for the first footer row. */
     private statsText;
     /** Refresh the terminal window title (throttled while running). */
@@ -569,6 +593,7 @@ export declare class SshTui {
     private resolveSuperGrokToken;
     private fetchJson;
     private readonly handleData;
+    private handleInputText;
     /** Handle one data chunk that may contain bracketed-paste markers. */
     private processPasteChunk;
     /** Insert pasted text into the input buffer; CR/LF are literal newlines. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ssh-tui",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "description": "SSH-friendly interactive terminal TUI plugin for DeepSeek Harness",
   "keywords": [
     "deepseek-harness",
@@ -64,9 +64,12 @@
         "0.1.3-alpha.2": "compatible",
         "0.1.5-alpha.1": "compatible",
         "0.1.5-alpha.2": "compatible",
-        "0.1.5-rc.1": "compatible"
+        "0.1.5-rc.1": "compatible",
+        "0.1.5-rc.2": "compatible"
       },
-      "profiles": ["tui"]
+      "profiles": [
+        "tui"
+      ]
     }
   },
   "scripts": {
@@ -102,11 +105,11 @@
     "@deepseek-ai/dsh-credentials": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
     "@deepseek-ai/dsh-llm": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
     "@deepseek-ai/dsh-session": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
+    "@deepseek-ai/dsh-session-persistence": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
     "@deepseek-ai/dsh-settings": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
     "@deepseek-ai/dsh-subagent": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
     "@deepseek-ai/dsh-user-approval": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
-    "@deepseek-ai/dsh-user-questions": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6",
-    "@deepseek-ai/dsh-session-persistence": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6"
+    "@deepseek-ai/dsh-user-questions": ">=0.1.2-rc.1 <0.1.6 || >=0.1.3-alpha.2 <0.1.6 || >=0.1.5-alpha.1 <0.1.6"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-user-approval": {
@@ -125,6 +128,7 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/cordis-plugin-loader": "^1.0.3",
+    "@deepseek-ai/dsh": "0.1.5-rc.1",
     "@deepseek-ai/dsh-agent": "0.1.5-rc.1",
     "@deepseek-ai/dsh-agent-default-model": "0.1.5-rc.1",
     "@deepseek-ai/dsh-agent-loop": "0.1.5-rc.1",
@@ -139,6 +143,7 @@
     "@deepseek-ai/dsh-invariants": "0.1.5-rc.1",
     "@deepseek-ai/dsh-jobs": "0.1.5-rc.1",
     "@deepseek-ai/dsh-llm": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-llm-mock-server": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-sandbox": "0.1.5-rc.1",
     "@deepseek-ai/dsh-sandbox-policy": "0.1.5-rc.1",
     "@deepseek-ai/dsh-scope": "0.1.5-rc.1",
@@ -155,6 +160,7 @@
     "@deepseek-ai/dsh-user-approval": "0.1.5-rc.1",
     "@deepseek-ai/dsh-user-questions": "0.1.5-rc.1",
     "@types/node": "^24.0.0",
+    "@xterm/headless": "^6.0.0",
     "semver": "^7.8.5",
     "typescript": "^5.9.0"
   }