@sagmans/dsh-tui 0.6.0 → 0.8.0

package/README.md

@@ -6,7 +6,7 @@ Status: **v1 feature-complete; published on npm as `@sagmans/dsh-tui`.** The sur
 
 ## Install
 
-A profile keeps this plugin as one bundle layer. Install it from a checkout of this repository, or from the registry (`0.1.0` or later). Both paths need Node.js >= 22.19 and `pnpm` on `PATH`. Both need a real terminal: stdin and stdout must be TTYs.
+A profile keeps this plugin as one bundle layer. Install it from a checkout of this repository, or from the registry (`0.1.0` or later). Both paths need Node.js >= 22.19 and `pnpm` on `PATH`. Interactive sessions need a real terminal: stdin and stdout must be TTYs.
 
 ### From a plugin checkout
 
@@ -30,6 +30,47 @@ dsh --profile tui
 
 Releases are published, so this path works today. A checkout stays the path for unreleased work.
 
+### Install the dogfood skill (optional)
+
+Run this explicit command after you add the plugin:
+
+```sh
+dsh --profile tui install-skills
+```
+
+The command copies `dsh-tui-dogfood` to
+`~/.agents/skills/dsh-tui-dogfood/`. Agents can then load it from any dsh
+plugin repository. The skill uses a cloned dsh home, so tests do not change
+your real profile. A first install needs no TTY. `npm install` does not copy
+skills into your home.
+
+If the skill exists, the command asks `Update existing skill? [y/N]` in a
+terminal. Only `y` or `yes` replaces it. Enter or `n` keeps the existing
+copy. To update without a prompt, including in non-interactive runs, use:
+
+```sh
+dsh --profile tui install-skills --update
+```
+
+Updating removes any local changes inside the previous skill directory.
+The command stages the new copy before replacement and restores the old
+copy if replacement fails. If cleanup fails after replacement, the new copy
+stays installed and the command reports the old backup path.
+
+A started session compares every installed copy with the skills this build
+ships and prints one line when they differ, because an agent loading a stale
+skill is told the old wiring:
+
+```text
+bundled skills changed since they were installed: dsh-tui-update-models · run dsh --profile tui install-skills --update
+```
+
+The comparison reads content only, over the files this package ships: a
+helper's execute bit is the installer's own doing, and a note kept beside a
+skill stays unremarked. A skill that was never installed is not drift — a first
+install is the prompt above — and a run that never opens the screen, like
+`list-models`, prints nothing.
+
 ### Confirm the plugin mounted
 
 The profile records its layers in `$DSH_HOME/profiles/tui/package.json` (`~/.dsh` by default). `@sagmans/dsh-tui` must appear in `dsh.profile.bundles`:
@@ -117,8 +158,18 @@ dsh --profile tui --preset minimal          # start in a shipped mode other than
 dsh --profile tui --model deepseek-chat
 dsh --profile tui --no-color
 dsh --profile tui --no-bell            # do not ring when a long turn finishes
+dsh --profile tui list-models          # print every provider/model the picker can reach
 ```
 
+`list-models` prints one line per route the `/model` picker can reach —
+`provider/model`, a tab, then the model's display name — in picker order:
+providers as the llm service registered them, then each provider's own model
+order. It writes plain stdout, so it works piped or redirected, never opens the
+alternate screen, and exits 0 after printing at least one route. When the
+profile has no llm service, when the provider listing cannot be read, or when
+nothing is configured to advertise a model, it names the reason on stderr and
+exits 1.
+
 Every key below is a shipped default. `/keys` opens every action the surface
 and its library can perform as a list you filter as you type, with the keys in
 force, and the `keys:` section moves any of them — see [Keys](#keys).
@@ -130,7 +181,7 @@ force, and the `keys:` section moves any of them — see [Keys](#keys).
 | Ctrl+C | take back one thing at a time: the draft in the bar, the prompts waiting in the agent's inbox, the running turn, or a child's conversation; with a picker, an approval, a question, or the transcript search open it closes that instead. With nothing left to cancel it does nothing — it never leaves |
 | Ctrl+D | leave and print the resume command, when the bar holds no text and nothing is open; a running turn is cancelled first |
 | Ctrl+O | open every tool card: its header plus every retained row. Folded, a card is one line, and a shell card keeps its command plus the last 20 rows of output with a hint naming what it dropped |
-| Ctrl+Y | show or hide the calls a PTC program dispatched: one two-space-indented row per call under its `run_code` card, named and argued from the tool's own header and cut at the screen edge; clicking one row opens that call in full — the change it declared, then what it produced — for every tool, a failed call included; shown by default |
+| Ctrl+Y | show or hide the calls a PTC program dispatched: one two-space-indented row per call under its `run_code` card, named and argued from the tool's own header and cut at the screen edge; clicking the card's own header does the same for that card alone, and one level only — the program's own rows stay under `Ctrl+O`; clicking one call's row opens that call in full — the change it declared, then what it produced — for every tool, a failed call included; hidden by default |
 | Shift+Tab | expand or fold every thought behind the answers: folded, the row names itself, its token count, and the key; opened, it adds the thought, laid out as markdown; a click decides for one thought instead |
 | Ctrl+T | pick the reasoning effort for the next step |
 | Ctrl+R | reverse-search recorded prompts: the list opens filtered by whatever is in the bar, `enter` puts one back, `esc` keeps the draft |
@@ -223,7 +274,7 @@ While a turn runs, a prompt submitted into the editor waits in the agent's own i
 
 Copying is read back through what the surface drew rather than through the screen, so a selection is the words alone: dragging across a message takes its box with it on screen, and the surface takes its own frame back out before the text reaches the clipboard — the sides, the padding beside them, and the rules above and below. A selection that covers a whole message, two of them, or a part of one is read the same way, and a row the transcript did not draw — the editor's own bar, a picker's card — is copied exactly as it read, and a selection that was nothing but frame is handed back as the reader made it, because a copy is never emptied. The frame still comes back in a copy taken with the terminal's own selection — Shift held while dragging, or a terminal that keeps selection to itself — which is the one path no program can filter.
 
-Every submitted line is also kept in a global prompt history at
+When prompt history is enabled, each submitted line is kept in a global history at
 `$DSH_HOME/prompt-history.json`. Typing the start of a prompt that was sent
 before draws the rest of the newest match after the cursor in a faint shade.
 `Ctrl+E` takes the whole suggestion and the word-movement key takes the next
@@ -328,13 +379,13 @@ must not also be a way to lose the work.
 
 Every styled element is a named token with a shipped default, and every key is
 an action with one, so the surface can be restyled and rebound without touching
-code. Preferences live in the same user-settings document as every other
-(`$DSH_HOME/settings.yaml`), under a `dsh-tui:` section:
+code. Released hosts with section APIs store preferences in
+`$DSH_HOME/settings.yaml`, under a `dsh-tui:` section:
 
 ```yaml
 dsh-tui:
