dsh-ssh-tui 0.7.3 → 0.8.0

package/lib/types/attach.d.ts

@@ -48,6 +48,12 @@ export interface LiveHost {
     kind: 'attachable' | 'zombie';
     sock: string;
     pid: number;
+    /**
+     * The lock's own view of the session: `attached` while a display relay is
+     * connected, `paused` / `running-detached` once its window is gone. Absent on
+     * a lock written before the field existed, which must not read as "in use".
+     */
+    state?: string;
     exitWatch?: {
         dispose(): void;
         exited: Promise<number | null>;
@@ -97,6 +103,8 @@ export interface AttacherDeps {
         replaced(sessionId: string): string;
         flapping(sessionId: string): string;
         zombie(sessionId: string, pid: number): string;
+        /** Refused: a window is on this session right now (see `attachOrSpawn`). */
+        attached(sessionId: string, pid: number): string;
     };
     locksDisabled?(): boolean;
     now?(): number;

package/lib/types/auth-failure.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Where an authentication failure came from.
+ *
+ * A turn can die with `code: "AUTH"` for two very different reasons, and the
+ * difference decides what the reader should do:
+ *
+ *  - **provider**: the request left the machine and the provider (or something
+ *    between it and the model) rejected it. The local credential is present, so
+ *    changing it is the wrong move — the usual causes are a transient upstream
+ *    failure, a plan/quota limit, or a model the account may not call. Retrying
+ *    is reasonable.
+ *  - **local**: nothing usable is configured on this machine, so every request
+ *    would fail the same way. Retrying changes nothing; the key has to be set.
+ *
+ * The host reports both as `AUTH`, and the only place the difference survives is
+ * the message body — which is why this is a text classifier and why it is kept
+ * pure: the caller resolves the actual credential and decides what to say.
+ *
+ * Observed bodies (2026-09-29, command-code):
+ *   provider → `OpenAI API error (403): {"message":"Authentication failed.
+ *               Please check your credentials.","type":"permission_error"}`
+ *   provider → `403 {"type":"error","error":{"type":"permission_error",
+ *               "message":"MODEL_NOT_IN_PLAN: …"}}`
+ *   local    → `dsh-llm: no API key for provider "x" (set X_API_KEY)`
+ * A *missing* credential on that gateway answered with a 401 and its own
+ * envelope (`{"success":false,"error":{"code":"UNAUTHORIZED"}}`), which is why
+ * an HTTP status alone cannot classify this: 401 and 403 both appear on the
+ * provider side.
+ *
+ * @module dsh-ssh-tui/auth-failure
+ */
+/** Which side rejected the request. */
+export type AuthFailureOrigin = 'provider' | 'local';
+export interface AuthFailure {
+    origin: AuthFailureOrigin;
+    /** The HTTP status, when the message carried one. */
+    status?: number;
+}
+/** The HTTP status inside a host-formatted failure, if there is one. */
+export declare function statusOf(message: string): number | undefined;
+/**
+ * Classify one failure message.
+ * @param message - the failure text the host attached to the turn.
+ * @returns the origin (and status when known), or undefined when the message
+ *   says nothing about authentication — an unrelated failure keeps its own row
+ *   and gets no advice.
+ */
+export declare function classifyAuthFailure(message: string): AuthFailure | undefined;

package/lib/types/commands.d.ts

@@ -39,6 +39,12 @@ export declare const LOCAL_COMMANDS: readonly [{
 }, {
     readonly name: "disconnect";
     readonly key: "cmd.disconnect";
+}, {
+    readonly name: "retryauth";
+    readonly key: "cmd.retryauth";
+}, {
+    readonly name: "notify";
+    readonly key: "cmd.notify";
 }, {
     readonly name: "approval";
     readonly key: "cmd.approval";

package/lib/types/diag.d.ts

@@ -38,6 +38,8 @@ export interface DiagSnapshot {
         title: boolean;
         /** `DSH_TUI_TERM_CAPS` tokens that were rejected (typos), for the row. */
         ignoredOverrides: readonly string[];
+        /** Chrome is being drawn in ASCII because the console cannot decode UTF-8. */
+        ascii: boolean;
     };
     /**
      * What the palette resolved to and which hints decided it. A "no colour on

package/lib/types/dialogs.d.ts

@@ -55,6 +55,22 @@ export interface InspectDialog {
     subagentSessionId?: string;
     /** `/find` already scrolled to its hit here; later repaints keep the offset. */
     searchRevealed?: boolean;
+    /**
+     * What the copy key takes while this overlay is up.
+     *
+     * The reader asked to see this body full-screen, so the body is what they
+     * mean by "copy this" — the overlay has no input line, and `/copy` typed at
+     * the prompt is covered by it. Undefined falls back to whatever is selected
+     * behind the overlay, which is the card the reader opened to get here.
+     */
+    copyText?: string;
+    /**
+     * Confirmation line shown in place of the key hint after an in-overlay copy.
+     *
+     * The notice row the copy also pushes is behind this screen, and silence after
+     * a clipboard write is the one thing that reads as a failure.
+     */
+    notice?: string;
 }
 export type Dialog = ConfirmDialog | QuestionDialog | OnboardingDialog | InspectDialog;
 export interface DialogAnswer {

package/lib/types/display-sock.d.ts

@@ -5,6 +5,29 @@ export declare const FRAME_HELLO = 4;
 export declare const FRAME_GOODBYE = 5;
 export declare const FRAME_RTT = 6;
 export declare const FRAME_REPLACED = 7;
+/** Host → relay: round-trip your terminal now and say what it answered. */
+export declare const FRAME_PROBE = 8;
+/** Relay → Host: the answer to {@link FRAME_PROBE}. */
+export declare const FRAME_PROBE_REPLY = 9;
+/** A prober → Host: is a window *really* on this session? Does not claim it. */
+export declare const FRAME_QUERY = 10;
+/** Host → prober: the answer to {@link FRAME_QUERY}. */
+export declare const FRAME_QUERY_REPLY = 11;
+/**
+ * What a relay's own terminal round trip said.
+ *
+ * `live` — the terminal answered just now, so somebody has a screen in front of
+ *   them. `silent` — it answered when this relay attached and does not answer
+ *   now: that window is gone. The distinction is the whole point: a cut SSH link
+ *   leaves the launcher *connected* (it sees no hangup until sshd does, which
+ *   can be hours with TCP keepalive), so the socket alone cannot tell a live
+ *   window from a dead one — only the far end can. `unknown` — it never answered
+ *   (a pipe, a dumb terminal, or a link that was already dead at attach), and
+ *   silence must not be read as an answer.
+ */
+export type TerminalVerdict = 'live' | 'silent' | 'unknown';
+/** What a Host tells a prober about the window on its session. */
+export type AttachmentVerdict = 'attached' | 'detached' | 'unknown';
 /**
  * Drop launcher SIGTERM/SIGINT/SIGHUP so closing SSH cannot dispose the tree
  * before hangup handling. Leaving the session with setsid() is best-effort:
@@ -89,6 +112,12 @@ export declare function decodeResize(payload: Buffer): {
 } | undefined;
 export declare function encodeRtt(rttMs: number | undefined): Buffer;
 export declare function decodeRtt(payload: Buffer): number | undefined;
+export declare function encodeProbe(): Buffer;
+export declare function encodeProbeReply(verdict: TerminalVerdict): Buffer;
+export declare function decodeProbeReply(payload: Buffer): TerminalVerdict;
+export declare function encodeQuery(): Buffer;
+export declare function encodeQueryReply(verdict: AttachmentVerdict): Buffer;
+export declare function decodeQueryReply(payload: Buffer): AttachmentVerdict;
 /** Incremental decoder for one socket. */
 export declare class FrameReader {
     private buffer;
@@ -113,19 +142,45 @@ export interface DisplayHostHandlers {
 export declare class DisplayHost {
     readonly path: string;
     private readonly handlers;
-    /** Test seam: how long a silent connection may wait for its HELLO. */
+    /** Test seams: how long a silent connection may wait for its HELLO, and
+     *  how long a relay may take to report its terminal round trip. */
     private readonly options;
     private server;
     private socket;
     private reader;
     attached: boolean;
+    /** Set while a {@link FRAME_PROBE} round trip is waiting for its answer. */
+    private probeSettle;
+    private probeInFlight;
     constructor(path: string, handlers: DisplayHostHandlers, 
-    /** Test seam: how long a silent connection may wait for its HELLO. */
+    /** Test seams: how long a silent connection may wait for its HELLO, and
+     *  how long a relay may take to report its terminal round trip. */
     options?: {
         helloGraceMs?: number;
+        probeTimeoutMs?: number;
     });
     listen(): Promise<void>;
     private accept;
+    /**
+     * Whether a window is really on this session — asked of the window itself.
+     *
+     * "The socket answers" is not evidence. A relay whose SSH link was cut stays
+     * connected (its launcher sees no hangup until sshd does), and the Host then
+     * truthfully reports a display that no longer has a screen behind it. Only the
+     * far end can settle it, so this round-trips the terminal through the relay.
+     */
+    attachmentVerdict(): Promise<AttachmentVerdict>;
+    /** One answer to one prober; never claims the display, never throws. */
+    private answerQuery;
+    /**
+     * Ask the claimed relay to round-trip its terminal, with a deadline.
+     *
+     * Sharing one in-flight round trip matters: a second question while the first
+     * is unanswered would be settled by the first reply, and two windows asking at
+     * once is a normal resume, not an error.
+     */
+    private probeTerminal;
+    private settleProbe;
     sendStdout(bytes: Buffer | string): boolean;
     sendGoodbye(): void;
     close(): Promise<void>;
@@ -142,6 +197,24 @@ export declare class DisplayHost {
  * it without stealing the display.
  */
 export declare function displaySockExists(path: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * How long a prober waits for the Host's answer to {@link FRAME_QUERY}.
+ *
+ * It has to cover the relay's own two probe windows (see
+ * {@link DISPLAY_PROBE_TIMEOUT_MS}) plus the hop; the answer only takes this
+ * long when the display really is silent.
+ */
+export declare const DISPLAY_QUERY_TIMEOUT_MS = 4000;
+/**
+ * Ask a live Host whether a window is really on its session.
+ *
+ * `undefined` means the Host did not answer — an older Host that does not know
+ * the frame, or one whose event loop is stuck. Every caller must read that as
+ * "cannot tell" and never as "free": the cost of the doubt is one confirmation
+ * prompt, and the cost of guessing wrong is taking a session away from a window
+ * somebody is still typing in.
+ */
+export declare function queryDisplayAttachment(path: string, timeoutMs?: number): Promise<AttachmentVerdict | undefined>;
 /** Watches a freshly spawned Host so a crash is reported immediately. */
 export interface HostExitWatch {
     /** Resolves with the exit code (or null when killed) once the Host exits. */
@@ -271,6 +344,9 @@ export interface DisplayRelayOptions {
     signals?: Pick<NodeJS.Process, 'on' | 'off' | 'removeListener'>;
     /** Link kind for the RTT probe; defaults to this process's SSH env. */
     ssh?: boolean;
+    /** Re-measure cadences (tests); defaults to {@link RTT_RECHECK_FIRST_MS} / {@link RTT_RECHECK_MS}. */
+    rttFirstRecheckMs?: number;
+    rttRecheckMs?: number;
     /** Typing captured before this relay existed; sent to the Host after HELLO. */
     seed?: string;
     /**

package/lib/types/dsh-compat.d.ts

@@ -14,23 +14,55 @@ import type { ContextFormed } from '@deepseek-ai/dsh-llm';
 import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
 import type z from '@deepseek-ai/schemastery';
+/**
+ * The source kind this plugin declares for the messages it commits itself: the
+ * plan-close nudge and the approval-denied steering notice.
+ *
+ * These used to ride the released catch-all wrapper —
+ * `<kind: 'plugin', plugin: 'dsh-ssh-tui'>` — which 0.1.5 shipped as a member and
+ * 0.1.7 deleted ("each producer declares its own `kind` in its own module; there
+ * is no shared catch-all `plugin` kind"). Worse than missing on 0.1.7: its V4
+ * native admission *refuses* the wrapper outright, so an append under that
+ * spelling throws "format v4 message requires a producer-owned source kind" and
+ * takes the whole turn down with it — which is what the plan nudge and the
+ * approval-denied notice did to any turn they fired in on a V4 session.
+ *
+ * The producer-owned spelling is the one shape both supported lines admit: the
+ * wrapper was only ever mandatory for `system/message` (`SystemMessage['source']`
+ * is the `plugin` member on 0.1.5), while user-role messages have always carried
+ * a producer's own kind — the 0.1.5 line's own `goal`, `webhook`, and
+ * `agent-instructions` producers all commit `kind: '<their name>'`.
+ */
+export declare const TUI_SOURCE_KIND = "dsh-ssh-tui";
 declare module '@deepseek-ai/dsh-llm' {
-    /**
-     * The TUI's own notice/steering messages, which it commits to the durable log
-     * with `source.kind === 'plugin'`.
-     *
-     * 0.1.5 shipped this member; 0.1.7 removed the catch-all and documents the
-     * intended pattern instead — "each producer declares its own `kind` in its
-     * own module". This is that declaration, and it keeps the committed log shape
-     * identical on both lines.
-     */
     interface MessageSourceMap {
-        plugin: {
-            kind: 'plugin';
-            plugin: string;
+        'dsh-ssh-tui': {
+            kind: 'dsh-ssh-tui';
         } & ContextFormed;
     }
 }
+/**
+ * The kind the V3-to-V4 lane gives the same messages in a converted log.
+ *
+ * The conversion lifts a released plugin wrapper to the producer's kind when it
+ * knows the plugin, and falls back to `plugin:<name>` when it does not — which is
+ * this plugin's case, so a resumed V3 session carries the prefixed spelling.
+ */
+export declare const TUI_CONVERTED_SOURCE_KIND = "plugin:dsh-ssh-tui";
+/**
+ * Whether a durable message source came from this plugin.
+ *
+ * Three spellings reach a reader: the producer-owned kind written now, the
+ * `plugin:`-prefixed compatibility kind the V3-to-V4 conversion assigns, and the
+ * original wrapper (`kind: 'plugin'` + `plugin: 'dsh-ssh-tui'`) that a log
+ * committed before this change — or an unconverted V3 file read on the 0.1.5
+ * line — still carries.
+ *
+ * @param kind - the source's `kind`, when it has one.
+ * @param plugin - the source's legacy `plugin` field, when it carries the wrapper.
+ * @returns whether this plugin produced the message.
+ */
+export declare function isTuiMessageSource(kind: unknown, plugin?: unknown): boolean;
 /**
  * Settings namespaces are branded strings at the type level on both supported
  * lines; this cast supplies the brand from a plain literal.

package/lib/types/i18n/index.d.ts

@@ -16,7 +16,7 @@ export declare const UI_LOCALE_NAMESPACE: import("@deepseek-ai/dsh-settings").Se
  * Every field is live: on 0.1.7 the section *is* this form, and only volatile
  * paths may be written (see {@link liveField}).
  */
-export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<{
+export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<NoInfer<{
     language: z<string>;
     skipUpdate: z<string>;
     view: z<string>;
@@ -24,7 +24,12 @@ export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<{
     autoApproval: z<string>;
     /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
     idleExit: z<number>;
-}>, Schemastery.ObjectT<{
+    /**
+     * Command run once when a question starts waiting and nobody is attached.
+     * Empty means off. See `question-wait.ts` for the environment it receives.
+     */
+    notify: z<string>;
+}>>, Schemastery.ObjectT<NoInfer<{
     language: z<string>;
     skipUpdate: z<string>;
     view: z<string>;
@@ -32,7 +37,12 @@ export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<{
     autoApproval: z<string>;
     /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
     idleExit: z<number>;
-}>>;
+    /**
+     * Command run once when a question starts waiting and nobody is attached.
+     * Empty means off. See `question-wait.ts` for the environment it receives.
+     */
+    notify: z<string>;
+}>>, "plain">;
 export declare function localeFromTag(tag: string): Locale | undefined;
 /** Pick zh/en from env, optionally after a saved settings value. */
 export declare function resolveLocale(env?: NodeJS.ProcessEnv, saved?: string): Locale;

package/lib/types/index.d.ts

@@ -46,6 +46,12 @@ export interface Config {
     autoApproval?: string;
     /** Milliseconds a leftover finished Host waits before exiting; 0 = never. */
     idleExit?: number;
+    /**
+     * Retry once when the *provider* rejects a request with 401/403 while a local
+     * credential is configured (see `auth-failure.ts`). Off by default: the retry
+     * re-sends the whole context, which in a long session is expensive.
+     */
+    retryProviderAuth?: boolean;
 }
 /** Every field above, as schemastery resolves them (all optional). */
 interface ConfigFields {
@@ -65,6 +71,7 @@ interface ConfigFields {
     disconnect?: string;
     autoApproval?: string;
     idleExit?: number;
+    retryProviderAuth?: boolean;
 }
 /**
  * The entry's schema. Everything a launch supplies (`config:` in

package/lib/types/paint.d.ts

@@ -37,6 +37,27 @@ export declare function ignoreFurtherHangupSignals(): void;
 export declare function waitUntilIdleOrTimeout(isIdle: () => boolean, timeoutMs: number, now?: () => number, wait?: (ms: number) => Promise<void>): Promise<'idle' | 'timeout'>;
 /** Map a CSI-6n round-trip to a paint cadence. Unknown RTT uses the SSH default. */
 export declare function paintIntervalForRtt(rttMs: number | undefined): number;
+/**
+ * How many measurements the link's reported round-trip is taken over.
+ *
+ * Three is the smallest window where one outlier cannot move the answer and two
+ * agreeing measurements can.
+ */
+export declare const RTT_HISTORY = 3;
+/**
+ * The link's current round-trip, from the last few measurements.
+ *
+ * The median — not the latest, not the mean. The probe shares the wire with the
+ * paint it is measuring, so a single burst can read like an overloaded link, and
+ * because the cadence *and* the per-frame byte budget follow this number, one
+ * bad measurement used to sit on the footer chip (and in the paint budget) for
+ * the rest of the session. A median ignores one outlier, follows a real change
+ * as soon as two measurements agree, and averages the pair in between so the
+ * chip does not jump.
+ * @param samples - measured round-trips, oldest first; non-finite ones ignored.
+ * @returns the median in whole milliseconds, or undefined with nothing to go on.
+ */
+export declare function medianRtt(samples: readonly number[]): number | undefined;
 export declare function paintLinkLabel(kind: PaintLinkKind, intervalMs: number, probed: boolean): string;
 export type LinkQuality = 'local' | 'good' | 'ok' | 'slow' | 'poor' | 'unknown';
 /** Signal-bar quality from a measured SSH round-trip, or local TTY. */

package/lib/types/picker.d.ts

@@ -44,6 +44,18 @@ export interface SessionPickerState {
     loading?: boolean;
     /** Sessions in history that have not been read yet. */
     more?: number;
+    /**
+     * A row whose session another window is attached to, waiting for the user to
+     * confirm. Submitting such a row does not attach on its own: the lock says a
+     * window is on that session, and attaching kicks that window. The note under
+     * the row cannot prove the window is still alive, so the picker asks once
+     * instead of either refusing forever or silently stealing the session.
+     */
+    confirmTakeover?: {
+        id: string;
+        sock: string;
+        pid: number;
+    };
 }
 /** One key / control action against {@link SessionPickerState}. */
 export type SessionPickerAction = {
@@ -89,6 +101,16 @@ export type SessionPickerStep = {
 export declare function sessionSearchHaystack(session: ResumableSession): string;
 /** Whether one session matches a whitespace-separated query (every token). */
 export declare function sessionMatchesQuery(session: ResumableSession, query: string): boolean;
+/**
+ * Whether a live Host is holding this session in a window *right now*.
+ *
+ * The lock's `state` is written by the Host: `attached` while a display relay is
+ * connected, `paused` / `running-detached` once the window is gone (a dropped
+ * link, a closed window) and the Host stayed behind. Only an explicit
+ * `attached` counts — a lock from before the field existed has no state, and
+ * treating "unknown" as "in use" would block a resume that used to work.
+ */
+export declare function sessionAttachedElsewhere(session: ResumableSession): boolean;
 /** Sessions still visible under the current filter, in list order. */
 export declare function filterResumableSessions(sessions: readonly ResumableSession[], query: string): ResumableSession[];
 /** Keep `cursor` inside `[0, total)`. Empty lists pin to 0. */

package/lib/types/platform.d.ts

@@ -213,3 +213,25 @@ export declare function restrictPathToUserSync(path: string, options?: {
     mode: number;
     directory?: boolean;
 } & RestrictDeps): boolean;
+/**
+ * Whether the terminal in front of us can paint UTF-8 at all.
+ *
+ * The chrome this TUI draws — rules, status dots, the warning glyph — is
+ * Unicode. A console whose output code page is not UTF-8 (a legacy Windows
+ * console left on CP936 or CP437) and a POSIX locale that is not UTF-8 both
+ * render those bytes as mojibake, which is worse than plain ASCII: the frame
+ * still has to line up. This answers only "can it decode UTF-8", never "which
+ * terminal", so the capability table stays where it is.
+ *
+ * The decision is read from the environment, which is all a portable test can
+ * assert: `DSH_TUI_ASCII=1` forces the fallback and `=0` forbids it; otherwise
+ * a locale naming a non-UTF-8 charset (or the bare `C` / `POSIX`) opts in,
+ * and so does a Windows console whose output code page is recorded as anything
+ * but 65001. An unset locale is left alone — a UTF-8 SSH session often exports
+ * nothing, and guessing "ASCII" there would strip the chrome from the audience
+ * this TUI is built for.
+ * @param env - the environment to read (tests pass their own).
+ * @param platform - the platform the decision is for.
+ * @returns true when chrome must be drawn in ASCII.
+ */
+export declare function asciiFallbackEnabled(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;

package/lib/types/preset-rows.d.ts

@@ -7,8 +7,8 @@
  * STORE accepts additive rows with plugin-owned ids and no `@deepseek-ai/*`
  * module names. The profile's user layer is the supported home for the row, so
  * both the install script and the running TUI write the same block here — the
- * TUI needs it because `dsh plugin add dsh-ssh-tui@latest` (the in-app update
- * path) never runs `scripts/`, which npm installs do not ship.
+ * TUI needs it because the in-app update (`dsh plugin add`, at whatever version)
+ * never runs `scripts/`, which npm installs do not ship.
  *
  * The roster is not cosmetic: without it `/mode` cannot switch, and the tools
  * the shipped presets own (`ask_user_question`, `present`, PTC's presentation)
@@ -42,11 +42,15 @@ export declare const ROSTER_ROWS: readonly RosterRow[];
  * per-session declarations a surface mounts (`@deepseek-ai/dsh-agent-preset`
  * rows over the `agent-preset-registry` service), and `dsh-base` keeps the
  * agent-plane rows enabled for the TUI, which is single-session and composes
- * its agent process-wide. What the base does *not* mount are the three rows the
- * shipped standard preset owns beyond it — the persona prompt, and the
- * `ask_user_question` / `present` tools — so those are what a TUI profile adds.
- * Written verbatim as upstream's own `dsh-web-app/presets/standard.patch.yml`
- * declares them, minus the rows the base already carries.
+ * its agent process-wide. Beyond the base, upstream's standard preset declares a
+ * persona and these two tools. Only the tools are mounted here: a *preset* is an
+ * agent scope, but a profile is not one, and `@deepseek-ai/dsh-persona`
+ * registers the two prompt sections `dsh-system-prompt` already owns at this
+ * layer — the loader rejects the row ("prompt section
+ * \"deployment:persona-prefix\" is already registered") and one entry then
+ * silently never activates. The deployment persona this line ships with is
+ * `dsh-system-prompt`'s own empty default, which is what a profile is meant to
+ * use unless it deliberately sets one.
  */
 export declare const FORMS_ROWS: readonly RosterRow[];
 /** The rows one host line's profile has to mount. */
@@ -56,11 +60,15 @@ export declare const ALL_ROSTER_ROWS: readonly RosterRow[];
 /** The comment header the block introduces itself with, in both writers. */
 export declare const ROSTER_PATCH_HEADER = "# dsh-ssh-tui /mode: the agent-preset roster (standard / minimal / PTC /\n# cordis, plus every preset under $DSH_HOME/.agent-presets) and the two host\n# services the shipped presets need. dsh-base composes no roster in a terminal\n# profile, and a third-party bundle patch may not mount an @deepseek-ai row, so\n# the profile's user layer owns them.\n";
 /** The same header on a host that composes its agent process-wide. */
-export declare const FORMS_PATCH_HEADER = "# dsh-ssh-tui: the agent-plane rows a 0.1.7 terminal profile mounts for itself.\n# That line composes the agent process-wide (presets are a per-session Web\n# feature now), and dsh-base already carries every row the standard preset\n# needs except these three: the persona prompt and the ask_user_question /\n# present tools. The profile's user layer owns them.\n";
+export declare const FORMS_PATCH_HEADER = "# dsh-ssh-tui: the agent-plane rows a 0.1.7 terminal profile mounts for itself.\n# That line composes the agent process-wide (presets are a per-session Web\n# feature now), and dsh-base already carries the rest of what the standard\n# preset declares: dsh-system-prompt owns the persona sections at this layer, so\n# only the two tools are left to mount. @deepseek-ai/dsh-persona is deliberately\n# absent \u2014 mounting it here collides with those sections and never activates.\n";
 /** The header for one host line. */
 export declare function rosterPatchHeader(generation: HostGeneration): string;
-/** One top-level `- insert:` entry mounting exactly these rows. */
-export declare function rosterInsertEntry(rows: readonly RosterRow[]): string;
+/**
+ * The entries one host line's rows need: a single `- insert:` list.
+ * @param rows - the rows to write.
+ * @returns the YAML text, ending in a newline.
+ */
+export declare function rosterEntriesText(rows: readonly RosterRow[]): string;
 /**
  * The exact profile patch block that mounts the roster and the two host
  * services the shipped presets need. `scripts/ensure-profile-rows.sh` carries