dsh-ssh-tui 0.7.2 → 0.7.4

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

@@ -10,23 +10,39 @@ import type { Context } from '@deepseek-ai/cordis';
 export type Locale = 'zh' | 'en';
 export type MessageVars = Record<string, string | number>;
 export declare const UI_LOCALE_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
-export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<{
-    language: z<string, string>;
-    skipUpdate: z<string, string>;
-    view: z<string, string>;
-    disconnect: z<string, string>;
-    autoApproval: z<string, string>;
+/**
+ * Fields `/language`, `/view`, `/disconnect` and `/autoapproval` persist.
+ *
+ * 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<NoInfer<{
+    language: z<string>;
+    skipUpdate: z<string>;
+    view: z<string>;
+    disconnect: z<string>;
+    autoApproval: z<string>;
     /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
-    idleExit: z<number, number>;
-}>, Schemastery.ObjectT<{
-    language: z<string, string>;
-    skipUpdate: z<string, string>;
-    view: z<string, string>;
-    disconnect: z<string, string>;
-    autoApproval: z<string, string>;
+    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>;
+}>>, Schemastery.ObjectT<NoInfer<{
+    language: z<string>;
+    skipUpdate: z<string>;
+    view: z<string>;
+    disconnect: z<string>;
+    autoApproval: z<string>;
     /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
-    idleExit: z<number, number>;
-}>>;
+    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

@@ -6,6 +6,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 export { ATTACH_RECOVERY_WINDOW_MS, attachPeerVanished } from './attach.js';
+import z from '@deepseek-ai/schemastery';
 export declare const name = "ssh-tui";
 /** Core services required before the terminal channel can drive an agent. */
 export declare const inject: string[];
@@ -27,7 +28,51 @@ export interface Config {
     model?: string;
     /** Minimum milliseconds between paints; see DSH_TUI_PAINT_MS. */
     paintIntervalMs?: number;
+    /**
+     * The fields below are the TUI's live settings, i.e. the `ssh-tui` section.
+     * They ride on this entry's schema so 0.1.7 can project a form for it — and so
+     * a pre-0.1.7 `$DSH_HOME/settings.yaml` `ssh-tui:` section is imported into
+     * this entry rather than left behind.
+     */
+    /** UI language (`/language`); zh unless the environment says otherwise. */
+    language?: string;
+    /** Newest plugin version whose update notice was dismissed. */
+    skipUpdate?: string;
+    /** Workspace pane layout (`/view`). */
+    view?: string;
+    /** What a dropped display does (`/disconnect`). */
+    disconnect?: string;
+    /** Auto-approval mode (`/autoapproval`). */
+    autoApproval?: string;
+    /** Milliseconds a leftover finished Host waits before exiting; 0 = never. */
+    idleExit?: number;
 }
+/** Every field above, as schemastery resolves them (all optional). */
+interface ConfigFields {
+    sessionId?: string;
+    showReasoning?: boolean;
+    maxToolOutputLines?: number;
+    color?: boolean;
+    welcome?: string;
+    resume?: boolean;
+    resumePicker?: boolean;
+    provider?: string;
+    model?: string;
+    paintIntervalMs?: number;
+    language?: string;
+    skipUpdate?: string;
+    view?: string;
+    disconnect?: string;
+    autoApproval?: string;
+    idleExit?: number;
+}
+/**
+ * The entry's schema. Everything a launch supplies (`config:` in
+ * `cordis.patch.yml`, including its `!!js` expressions) stays ordinary,
+ * non-live configuration; the TUI's own settings are the live fields, which is
+ * what makes them visible to, and writable through, the 0.1.7 settings service.
+ */
+export declare const Config: z<ConfigFields>;
 /**
  * Mount the SSH TUI. The `main` agent is created here after the loader
  * settles, reading the saved default provider/model from

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

@@ -11,6 +11,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { openResumableSessionPager, type ResumableSession } from './session-list.js';
+import { type TerminalCapabilities } from './terminal-caps.js';
 /** What the launch picker decided. */
 export type SessionPickerResult = {
     kind: 'resume';
@@ -43,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 = {
@@ -88,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. */
@@ -144,5 +167,7 @@ export interface SessionPickerOptions {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
     openPager?: typeof openResumableSessionPager;
+    /** The terminal to act on; defaults to reading the environment (tests inject). */
+    terminalCaps?: TerminalCapabilities;
 }
 export declare function showSessionPicker(ctx: Context, color: boolean, signal?: AbortSignal, options?: SessionPickerOptions): Promise<SessionPickerResult>;

package/lib/types/platform.d.ts

@@ -22,21 +22,125 @@ export declare function usesProcessIdentity(platform?: NodeJS.Platform): boolean
  * POSIX wants `detached: true` (setsid) so the Host survives the launcher and a
  * hung-up terminal.
  *
- * Windows is the opposite: `detached: true` maps to DETACHED_PROCESS, which
- * gives the Host **no console at all**, and Windows ignores CREATE_NO_WINDOW
- * (what `windowsHide` sets) when DETACHED_PROCESS is present. Every console
- * child the Host then starts — each tool call, every shell, node, git — has to
- * allocate its own console, which is a visible window flashing over the TUI.
- * Dropping `detached` there lets `windowsHide` do its job: the Host gets its
- * own invisible console, and descendants inherit it instead of creating one.
- * The Host still outlives the launcher: Windows does not kill children with
- * their parent, and its console is its own, so closing the user's terminal does
- * not reach it either.
+ * Windows is the opposite, and the trade-off is forced: `detached: true` maps to
+ * DETACHED_PROCESS, and Windows ignores CREATE_NO_WINDOW (what `windowsHide`
+ * sets) when DETACHED_PROCESS is present. Every console child the Host then
+ * starts — each tool call, every shell, node, git — allocates its own console,
+ * which is a visible window flashing over the TUI. So the Host is spawned
+ * non-detached and inherits the launcher's console; descendants inherit it too
+ * instead of creating one.
+ *
+ * The price *was* on the lifecycle side, and it was measured (on the Windows CI
+ * leg by `scripts/tui-mock-probe.mjs --busy`, not reasoned about): libuv assigns
+ * a non-detached child to its global job object, which is created with
+ * KILL_ON_JOB_CLOSE. The launcher died, the job closed, and the Host was
+ * terminated with it — a closed terminal window ended the session's compute.
+ *
+ * This function still returns `detached: false` there, because it describes a
+ * *direct* spawn, and a direct spawn cannot have both properties: Node exposes
+ * `detached` (DETACHED_PROCESS, which makes Windows ignore CREATE_NO_WINDOW) and
+ * `windowsHide`, but not `CREATE_NEW_CONSOLE`. The way out is to not spawn the
+ * Host directly on Windows: {@link hostBootstrapCommand} starts it through the
+ * OS PowerShell, which *can* ask for a new console and hide it. This direct path
+ * stays as the fallback for a Windows box without PowerShell.
  */
 export declare function hostSpawnOptions(platform?: NodeJS.Platform): {
     detached: boolean;
     windowsHide: boolean;
 };
+/**
+ * The Windows PowerShell that ships with the operating system.
+ *
+ * `powershell.exe` and not `pwsh.exe`: the latter is PowerShell 7, an optional
+ * install, while 5.1 is part of Windows 10/11. `%SystemRoot%` is where it lives
+ * (`%windir%` is the legacy spelling of the same thing); when neither is set
+ * there is nothing to find, and the caller falls back to a direct spawn.
+ */
+export declare function windowsPowerShellPath(env?: NodeJS.ProcessEnv): string | undefined;
+/** A PowerShell single-quoted literal; `''` is the only escape inside one. */
+export declare function psQuote(value: string): string;
+/**
+ * Quote one argv array into a Windows command line, the way `CreateProcess`
+ * parses it back (the rule from "Everyone quotes command line arguments the
+ * wrong way"): wrap in double quotes when the argument is empty or contains
+ * whitespace or a quote, double the backslashes that precede a quote, and double
+ * trailing backslashes before the closing quote. `Start-Process -ArgumentList`
+ * joins its array with spaces and adds no quoting of its own, so the line has to
+ * be right before it is handed over — a `DSH_HOME` with a space in it is the
+ * normal case, not the exotic one.
+ */
+export declare function windowsCommandLine(argv: string[]): string;
+/** `-EncodedCommand` wants base64 of UTF-16LE, which is also what dodges quoting. */
+export declare function encodePowerShellCommand(script: string): string;
+/**
+ * The bootstrap script: start the Host with **its own console, hidden**, and
+ * print its pid so the launcher can watch it.
+ *
+ * `Start-Process -WindowStyle Hidden` is the only way to ask for this from a
+ * Node process. It is ShellExecuteEx/CreateProcess with `CREATE_NEW_CONSOLE` and
+ * `SW_HIDE`: the Host gets a console of its own, so closing the user's terminal
+ * no longer takes it down, and that console is invisible, so the tool calls that
+ * inherit it do not flash. `-PassThru` gives the object whose `Id` is printed;
+ * `-RedirectStandardError` keeps the Host's stderr log, which the direct spawn
+ * used to feed through an inherited fd.
+ *
+ * The whole script travels as an encoded command, so nothing in it is ever
+ * re-parsed by a shell.
+ */
+export declare function hiddenConsoleHostScript(options: {
+    execPath: string;
+    argv: string[];
+    /** Where the Host's stderr goes; omitted only in tests. */
+    stderrFile?: string;
+    /** Where the Host's pid is written for the launcher to read. */
+    pidFile: string;
+}): string;
+/**
+ * Set on the Host's environment by the bootstrap below, through
+ * {@link bootstrapEnv}.
+ *
+ * The Host cannot ask whether it has a console of its own — Node exposes no such
+ * question — so the launcher tells it. That is what lets the one build where the
+ * lifecycle promise does not hold (Windows, no PowerShell, direct child) say so
+ * at boot instead of letting the user discover it by closing the window.
+ */
+export declare const TUI_HOST_START_ENV = "DSH_TUI_HOST_START";
+/** Marker value for a Host started with a hidden console of its own. */
+export declare const TUI_HOST_START_BOOTSTRAP = "hidden-console";
+/** The environment the bootstrap hands to the Host: the marker is added here. */
+export declare function bootstrapEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * Whether this Host survives its terminal being closed.
+ *
+ * POSIX always does (`setsid`); Windows does exactly when the bootstrap started
+ * it. A Windows Host without the marker is the fallback direct child, which
+ * libuv's `KILL_ON_JOB_CLOSE` job takes down with the launcher — the one case
+ * worth a boot notice.
+ */
+export declare function hostHasOwnConsole(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/** How the Host is started when it must not be a direct child. */
+export interface HostBootstrapCommand {
+    command: string;
+    args: string[];
+}
+/**
+ * The hidden-console bootstrap for this platform, or `undefined` when the Host
+ * should be spawned directly.
+ *
+ * Windows only, and only when the OS PowerShell is really there: the caller
+ * falls back to {@link hostSpawnOptions}, which keeps the boot working (without
+ * the survival property) on a machine where PowerShell is missing or blocked.
+ * `exists` is injectable so the decision is assertable on Linux.
+ */
+export declare function hostBootstrapCommand(options: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    exists?: (path: string) => boolean;
+    execPath: string;
+    argv: string[];
+    stderrFile?: string;
+    pidFile: string;
+}): HostBootstrapCommand | undefined;
 /**
  * A path a human can read, with the platform's own shorthand.
  *
@@ -48,3 +152,86 @@ export declare function displayHomePath(home: string, file: string, options?: {
     env?: NodeJS.ProcessEnv;
     userHome?: string;
 }): string;
+/**
+ * Who owns the files this plugin writes, and how to keep it that way.
+ *
+ * On POSIX the `mode` passed to `writeFile`/`mkdir` (`0o600`, `0o700`) is the
+ * whole story. **On Windows it is silently ignored**, and the files that matter
+ * here are not cosmetic: `env.cmd` carries API keys, the SuperGrok token file
+ * carries an OAuth grant, and the lock/socket directories carry session
+ * metadata. What they get instead is the ACL inherited from their parent — fine
+ * under `%USERPROFILE%\.dsh`, and *not* fine when `DSH_HOME` points somewhere
+ * shared (`C:\dsh`, a network share, a machine where `Users` can read the
+ * directory), which is exactly when nobody notices.
+ *
+ * So the intent is applied explicitly: `icacls` with inheritance removed and a
+ * single grant to the current user. The argv is built by a pure function so it
+ * can be asserted on Linux; applying it is best-effort by design — a machine
+ * without `icacls`, or a path held open by another process, must not fail the
+ * write that just succeeded. Failing closed here would mean a TUI that cannot
+ * save its own settings.
+ */
+/**
+ * The account `icacls` should grant, or undefined when the environment has none.
+ *
+ * `%USERDOMAIN%\%USERNAME%` where both are present: on a domain-joined machine a
+ * bare name can resolve to the machine-local account of the same name, and a
+ * grant to the wrong account — with inheritance already removed — would leave
+ * the user's own API keys inaccessible to them.
+ */
+export declare function aclUserName(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string | undefined;
+/**
+ * The exact `icacls` arguments for one path.
+ *
+ * `/inheritance:r` drops what the parent offered (this is the part that matters:
+ * adding a grant without removing inheritance leaves `Users` in place), and
+ * `(OI)(CI)` makes a directory's grant apply to what is created inside it —
+ * without it every new lock file would need its own call.
+ */
+export declare function restrictPathArgs(path: string, user: string, options?: {
+    directory?: boolean;
+}): string[];
+/** Directories and files whose contents must not be readable by other users. */
+export interface RestrictDeps {
+    /** Runner for `icacls`; injected by tests. Returns true on success. */
+    run?: (command: string, args: string[]) => boolean;
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Apply `mode` on POSIX, a single-user ACL on Windows.
+ *
+ * Returns whether the restriction was applied. Never throws: the caller has
+ * already written the file, and a permission call is not worth losing it over.
+ */
+export declare function restrictPathToUser(path: string, options?: {
+    mode: number;
+    directory?: boolean;
+} & RestrictDeps): Promise<boolean>;
+/** Synchronous twin, for the sites that create their file with `openSync`. */
+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-authoring.d.ts

@@ -20,21 +20,13 @@
  *   every later launch falls back to the default.
  * @module dsh-ssh-tui/preset-authoring
  */
-import { type AgentPreset, type PresetMetadata } from '@deepseek-ai/dsh-agent-presets';
+import { presetDirectory, type AgentPreset, type PresetMetadata } from './preset-compat.js';
+export { presetDirectory };
 /** The id shape discovery accepts; a directory that fails it is skipped. */
 export declare const PRESET_ID_PATTERN: RegExp;
 /** Whether an id would be discovered at all. */
 export declare function validatePresetId(id: string): boolean;
-/**
- * The directory a preset owns.
- *
- * `AgentPreset.path` is the composition file the preset publishes, not the
- * directory, so anything that writes beside it (display metadata) starts here.
- * @param preset - a discovered preset.
- * @returns the absolute preset directory.
- */
-export declare function presetDirectory(preset: AgentPreset): string;
-export type PresetRefusalCode = 'invalid-id' | 'exists' | 'not-found' | 'read-only' | 'system' | 'running' | 'empty-metadata';
+export type PresetRefusalCode = 'invalid-id' | 'exists' | 'not-found' | 'read-only' | 'system' | 'managed' | 'running' | 'empty-metadata';
 export interface PresetRefusal {
     error: PresetRefusalCode;
     /** The id the refusal is about, when it names one. */
@@ -78,9 +70,11 @@ export interface PresetCompositionView {
 }
 /**
  * The authoring subset of the service, feature-detected rather than assumed:
- * the plugin still supports 0.1.2-rc.1, whose `agentPresets` may predate
- * `copy`, `remove`, `read`, and `compositionInventory`. A missing member turns
- * into a clear message instead of a crash.
+ * the two supported lines expose different preset services under the same
+ * `agentPresets` name. 0.1.5's `dsh-agent-presets` carries `copy`, `remove`,
+ * `read` and `compositionInventory`; the 0.1.7 registry
+ * (`dsh-agent-preset-registry`) does not. A missing member turns into a clear
+ * message instead of a crash.
  */
 export interface PresetAuthoringApi {
     readonly authorable?: boolean;

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

@@ -0,0 +1,58 @@
+/** The optional display-metadata file beside a preset's composition. */
+export declare const METADATA_FILE = "preset.yml";
+/** Display text a preset may publish about itself. */
+export interface PresetMetadata {
+    /** Human-facing name; falls back to the preset id when absent. */
+    readonly name?: string;
+    /** One sentence on what this preset is for. */
+    readonly description?: string;
+    /** Position within its group; lower comes first. */
+    readonly order?: number;
+}
+/** Where a preset's composition came from, on the line that still records it. */
+export type PresetTrust = 'system' | 'user';
+/**
+ * One preset, as much of it as this plugin reads.
+ *
+ * `id`/`name`/`description`/`order`/`broken` are the fields both lines agree on.
+ * `path` (the composition file) and `trust` (the root it was discovered under)
+ * only exist on the 0.1.5 line; every consumer here treats them as optional,
+ * and the authoring paths refuse rather than guess when they are gone.
+ */
+export interface AgentPreset {
+    readonly id: string;
+    readonly name?: string;
+    readonly description?: string;
+    readonly order?: number;
+    readonly broken?: string;
+    /** 0.1.5 line only: absolute path of the preset's agent composition file. */
+    readonly path?: string;
+    /** 0.1.5 line only: trust recorded from the root it was discovered under. */
+    readonly trust?: PresetTrust;
+}
+/**
+ * The directory a preset owns, when the host still exposes one.
+ *
+ * `AgentPreset.path` is the composition file the preset publishes, not the
+ * directory, so anything that writes beside it (display metadata) starts here.
+ * `undefined` on a host that lists declarative presets instead of directories.
+ * @param preset - a discovered preset.
+ * @returns the absolute preset directory, or undefined when there is none.
+ */
+export declare function presetDirectory(preset: AgentPreset): string | undefined;
+/**
+ * Read a preset's display metadata. Every failure degrades to no metadata: a
+ * preset whose display text is missing, malformed, or unreadable still mounts.
+ * @param directory - the preset directory to read `preset.yml` from.
+ * @returns the published name/description/order, or `{}`.
+ */
+export declare function readPresetMetadata(directory: string): Promise<PresetMetadata>;
+/**
+ * Render display metadata as the file's contents.
+ *
+ * Absent fields are omitted rather than written empty, so a preset with no
+ * description does not ship a key that reads as an intentional blank.
+ * @param metadata - the display text to store.
+ * @returns the YAML document, or undefined when there is nothing to store.
+ */
+export declare function renderPresetMetadata(metadata: PresetMetadata): string | undefined;

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

@@ -9,7 +9,7 @@
  * service — the caller passes what `list()` returned.
  * @module dsh-ssh-tui/preset-picker
  */
-import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets';
+import type { AgentPreset } from './preset-compat.js';
 /** One option as the question dialog wants it, plus the id it stands for. */
 export interface PresetPickerOption {
     id: string;