-  theme: violet-orbit         # restyle the whole surface by name (default: deepseek-blue)
-  subcalls: collapsed         # fold the calls a PTC program dispatched (default inline)
+  theme: deepseek-blue        # restyle the whole surface by name (default: violet-orbit)
+  subcalls: inline            # draw the calls a PTC program dispatched (default collapsed)
   mermaid: streaming          # draw a reply's mermaid fences: off, final, or streaming (default streaming)
   tools:
     default: { collapsed: true, output: hidden }  # how every tool's card starts
@@ -364,17 +415,73 @@ dsh-tui:
       hidden: true            # the element renders nothing at all
 ```
 
+Config-backed source hosts store the same preference fields in the TUI entry's
+`config` in the active profile patch. Use the actual entry ID, normally `tui`,
+not the legacy `dsh-tui` namespace. For example:
+
+```yaml
+- id: tui
+  config:
+    theme: violet-orbit
+    history:
+      enabled: false
+      ghost: false
+```
+
+The plugin exports a Config schema for all preferences shown above, including
+`prefix`, `prefixWindow`, and `keys`. Launch fields such as `sessionId`,
+`model`, and `provider` remain separate from live preference edits.
+The settings service owns persistence. TUI does not create another preference store.
+It uses released `installSection` or `register` APIs, or Config-backed
+`describe` and revision-checked `update` APIs. Unsupported or read-only writes
+show a notice instead of reporting success. A rejected theme selection restores
+the applied theme, and `/theme tokens` reports that same appearance.
+
+On Config-backed hosts, absent `history.enabled` and `history.ghost` stay off.
+Set each switch to `true` explicitly to enable it. This prevents recording while
+the host's asynchronous legacy import is pending or has failed. Released section
+hosts retain their existing defaults. If the host reports unreadable preferences,
+history stays off. Readable `false` switches survive errors in other fields.
+Malformed updates retain the last valid appearance and do not overwrite their source.
+
+When public descriptors expose raw user layers, history checks those layers at use
+time. A readable opt-out survives rejected siblings even without a change event.
+Another rejected opt-in cannot clear this protection; a valid committed update can.
+A released-provider limit remains: after an absent user section, rejected scalar
+sections can produce identical public descriptors. TUI cannot detect that transition
+without host validity metadata, so normal released defaults remain active.
+
+The inspected source host has no legacy import alias from `dsh-tui` to `tui`.
+Exporting Config does not resolve that namespace mismatch. The host can rename
+`settings.yaml` to `settings.yaml.imported` before import completes.
+TUI does not retry or restore that file automatically. Preserve current privacy
+opt-outs and copy only the intended legacy fields into the actual TUI entry's
+`config`. Keep the original file for rollback.
+
+Live Config edits require the loaded schema runtime to create native volatile
+references. The released schemastery 3.18.2 implementation used by this checkout's
+unit tests lacks that API. A source host can resolve a different implementation
+with the same version label. TUI checks the loaded implementation and actual
+references, not the package version or CLI identity.
+
+If the loaded schema runtime lacks native support, TUI exports ordinary fields
+rather than unsupported live metadata. TUI then rejects Config-backed writes,
+and the host cannot import preferences through its volatile-field settings API.
+Reading row preferences still works, and ordinary profile changes use the host's
+reload lifecycle. Native schema-backed hosts can apply live preference updates.
+
 Every field is optional, so a section that changes one shade is enough. The
 document is hot-reloaded: an edit restyles a running session and re-arms the
 keymap on the next press, and `/theme` shows each element's effective value and
 whether it came from an override, the palette, or the default.
 
 
-The section is not only shades. By default every session draws one row per call
-a PTC program dispatched under its card, and `subcalls: collapsed` starts with
-the card alone instead. `Ctrl+Y` toggles the same choice for the current
-session, and an edit to the document re-seeds it. An unknown key or value is
-refused with a notice naming it, so a typo cannot quietly do nothing.
+The section is not only shades. By default a PTC program's card arrives alone,
+and `subcalls: inline` draws one row per call it dispatched under that card
+instead — or one click on the card's own header, for that card alone.
+`Ctrl+Y` toggles the same choice for the current session, and an edit to the
+document re-seeds it. An unknown key or value is refused with a notice naming
+it, so a typo cannot quietly do nothing.
 
 The `tools` block decides how each tool's cards draw. `collapsed` starts a
 tool folded to one header row (default `true`), and `output` is `hidden`
@@ -388,8 +495,11 @@ profile mounts. Clicking a card opens or folds that one message, and a dispatche
 call's row opens on the same click to what the tool itself drew for it — an
 edit's diff in the diff colours, a read's numbered lines, a command and its
 output — followed by the outcome it produced; a call that failed opens to the
-reason it reported instead of rows for work that never happened. `Ctrl+O` still
-decides for every message nobody clicked.
+reason it reported instead of rows for work that never happened. A program's
+card opens one level at a time: its own row draws the calls, and the rows below
+them — what the program returned — are the card's, so a click on each answers
+for what it drew. `Ctrl+O` still decides for every message nobody clicked, and
+`Ctrl+Y` for every program whose own header nobody clicked.
 
 The `history` block tunes the prompt history. `enabled: false` stops recording
 and offering it; `ghost: false` keeps reverse search but stops the dimmed
@@ -428,9 +538,9 @@ leaving a gap, and `NO_COLOR` draws the fence as plain text. `/export` and the
 session file still keep the fence exactly as the model wrote it.
 
 A theme restyles the whole surface by name, and a theme is a file. The package
-ships two: `deepseek-blue`, the table written out in full in the colours the
-project answers to, and `violet-orbit`, a port of pi's theme of that name — its
-palette, plus the elements it draws its own way. `deepseek-blue` is also what a
+ships two: `violet-orbit`, a port of pi's theme of that name — its palette, plus
+the elements it draws its own way — and `deepseek-blue`, the table written out
+in full in the colours the project answers to. `violet-orbit` is also what a
 document naming no theme draws, so the default look is a file you can read, list,
 and copy rather than a table compiled in. Your own themes live in
 `$DSH_HOME/themes/`, which the surface creates at start-up and watches, so saving
@@ -620,7 +730,7 @@ The fold is durable-only: the live stream decorates the row that is still being
 
 Tool cards are folded by default: a card draws one header row — the tool, its argument clipped to the configured budget, and the facts the result measured — so a long read, diff, or search cannot bury the conversation. A call that has not answered yet names itself in the running colour, `tool.running.title`, and ends that row with the whole seconds it has been waiting, in `tool.running.elapsed`, once it has waited one, so a reader can tell the call they are watching from the one below it that already finished; both give way to the measured facts the moment the result lands. A call that failed names itself in the failed colour, `tool.failed.title` — including a shell whose command exited non-zero or died on a signal, which is a failure whether or not the tool that ran it said so. A shell card's row also carries the exit status and the count of output rows waiting behind the fold, because its output is the answer the reader asked for and a fold that left no trace of it would read as a call that produced nothing. Clicking a card opens or folds that one message; `Ctrl+O` opens or folds every card at once, and `tools:` in the [settings](#settings) decides how each tool starts and whether a fold hides its rows or keeps a `tail` of them.
 
-A PTC card is the one card with children: every call the `run_code` program dispatched hangs off the card that made it, and each draws under the header as the tool's own name and argument, on one row cut at the screen edge whether the card itself is open or folded — a program's work must stay legible without opening its card. Each of those rows names its own call in the colour of what that call is doing — `tool.subcall.running` while the program is waiting on it, `tool.failed.title` when it failed, and `tool.subcall.title` once it is back — and a settled row keeps the one line the tool itself drew about its outcome, in `tool.terminal.status` where that tool declares one. A shell call therefore reads `bash pnpm test · exit 0` when it worked and the same row in red, with `exit 1`, when it did not, so a program's work reads row by row without opening the card. The program's own row is the one card that shows no mark: its timer is what says it is still running, and it is also what the card keeps when the program answers — the total it ran for, drawn in `tool.elapsed.done`, dimmed and italic, because the work it measured is over. Clicking one of those rows opens that call's argument in full and leaves its neighbours and the card as they were; a shell call also brings back the rows it printed, because the program's return value is all the card itself keeps. `Ctrl+Y` hides or shows them all, and `subcalls: collapsed` starts every session with them hidden; see [Settings](#settings).
+A PTC card is the one card with children: every call the `run_code` program dispatched hangs off the card that made it, and once shown, each draws under the header as the tool's own name and argument, on one row cut at the screen edge whether the card itself is open or folded — a program's work must stay legible without opening its card. Those rows start folded, because a program can dispatch hundreds of calls and what a reader came for is the answer they produced: one click on the card's own header draws them for that card and for that card alone, `Ctrl+Y` draws them for every card at once, and `subcalls:` decides what a session starts with. Nothing else arrives with that click: the program's own rows are the level below, and `Ctrl+O` is what opens them. Each of those rows names its own call in the colour of what that call is doing — `tool.subcall.running` while the program is waiting on it, `tool.failed.title` when it failed, and `tool.subcall.title` once it is back — and a settled row keeps the one line the tool itself drew about its outcome, in `tool.terminal.status` where that tool declares one. A shell call therefore reads `bash pnpm test · exit 0` when it worked and the same row in red, with `exit 1`, when it did not, so a program's work reads row by row without opening the card. The program's own row is the one card that shows no mark: its timer is what says it is still running, and it is also what the card keeps when the program answers — the total it ran for, drawn in `tool.elapsed.done`, dimmed and italic, because the work it measured is over. Clicking one of those rows opens that call's argument in full and leaves its neighbours and the card as they were; a shell call also brings back the rows it printed, because the program's return value is all the card itself keeps. `Ctrl+Y` hides or shows them all, and `subcalls: collapsed`, the shipped default, starts every session with them hidden; see [Settings](#settings).
 
 A card's header names the tool, then the argument the call was made with — a path or a command — in the `tool.args` colour, then the facts the result measured: a read reports its line range, line count, and token size; a file change that carried no prior content to compare against reports its lines and tokens; one that did reports added, changed, and removed lines as `+n ~n -n` in green, yellow, and red. Each stat is its own token, so any of them can be recoloured or hidden independently, and so are the elements a call in flight is drawn with — hiding `tool.running.elapsed` leaves the name in its running colour, hiding `tool.running.title` leaves the seconds counting, hiding `tool.elapsed.done` takes the total off a program's settled row, and a dispatched row is toned the same way per state with `tool.subcall.running` and `tool.subcall.title`. A state is only how a name is painted, so hiding one of those colours leaves the name in the colour a call with no state is read in rather than taking the name away.
 
@@ -659,15 +769,29 @@ The list the dock and `/todo` draw follows the same lifetime every other surface
 |---|---|
 | the screen is taken, before any session opens | `idle`, claiming the pane's agent row |
 | the agent's driver starts, including a run of turns chained through pending work | `working` |
-| an approval, a question, or a picker takes the keyboard | `blocked`, with that card's title sent along |
-| the decision settles | `working` if the driver is running, otherwise `idle` |
-| the agent's driver stops with nothing pending | `idle` |
+| a subagent or background job remains live after the driver stops | `working` until the last one settles |
+| an approval or a question takes the keyboard | `blocked`, with that card's title sent along, and set as the `blocked` display label |
+| the decision settles | `working` if the driver or background work is running, otherwise `idle` |
+| the agent's driver stops with no live subagent or job | `idle` |
 | a session opens, resumes, forks, or is switched to | its id and reason, plus the `dsh_session` / `dsh_cwd` pane tokens |
 | exit, signal, or boot failure | `herdr pane release-agent`, so no row is left waiting on a process that is gone |
 
-A wait outranks a running driver: an agent waiting on a human is not making progress, and the wait is the only thing worth acting on from a wall of panes. The pane reports the agent's driver rather than each turn: the harness chains turns through a pending inbox inside one driver run, and reporting each turn's end would read as done between two turns of an agent that is still working. Reports are sequenced per source, so a delivery that arrives late cannot undo the state the surface already moved past, and a state Herdr is already showing is not sent again. A report is only counted as made when Herdr acknowledges it: one that failed is tried again — soon after, then with a growing wait — and a session identity Herdr never confirmed travels with the next report of any kind. The retry cannot wait for another state change, because the pane may have nothing left to say: a driver that stopped while the socket was down produces no further event. States still waiting to be sent are collapsed into the newest one, so a socket that was down for a minute is told where the pane is rather than where it has been. The release carries the next number in that same sequence for the same reason: Herdr reads one that cannot beat the pane's last report as stale, and a stale release leaves the row waiting on a process that is gone. It also stops reporting first — a claim landing after the release would take the row back for a process that is leaving — and the report already on the wire is waited for before the row goes back, because Herdr ignores the release of a pane nothing has claimed yet and that late report would then claim it. What is still waiting behind it is dropped rather than sent.
+A picker is deliberately absent from that table. Herdr answers a transition into `blocked` with a needs-attention notification and its sound, and 0.9.1 plays it for the focused pane of the active tab as well as for a background one, so a menu the reader opened themselves would ring for their own navigation — once per menu, on the model picker and the reasoning picker behind it — and the row would read as an agent stuck on a decision it never asked for. A gate is the opposite case: the agent asked, and may have asked somebody who walked away.
+
+A wait outranks running work: an agent waiting on a human is not making progress, and the wait is the only thing worth acting on from a wall of panes. The pane follows the agent's driver and the live subagents and jobs it owns. The harness chains turns through a pending inbox inside one driver run, and reporting each turn's end would read as done between two turns of an agent that is still working. A parent driver can also stop while a delegated child or job continues, so its idle transition alone does not make the pane done. The job registry announces settlement before its completion notice wakes the parent, so the pane checks for idle after that handoff instead of briefly announcing done in the middle. Reports are sequenced per source, so a delivery that arrives late cannot undo the state the surface already moved past, and a state Herdr is already showing is not sent again. A report is only counted as made when Herdr acknowledges it: one that failed is tried again — soon after, then with a growing wait — and a session identity Herdr never confirmed travels with the next report of any kind. The retry cannot wait for another state change, because the pane may have nothing left to say: a driver that stopped while the socket was down produces no further event. States still waiting to be sent are collapsed into the newest one, so a socket that was down for a minute is told where the pane is rather than where it has been. The release carries the next number in that same sequence for the same reason: Herdr reads one that cannot beat the pane's last report as stale, and a stale release leaves the row waiting on a process that is gone. It also stops reporting first — a claim landing after the release would take the row back for a process that is leaving — and the report already on the wire is waited for before the row goes back, because Herdr ignores the release of a pane nothing has claimed yet and that late report would then claim it. What is still waiting behind it is dropped rather than sent.
+
+Herdr persists a session reference only for its own built-in integrations, so this pane's session identity travels as metadata tokens instead: a script or a companion plugin reads them back with `herdr pane get <id>` and resumes that exact conversation with `dsh --profile tui --resume=<id>`. Herdr holds a token value up to 80 characters and shortens anything longer, so a session id or directory that cannot be sent whole has its token cleared instead: a shortened path would read as a different directory, and a pane must not claim one. What Herdr cannot do is identify the process itself — its detection table and its screen rules both name built-in agents only — so a pane that has not reported yet reads as an ordinary pane, and is not yet a target: `herdr agent wait` on it fails with `agent_not_found` until the first report lands. Herdr 0.9.1 keeps the title that accompanies a `blocked` state without drawing it anywhere, so the same title is sent again as that state's display label — the one Herdr's sidebar renders through its `state_text` token. The complete default agent rows do not include it:
+
+```toml
+[ui.sidebar.agents]
+rows = [
+  ["state_icon", "machine", "workspace", "tab"],
+  ["state_text"],
+  ["agent"],
+]
+```
 
-Herdr persists a session reference only for its own built-in integrations, so this pane's session identity travels as metadata tokens instead: a script or a companion plugin reads them back with `herdr pane get <id>` and resumes that exact conversation with `dsh --profile tui --resume=<id>`. Herdr holds a token value up to 80 characters and shortens anything longer, so a session id or directory that cannot be sent whole has its token cleared instead: a shortened path would read as a different directory, and a pane must not claim one. What Herdr cannot do is identify the process itself — its detection table and its screen rules both name built-in agents only — so a pane that has not reported yet reads as an ordinary pane, and is not yet a target: `herdr agent wait` on it fails with `agent_not_found` until the first report lands. Herdr 0.9.1 also keeps the title that accompanies a `blocked` state without showing it anywhere, so a reader sees the state and reads the card on screen.
+With that row present, a pane waiting on a decision names the tool that asked instead of showing a colour alone. A label longer than the 80 characters Herdr holds whole is cut here rather than server-side, so the ellipsis lands where this surface put it; the message that rides the state report keeps its own, longer bound.
 
 ## Development
 
@@ -684,6 +808,7 @@ pnpm run build
 node tools/pty-drive.mjs --prompt 'Reply with exactly: pong'
 node tools/pty-drive.mjs --prompt 'Run: echo hi' --approve 20   # answer the approval gate
 node tools/pty-drive.mjs --home /tmp/scratch-home --seconds 20  # no credentials: proves failures are visible
+node tools/pty-drive.mjs --prompt 'Run: echo hi' --click 20:12   # press the left button at row 12
 ```
 
 Keep verification off your real home: install the profile into a throwaway one and copy only the credentials it needs.
