dsh-ssh-tui 0.7.1 → 0.7.2

package/lib/types/color-depth.d.ts

@@ -18,10 +18,10 @@ export type ColorDepth = 'truecolor' | '256' | '8' | 'none';
  * Decide the palette from the environment.
  *
  * `DSH_TUI_COLOR_DEPTH` wins outright so a user can correct a wrong guess.
- * Otherwise: no colour at all when `NO_COLOR` is set or `TERM` names a
- * monochrome terminal; truecolor when `COLORTERM` says so; 256 for a
+ * Otherwise: no colour at all when `NO_COLOR` is set or `TERM` is `dumb`
+ * (or empty on POSIX); truecolor when `COLORTERM` says so; 256 for a
  * `*256color` terminal and for tmux/screen (their default palette is 256 and
- * they translate truecolor poorly); 8 for everything else.
+ * they translate truecolor poorly); 8 for Linux/VT consoles and everything else.
  * @param env - the environment to read (tests pass their own).
  * @returns the palette to paint with.
  */

package/lib/types/dialogs.d.ts

@@ -51,6 +51,10 @@ export interface InspectDialog {
     title: string;
     lines: DiffDisplayLine[];
     offset: number;
+    /** Child session whose live log should refresh this overlay in place. */
+    subagentSessionId?: string;
+    /** `/find` already scrolled to its hit here; later repaints keep the offset. */
+    searchRevealed?: boolean;
 }
 export type Dialog = ConfirmDialog | QuestionDialog | OnboardingDialog | InspectDialog;
 export interface DialogAnswer {

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

@@ -33,12 +33,36 @@ export declare function resolveDshHome(env?: NodeJS.ProcessEnv, home?: string):
 export declare function sessionSockDir(dshHome?: string): string;
 /** Filesystem/pipe-safe form of a session id, as used for locks and channels. */
 export declare function safeSessionId(sessionId: string): string;
+/**
+ * Readable, collision-free short label for one session: a sanitized head plus a
+ * digest of the raw id. The digest is always appended because sanitizing alone
+ * collapses distinct ids (`foo/bar` and `foo_bar`, `abc` and `abc.`) into one
+ * name. On Windows the pipe namespace is machine-wide; on POSIX the same
+ * collapse would share a socket file and a lock, so a relay could attach to
+ * the wrong session.
+ */
+export declare function sessionLabel(sessionId: string, maxLength: number): string;
 /**
  * Address of the per-session display channel: a filesystem path on POSIX, a
  * named pipe on Windows. `platform` is injectable so the Windows shape stays
  * testable from a POSIX test run.
  */
 export declare function sessionSockPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string;
+/**
+ * Pre-digest POSIX socket path (`tui-socks/<safeId>.sock`).
+ *
+ * 0.7.1 Hosts still listen here. A newer build's attach must find that channel
+ * instead of spawning a second Host that dies on the session write handle.
+ * Distinct ids that collapsed under sanitizing (`foo/bar` vs `foo_bar`)
+ * share this name — that is why the digest form exists — so a leftover
+ * file is only an attach target, never the path a new Host binds.
+ */
+export declare function legacySessionSockPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string | undefined;
+/**
+ * Channel a leftover Host may still be listening on: the digested path first,
+ * then the 0.7.1 name when it is different.
+ */
+export declare function sessionSockLookupPaths(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string[];
 /**
  * Host stderr log for one session. POSIX keeps the historical `<sock>.err`
  * next to the socket; a Windows pipe name is not a file path, so the log lives
@@ -47,6 +71,8 @@ export declare function sessionSockPath(sessionId: string, dshHome?: string, pla
  * device names (`CON`, `NUL`, …) from becoming the file stem.
  */
 export declare function sessionErrPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string;
+/** Pre-digest Host stderr log next to the 0.7.1 socket, when that name differs. */
+export declare function legacySessionErrPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string | undefined;
 export declare function encodeFrame(type: number, payload?: Buffer): Buffer;
 export declare function encodeResize(columns: number, rows: number): Buffer;
 export declare function decodeResize(payload: Buffer): {
@@ -165,8 +191,33 @@ export declare function quietTerminalInput(stdin?: NodeJS.ReadStream): number;
  * written into a link that may already be dead.
  */
 export declare function restoreTerminalInput(stdin?: NodeJS.ReadStream): void;
+/**
+ * How to start the background Host so it outlives this process *and* does not
+ * make its own children flash console windows on Windows.
+ *
+ * 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.
+ *
+ * Pure and platform-parameterised so the Windows branch can be asserted from
+ * Linux (see docs/platform.md).
+ */
+export declare function hostSpawnOptions(platform?: NodeJS.Platform): {
+    detached: boolean;
+    windowsHide: boolean;
+};
 /** Spawn a detached Host copy of this `dsh` invocation and return its sock path. */
-export declare function spawnDetachedHost(sessionId: string): SpawnedHost;
+export declare function spawnDetachedHost(sessionId: string, platform?: NodeJS.Platform): SpawnedHost;
 export declare function probeDisplaySock(path: string, timeoutMs?: number): Promise<boolean>;
 export interface RelayResult {
     /** Host sent goodbye — user exited from the attached session. */

package/lib/types/footer.d.ts

@@ -1,6 +1,7 @@
 /**
  * Footer stats, status identity, context-pressure chips, and `/status` report.
  */
+import { type ColorDepth } from './color-depth.js';
 import { type QuotaPeriod, type QuotaSnapshot, type QuotaSource } from './quota.js';
 import type { DisconnectPolicyName } from './transcript-types.js';
 export declare const WAIT_INDICATOR_MS = 8000;
@@ -161,12 +162,25 @@ export declare function formatQuotaBar(remainingPercent: number, width?: number)
  * `sub:<model>` chip for the identity row: `sub:grok-4.5`, or
  * `sub:grok-4.5(xhigh)` when an explicit `/subeffort` is set.
  *
- * It shows the model name only, like the parent's own chip: a `provider/model`
- * prefix on both chips doubled the same route and pushed the quota badge towards
- * the drop edge. The provider is not lost — `/submodel` and `/status` report it,
- * and the child's model name is the part that differs from the parent's.
+ * It shows the model name only, like the parent's own chip, unless `/submodel`
+ * pinned a different provider — then `sub:xai/grok-4.5` so the foreign route
+ * is visible on the identity row as well as the recolored chip.
  */
 export declare function subagentRouteLabel(model: string, provider?: string, effort?: string): string;
+/**
+ * Paint the `sub:` chip on an otherwise muted status line.
+ *
+ * Only a *foreign* route is accented: cyan when `/submodel` pinned a supplier
+ * the parent is not on. A child that follows the parent (or that was pinned
+ * back onto the parent's own provider) keeps the identity row's mute — the
+ * accent means "this route is not your parent's", and spending it on every
+ * child made the following case look pinned.
+ *
+ * The mute (`90`) is reopened after the chip so the rest of the identity row
+ * stays dim.
+ */
+export declare function paintFooterSubagentChip(line: string, chip: string, foreign: boolean, muteSgr?: string, depth?: ColorDepth): string;
+export declare function footerSubagentForeign(input: Pick<FooterStatusInput, 'provider' | 'subProvider'>): boolean;
 /**
  * The model as the footer shows it: the model's own name, without a
  * `provider/model` route prefix.

package/lib/types/gateway-protocol.d.ts

@@ -0,0 +1,88 @@
+/**
+ * One gateway, several wire protocols.
+ *
+ * `llm-pi-ai` puts `api` on the *provider* entry, not on a model entry, so a
+ * gateway whose catalogue spans protocols (Command Code: 55 of 71 models answer
+ * `/responses`, 8 only `/chat/completions`, the Claude family only `/messages`)
+ * cannot be one entry. The wizard therefore keeps one row per gateway and
+ * expands it into sibling entries — `command-code`, `command-code-responses`,
+ * `command-code-messages` — with each model filed under the protocol it
+ * actually speaks. Everything here is pure so the split can be tested without
+ * a settings file or a network.
+ */
+export type GatewayProtocol = 'openai-responses' | 'openai-completions' | 'anthropic-messages';
+/** Preference order for a model a gateway lists on more than one route. */
+export declare const GATEWAY_PROTOCOL_PREFERENCE: readonly GatewayProtocol[];
+/** Id suffix per protocol; the base entry keeps the plain gateway id. */
+export declare const GATEWAY_PROTOCOL_SUFFIX: Record<GatewayProtocol, string>;
+/** The endpoint path each protocol speaks, for messages and hints. */
+export declare const GATEWAY_PROTOCOL_ENDPOINT: Record<GatewayProtocol, string>;
+/** The endpoint strings gateways publish; `null` for anything unrecognised. */
+export declare function endpointProtocol(endpoint: string): GatewayProtocol | null;
+/** `command-code` + `openai-responses` → `command-code-responses`. */
+export declare function siblingProviderId(baseId: string, protocol: GatewayProtocol): string;
+/** The protocol a sibling id carries, or null when it is not one of ours. */
+export declare function siblingProtocolOf(id: string): GatewayProtocol | null;
+/** True when `id` is a sibling of `baseId` (and not the base itself). */
+export declare function isSiblingOf(baseId: string, id: string): boolean;
+/** The gateway id a sibling row belongs to; a base id comes back unchanged. */
+export declare function baseProviderIdOf(id: string): string;
+/** The protocol a provider entry's `api` names, when it is one of the three we model. */
+export declare function declaredProtocol(value: unknown): GatewayProtocol | undefined;
+/**
+ * Whether an entry that speaks `protocol` may serve `model`, according to the
+ * gateway's own `supported_endpoints`. A gateway that publishes nothing about
+ * the model — or no protocol to check against — never blocks it: silence is not
+ * a refusal, only an explicit list that omits the protocol is.
+ */
+export declare function gatewayServesModel(endpoints: ReadonlyMap<string, readonly string[]> | undefined, model: string, protocol: GatewayProtocol | undefined): boolean;
+/**
+ * The protocols a gateway lists for `model`, in preference order. Empty when the
+ * gateway says nothing, which callers read as "no opinion".
+ */
+export declare function advertisedProtocols(endpoints: ReadonlyMap<string, readonly string[]> | undefined, model: string): GatewayProtocol[];
+/**
+ * The protocol one model should be filed under. The gateway's own
+ * `supported_endpoints` decide when it publishes them; a model already
+ * configured on a route the gateway still lists keeps that route, and a model
+ * the gateway does not describe keeps the route it is already on rather than
+ * being relocated by a hand-maintained table. Otherwise the earliest entry in
+ * `preference` wins, then the table, then the gateway's own primary protocol.
+ */
+export declare function resolveModelProtocol(input: {
+    advertised?: readonly string[];
+    /** The provider protocol this model is already configured on, if any. */
+    existing?: GatewayProtocol;
+    table?: GatewayProtocol;
+    fallback: GatewayProtocol;
+    preference?: readonly GatewayProtocol[];
+}): GatewayProtocol;
+/**
+ * Every model of one gateway, filed by protocol. `existing` carries the
+ * protocol each model is already configured on, so re-running setup keeps a
+ * working placement instead of re-homing it. Models the gateway does not
+ * describe, that are not configured yet, and that the table does not know land
+ * on `fallback`, which is the gateway's own pinned protocol — the one its
+ * default models were verified on.
+ */
+export declare function splitModelsByProtocol(input: {
+    models: readonly string[];
+    advertised?: ReadonlyMap<string, readonly string[]>;
+    existing?: ReadonlyMap<string, GatewayProtocol>;
+    table?: Readonly<Record<string, GatewayProtocol>>;
+    fallback: GatewayProtocol;
+    preference?: readonly GatewayProtocol[];
+}): Map<GatewayProtocol, string[]>;
+/**
+ * OpenCode Go's published endpoint table (https://opencode.ai/docs/go/), because
+ * `GET /zen/go/v1/models` carries no `supported_endpoints` field at all.
+ *
+ * The whole DeepSeek family answers `/responses` (verified against the live
+ * gateway, and what this plugin's pinned template has shipped since 0.7.0) even
+ * though the page still lists those models under chat. A route that works is not
+ * downgraded because a document lags. Zen's own (non-Go) route publishes no
+ * table here — unknown models there take the gateway's primary protocol.
+ */
+export declare const ZEN_GO_MODEL_PROTOCOLS: Readonly<Record<string, GatewayProtocol>>;
+/** The built-in table for a gateway base URL, when we have one. */
+export declare function gatewayModelTable(baseURL: string): Readonly<Record<string, GatewayProtocol>> | undefined;

package/lib/types/job-label.d.ts

@@ -1,20 +1,51 @@
 /**
- * Friendly display names for background jobs.
+ * Friendly display names for background jobs and subagent chips.
  *
- * `job_*` cards otherwise read as the raw tool vocabulary (`job_output`,
- * `job_id: bash-1`), which is both untranslated and hard to talk about out
- * loud. Each job id instead gets a two-word alias — "蔚蓝水獭", "azure otter" —
- * derived from the id itself rather than from a random draw, so the same job
- * keeps one name across its call card, its result card, and every later
+ * Background `job_*` cards otherwise read as the raw tool vocabulary
+ * (`job_output`, `job_id: bash-1`). Each job id gets a two-token alias
+ * (hour + weather: 昏风 / twilight wind) derived from the id itself rather
+ * than from a random draw, so the same
+ * job keeps one name across its call card, its result card, and every later
  * `job_output` / `job_kill` mention. The model-facing id stays authoritative;
  * the alias is presentation only.
  *
+ * Subagent chips use a different scheme: a role distilled from the parent
+ * spawn description, joined to one of the four directional beasts
+ * (青龙 / 白虎 / 朱雀 / 玄武) hashed from the child session id.
+ *
  * @module dsh-ssh-tui/job-label
  */
+/** FNV-1a over the job id: stable, dependency-free, and well spread for short ids. */
+export declare function hashJobId(id: string): number;
 /**
  * One stable alias for a background job, or `undefined` when the id is empty
  * or the locale carries no vocabulary.
  * @param jobId - the native job id (`bash-1`, `pwsh-2`, …).
- * @returns the locale-formatted alias, e.g. `蔚蓝水獭` / `azure otter`.
+ * @returns the locale-formatted alias, e.g. `昏风` / `twilight wind`.
  */
 export declare function jobAlias(jobId: string): string | undefined;
+/** The four directional beasts, hashed from the child session id. */
+export declare const SUBAGENT_BEASTS: readonly ["azure-dragon", "white-tiger", "vermilion-bird", "black-tortoise"];
+export type SubagentBeastId = (typeof SUBAGENT_BEASTS)[number];
+export type SubagentRoleId = 'scout' | 'scribe' | 'artisan' | 'envoy' | 'inquirer' | 'sentinel' | 'steward' | 'courier';
+/** Distill a parent spawn description into one role id. */
+export declare function subagentRoleId(task: string): SubagentRoleId;
+/** Hash the child session onto one of the four beasts. */
+export declare function subagentBeastId(sessionId: string): SubagentBeastId;
+/** Localized role label (`探路` / `scout`). */
+export declare function subagentRoleLabel(role: SubagentRoleId): string;
+/** Localized beast label (`青龙` / `Azure Dragon`). */
+export declare function subagentBeastLabel(beast: SubagentBeastId): string;
+/**
+ * Chip title: `探路·青龙` / `Scout · Azure Dragon`.
+ * Falls back to the spawn-time label when neither task nor id can be named.
+ */
+export declare function subagentCourtesyName(input: {
+    sessionId: string;
+    task?: string;
+    fallback: string;
+}): string;
+/** True when a string looks like a session / tool-call id, not a display name. */
+export declare function looksLikeOpaqueId(value: string): boolean;
+/** Prefer a recorded tool name; never surface `call-<uuid>` as a title. */
+export declare function displayToolName(name: string | undefined): string;

package/lib/types/plan.d.ts

@@ -1,7 +1,8 @@
 /**
  * Plan dock, todo lists, /find, prompt-injection cards, and compact errors.
  */
-import type { DisplayKind, PlanTodoItem, Row, SubagentLogEntry } from './transcript-types.js';
+import { type TextSegment } from './term-text.js';
+import type { DiffDisplayLine, DisplayKind, PlanTodoItem, Row, SubagentLogEntry } from './transcript-types.js';
 export declare const MAX_SUBAGENT_LOGS = 80;
 export declare const TODO_STATUS_MARK: Record<PlanTodoItem['status'], string>;
 /** True while a plan still belongs in the dock (latest incomplete work). */
@@ -78,10 +79,99 @@ export declare function parsePlanTodos(value: unknown): PlanTodoItem[];
 export declare function todoSummary(value: unknown): string;
 /** Compact ask_user_question summary from tool arguments. */
 export declare function askSummary(value: unknown): string;
-/** One-line subagent card header used while collapsed. */
-export declare function subagentHeaderText(row: Extract<Row, {
+/** First non-empty line, collapsed to a single scan line. */
+export declare function firstDisplayLine(text: string): string;
+/** Collapse a child-session blob to one short chip/wait-card line. */
+export declare function clipSubagentActivity(text: string, maxChars?: number): string;
+/** Running / ok / aborted / error → ANSI for the status dot and status word. */
+export declare function subagentStateColor(status: Extract<Row, {
     kind: 'subagent';
-}>, now?: number): string;
+}>['status']): '33' | '32' | '31' | '90';
+/**
+ * Rebuild a subagent chip from the parent spawn tool call that survives in the
+ * session log. Live `subagent/start` is not replayed, so resume would otherwise
+ * show a generic tool card titled from the English description ("probe").
+ */
+export declare function subagentRowFromSpawnTool(input: {
+    callId: string;
+    task: string;
+    provider?: string;
+    /** Model route for the child, when the caller knows it. */
+    modelProvider?: string;
+    local?: boolean;
+    status?: Extract<Row, {
+        kind: 'subagent';
+    }>['status'];
+    startedAt?: number;
+    endedAt?: number;
+    output?: string;
+}): Extract<Row, {
+    kind: 'subagent';
+}>;
+/**
+ * Courtesy title: distilled role plus a directional beast.
+ *
+ * The beast comes from the child's own session id, never the parent call id a
+ * replayed chip was built with: the same child must keep its symbol across a
+ * `--resume`.
+ */
+export declare function subagentDisplayName(row: Extract<Row, {
+    kind: 'subagent';
+}>): string;
+/**
+ * Short activity for the collapsed chip and wait card: prefer the parent
+ * task name, else a clipped last log line. Never the full child transcript.
+ */
+export declare function subagentChipSummary(row: Extract<Row, {
+    kind: 'subagent';
+}>): string;
+/** Header + SGR spans: identity color, status dot/word, muted summary. */
+export declare function buildSubagentHeader(input: {
+    focused: boolean;
+    title: string;
+    status: Extract<Row, {
+        kind: 'subagent';
+    }>['status'];
+    elapsedLabel: string;
+    summary: string;
+    spinner?: string;
+    inspectHint?: string;
+    /** Different provider from the parent: paint the title cyan, not violet. */
+    foreign?: boolean;
+}): {
+    plain: string;
+    segments: TextSegment[];
+};
+/** Map a folded child-session event onto an existing display role. */
+export declare function subagentLogDisplayKind(entry: SubagentLogEntry, status: Extract<Row, {
+    kind: 'subagent';
+}>['status']): DisplayKind;
+/**
+ * Overlay body: session line, stop reason, then the clipped child log.
+ *
+ * The child's session id is the one `/subagents kill` takes, so it belongs on
+ * this line — the collapsed chip stays free of opaque ids.
+ */
+export declare function subagentInspectLines(row: Extract<Row, {
+    kind: 'subagent';
+}>): DiffDisplayLine[];
+/**
+ * Classify a child-session error so the chip can say *why* it died, not just
+ * that it ended. Quota and expired auth get a command that actually helps;
+ * everything else keeps a clipped diagnostic.
+ */
+export declare function describeSubagentFailure(input: {
+    stopReason?: string;
+    message?: string;
+    provider?: string;
+}): {
+    hint: string;
+    kind: 'quota' | 'auth' | 'effort' | 'error';
+} | undefined;
 export declare function appendSubagentLog(row: Extract<Row, {
     kind: 'subagent';
 }>, entry: SubagentLogEntry): void;
+/** Fold a child user/plugin blob: reminders become one inject chip, not raw XML. */
+export declare function foldSubagentUserLog(row: Extract<Row, {
+    kind: 'subagent';
+}>, text: string, sourceKind?: string, plugin?: string): void;

package/lib/types/platform.d.ts

@@ -0,0 +1,50 @@
+/** This process is running on Windows. */
+export declare const IS_WINDOWS: boolean;
+/** Windows delivers resizes on the stream; everyone else raises SIGWINCH. */
+export declare function usesSigwinch(platform?: NodeJS.Platform): boolean;
+/** The launcher's environment file: a shell fragment or a `cmd` script. */
+export declare function envFileName(platform?: NodeJS.Platform): string;
+/** The shell a Windows user has: PowerShell, where POSIX code would say bash. */
+export declare function shellName(platform?: NodeJS.Platform): string;
+/**
+ * Whether lock liveness is decided by asking the OS about the process (Windows:
+ * `Get-Process` + creation time) rather than by reading `/proc` (Linux) or the
+ * command line (darwin).
+ *
+ * `lockOwnerIsAlive` returns early into `windowsProcessMatchesLock` when this is
+ * true; the POSIX body below it has no meaning there (`/proc` does not exist).
+ */
+export declare function usesProcessIdentity(platform?: NodeJS.Platform): boolean;
+/**
+ * How to start the background Host so it outlives this process *and* does not
+ * make its own children flash console windows on Windows.
+ *
+ * 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.
+ */
+export declare function hostSpawnOptions(platform?: NodeJS.Platform): {
+    detached: boolean;
+    windowsHide: boolean;
+};
+/**
+ * A path a human can read, with the platform's own shorthand.
+ *
+ * `~/.dsh/env.sh` is the POSIX form; Windows users know `%USERPROFILE%`, and a
+ * `C:\Users\...` prefix spelled out is noise in a one-line hint.
+ */
+export declare function displayHomePath(home: string, file: string, options?: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    userHome?: string;
+}): string;

package/lib/types/route-memory.d.ts

@@ -5,28 +5,23 @@
 import z from '@deepseek-ai/schemastery';
 import type { Context } from '@deepseek-ai/cordis';
 export declare const ROUTE_MEMORY_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
-/** Settings schema for `$DSH_HOME/settings.yaml` under ssh-tui-routes. */
-export declare const ROUTE_MEMORY_SCHEMA: z<Schemastery.ObjectS<{
-    providers: z<import("@deepseek-ai/cosmokit").Dict<{
-        model?: string | null | undefined;
-        reasoningEffort?: string | null | undefined;
-        updatedAt?: number | null | undefined;
-    } & import("@deepseek-ai/cosmokit").Dict, string>, import("@deepseek-ai/cosmokit").Dict<Schemastery.ObjectT<{
-        model: z<string, string>;
-        reasoningEffort: z<string, string>;
-        updatedAt: z<number, number>;
-    }>, string>>;
-}>, Schemastery.ObjectT<{
-    providers: z<import("@deepseek-ai/cosmokit").Dict<{
-        model?: string | null | undefined;
-        reasoningEffort?: string | null | undefined;
-        updatedAt?: number | null | undefined;
-    } & import("@deepseek-ai/cosmokit").Dict, string>, import("@deepseek-ai/cosmokit").Dict<Schemastery.ObjectT<{
-        model: z<string, string>;
-        reasoningEffort: z<string, string>;
-        updatedAt: z<number, number>;
-    }>, string>>;
-}>>;
+/** The shape `ssh-tui-routes` takes in `$DSH_HOME/settings.yaml`. */
+export interface RouteMemorySettings {
+    providers: Record<string, {
+        model: string;
+        reasoningEffort: string;
+        updatedAt: number;
+    }>;
+}
+/**
+ * Settings schema for `$DSH_HOME/settings.yaml` under ssh-tui-routes.
+ *
+ * The type argument is spelled out rather than inferred: `schemastery`'s
+ * builder names its own package internally, so an inferred schema makes `tsc`
+ * emit a declaration that references a path inside `node_modules` and fails
+ * with TS2742 on any layout that does not match this machine's.
+ */
+export declare const ROUTE_MEMORY_SCHEMA: z<RouteMemorySettings>;
 export interface RememberedRoute {
     model: string;
     reasoningEffort?: string;

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

@@ -10,10 +10,15 @@ export declare function formatFooterCwd(cwd: string): string;
 /**
  * Switch the process into a persisted session working directory. Returns the
  * directory actually used; missing/invalid paths stay put and are reported.
+ *
+ * The target must be an absolute directory. A regular file that happens to
+ * exist at the recorded path used to pass `existsSync` and then fail inside
+ * `chdir` with a platform errno; resume now refuses it before moving.
  */
 export declare function enterSessionCwd(cwd: string | undefined, options?: {
     current?: string;
     exists?: (path: string) => boolean;
+    isDirectory?: (path: string) => boolean;
     chdir?: (path: string) => void;
 }): {
     cwd: string;

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

@@ -21,6 +21,15 @@ export declare class SessionLockHeldError extends Error {
     constructor(lock: SessionLockInfo, path: string);
 }
 export declare function sessionLockPath(sessionId: string, dshHome?: string): string;
+/**
+ * Pre-digest lock path (`tui-locks/<safeId>.json`).
+ *
+ * 0.7.1 Hosts still write here. Lookup must find that file; a new Host must
+ * not bind a second lock beside a live one just because the filename changed.
+ */
+export declare function legacySessionLockPath(sessionId: string, dshHome?: string): string;
+/** Digested lock first, then the 0.7.1 name when it is different. */
+export declare function sessionLockLookupPaths(sessionId: string, dshHome?: string): string[];
 export declare function parseSessionLock(raw: string): SessionLockInfo | undefined;
 /** True when `pid` still exists on this machine (best-effort). */
 export declare function processIsAlive(pid: number): boolean;