@@ -713,11 +838,11 @@ The automated checks drive a real PTY, but they run on this machine's terminal.
 | `NO_COLOR=1 dsh --profile tui` | no styling anywhere, layout unchanged |
 | `dsh --profile tui --no-bell` | a turn that runs for minutes still ends silently |
 | `dsh --profile tui --preset ptc`, then a turn | the status line names `ptc`, and the agent reaches its tools through one TypeScript program rather than one shell call at a time |
-| a PTC turn | one row per dispatched call draws two spaces indented under the `run_code` header without opening it |
+| a PTC turn | the `run_code` card arrives alone, whatever the program dispatched; `ctrl+y` draws one row per call two spaces indented under it without opening it, and a click on the card's own header does the same for that card — and for that card alone, one level, with the program's own rows still behind `ctrl+o` |
 | that turn, then a click on one of those rows | that call unfolds in full at the same indent: its argument, then what the tool itself drew — an edit's diff in the diff colours, a read's lines, a shell's output — and its neighbours and the card stay as they were |
 | a PTC turn in which a dispatched call failed, then a click on that red row | the row opens to the reason the call reported, and a click on those rows folds it back |
-| that same turn, then `ctrl+y` | the rows fold away; `ctrl+y` again draws them back |
-| `dsh-tui: { subcalls: collapsed }` in `$DSH_HOME/settings.yaml`, then a PTC turn | the card arrives alone, and editing the document to `inline` draws the one-line calls in a running session |
+| that same turn, then `ctrl+y` | the rows draw under the folded card; `ctrl+y` again folds them away, and one click on the card's own header does the same for that card alone |
+| `dsh-tui: { subcalls: inline }` in `$DSH_HOME/settings.yaml`, then a PTC turn | the one-line calls draw under the card; deleting the key folds them away |
 | a thought, folded | a click on the row opens the thought under its summary; a click on the body folds it back, and the other thoughts keep their own state |
 | a bash card, then a click on it | the row opens to its command, its retained output, and its exit status; a click folds it back to one row |
 | a bash command that exits non-zero | the same row as any other failure: the tool's name in the failed colour, with the `exit 1` it ended on |
@@ -778,9 +903,11 @@ The workflow stores no npm token: the registry trusts `release.yml` on the `npm-
 
 - Two different things are called a preset. The agent mode (`--preset`, `/preset`) is fixed once a session has produced a turn; the permission preset (`/permission <preset>`, named in the status line) can change at any time.
 - `/model` changes the route and reasoning effort for the running session only. Catalog membership is advisory — an adapter may accept an id it does not advertise, while an explicit effort is checked against the route's own levels before it is applied. The picker offers the routes this deployment configured, not the ones it can prove credentialed: a provider whose key or sign-in is still missing appears like any other, and its first request names the missing credential.
+- Model discovery failures show a safe notice. Healthy provider catalogs remain selectable. Check provider configuration and credentials before retrying `/model`.
 - Scrolling is the mouse wheel, or the terminal's own scrollback keys where it offers them.
 - A turn that ran longer than ten seconds rings the terminal bell when it ends, because the reader may have walked away; `--no-bell` turns that off.
 - The dock shows the goal, plan mode, the todo items still to do, and any background job or delegation still running; a settled item leaves rather than turns into a completed row, and the list clears when the next turn opens so a fresh task never inherits the previous one's checklist. The transcript marks where older history was compacted away. `/plan` toggles plan mode; `/plan <message>` also steers that message, which is the base command's own behaviour.
+- The dock shows three running subagents by default. When more than three run, click the heading, overflow row, or blank cells in that section to show all. Click again to show three. Click a child’s text to view its transcript. Press `ctrl+b` to return.
 - Background jobs and subagent runs are live process state, not durable events: they disappear when the run ends, and a resumed session starts with an empty board and roster.
 - A card reads its tool's own render intent through the agent whose session is on screen, so a stored session with no live agent — one this process is not running, or a child that has already finished — folds to the generic card instead of the tool's own.
 - Reading a child's conversation does not move the terminal: commands, approvals, and the status line stay with the session you launched, and the transcript is the only thing that switches. The status line carries the way back, read from the map in force, so a remap shows up without reopening the view.
@@ -804,7 +931,7 @@ discipline as this one.
 | Plugin | What it adds |
 |---|---|
 | [`@sagmans/dsh-auto-compact`](https://github.com/sagmans/dsh-auto-compact) | An absolute token trigger for automatic compaction: the conversation condenses at `min(thresholdTokens, contextWindow × thresholdRatio)` instead of the window ratio alone, so a large-window model pays a fixed price, with per-route overrides. Its patch swaps the shipped `compaction-basic` backend — the same row this bundle already takes out of the global composition — so the profile still keeps exactly one compaction service, and this surface needs no setting for it. |
-| [`@sagmans/dsh-provider-extra`](https://github.com/sagmans/dsh-provider-extra) | Extra provider routes: OpenCode Go, which sends the live conversation id in `x-opencode-session` for routing and prompt caching, and OpenAI Codex over a ChatGPT subscription's OAuth flow with the harness credential store. Its routes join the `/model` picker like every configured provider. |
+| [`@sagmans/dsh-provider-extra`](https://github.com/sagmans/dsh-provider-extra) | Extra provider routes: OpenCode Go, which sends the live conversation id in `x-opencode-session` for routing and prompt caching, and OpenAI Codex over a ChatGPT subscription's OAuth flow with the harness credential store. Its routes join the `/model` picker like every configured provider. TUI also works without this package, using the core `llm` and `agentDefaultModel` services. |
 
 ```sh
 dsh plugin --profile tui add @sagmans/dsh-auto-compact

package/lib/agent/present.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"present.d.ts","sourceRoot":"","sources":["../../src/agent/present.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,aAAa,CAAA;AA4BpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG,SAAS,GAAG,aAAa,CAqChG"}
+{"version":3,"file":"present.d.ts","sourceRoot":"","sources":["../../src/agent/present.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAEnD,OAAO,EAAgB,KAAK,aAAa,EAAwB,MAAM,aAAa,CAAA;AA4BpF;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG,SAAS,GAAG,aAAa,CAqChG"}

package/lib/agent/present.js

@@ -1,4 +1,5 @@
-import { cardOfCall, cardOfResult, contentLines, } from "../cards.js";
+import { cardOfCall, cardOfResult } from "../cards/presenter.js";
+import { contentLines } from "../cards.js";
 function parseArguments(argumentsJson) {
     try {
         return JSON.parse(argumentsJson);

package/lib/agent/present.js.map

@@ -1 +1 @@
-{"version":3,"file":"present.js","sourceRoot":"","sources":["../../src/agent/present.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,YAAY,EACZ,YAAY,GAGb,MAAM,aAAa,CAAA;AAEpB,SAAS,cAAc,CAAC,aAAqB;IAC3C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAY,CAAA;IAC7C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,iBAAiB,CAAC,OAAgB;IACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAA;IAC3C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,SAAQ;QACzD,MAAM,MAAM,GAAG,KAAgC,CAAA;QAC/C,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;YAAE,OAAO,MAAM,CAAC,OAAO,CAAA;IAC3F,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY,EAAE,KAA+B;IAC/E,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,EAAE;QAClC,IAAI,CAAC;YACH,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC,CAAA;IACD,OAAO;QACL,IAAI,CAAC,IAAI,EAAE,aAAa;YACtB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC,cAAc,CAAC,aAAa,CAAU,CAAC,CAAA;gBACpF,wEAAwE;gBACxE,wEAAwE;gBACxE,sEAAsE;gBACtE,yCAAyC;gBACzC,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YAChE,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,SAAS,CAAA;YAClB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,EAAE,KAAsB;YACjC,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,CAC5C,cAAc,CAAC,KAAK,CAAC,aAAa,CAAU,EAC5C,EAAE,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAW,CACjG,CAAA;gBACD,OAAO,YAAY,CAAC,IAAI,EAAE;oBACxB,IAAI;oBACJ,MAAM,EAAE,KAAK,CAAC,OAAO;oBACrB,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC;iBAC1C,CAAC,CAAA;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,SAAS,CAAA;YAClB,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"present.js","sourceRoot":"","sources":["../../src/agent/present.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,EAAE,YAAY,EAA4C,MAAM,aAAa,CAAA;AAEpF,SAAS,cAAc,CAAC,aAAqB;IAC3C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAY,CAAA;IAC7C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,iBAAiB,CAAC,OAAgB;IACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAA;IAC3C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;YAAE,SAAQ;QACzD,MAAM,MAAM,GAAG,KAAgC,CAAA;QAC/C,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;YAAE,OAAO,MAAM,CAAC,OAAO,CAAA;IAC3F,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY,EAAE,KAA+B;IAC/E,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,EAAE;QAClC,IAAI,CAAC;YACH,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC,CAAA;IACD,OAAO;QACL,IAAI,CAAC,IAAI,EAAE,aAAa;YACtB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC,cAAc,CAAC,aAAa,CAAU,CAAC,CAAA;gBACpF,wEAAwE;gBACxE,wEAAwE;gBACxE,sEAAsE;gBACtE,yCAAyC;gBACzC,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YAChE,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,SAAS,CAAA;YAClB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,EAAE,KAAsB;YACjC,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,CAC5C,cAAc,CAAC,KAAK,CAAC,aAAa,CAAU,EAC5C,EAAE,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAW,CACjG,CAAA;gBACD,OAAO,YAAY,CAAC,IAAI,EAAE;oBACxB,IAAI;oBACJ,MAAM,EAAE,KAAK,CAAC,OAAO;oBACrB,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC;iBAC1C,CAAC,CAAA;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,SAAS,CAAA;YAClB,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

package/lib/cards/composition.d.ts

@@ -0,0 +1,68 @@
+import { type ToolSubCall, type ToolSubCallRows, type ToolCard } from '../cards.ts';
+/**
+ * Nested calls retained on one PTC card.
+ *
+ * A program can dispatch in a loop, and one line each is small but not free;
+ * the cap keeps a card bounded while {@link ToolCard.subCallsTotal} still
+ * reports everything the program ran.
+ */
+export declare const SUBCALL_MAX = 100;
+/**
+ * What the fold learned about one dispatched call, in the order it learned it.
+ *
+ * A call is logged twice — once when the program asks for it, once with what it
+ * answered — and each moment supplies part of the row: the call view names it,
+ * the result view says how it ended and what it produced.
+ */
+export interface SubCallFacts {
+    /** The card the call declared, or nothing when no presenter answered for it. */
+    readonly view: ToolCard | undefined;
+    /** The rows the row opens to, once the call reported them. */
+    readonly output: ToolSubCallRows | undefined;
+    /** How the call finished, as the tool that ran it reported. */
+    readonly status: string | undefined;
+    /** Whether the call is logged and still unanswered. */
+    readonly running: boolean;
+    /** Whether the call is one the log marked as an error. */
+    readonly failed: boolean;
+}
+/**
+ * The one-line row for one nested call, as its start or its settle leaves it.
+ *
+ * A tool that declares a call view is drawn exactly as its own header would be;
+ * only a tool with no view at all falls back to its registry name and raw call,
+ * because the surface cannot name a salient argument for a schema it never saw.
+ * A settle logs the same call again, and the presenter that answered the first
+ * time is asked again for the view it would draw — so the row's identity comes
+ * from the row already on screen wherever there is one, and only a call that was
+ * dropped earlier is named from the log. The row also keeps how the call ended,
+ * because a program's calls are told apart by their outcomes rather than by
+ * anything the program itself says about them.
+ */
+export declare function subCallRow(id: string, name: string, argumentsJson: string, facts: SubCallFacts, existing?: ToolSubCall): ToolSubCall;
+/**
+ * The rows one dispatched call keeps, from the card that drew them.
+ *
+ * The total is clamped to what was kept: a card built from a call or result
+ * view reports no total of its own, because it is not a stream retention had to
+ * cut, and a count below the rows on screen would hint at rows already shown.
+ */
+export declare function subCallRows(card: ToolCard | undefined): ToolSubCallRows | undefined;
+/**
+ * The header fields a rebuilt card must keep.
+ *
+ * Replacing a card's rows says nothing about what the call was made with, what
+ * it measured, how it ended, or which calls it dispatched, so those fields
+ * travel with the rebuild: dropping the argument is how a shell card loses its
+ * command the moment a presenter declines the result.
+ */
+export declare function carriedFields(card: ToolCard): Pick<ToolCard, 'argument' | 'stats' | 'status' | 'subCalls' | 'subCallsTotal'>;
+/**
+ * Collapse one call and its result into the single row the reader sees.
+ *
+ * The pending row already told the reader what the tool is doing, so the
+ * settled row keeps that header and swaps in the outcome; a result that
+ * presents nothing keeps the call's detail rather than blanking the row.
+ */
+export declare function mergeCards(call: ToolCard | undefined, result: ToolCard | undefined): ToolCard;
+//# sourceMappingURL=composition.d.ts.map

package/lib/cards/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../../src/cards/composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAY,MAAM,aAAa,CAAA;AAG7F;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,MAAM,CAAA;AAE9B;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;IACnC,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAA;IAC5C,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,WAAW,CAuBpI;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAGnF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,eAAe,CAAC,CAQ5H;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CA8B7F"}

package/lib/cards/composition.js

@@ -0,0 +1,117 @@
+import { clipLine } from "../cards.js";
+import { title } from "./presenter.js";
+/**
+ * Nested calls retained on one PTC card.
+ *
+ * A program can dispatch in a loop, and one line each is small but not free;
+ * the cap keeps a card bounded while {@link ToolCard.subCallsTotal} still
+ * reports everything the program ran.
+ */
+export const SUBCALL_MAX = 100;
+/**
+ * The one-line row for one nested call, as its start or its settle leaves it.
+ *
+ * A tool that declares a call view is drawn exactly as its own header would be;
+ * only a tool with no view at all falls back to its registry name and raw call,
+ * because the surface cannot name a salient argument for a schema it never saw.
+ * A settle logs the same call again, and the presenter that answered the first
+ * time is asked again for the view it would draw — so the row's identity comes
+ * from the row already on screen wherever there is one, and only a call that was
+ * dropped earlier is named from the log. The row also keeps how the call ended,
+ * because a program's calls are told apart by their outcomes rather than by
+ * anything the program itself says about them.
+ */
+export function subCallRow(id, name, argumentsJson, facts, existing) {
+    const { view, output, status, running, failed } = facts;
+    const title = view?.title ?? existing?.title ?? name;
+    const raw = view !== undefined || existing !== undefined ? undefined : clipLine(argumentsJson);
+    const argument = view?.argument ?? existing?.argument ?? raw;
+    // A failed call keeps only what still holds: the change it declared never
+    // happened, so the rows that drew as applied go with the outcome that never
+    // came. Its outcome stays, because the reason it failed is what a reader opens
+    // the row to read.
+    const presented = failed ? undefined : subCallRows(view) ?? existing?.presented;
+    // A settle that reports nothing keeps what the row already said about its own
+    // outcome, because a call does not stop having finished a certain way.
+    const ended = status ?? existing?.status;
+    return {
+        id,
+        title,
+        ...(argument === undefined || argument === '' ? {} : { argument }),
+        ...(ended === undefined || ended === '' ? {} : { status: ended }),
+        failed,
+        running,
+        ...(presented === undefined ? {} : { presented }),
+        ...(output === undefined ? {} : { output }),
+    };
+}
+/**
+ * The rows one dispatched call keeps, from the card that drew them.
+ *
+ * The total is clamped to what was kept: a card built from a call or result
+ * view reports no total of its own, because it is not a stream retention had to
+ * cut, and a count below the rows on screen would hint at rows already shown.
+ */
+export function subCallRows(card) {
+    if (card === undefined || card.detail.length === 0)
+        return undefined;
+    return { kind: card.kind, rows: card.detail, totalLines: Math.max(card.totalLines, card.detail.length) };
+}
+/**
+ * The header fields a rebuilt card must keep.
+ *
+ * Replacing a card's rows says nothing about what the call was made with, what
+ * it measured, how it ended, or which calls it dispatched, so those fields
+ * travel with the rebuild: dropping the argument is how a shell card loses its
+ * command the moment a presenter declines the result.
+ */
+export function carriedFields(card) {
+    return {
+        ...(card.argument === undefined ? {} : { argument: card.argument }),
+        ...(card.stats === undefined ? {} : { stats: card.stats }),
+        ...(card.status === undefined ? {} : { status: card.status }),
+        ...(card.subCalls === undefined ? {} : { subCalls: card.subCalls }),
+        ...(card.subCallsTotal === undefined ? {} : { subCallsTotal: card.subCallsTotal }),
+    };
+}
+/**
+ * Collapse one call and its result into the single row the reader sees.
+ *
+ * The pending row already told the reader what the tool is doing, so the
+ * settled row keeps that header and swaps in the outcome; a result that
+ * presents nothing keeps the call's detail rather than blanking the row.
+ */
+export function mergeCards(call, result) {
+    const base = call ?? result;
+    if (base === undefined)
+        throw new Error('mergeCards requires at least one card');
+    if (call === undefined || result === undefined)
+        return base;
+    const kind = result.kind === 'generic' ? call.kind : result.kind;
+    // The result, when it names one, knows the argument that was actually acted
+    // on; a terminal result omits it, so the pending call's command is kept. The
+    // result also owns the measured facts, because only it knows the outcome.
+    const argument = result.argument ?? call.argument;
+    const stats = result.stats ?? call.stats;
+    const status = result.status ?? call.status;
+    // The nested calls belong to the call, not the outcome: a result never carries
+    // them, so the merge has to hand the call's own list through.
+    const subCalls = result.subCalls ?? call.subCalls;
+    const subCallsTotal = result.subCallsTotal ?? call.subCallsTotal;
+    return {
+        kind,
+        // The tool that ran is the call's identity: a result card describes the same
+        // call, so it cannot rename the message a reader's clicks are remembered by.
+        tool: call.tool,
+        title: call.title,
+        ...(argument === undefined ? {} : { argument }),
+        ...(stats === undefined ? {} : { stats }),
+        ...(status === undefined ? {} : { status }),
+        ...(subCalls === undefined ? {} : { subCalls }),
+        ...(subCallsTotal === undefined ? {} : { subCallsTotal }),
+        detail: result.detail.length > 0 ? result.detail : call.detail,
+        failed: result.failed,
+        totalLines: result.detail.length > 0 ? result.totalLines : call.totalLines,
+    };
+}
+//# sourceMappingURL=composition.js.map

package/lib/cards/composition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.js","sourceRoot":"","sources":["../../src/cards/composition.ts"],"names":[],"mappings":"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"}

package/lib/cards/presenter.d.ts

@@ -0,0 +1,23 @@
+import { type CardRow, type ToolCard } from '../cards.ts';
+import { type FileDiff, type ToolCallView, type ToolResultView } from '@deepseek-ai/dsh-tools';
+/**
+ * Render one file change as a bounded unified hunk.
+ *
+ * Only the changed middle is shown: a presenter has the prior and next text but
+ * no hunk list, so trimming the shared prefix and suffix yields the same region
+ * a full diff would highlight without paying for a line-diff computation on
+ * every frame.
+ */
+export declare function renderFileDiff(diff: FileDiff): CardRow[];
+export declare function title(view: {
+    title?: string;
+}, fallback: string): string;
+/** Map a tool's pending-call intent to a card, falling back to the raw call name. */
+export declare function cardOfCall(view: ToolCallView | undefined, name: string): ToolCard;
+/** Map a tool's result intent to a card, falling back to the model-facing text. */
+export declare function cardOfResult(view: ToolResultView | undefined, input: {
+    readonly name: string;
+    readonly failed: boolean;
+    readonly contentLines: readonly string[];
+}): ToolCard;
+//# sourceMappingURL=presenter.d.ts.map

package/lib/cards/presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter.d.ts","sourceRoot":"","sources":["../../src/cards/presenter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAA0B,KAAK,QAAQ,EAAkC,MAAM,aAAa,CAAA;AACjH,OAAO,EAA0C,KAAK,QAAQ,EAA4I,KAAK,YAAY,EAAE,KAAK,cAAc,EAAsB,MAAM,wBAAwB,CAAA;AAoGpS;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,EAAE,CAsBxD;AAaD,wBAAgB,KAAK,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkBD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAgEjF;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,GAAG,SAAS,EAChC,KAAK,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACnG,QAAQ,CAoJV"}