@songtonyli/dsh-cli 0.1.13 → 0.1.14

package/README.md

@@ -26,7 +26,7 @@ workspace and no build step. Native packages that ship one build per platform
 ripgrep, the PTY backend's addons, sharp, koffi, and the Landlock launcher — are
 ordinary optional dependencies, so npm resolves the right one for your machine.
 
-Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.13; `dsh --version`
+Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.14; `dsh --version`
 also reports the harness build the package was assembled from.
 
 ## License

package/bin/dsh.mjs

@@ -18,7 +18,7 @@ const argv = process.argv.slice(2)
 // version this package publishes. Reporting only one of the two would make an
 // ordinary `npm install @songtonyli/dsh-cli@x` look like it installed something else.
 if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V')) {
-  console.log('@songtonyli/dsh-cli 0.1.13 (deepseek-harness 0.1.6-alpha.2)')
+  console.log('@songtonyli/dsh-cli 0.1.14 (deepseek-harness 0.1.6-alpha.2)')
   process.exit(0)
 }
 

package/node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/client.js

@@ -160,7 +160,7 @@ window.__ModuleLoader__.load({
 		const SCROLLBAR_LINGER_MS = 2e3;
 		/** Format complete-build metadata for the local brand badge. */
 		function localBuildVersion() {
-			return `0.1.6-alpha.2-c107a31` + ({}.DSH_CLIENT_GIT_DIRTY === "true" ? "-dirty" : "");
+			return `0.1.6-alpha.2-1d90b61-dirty`;
 		}
 		/** Each panel row subscribes only to its own selection state. */
 		function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {

package/node_modules/@deepseek-ai/dsh-cordis-client-runner/lib/client.js

@@ -3319,7 +3319,7 @@ call: (method, args = null) => env.invoke(method, args) }, harnessTrap(), ...Obj
 				occupants: ["client-ui-plan PlanReviewOpen"],
 				replaceRisk: "none",
 				example: "return {\n  inject: ['slots'],\n  apply(ctx) {\n    ctx.slots.inject('conversation.plan-review.actions', () => ctx.slots.register(\n      { name: 'conversation.plan-review.actions', id: 'my-entry', order: 100, label: 'My entry' },\n      () => React.createElement('div', null, 'hello'),\n    ))\n  },\n}",
-				source: "packages/client/ui-user-questions/src/client/contract/slots.ts:21"
+				source: "packages/client/ui-user-questions/src/client/contract/slots.ts:22"
 			},
 			{
 				key: "conversation.session",

package/node_modules/@deepseek-ai/dsh-tui-app/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/bundle/tui-app/README.md
-README.md: d6882721f6938b3c7bd0bbf0637166de2c84fb1d
-README.zh.md: d6fd797cf514205ffe396b2e95529afbd00ed4e6
+README.md: 609455db6daa218a2d71ed685495d1e9a5ca7283
+README.zh.md: 4b943b769e10c62bfe960fb133f311d759f63093

package/node_modules/@deepseek-ai/dsh-tui-app/README.md

@@ -40,11 +40,11 @@ On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui
 
 ### The screen
 
-The header names the session by its title once one is generated or set, with the id beside it. The transcript grows in the terminal's own scrollback: your prompts start with `›` (attachments listed under them), assistant reasoning is dim above the Markdown reply, and each tool call is a card with a status glyph, the tool name, the presenter headline, and a body folded to `toolPreviewLines` rows. Streamed text fades in and every word keeps its own clock: a word enters near the terminal's background color and brightens to the color it settles in over `streamFadeSteps` levels of `streamFadeStepMs` each, so a fast stream leaves a longer trail of brightening words rather than a darker one. The same fade covers streamed reasoning, which settles at the dim foreground it is drawn in, and a tool card, whose header and call rows fade in when the call is logged and whose result rows fade in when the tool answers; a card redrawn from persisted history carries no fade, and text that has settled is never dimmed again. Below the transcript sit a spinner while the agent works, any open prompt, the editor, the subagent panel, and the footer: a status bar of segments over a line of key hints. The editor's caret is the terminal's own blinking bar: the app asks for that shape at start, gives your default back on quit, and draws no caret at all while the status bar or the panel holds the keyboard. Each segment appears only when its fact exists — the model and reasoning effort, the permission preset, the running turn's elapsed time, cumulative token usage, the context window percentage, todo and goal and plan-mode markers from the projection seam, the workspace path (shortened with `~` and `…/` when long), and the count of pending attachments — and `Shift+Down` moves focus into the bar to read a segment's details. Compaction and model-request retries appear as notices, the same facts the browser's markers carry.
+The header names the session by its title once one is generated or set, with the id beside it. The transcript grows in the terminal's own scrollback: your prompts start with `›` (attachments listed under them), assistant reasoning is dim above the Markdown reply, and each tool call is a card with a status glyph, the tool name, the presenter headline, and a body folded to `toolPreviewLines` rows. Streamed reply text fades in and every word keeps its own clock: a word enters near the terminal's background color and brightens to the color it settles in over `streamFadeSteps` ticks of `streamFadeStepMs` each, so a fast stream leaves a longer trail of brightening words rather than a darker one. Streamed reasoning and a tool card float out over the same duration: they appear at a lifted color and recede to the dim italic or palette colors they settle in; a card redrawn from persisted history carries no fade, and text that has settled is never dimmed again. Below the transcript sit a spinner while the agent works, any open prompt, the editor, the subagent panel, and the footer: a status bar that, unfocused, is one line of key facts. The editor's caret is the terminal's own blinking bar: the app asks for that shape at start, gives your default back on quit, and draws no caret at all while the status bar or the panel holds the keyboard. The model, effort (`effort default` when the selection leaves reasoning to the model), and workspace path (shortened with `~` and `…/` when long) are always present; every other segment appears only when its fact exists — the permission preset, the running turn's elapsed time, cumulative token usage, the context window percentage, todo and goal and plan-mode markers from the projection seam, and the count of pending attachments — and `Shift+Down` expands the bar around the selected segment so that segment stays on screen. Compaction and model-request retries appear as notices, the same facts the browser's markers carry.
 
 While the keyboard walks the conversation an inspector is docked directly above the editor. It names the focused section — its position among the navigable blocks, the turn it belongs to, and what the section is, such as `3/12 · turn 2 · bash git status · result` — draws the block's parts as a strip like `‹ reasoning · reply ›` when it has more than one, shows the section's own source rows cut to `focusPreviewLines` with `… <n> more rows · Enter opens the page` under them, and ends with a dim line of the keys it answers. The focused block is also marked where it stands, with a two-column gutter that is dim beside the block's other lines and accented beside the focused section's own, and its content wraps two columns narrower while the mark is drawn. That mark reaches only the lines pi-tui still repaints differentially — the last `rows` lines of the last frame it wrote, a boundary a taller frame raises and a shorter one never lowers — because changing anything above them would clear the terminal's scrollback; a block that has scrolled past that point keeps no gutter and its inspector heading reads `off screen` instead, and a fade whose rows reach that edge settles them to their final colors in the frame that writes them, so nothing stays dim in the scrollback.
 
-The subagent panel is drawn while a subagent session under the bound one is resident, or the listing carries a candidate it could not read. Its heading counts what it lists, and each row gives the child's depth indent, its label or id, its mode (`one-shot` or `continuable`), `resident`, whether its agent is `running` or `idle`, its elapsed time — the open turn's, else the total its settled turns took — and its token usage, as far as this process's own view of that child and the composed projections carry them. Six rows are drawn at most, with `+<n> more · /subagents lists them all` under them; a candidate the listing could not interpret draws as `unreadable: <reason>` and opens nothing, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row.
+The subagent panel is drawn while a subagent session under the bound one is resident, or the listing carries a candidate it could not read. Unfocused it is one summary line with the listed count and the first child's key label; focused, its heading counts what it lists, and each row gives the child's depth indent, its label or id, its mode (`one-shot` or `continuable`), `resident`, whether its agent is `running` or `idle`, its elapsed time — the open turn's, else the total its settled turns took — and its token usage, as far as this process's own view of that child and the composed projections carry them. Six rows are drawn at most, with `+<n> more · /subagents lists them all` under them; a candidate the listing could not interpret draws as `unreadable: <reason>` and opens nothing, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row.
 
 ### Keys and commands
 
@@ -64,7 +64,7 @@ The subagent panel is drawn while a subagent session under the bound one is resi
 
 The conversation, the subagent panel, and the status bar stack in that order, and `Up` / `Down` walk the whole stack without wrapping at either end. While the conversation has focus, `Up` / `Down` move between blocks — your prompts, assistant messages, and tool cards, with notices and printed reports skipped — `Left` / `Right` move between a block's parts, which are the reasoning and the reply of a message and the call and the result of a tool, `Enter` opens the focused part as a read-only page carrying its full rows and comes back to the same part, and `Esc` returns focus to the editor. The rows a part carries are the block's own source text, so a reply reads as the Markdown the model wrote rather than the rendering drawn above. Every other key is consumed there, apart from `Ctrl+C` and `Ctrl+D`; a session switch drops the focus back to the editor, and a session with nothing to inspect yet answers `Shift+Up` with `nothing in the transcript to inspect yet` and leaves the keyboard in the editor.
 
-While the status bar has focus, `Left` / `Right` and `Tab` / `Shift+Tab` move between segments and wrap at both ends, `Up` leaves the bar for the subagent panel's last row while it is drawn and for the conversation otherwise, `Enter` opens the selected segment while the bar keeps focus, and `Esc` returns focus to the editor. No other key reaches the editor while the bar has focus; `Ctrl+C` and `Ctrl+D` keep their usual meaning and return focus to the editor.
+While the status bar has focus, `Left` / `Right`, `Shift+Left` / `Shift+Right`, and `Tab` / `Shift+Tab` move between segments and wrap at both ends, `Up` leaves the bar for the subagent panel's last row while it is drawn and for the conversation otherwise, `Enter` opens the selected segment while the bar keeps focus, and `Esc` returns focus to the editor. No other key reaches the editor while the bar has focus; `Ctrl+C` and `Ctrl+D` keep their usual meaning and return focus to the editor.
 
 While the subagent panel has focus, `Up` / `Down` move the selection and continue into the neighboring regions at its ends — `Up` on the first row reaches the conversation and `Down` on the last row the status bar — `Enter` opens that child's session details as a read-only page and comes back to the panel on the same row, and `Esc` returns focus to the editor. Every other key is consumed there as well, apart from `Ctrl+C` and `Ctrl+D`; the panel also hands the keyboard back to the editor when its last row leaves.
 
@@ -124,8 +124,8 @@ An approval request draws `Allow <tool>?` with the asker's reason, the logged ca
 | `toolPreviewLines` | `8` | Collapsed tool-card body rows before `Ctrl+O` expands them |
 | `focusPreviewLines` | `12` | Rows of the focused section the docked inspector shows before `Enter` opens the whole of it |
 | `liveRefreshMs` | `1000` | Period of the redraw that advances the `turn` segment and the panel's elapsed values and re-reads a stale subagent listing |
-| `streamFadeSteps` | `8` | Brightness levels a streamed word, a reasoning word, or a tool card climbs before it draws in the color it settles in |
-| `streamFadeStepMs` | `33` | How long one brightness level lasts, so a word settles `streamFadeSteps × streamFadeStepMs` after it appeared; it is also the repaint period of the fade |
+| `streamFadeSteps` | `8` | How many ticks a fade lasts: reply text fades in, reasoning and tool cards float out, over `streamFadeSteps × streamFadeStepMs` |
+| `streamFadeStepMs` | `33` | One fade tick, and the repaint period while anything is still fading; duration is `streamFadeSteps × streamFadeStepMs` |
 | `reducedMotion` | `false` | Draw streamed text, streamed reasoning, and tool cards in their settled colors, with no fade and no repeating repaint |
 | `openBrowser` | `true` | Hand marked authorization pages to the local default browser |
 
@@ -167,7 +167,7 @@ The patch rides over `dsh-base`: it sets the coding persona prefix and cwd suffi
 | [`src/navigation.ts`](src/navigation.ts) | The transcript as sections, the cursor that walks them, and the inspector heading |
 | [`src/inspector.ts`](src/inspector.ts) | The docked inspector: the focused section's heading, parts strip, folded rows, and its mounted component |
 | [`src/screen.ts`](src/screen.ts) | The main screen with the settle passes between building a frame and writing it, the repaint window each pass is judged against, and the per-block repaint floor |
-| [`src/fade.ts`](src/fade.ts) | The streamed-text fade: the wall-clock tail tracker, the block-fade clock and registry, the perceptual ramp, and the recolor of rendered lines |
+| [`src/fade.ts`](src/fade.ts) | The streamed-text fade: the wall-clock tail tracker, the block-fade clock and registry, the fade-in ramp, the float-out mix, and the recolor of rendered lines |
 | [`src/prompts.ts`](src/prompts.ts) | Approval, question, picker, and read-only detail prompts plus the modal queue |
 | [`src/transcript.ts`](src/transcript.ts) | Pure text folding of presentation views, usage, and turn-end reasons |
 | [`src/diff.ts`](src/diff.ts) | Line diff and hunk selection for diff cards |
@@ -175,8 +175,8 @@ The patch rides over `dsh-base`: it sets the coding persona prefix and cwd suffi
 | [`src/completion.ts`](src/completion.ts) | Slash-command and `@`-reference completion for the editor |
 | [`src/editor.ts`](src/editor.ts) | The prompt editor without pi-tui's drawn block cursor, and the DECSCUSR sequences for the terminal's own caret |
 | [`src/status.ts`](src/status.ts) | Projection-seam facts and the sections the `/status` report and the segment details share; compaction and retry notices |
-| [`src/footer.ts`](src/footer.ts) | The status bar: the ordered segments, each segment's detail rows, and the footer's two rendered lines |
-| [`src/subagent-panel.ts`](src/subagent-panel.ts) | The live subagent panel: one descendant listing plus sampled live facts become its rows, and the rows its text |
+| [`src/footer.ts`](src/footer.ts) | The status bar: the ordered segments, each segment's detail rows, the one-line unfocused facts, and the focused sliding window |
+| [`src/subagent-panel.ts`](src/subagent-panel.ts) | The live subagent panel: one descendant listing plus sampled live facts become its rows, the unfocused summary line, and the focused listing |
 | [`src/catalog.ts`](src/catalog.ts) | Rows for `/settings`, `/plugins`, `/subagents`, `/deliverables`, `/changes`, and `/outline`, and the `/plugins` management verbs |
 | [`src/todos.ts`](src/todos.ts) | The todo list: the status glyphs, the picker rows, and one item's detail rows |
 | [`cordis.patch.yml`](cordis.patch.yml) | The terminal patch over `dsh-base` |

package/node_modules/@deepseek-ai/dsh-tui-app/README.zh.md

@@ -40,11 +40,11 @@ dsh tui --no-open                         # print sign-in URLs without opening a
 
 ### 屏幕布局
 
-页眉在标题生成或设置后以标题命名会话，并在旁边显示 id。对话记录在终端自身的回滚区中增长：你的提示以 `›` 开头（附件列在其下），assistant 的推理以暗色显示在 Markdown 回复上方，每次工具调用是一张卡片，含状态符号、工具名、呈现器标题，以及折叠到 `toolPreviewLines` 行的正文。流式文字会淡入，而且每个词各走各的时钟：一个词以接近终端背景色的亮度出现，并经 `streamFadeSteps` 级亮度、每级 `streamFadeStepMs` 提亮到它最终稳定的颜色，因此流得更快只会留下更长的一串正在提亮的词，而不会更暗。同一套淡入也覆盖流式推理（它稳定在自身绘制所用的暗色前景）与工具卡片：卡片的表头与调用行在调用被记录时淡入，结果行在工具应答时淡入；从持久化历史重绘的卡片不带淡入，已经稳定下来的文字也不会再被调暗。对话记录下方依次是 agent 工作时的旋转指示、任何打开的提示、编辑器、子 agent 面板，以及页脚：一行分段状态栏，其下是一行按键提示。编辑器的光标是终端自身的闪烁竖条：应用在启动时请求这一形状，退出时把你的默认形状还回去，而状态栏或面板持有键盘期间完全不绘制光标。每个分段只在其事实存在时出现——模型与推理强度、权限预设、正在进行轮次的已用时间、累计 token 用量、上下文窗口百分比、来自投影接缝的 todo、目标与计划模式标记、workspace 路径（过长时以 `~` 与 `…/` 缩短）、待发送附件数量——`Shift+Down` 把焦点移入状态栏以查看某个分段的详情。压缩与模型请求重试以通知形式出现，与浏览器标记承载的事实相同。
+页眉在标题生成或设置后以标题命名会话，并在旁边显示 id。对话记录在终端自身的回滚区中增长：你的提示以 `›` 开头（附件列在其下），assistant 的推理以暗色显示在 Markdown 回复上方，每次工具调用是一张卡片，含状态符号、工具名、呈现器标题，以及折叠到 `toolPreviewLines` 行的正文。流式回复文字会淡入，而且每个词各走各的时钟：一个词以接近终端背景色的亮度出现，并经 `streamFadeSteps` 次、每次 `streamFadeStepMs` 提亮到它最终稳定的颜色，因此流得更快只会留下更长的一串正在提亮的词，而不会更暗。流式推理与工具卡片在同一时长内浮出：它们以抬高的颜色出现，再退回到稳定时的暗色斜体或调色板颜色；从持久化历史重绘的卡片不带淡入，已经稳定下来的文字也不会再被调暗。对话记录下方依次是 agent 工作时的旋转指示、任何打开的提示、编辑器、子 agent 面板，以及页脚：未聚焦时是一行关键事实的状态栏。编辑器的光标是终端自身的闪烁竖条：应用在启动时请求这一形状，退出时把你的默认形状还回去，而状态栏或面板持有键盘期间完全不绘制光标。模型、推理强度（选择把推理交给模型时标为 `effort default`）以及 workspace 路径（过长时以 `~` 与 `…/` 缩短）始终出现；其余分段只在其事实存在时出现——权限预设、正在进行轮次的已用时间、累计 token 用量、上下文窗口百分比、来自投影接缝的 todo、目标与计划模式标记、待发送附件数量——`Shift+Down` 展开状态栏并使所选分段留在屏幕上。压缩与模型请求重试以通知形式出现，与浏览器标记承载的事实相同。
 
 键盘在对话记录中移动时，编辑器正上方停靠着一个检视面板。它写出当前聚焦小节的名称——它在可导航块中的位置、所属轮次，以及这是哪一种小节，例如 `3/12 · turn 2 · bash git status · result`——在块含多个部分时把这些部分绘制成形如 `‹ reasoning · reply ›` 的一条选择行，把该小节自身的源文本行截到 `focusPreviewLines` 行并在其下写出 `… <n> more rows · Enter opens the page`，最后以一行暗色文字列出它所应答的按键。被聚焦的块也会在原地被标记：一条两列宽的标记条，在块的其他行旁为暗色、在被聚焦小节自身的行旁为强调色，标记绘制期间该块的内容按窄两列换行。这个标记只能落在 pi-tui 仍以差分方式重绘的行上——也就是它写出的上一帧的最后 `rows` 行，这条边界只会被更高的帧抬高、不会被更矮的帧降低——因为改动其上方的任何一行都会清空终端的回滚区；已经滚过该位置的块不带标记条，其检视面板标题改为写出 `off screen`；淡入中的各行抵达这一边界时，会在写出该帧的同一帧内被结算为最终颜色，因此回滚区里不会留下暗色文字。
 
-子 agent 面板在绑定会话之下有常驻的子 agent 会话、或列表中带有无法读取的候选者时绘制。其标题统计所列出的条目，每一行给出该子会话的层级缩进、其标签或 id、其模式（`one-shot` 或 `continuable`）、`resident`、其 agent 处于 `running` 还是 `idle`、其已用时间——进行中轮次的用时，否则是已结束轮次的合计——以及其 token 用量，以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行，其下是 `+<n> more · /subagents lists them all`；列表无法解读的候选者绘制为 `unreadable: <reason>` 且打不开任何页面，读取失败的列表则保留上一次成功读取产生的各行，并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。
+子 agent 面板在绑定会话之下有常驻的子 agent 会话、或列表中带有无法读取的候选者时绘制。未聚焦时它是一行摘要，含列出的数量与第一个子会话的关键标签；聚焦时其标题统计所列出的条目，每一行给出该子会话的层级缩进、其标签或 id、其模式（`one-shot` 或 `continuable`）、`resident`、其 agent 处于 `running` 还是 `idle`、其已用时间——进行中轮次的用时，否则是已结束轮次的合计——以及其 token 用量，以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行，其下是 `+<n> more · /subagents lists them all`；列表无法解读的候选者绘制为 `unreadable: <reason>` 且打不开任何页面，读取失败的列表则保留上一次成功读取产生的各行，并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。
 
 ### 按键与命令
 
@@ -64,7 +64,7 @@ dsh tui --no-open                         # print sign-in URLs without opening a
 
 对话记录、子 agent 面板与状态栏按此顺序自上而下排布，`Up` / `Down` 走遍整个序列且在两端都不环绕。对话记录持有焦点时，`Up` / `Down` 在块之间移动——你的提示、assistant 消息与工具卡片，通知与打印出的报告会被跳过——`Left` / `Right` 在块的各部分之间移动，也就是一条消息的推理与回复、一次工具调用的调用与结果，`Enter` 把当前聚焦的部分作为只读页面打开、其中带有该部分的完整各行，离开后回到同一部分，`Esc` 把焦点交还编辑器。各部分承载的是块自身的源文本，因此一条回复读到的是模型写下的 Markdown，而不是其上方绘制出的渲染结果。除 `Ctrl+C` 与 `Ctrl+D` 外，其他按键都在此被消费；切换会话会把焦点交回编辑器，尚无可查看内容的会话对 `Shift+Up` 回以 `nothing in the transcript to inspect yet` 并把键盘留在编辑器。
 
-状态栏持有焦点时，`Left` / `Right` 与 `Tab` / `Shift+Tab` 在分段之间移动并在两端环绕，`Up` 在面板已绘制时离开状态栏前往面板的最后一行、否则前往对话记录，`Enter` 打开所选分段且状态栏保持焦点，`Esc` 把焦点交还编辑器。状态栏持有焦点期间其他按键不会到达编辑器；`Ctrl+C` 与 `Ctrl+D` 保持其一贯含义，并把焦点交还编辑器。
+状态栏持有焦点时，`Left` / `Right`、`Shift+Left` / `Shift+Right` 与 `Tab` / `Shift+Tab` 在分段之间移动并在两端环绕，`Up` 在面板已绘制时离开状态栏前往面板的最后一行、否则前往对话记录，`Enter` 打开所选分段且状态栏保持焦点，`Esc` 把焦点交还编辑器。状态栏持有焦点期间其他按键不会到达编辑器；`Ctrl+C` 与 `Ctrl+D` 保持其一贯含义，并把焦点交还编辑器。
 
 子 agent 面板持有焦点时，`Up` / `Down` 移动选择，并在其两端继续进入相邻区域——在第一行按 `Up` 到达对话记录，在最后一行按 `Down` 到达状态栏——`Enter` 把该子会话的详情作为只读页面打开、离开后回到面板的同一行，`Esc` 把焦点交还编辑器。除 `Ctrl+C` 与 `Ctrl+D` 外，其他按键同样在此被消费；面板的最后一行离开时，它也会把键盘交还编辑器。
 
@@ -124,8 +124,8 @@ dsh tui --no-open                         # print sign-in URLs without opening a
 | `toolPreviewLines` | `8` | `Ctrl+O` 展开前折叠的工具卡片正文行数 |
 | `focusPreviewLines` | `12` | `Enter` 完整打开之前，停靠的检视面板为聚焦小节显示的行数 |
 | `liveRefreshMs` | `1000` | 重绘周期：推进 `turn` 分段与面板中的已用时间，并重新读取已过期的子 agent 列表 |
-| `streamFadeSteps` | `8` | 一个流式词、一个推理词或一张工具卡片在以其稳定颜色绘制之前经过的亮度级数 |
-| `streamFadeStepMs` | `33` | 每级亮度持续多久，因此一个词在出现后 `streamFadeSteps × streamFadeStepMs` 稳定下来；这也是淡入的重绘周期 |
+| `streamFadeSteps` | `8` | 一次淡入或浮出持续多少拍：回复文字淡入，推理与工具卡片浮出，时长为 `streamFadeSteps × streamFadeStepMs` |
+| `streamFadeStepMs` | `33` | 一拍淡入或浮出的时长，也是仍在变化时的重绘周期；总时长为 `streamFadeSteps × streamFadeStepMs` |
 | `reducedMotion` | `false` | 以稳定颜色绘制流式文本、流式推理与工具卡片，不做淡入，也不重复重绘 |
 | `openBrowser` | `true` | 把被标记的授权页面交给本地默认浏览器 |
 
@@ -167,7 +167,7 @@ runner 等待完整应用就绪（`ctx.get('loader')?.await()`），并在核心
 | [`src/navigation.ts`](src/navigation.ts) | 把对话记录看作各个小节、走遍它们的光标，以及检视面板的标题 |
 | [`src/inspector.ts`](src/inspector.ts) | 停靠的检视面板：聚焦小节的标题、各部分选择行、折叠后的各行，及其挂载的组件 |
 | [`src/screen.ts`](src/screen.ts) | 在构建一帧与写出该帧之间带若干次结算的主屏幕、每次结算所依据的重绘窗口，以及每个块的重绘下界 |
-| [`src/fade.ts`](src/fade.ts) | 流式文本淡入：基于挂钟的尾部追踪器、块淡入时钟与注册表、感知均匀的亮度级别，以及对已渲染行的重新着色 |
+| [`src/fade.ts`](src/fade.ts) | 流式文本淡入与浮出：基于挂钟的尾部追踪器、块时钟与注册表、淡入亮度级别、浮出混合，以及对已渲染行的重新着色 |
 | [`src/prompts.ts`](src/prompts.ts) | 审批、提问、选择器与只读详情提示以及模态队列 |
 | [`src/transcript.ts`](src/transcript.ts) | 呈现视图、用量与轮次结束原因的纯文本折叠 |
 | [`src/diff.ts`](src/diff.ts) | diff 卡片的行 diff 与 hunk 选择 |
@@ -175,8 +175,8 @@ runner 等待完整应用就绪（`ctx.get('loader')?.await()`），并在核心
 | [`src/completion.ts`](src/completion.ts) | 编辑器的斜杠命令与 `@` 引用补全 |
 | [`src/editor.ts`](src/editor.ts) | 去掉 pi-tui 自绘块状光标的提示编辑器，以及终端自身光标所用的 DECSCUSR 序列 |
 | [`src/status.ts`](src/status.ts) | 投影接缝的事实，以及 `/status` 报告与分段详情共享的小节；压缩与重试通知 |
-| [`src/footer.ts`](src/footer.ts) | 状态栏：有序的各分段、每个分段的详情行，以及页脚渲染出的两行 |
-| [`src/subagent-panel.ts`](src/subagent-panel.ts) | 实时子 agent 面板：一次后代列表加上采样到的实时事实构成其各行，各行再构成其文本 |
+| [`src/footer.ts`](src/footer.ts) | 状态栏：有序的各分段、每个分段的详情行、未聚焦时的一行关键事实，以及聚焦时的滑动窗口 |
+| [`src/subagent-panel.ts`](src/subagent-panel.ts) | 实时子 agent 面板：一次后代列表加上采样到的实时事实构成其各行、未聚焦时的摘要行，以及聚焦时的列表 |
 | [`src/catalog.ts`](src/catalog.ts) | `/settings`、`/plugins`、`/subagents`、`/deliverables`、`/changes` 与 `/outline` 的行，以及 `/plugins` 的管理动作 |
 | [`src/todos.ts`](src/todos.ts) | todo 列表：状态符号、选择器行与单个条目的详情行 |
 | [`cordis.patch.yml`](cordis.patch.yml) | 基于 `dsh-base` 的终端 patch |

package/node_modules/@deepseek-ai/dsh-tui-app/lib/index.js

@@ -1014,6 +1014,10 @@ const LUMINANCE = {
 };
 /** Largest value one color channel encodes. */
 const CHANNEL_MAX = 255;
+/** Channel scale SGR faint applies when a float-out reads a dim run. */
+const DIM_CHANNEL = .5;
+/** How far a float-out lifts a color that is already brighter than `fg` toward white. */
+const LIFT_TOWARD_WHITE = .5;
 /** Encoded sRGB value below which the transfer function is the linear segment. */
 const SRGB_LINEAR_CUT = .04045;
 /** Linear intensity below which the sRGB transfer function is the linear segment. */
@@ -1093,6 +1097,34 @@ function mix(from, to, ratio) {
 	return toSrgb(linear + (toLinear(to) - linear) * ratio);
 }
 /**
+* Mix `from` toward `to` with the same smoothstep-in-linear-light interpolation
+* {@link buildFadeRamp} uses. Positions at or below 0 and at or above 1 return
+* that endpoint's bytes, so a float-out's last computed mix can match the
+* settled color it recedes toward.
+* @param from - the color at t = 0.
+* @param to - the color at t = 1.
+* @param t - position along the mix; values outside 0..1 clamp to an endpoint.
+* @returns the mixed sRGB color.
+*/
+function mixFadeColor(from, to, t) {
+	if (t <= 0) return {
+		r: from.r,
+		g: from.g,
+		b: from.b
+	};
+	if (t >= 1) return {
+		r: to.r,
+		g: to.g,
+		b: to.b
+	};
+	const eased = t * t * (3 - 2 * t);
+	return {
+		r: mix(from.r, to.r, eased),
+		g: mix(from.g, to.g, eased),
+		b: mix(from.b, to.b, eased)
+	};
+}
+/**
 * Decode one sRGB channel to linear light, by the sRGB transfer function.
 * @param value - the channel byte.
 * @returns the linear intensity in 0..1.
@@ -1121,7 +1153,7 @@ function toSrgb(value) {
 function fadeSgr(style, age) {
 	if (style.capability === "none") return "";
 	if (style.capability === "dim") return age < DIM_AGES ? DIM : "";
-	const level = style.ramp[Math.max(0, Math.min(age, style.ramp.length - 1))];
+	const level = style.ramp[Math.max(0, Math.min(Math.floor(age), style.ramp.length - 1))];
 	if (level === void 0) return "";
 	return style.capability === "truecolor" ? truecolorSgr(level) : grayscaleSgr(level);
 }
@@ -1163,31 +1195,340 @@ function restoreFor(capability) {
 /** Every SGR sequence, the sequences a block's own palette styling writes. */
 const SGR_SEQUENCE = /\u001b\[[0-9;]*m/g;
 /**
-* Draw whole rendered lines at one brightness level, for a block that fades in
-* as a unit rather than word by word.
+* Draw whole rendered lines as a float-out: each SGR run starts at a lifted
+* mix toward the assumed foreground and recedes to the run's own settled
+* color. At `age >= ramp.length` the lines come back byte-identical, so the
+* palette sequences win without a snap. The two-level mode overlays faint for
+* the whole flight; the caller stops invoking this once the clock settles.
 *
-* The level is opened at the start of the line and reasserted after every SGR
-* the line already carries, so the palette colors inside a card - the status
-* glyph, the dim body rule, the bold tool name - are overridden while the card
-* fades and come back on their own once it settles. Each line ends with the
-* sequence that undoes what the level set - the terminal's own foreground, or
-* its normal intensity in the two-level mode - so the level never leaks past
-* the line it was applied to. Empty lines come back byte-identical, so
-* the renderer leaves the blank rows around a card alone.
+* The mix is opened after every SGR the line already carries, so the status
+* glyph, the dim body rule, and the bold tool name each recede toward their
+* own color. Each line ends with the sequence that undoes the overlay, so the
+* mix never leaks past the line it was applied to. Empty lines come back
+* byte-identical, so the renderer leaves the blank rows around a card alone.
 * @param lines - the rendered lines of the block.
-* @param age - the brightness level to draw them at.
-* @param style - the capability and the ramp.
-* @param from - first line the level is applied to; the lines before it come
+* @param age - elapsed time in units of `stepMs`; `ramp.length` is t = 1.
+* @param style - the capability and the ramp whose last level is the assumed foreground.
+* @param from - first line the mix is applied to; the lines before it come
 * back byte-identical, which is how a caller keeps rows the renderer can no
 * longer repaint out of the fade.
-* @returns the lines at that level; copies when the style writes no sequence
-* for this age, which is what the `none` capability and a settled age yield.
+* @returns the lines at that mix; copies when the style writes no sequence,
+* which is what the `none` capability and a settled age yield.
 */
 function recolorLines(lines, age, style, from = 0) {
-	const sgr = fadeSgr(style, age);
-	if (sgr === "") return [...lines];
-	const restore = restoreFor(style.capability);
-	return lines.map((line, index) => index < from || line === "" ? line : `${sgr}${line.replace(SGR_SEQUENCE, (match) => match + sgr)}${restore}`);
+	const capability = style.capability;
+	if (capability === "none") return [...lines];
+	if (capability === "dim") return lines.map((line, index) => index < from || line === "" ? line : `${DIM}${line}${RESET_INTENSITY}`);
+	const steps = style.ramp.length;
+	const fg = style.ramp[steps - 1];
+	if (fg === void 0 || age >= steps) return [...lines];
+	const t = age / steps;
+	return lines.map((line, index) => index < from || line === "" ? line : floatOutLine(line, t, capability, fg));
+}
+/** Assumed terminal white, used only to lift a settled color that is already brighter than `fg`. */
+const WHITE_RGB = {
+	r: CHANNEL_MAX,
+	g: CHANNEL_MAX,
+	b: CHANNEL_MAX
+};
+/** xterm 16-color palette, indices 0..15. */
+const ANSI16 = [
+	{
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 205,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 205,
+		b: 0
+	},
+	{
+		r: 205,
+		g: 205,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 0,
+		b: 238
+	},
+	{
+		r: 205,
+		g: 0,
+		b: 205
+	},
+	{
+		r: 0,
+		g: 205,
+		b: 205
+	},
+	{
+		r: 229,
+		g: 229,
+		b: 229
+	},
+	{
+		r: 127,
+		g: 127,
+		b: 127
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 92,
+		g: 92,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 255
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 255
+	}
+];
+/**
+* Relative luminance of one sRGB color, using the same weights as the grayscale encoder.
+* @param color - the color.
+* @returns the weighted sum of the channels.
+*/
+function colorLuminance(color) {
+	return LUMINANCE.r * color.r + LUMINANCE.g * color.g + LUMINANCE.b * color.b;
+}
+/**
+* The color a float-out starts from: the assumed foreground when that is
+* brighter than the settle, otherwise a mix toward white.
+* @param settled - the run's color at t = 1.
+* @param fg - the assumed terminal foreground.
+* @returns the lifted color at t = 0.
+*/
+function liftColor(settled, fg) {
+	return colorLuminance(fg) >= colorLuminance(settled) ? fg : mixFadeColor(settled, WHITE_RGB, LIFT_TOWARD_WHITE);
+}
+/**
+* Apply SGR faint as a channel scale, matching what a dim palette run looks like.
+* @param color - the undimmed RGB.
+* @returns the dimmed RGB.
+*/
+function dimColor(color) {
+	return {
+		r: Math.round(color.r * DIM_CHANNEL),
+		g: Math.round(color.g * DIM_CHANNEL),
+		b: Math.round(color.b * DIM_CHANNEL)
+	};
+}
+/**
+* The RGB a run settles at, given the SGR in force and the assumed default foreground.
+* @param state - the SGR foreground and dim flag.
+* @param fg - the assumed default foreground.
+* @returns the settled color the mix recedes toward.
+*/
+function settledRgb(state, fg) {
+	const base = state.color ?? fg;
+	return state.dim ? dimColor(base) : base;
+}
+/**
+* Encode one mixed color under a color capability.
+* @param capability - `truecolor` or `ansi256`.
+* @param color - the mixed RGB.
+* @returns the SGR sequence, or empty when the capability cannot encode a mix.
+*/
+function encodeMix(capability, color) {
+	return capability === "truecolor" ? truecolorSgr(color) : `${CSI}38;5;${String(nearestAnsi256(color))}m`;
+}
+/**
+* Rebuild one card row as a per-run float-out mix.
+* @param line - the rendered line.
+* @param t - 0 at lift, 1 at settle.
+* @param capability - how the mix is encoded.
+* @param fg - the assumed default foreground.
+* @returns the line with each run overlaid, closed by {@link RESET_FOREGROUND}.
+*/
+function floatOutLine(line, t, capability, fg) {
+	let out = "";
+	let last = 0;
+	const state = {
+		color: void 0,
+		dim: false
+	};
+	for (const match of line.matchAll(SGR_SEQUENCE)) {
+		const start = match.index;
+		if (start > last) out += paintSegment(line.slice(last, start), state, t, capability, fg);
+		applySgr(state, match[0]);
+		out += match[0];
+		last = start + match[0].length;
+	}
+	if (last < line.length) out += paintSegment(line.slice(last), state, t, capability, fg);
+	return `${out}${RESET_FOREGROUND}`;
+}
+/**
+* Overlay one text run with the float-out mix for the SGR in force.
+* @param text - the run's characters, with no SGR.
+* @param state - the SGR in force.
+* @param t - 0 at lift, 1 at settle.
+* @param capability - how the mix is encoded.
+* @param fg - the assumed default foreground.
+* @returns the run prefixed by intensity-reset and the mixed color.
+*/
+function paintSegment(text, state, t, capability, fg) {
+	const settled = settledRgb(state, fg);
+	return `${RESET_INTENSITY}${encodeMix(capability, mixFadeColor(liftColor(settled, fg), settled, t))}${text}`;
+}
+/**
+* The float-out sequence one reasoning span draws under, toward dimmed `fg`.
+* @param style - the capability and the ramp.
+* @param age - elapsed time in units of `stepMs`.
+* @returns the sequence, or empty once `age` reaches the ramp length.
+*/
+function floatOutSpanSgr(style, age) {
+	if (style.capability === "dim") return DIM;
+	if (style.capability !== "truecolor" && style.capability !== "ansi256") return "";
+	const steps = style.ramp.length;
+	const fg = style.ramp[steps - 1];
+	if (fg === void 0 || age >= steps) return "";
+	const settled = dimColor(fg);
+	const mixed = mixFadeColor(liftColor(settled, fg), settled, age / steps);
+	return `${RESET_INTENSITY}${encodeMix(style.capability, mixed)}`;
+}
+/**
+* Apply one SGR sequence to the float-out foreground state.
+* @param state - the state to update.
+* @param sequence - a CSI SGR including the trailing `m`.
+*/
+function applySgr(state, sequence) {
+	const body = sequence.slice(2, -1);
+	const parts = body === "" ? [0] : body.split(";").map((part) => part === "" ? 0 : Number(part));
+	for (let index = 0; index < parts.length; index += 1) {
+		const code = colorParam(parts, index);
+		if (code === 0) {
+			state.color = void 0;
+			state.dim = false;
+		} else if (code === 2) state.dim = true;
+		else if (code === 22) state.dim = false;
+		else if (code === 39) state.color = void 0;
+		else if (code >= 30 && code <= 37) state.color = ANSI16[code - 30];
+		else if (code >= 90 && code <= 97) state.color = ANSI16[code - 90 + 8];
+		else if (code === 38) {
+			const read = readExtendedColor(parts, index);
+			state.color = read.color;
+			index += read.skip;
+		} else if (code === 48) index += readExtendedColor(parts, index).skip;
+	}
+}
+/**
+* Consume an ITU T.416 extended color (`38`/`48` plus `2;R;G;B` or `5;N`).
+* @param parts - the SGR parameter list.
+* @param index - index of the `38` or `48` code.
+* @returns the RGB for a foreground read, and how many following parameters were consumed.
+*/
+function readExtendedColor(parts, index) {
+	const mode = parts[index + 1];
+	if (mode === 2) return {
+		color: {
+			r: channel(colorParam(parts, index + 2)),
+			g: channel(colorParam(parts, index + 3)),
+			b: channel(colorParam(parts, index + 4))
+		},
+		skip: 4
+	};
+	if (mode === 5) return {
+		color: ansi256Rgb(colorParam(parts, index + 2)),
+		skip: 2
+	};
+	return {
+		color: void 0,
+		skip: mode === void 0 ? 0 : 1
+	};
+}
+/**
+* Read one SGR numeric parameter, defaulting a missing slot to 0.
+* @param parts - the SGR parameter list.
+* @param index - the slot to read.
+* @returns the parameter, or 0 when it is absent.
+*/
+function colorParam(parts, index) {
+	return parts[index] ?? 0;
+}
+/**
+* RGB for one xterm 256-color index.
+* @param index - 0..255.
+* @returns the palette color, clamped onto the table.
+*/
+function ansi256Rgb(index) {
+	const n = Math.max(0, Math.min(255, Math.floor(index)));
+	if (n < 16) {
+		const color = ANSI16[n];
+		/* v8 ignore next -- ANSI16 has 16 entries and n is already clamped to 0..15 */
+		if (color === void 0) return {
+			r: 0,
+			g: 0,
+			b: 0
+		};
+		return color;
+	}
+	if (n >= GRAY_FIRST_INDEX) {
+		const value = GRAY_FIRST_VALUE + (n - GRAY_FIRST_INDEX) * GRAY_VALUE_STEP;
+		return {
+			r: value,
+			g: value,
+			b: value
+		};
+	}
+	const cube = n - 16;
+	const r = Math.floor(cube / 36);
+	const g = Math.floor(cube % 36 / 6);
+	const b = cube % 6;
+	const level = (step) => step === 0 ? 0 : 55 + step * 40;
+	return {
+		r: level(r),
+		g: level(g),
+		b: level(b)
+	};
+}
+/**
+* Nearest xterm 256-color index to one RGB, by squared channel distance.
+* @param color - the mixed RGB.
+* @returns an index in 0..255.
+*/
+function nearestAnsi256(color) {
+	let best = 0;
+	let bestDist = Infinity;
+	for (let n = 0; n < 256; n += 1) {
+		const candidate = ansi256Rgb(n);
+		const dist = (candidate.r - color.r) ** 2 + (candidate.g - color.g) ** 2 + (candidate.b - color.b) ** 2;
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = n;
+		}
+	}
+	return best;
 }
 /**
 * The tail of one streaming region - the visible text or the reasoning of one
@@ -1202,8 +1543,8 @@ function recolorLines(lines, age, style, from = 0) {
 * Ages are read, never counted. A chunk's age is the elapsed time since it
 * became visible divided by `stepMs`, computed at the moment a render asks for
 * it, so a render triggered by a delta between two fade periods draws every
-* word at its own level and words do not move in lockstep. That is what makes
-* the trailing edge continuous rather than banded.
+* word at its own mix and words do not move in lockstep. Fade-in floors that
+* age onto a ramp slot; float-out uses the fractional value.
 *
 * Arrival rate changes the tail's length, never its depth: whatever the rate,
 * a chunk is at the foreground `steps * stepMs` after it appeared, so a fast
@@ -1252,7 +1593,7 @@ var FadeTracker = class {
 	* Drop the chunks that reached the step count, which the application runs
 	* once per fade period so a settled chunk stops being matched against the
 	* rendered lines.
-	* @returns whether a chunk still draws below the last brightness level, and
+	* @returns whether a chunk is still younger than `steps * stepMs`, and
 	* so whether the tail keeps moving after this period.
 	*/
 	tick() {
@@ -1263,11 +1604,10 @@ var FadeTracker = class {
 	}
 	/**
 	* Whether the current frame still differs from the settled rendering.
-	* @returns true while a tracked chunk draws below the last ramp level, which
-	* is the only reason to keep ticking.
+	* @returns true while a tracked chunk is younger than `steps * stepMs`.
 	*/
 	needsRepaint() {
-		return this.chunks.some((chunk) => this.ageOf(chunk) < this.steps - 1);
+		return this.chunks.some((chunk) => this.ageOf(chunk) < this.steps);
 	}
 	/**
 	* The tail {@link recolorTail} recolors.
@@ -1290,21 +1630,22 @@ var FadeTracker = class {
 		this.openChunk = void 0;
 	}
 	/**
-	* The brightness level one chunk draws at right now.
+	* The brightness age one chunk draws at right now.
 	* @param chunk - the tracked chunk.
-	* @returns levels elapsed since it became visible, 0 for a chunk younger than one level.
+	* @returns elapsed time since it became visible, in units of `stepMs`.
 	*/
 	ageOf(chunk) {
-		return Math.floor((this.now() - chunk.bornAt) / this.stepMs);
+		return (this.now() - chunk.bornAt) / this.stepMs;
 	}
 };
 /**
-* The age of one whole block that fades in as a unit - a tool card's rows,
+* The age of one whole block that floats out as a unit - a tool card's rows,
 * which arrive complete rather than word by word.
 *
-* The last level is withheld the way the word tail withholds it: that level is
-* an assumed foreground, so a block one level below the end is handed back to
-* the terminal's own colors instead, and nothing jumps color as it settles.
+* Progress is `elapsed / (steps * stepMs)`, eased by the same smoothstep the
+* ramp uses. {@link BlockFadeClock.age} stays defined until that progress
+* reaches 1, so the last overlay frame can sit near the settled colors and
+* the next frame is the component's own bytes.
 */
 var BlockFadeClock = class {
 	options;
@@ -1312,18 +1653,25 @@ var BlockFadeClock = class {
 		this.options = options;
 	}
 	/**
-	* The brightness level the block draws at right now.
-	* @returns the level, or undefined once the block reached the last drawn
-	* level and renders in the colors the component itself produced.
+	* How far through the float-out this block is.
+	* @returns 0 at birth, 1 at or after `steps * stepMs`.
 	*/
-	age() {
+	progress() {
 		const { bornAt, stepMs, steps, now } = this.options;
-		const age = Math.floor((now() - bornAt) / stepMs);
-		return age < steps - 1 ? age : void 0;
+		return Math.min(1, Math.max(0, (now() - bornAt) / (steps * stepMs)));
+	}
+	/**
+	* The fractional age the block draws at right now, in units of `stepMs`.
+	* @returns `progress * steps`, or undefined once progress has reached 1 and
+	* the block renders in the colors the component itself produced.
+	*/
+	age() {
+		const t = this.progress();
+		return t >= 1 ? void 0 : t * this.options.steps;
 	}
 	/**
-	* Whether this block still draws below the last brightness level.
-	* @returns true while {@link BlockFadeClock.age} yields a level.
+	* Whether this block still draws below the settled colors.
+	* @returns true while {@link BlockFadeClock.age} yields a value.
 	*/
 	needsRepaint() {
 		return this.age() !== void 0;
@@ -1376,27 +1724,32 @@ var FadeRegistry = class {
 *
 * Styling inside a recolored run survives. The run reasserts the sequences in
 * force at its start, so an enclosing bold or italic continues across it; an
-* enclosing foreground color reasserted there wins over the ramp, and that run
-* simply does not fade. Each recolored line ends with `ESC[39m` (or `ESC[22m`
-* in the two-level mode, which also ends bold) after the line's own closing
-* sequences, so the recolor never leaks past the line it was applied to.
+* enclosing foreground color reasserted there wins over the fade-in ramp, and
+* that run simply does not fade. Each recolored line ends with `ESC[39m` (or
+* `ESC[22m` in the two-level mode, which also ends bold) after the line's own
+* closing sequences, so the recolor never leaks past the line it was applied
+* to. Float-out resets intensity before the mixed color so a dim wrapper does
+* not stack on the overlay, and at t >= 1 the original lines come back
+* unchanged.
 * @param lines - the rendered lines of the streaming block, newest text last.
 * @param spans - the tail from {@link FadeTracker.spans}, oldest first.
 * @param style - the capability and the ramp.
 * @param from - first line the tail may recolor; the lines before it come back
 * byte-identical, which is how a caller keeps rows the renderer can no longer
 * repaint out of the fade.
+* @param mode - `in` climbs {@link buildFadeRamp}; `out` recedes toward the
+* dim foreground reasoning settles in. Defaults to `in`.
 * @returns the lines with the tail recolored; lines the tail does not cover
 * are returned byte-identical, so the renderer leaves them alone.
 */
-function recolorTail(lines, spans, style, from = 0) {
-	if (style.capability === "none" || spans.length === 0 || lines.length === 0) return [...lines];
+function recolorTail(lines, spans, style, from = 0, mode = "in") {
+	if (spans.length === 0 || lines.length === 0) return [...lines];
 	const cells = cellsFromEnd(lines);
 	const runs = [];
 	for (const span of [...spans].reverse()) {
 		const covered = consumeSpan(cells, span.text);
 		if (covered === void 0) break;
-		const sgr = fadeSgr(style, span.age);
+		const sgr = mode === "out" ? floatOutSpanSgr(style, span.age) : fadeSgr(style, span.age);
 		if (sgr !== "") collectRuns(runs, covered, sgr);
 	}
 	const byLine = /* @__PURE__ */ new Map();
@@ -1700,8 +2053,9 @@ var NoticeBlock = class {
 * durable `assistant/message` replaces both with the committed content.
 *
 * A block that is streaming right now can carry a {@link FadeRender} for its
-* text and another for its reasoning, each drawing that region's newest words
-* dimmed and brightening. A block rebuilt from history carries neither, and
+* text and another for its reasoning. Visible text draws newest words dimmed
+* and brightening; reasoning floats out from a lifted color toward the dim
+* italic it settles in. A block rebuilt from history carries neither, and
 * {@link AssistantBlock.commit} drops the ones a streaming block had, so
 * settled text is never recolored.
 */
@@ -1783,7 +2137,7 @@ var AssistantBlock = class {
 	setRepaintFloor(floor) {
 		if (floor <= this.repaintFloor) return false;
 		this.repaintFloor = floor;
-		return drawnSpans(this.fade).length > 0 || drawnSpans(this.reasoningFade).length > 0;
+		return this.fade !== void 0 && fadingInSpans(this.fade).length > 0 || this.reasoningFade !== void 0 && floatingOutSpans(this.reasoningFade).length > 0;
 	}
 	/**
 	* Append streamed visible text.
@@ -1849,13 +2203,11 @@ var AssistantBlock = class {
 		return withGutter(this.theme.palette, lines, (index) => index >= section.from && index < section.to);
 	}
 	/**
-	* The reasoning lines, with the streaming tail recolored.
+	* The reasoning lines, with the streaming tail floated out toward dim italic.
 	*
-	* The ramp climbs towards the assumed terminal foreground, but the reasoning
-	* draws inside the faint and italic sequences `appendReasoning` wrapped it
-	* in, and a recolored run reasserts the styling in force at its start. The
-	* tail therefore arrives at the dim foreground the settled reasoning carries,
-	* not at the plain one.
+	* The mix starts at a lifted color and recedes to the faint foreground the
+	* settled reasoning already carries. At full age the original dim italic
+	* bytes come back unchanged.
 	* @param width - the width the reasoning lays out in.
 	* @param at - index of the region's first line in this block's render.
 	* @returns the lines to draw.
@@ -1866,7 +2218,7 @@ var AssistantBlock = class {
 		if (fade === void 0) return lines;
 		if (this.reasoningFadeWidth !== void 0 && this.reasoningFadeWidth !== width) fade.flush();
 		this.reasoningFadeWidth = width;
-		return recolorTail(lines, drawnSpans(fade), fade.style(), this.repaintFloor - at);
+		return recolorTail(lines, floatingOutSpans(fade), fade.style(), this.repaintFloor - at, "out");
 	}
 	/**
 	* The Markdown lines, with the streaming tail recolored.
@@ -1885,14 +2237,14 @@ var AssistantBlock = class {
 		if (fade === void 0) return lines;
 		if (this.fadeWidth !== void 0 && this.fadeWidth !== width) fade.flush();
 		this.fadeWidth = width;
-		return recolorTail(lines, drawnSpans(fade), fade.style(), this.repaintFloor - at);
+		return recolorTail(lines, fadingInSpans(fade), fade.style(), this.repaintFloor - at);
 	}
 };
 /**
 * A tool call card: status glyph, tool name, headline, then a foldable body.
 *
-* The card arrives in two pieces, and each fades in on its own: the header and
-* the call rows when the call is logged, the result rows when the tool
+* The card arrives in two pieces, and each floats out on its own: the header
+* and the call rows when the call is logged, the result rows when the tool
 * answers. A card rebuilt from history carries neither fade.
 */
 var ToolBlock = class {
@@ -1961,7 +2313,7 @@ var ToolBlock = class {
 	}
 	/**
 	* Hand the rows the renderer can no longer repaint back to the colors this
-	* card drew them in, so a fade that is still climbing never rewrites them.
+	* card drew them in, so a fade that is still moving never rewrites them.
 	* @param floor - this card's own first repaintable line; the application
 	* raises it as the frame grows and never lowers it.
 	* @returns whether the floor took rows away from a fade that is drawing
@@ -2022,11 +2374,11 @@ var ToolBlock = class {
 	}
 };
 /**
-* Draw one group of a card's rows at the level its fade reports.
+* Draw one group of a card's rows at the mix its fade reports.
 * @param lines - the group's final rendered lines.
 * @param fade - the group's fade; absent for a card that never faded.
 * @param from - first line of the group the fade may recolor.
-* @returns the lines at that level, or the lines themselves once the fade
+* @returns the lines at that mix, or the lines themselves once the fade
 * settled or was never attached.
 */
 function faded(lines, fade, from) {
@@ -2035,18 +2387,30 @@ function faded(lines, fade, from) {
 	return age === void 0 ? lines : recolorLines(lines, age, fade.style(), from);
 }
 /**
-* The tail chunks one streaming region still draws below the terminal's own
+* The tail chunks one streaming reply still draws below the terminal's own
 * foreground.
 *
 * The last ramp level is an assumed foreground - pi-tui reports the terminal
 * background but not its foreground - so a chunk that reached it is left to
 * draw in the terminal's own foreground, which is also what it draws in once it
 * leaves the tail. No chunk can therefore jump color as it settles.
-* @param fade - the region's fade; absent for a region that never faded.
+* @param fade - the region's fade.
 * @returns the spans to recolor, oldest first.
 */
-function drawnSpans(fade) {
-	return fade === void 0 ? [] : fade.spans().filter((span) => span.age < fade.steps - 1);
+function fadingInSpans(fade) {
+	return fade.spans().filter((span) => span.age < fade.steps - 1);
+}
+/**
+* The tail chunks one streaming reasoning region still floats out.
+*
+* Overlay continues until `age >= steps`, which is `steps * stepMs` after the
+* word appeared. The last overlay sits near the dim settle; the next frame is
+* the original dim italic bytes.
+* @param fade - the region's fade.
+* @returns the spans to recolor, oldest first.
+*/
+function floatingOutSpans(fade) {
+	return fade.spans().filter((span) => span.age < fade.steps);
 }
 //#endregion
 //#region lib/types/completion.js
@@ -2304,7 +2668,7 @@ const OFF_SCREEN = " · off screen";
 /** The keys the inspector answers, drawn dim under its rows. */
 const HINT = "↑ ↓ blocks · ← → parts · Enter page · Esc back";
 /** What ends a line the width cut short; one column, so the mark itself fits. */
-const ELLIPSIS = "…";
+const ELLIPSIS$1 = "…";
 /**
 * Draw the focused section.
 * @param view - the section to show.
@@ -2321,7 +2685,7 @@ function renderInspector(view, render) {
 	const wrapped = view.rows.flatMap((row) => wrapTextWithAnsi(row, width));
 	lines.push(...foldRows(wrapped, render.previewLines, (hidden) => palette.dim(`… ${String(hidden)} more row${hidden === 1 ? "" : "s"} · Enter opens the page`)));
 	lines.push(palette.dim(HINT));
-	return lines.map((line) => truncateToWidth(line, width, ELLIPSIS));
+	return lines.map((line) => truncateToWidth(line, width, ELLIPSIS$1));
 }
 /**
 * The heading line. A tool title can run past any terminal, so the subject is
@@ -2336,7 +2700,7 @@ function heading(view, palette, width) {
 	const subject = palette.bold(palette.accent(view.heading));
 	if (view.highlighted) return subject;
 	const suffix = palette.dim(OFF_SCREEN);
-	return `${truncateToWidth(subject, Math.max(1, width - visibleWidth(suffix)), ELLIPSIS)}${suffix}`;
+	return `${truncateToWidth(subject, Math.max(1, width - visibleWidth(suffix)), ELLIPSIS$1)}${suffix}`;
 }
 /**
 * Draw the parts of the focused block as one row of choices.
@@ -2943,10 +3307,11 @@ function plural(count, noun) {
 * The status bar under the editor: plain session facts become an ordered list
 * of segments, each with a stable id, the short label the bar draws, and what
 * `Enter` on it does — the rows the app prints, or the app's own navigable
-* page; a second function renders the segments as the footer's two lines, dim
-* while the editor holds focus and with the selected segment accented while
-* the bar does. Everything here is pure — no Context, no services, no
-* terminal, and no clock: elapsed values arrive already formatted.
+* page; a second function renders those segments as one unfocused line of key
+* facts, or as two focused lines whose first is a sliding window that always
+* includes the selected segment. Everything here is pure — no Context, no
+* services, no terminal, and no clock: elapsed values arrive already formatted,
+* and the terminal width arrives as an input so every line fits it.
 * @module @deepseek-ai/dsh-tui-app/footer
 */
 /** The segment focus enters the bar on; `buildFooterSegments` always emits it first. */
@@ -2962,10 +3327,20 @@ const SEPARATOR$1 = " · ";
 const WORKSPACE_LABEL_WIDTH = 24;
 /** The last two segments of a path, with the separators that precede them. */
 const PATH_TAIL = /[/\\][^/\\]+[/\\][^/\\]+$/u;
-/** The keys the focused bar answers, replacing the usual hints. */
+/** The keys the focused bar answers, drawn on the expansion line. */
 const FOCUS_HINTS$1 = `← → select${SEPARATOR$1}↑ ↓ regions${SEPARATOR$1}Enter details${SEPARATOR$1}Esc back`;
-/** What the unfocused hints advertise as the two ways out of the editor. */
-const ENTRY_HINT = `Shift+↑ transcript${SEPARATOR$1}Shift+↓ status bar`;
+/** The one entry key the unfocused line keeps, trailing the facts. */
+const ENTRY_HINT = "Shift+↓";
+/** What ends a line the width cut short; one column, so the mark itself fits. */
+const ELLIPSIS = "…";
+/** Facts the unfocused line keeps; every other present segment folds into `+N`. */
+const KEY_SEGMENT_IDS = new Set([
+	"model",
+	"effort",
+	"turn",
+	"context",
+	"workspace"
+]);
 /** The command that prints every projection section at once. */
 const STATUS_COMMAND_ROW = "/status prints all of these sections";
 /**
@@ -3016,10 +3391,24 @@ function startsWithDirectory(path, directory) {
 	return next === "" || next === "/" || next === "\\";
 }
 /**
+* The effort segment: always present, labelled `effort default` when the
+* selection leaves reasoning effort to the model.
+* @param effort - the selection's reasoning effort; absent is the model's own default.
+* @returns the segment.
+*/
+function effortSegment(effort) {
+	const unset = effort === void 0;
+	return {
+		id: "effort",
+		label: unset ? "effort default" : `effort ${effort}`,
+		detail: printed([unset ? "reasoning effort: the model's own default" : `reasoning effort: ${effort}`, `Shift+Tab cycles it${SEPARATOR$1}/effort picks one`])
+	};
+}
+/**
 * Build the status bar's segments in the order it draws them: model, effort,
-* permission, turn, usage, the projection facts, workspace, attachments. Only
-* the model and workspace segments are always present; every other segment
-* needs its fact.
+* permission, turn, usage, the projection facts, workspace, attachments. The
+* model, effort, and workspace segments are always present; every other
+* segment needs its fact.
 * @param inputs - the facts the app read for the bound session.
 * @returns the segments, the model segment first.
 */
@@ -3035,12 +3424,7 @@ function buildFooterSegments(inputs) {
 			effort === void 0 ? "reasoning effort: the model's own default" : `reasoning effort: ${effort}`,
 			"/model picks the provider and model for the next request"
 		])
-	}];
-	if (effort !== void 0) segments.push({
-		id: "effort",
-		label: `effort ${effort}`,
-		detail: printed([`reasoning effort: ${effort}`, `Shift+Tab cycles it${SEPARATOR$1}/effort picks one`])
-	});
+	}, effortSegment(effort)];
 	if (inputs.permission !== void 0) {
 		const projected = permissionLines(facts);
 		segments.push({
@@ -3099,20 +3483,142 @@ function footerSelectionIndex(segments, selected) {
 	return index === -1 ? 0 : index;
 }
 /**
-* Render the footer's two lines: the segment labels, then the key hints.
-* Unfocused the whole bar is dim and the hints advertise the entry key;
-* focused the selected segment is accented and the hints name the navigation
-* keys instead.
+* Inclusive span of `widths` that contains `selected` and fits `budget`.
+* @param widths - visible width of each part, in order.
+* @param selected - the index that must stay in the span.
+* @param budget - maximum visible width of the joined span.
+* @param sep - visible width of the separator between two parts.
+* @returns start and end indices, inclusive.
+*/
+function windowSpan(widths, selected, budget, sep) {
+	let start = selected;
+	let end = selected;
+	let used = widths[selected];
+	if (used >= budget) return {
+		start,
+		end
+	};
+	while (end + 1 < widths.length) {
+		const next = used + sep + widths[end + 1];
+		if (next > budget) break;
+		end += 1;
+		used = next;
+	}
+	while (start > 0) {
+		const next = used + sep + widths[start - 1];
+		if (next > budget) break;
+		start -= 1;
+		used = next;
+	}
+	return {
+		start,
+		end
+	};
+}
+/**
+* Cut `line` to `width` columns.
+* @param line - the already-styled line.
+* @param width - terminal columns the line must fit; at least 1.
+* @returns the line, ellipsized when it was wider.
+*/
+function fitLine(line, width) {
+	return truncateToWidth(line, Math.max(1, width), ELLIPSIS);
+}
+/**
+* The unfocused line: key facts, a `+N` token for the rest, and the entry key.
+* @param segments - the segments in bar order.
+* @param palette - the palette the line is dimmed with.
+* @param width - terminal columns the line must fit.
+* @returns one dim line.
+*/
+function unfocusedLine(segments, palette, width) {
+	const key = segments.filter((segment) => KEY_SEGMENT_IDS.has(segment.id)).map((segment) => segment.label);
+	const folded = segments.length - key.length;
+	if (folded > 0) key.push(`+${String(folded)}`);
+	key.push(ENTRY_HINT);
+	return fitLine(palette.dim(key.join(SEPARATOR$1)), width);
+}
+/**
+* The first detail row of a printed segment, or the label of a page segment.
+* @param segment - the selected segment; absent when the bar has none.
+* @returns the expansion body.
+*/
+function expansionBody(segment) {
+	if (segment === void 0) return "";
+	if (segment.detail.kind === "page") return segment.label;
+	return segment.detail.rows[0];
+}
+/**
+* The focused second line: the selected segment's summary plus the navigation keys.
+* @param segment - the selected segment.
+* @param palette - the palette the line is dimmed with.
+* @param width - terminal columns the line must fit.
+* @returns one dim line that keeps the hints when they fit.
+*/
+function expansionLine(segment, palette, width) {
+	const body = expansionBody(segment);
+	const suffix = palette.dim(body === "" ? FOCUS_HINTS$1 : `${SEPARATOR$1}${FOCUS_HINTS$1}`);
+	const prefix = palette.dim(body);
+	const rest = width - visibleWidth(suffix);
+	if (rest < 1) return fitLine(`${prefix}${suffix}`, width);
+	return `${truncateToWidth(prefix, rest, ELLIPSIS)}${suffix}`;
+}
+/**
+* The focused bar: a sliding window of segment labels, then the expansion line.
+* @param segments - the segments in bar order.
+* @param selected - index of the held segment.
+* @param palette - the palette the labels and hints are styled with.
+* @param width - terminal columns each line must fit.
+* @returns two lines, the selected label always in the first.
+*/
+function focusedLines(segments, selected, palette, width) {
+	const held = Math.min(Math.max(0, selected), Math.max(0, segments.length - 1));
+	const styled = segments.map((segment, index) => index === held ? palette.bold(palette.accent(segment.label)) : palette.dim(segment.label));
+	const sep = palette.dim(SEPARATOR$1);
+	const { start, end } = windowSpan(styled.map(visibleWidth), held, width, visibleWidth(sep));
+	return [fitLine(styled.slice(start, end + 1).join(sep), width), expansionLine(segments[held], palette, width)];
+}
+/**
+* Render the footer. Unfocused it is one dim line of key facts with a trailing
+* `Shift+↓`; focused it is the navigable segments (windowed to `width` so the
+* selected one is never dropped) and an expansion of that segment plus the
+* navigation keys. Every returned line fits `width`.
 * @param segments - the segments in bar order.
-* @param render - the palette, the selected index, and the unfocused hints.
-* @returns the footer text, two lines separated by a newline.
+* @param render - the palette, optional selected index, and terminal width.
+* @returns the footer lines, one when unfocused and two when focused.
 */
 function renderFooter(segments, render) {
-	const { palette, selected, hints } = render;
-	const labels = segments.map((segment) => segment.label);
-	if (selected === void 0) return `${palette.dim(labels.join(SEPARATOR$1))}\n${palette.dim(`${hints}${SEPARATOR$1}${ENTRY_HINT}`)}`;
-	return `${labels.map((label, index) => index === selected ? palette.bold(palette.accent(label)) : palette.dim(label)).join(palette.dim(SEPARATOR$1))}\n${palette.dim(FOCUS_HINTS$1)}`;
+	const width = Math.max(1, render.width);
+	if (render.selected === void 0) return [unfocusedLine(segments, render.palette, width)];
+	return focusedLines(segments, render.selected, render.palette, width);
 }
+/**
+* The status bar as a mounted component. The view is read once per render
+* rather than pushed in, so the terminal width of that frame windows and
+* truncates the lines.
+*/
+var FooterBar = class {
+	view;
+	/**
+	* @param view - reads the segments and selection the bar draws.
+	*/
+	constructor(view) {
+		this.view = view;
+	}
+	invalidate() {}
+	/**
+	* Draw the status bar at `width`.
+	* @param width - the total width the bar lays out in.
+	* @returns the footer lines, each no wider than `width`.
+	*/
+	render(width) {
+		const { segments, render } = this.view();
+		return renderFooter(segments, {
+			...render,
+			width
+		});
+	}
+};
 //#endregion
 //#region lib/types/prompts.js
 /**
@@ -3835,18 +4341,25 @@ function subagentPanelView(inputs) {
 	};
 }
 /**
-* Render the panel: a heading counting the listed children, one line per
-* drawn row, the overflow count, and the last listing failure. The whole
-* panel is dim while the keyboard is elsewhere; the selected row is accented
-* while the panel holds it.
+* Render the panel. Unfocused it is one dim summary line — the listed count
+* and the first child's key label. Focused it is the heading with navigation
+* keys, one line per drawn row, the overflow count, and the last listing
+* failure. The selected row is accented while the panel holds the keyboard.
 * @param view - the rows one draw produced.
 * @param render - the palette, the selected row, and the listing failure.
-* @returns the panel text, one line per row.
+* @returns the panel text, one line when unfocused and one line per row when focused.
 */
 function renderSubagentPanel(view, render) {
 	const { palette, selected } = render;
 	const total = view.rows.length + view.hidden;
-	const heading = `subagents${SEPARATOR}${String(total)} listed${selected === void 0 ? "" : `${SEPARATOR}${FOCUS_HINTS}`}`;
+	if (selected === void 0) {
+		const first = view.rows[0]?.text.trimStart().split(SEPARATOR)[0];
+		const parts = [`subagents${SEPARATOR}${String(total)} listed`];
+		if (first) parts.push(first);
+		if (render.failure !== void 0) parts.push(`listing failed: ${render.failure}`);
+		return palette.dim(parts.join(SEPARATOR));
+	}
+	const heading = `subagents${SEPARATOR}${String(total)} listed${SEPARATOR}${FOCUS_HINTS}`;
 	const lines = [palette.dim(heading)];
 	for (const [index, row] of view.rows.entries()) lines.push(index === selected ? palette.bold(palette.accent(row.text)) : palette.dim(row.text));
 	if (view.hidden > 0) lines.push(palette.dim(`+${String(view.hidden)} more${SEPARATOR}/subagents lists them all`));
@@ -3863,8 +4376,8 @@ function renderSubagentPanel(view, render) {
 * the editor it keeps two docked regions the keyboard can take over — the
 * subagent panel and the status bar — and one repeating tick advances their
 * elapsed counters and re-reads a stale subagent listing. A second tick, at
-* its own period, brightens the text of the message streaming right now and
-* the tool cards that just landed, each only as far up the frame as the
+* its own period, brightens streamed reply text and floats out reasoning and
+* tool cards that just landed, each only as far up the frame as the
 * renderer repaints without discarding the terminal's scrollback
 * (`./screen.ts`).
 * @module @deepseek-ai/dsh-tui-app/app
@@ -4149,7 +4662,13 @@ var TuiApp = class {
 			this.onSubmit(text);
 		};
 		this.panel = new Text("", 0, 0);
-		this.footer = new Text("", 0, 0);
+		this.footer = new FooterBar(() => ({
+			segments: this.segments,
+			render: {
+				palette: this.deps.palette,
+				...this.focus === "bar" ? { selected: footerSelectionIndex(this.segments, this.barSelection) } : {}
+			}
+		}));
 		this.modals = new ModalQueue({
 			tui: this.tui,
 			slot: this.modalSlot,
@@ -4393,7 +4912,6 @@ var TuiApp = class {
 		this.tui.requestRender();
 	}
 	refreshFooter() {
-		const palette = this.deps.palette;
 		const permission = this.deps.ctx.get("permissionPresets")?.current(this.agent.session);
 		const started = this.turnStartedAt;
 		const inbox = this.agent.inbox;
@@ -4416,12 +4934,6 @@ var TuiApp = class {
 				kind: attachment.block.type
 			}))
 		});
-		const hints = this.agent.status === "running" ? "Enter queues for the next turn · Ctrl+S steers this turn · Esc stops it · Ctrl+O tool output · Ctrl+C twice quits" : "Enter sends · Esc stops the turn · Ctrl+O tool output · Ctrl+C twice quits";
-		this.footer.setText(renderFooter(this.segments, {
-			palette,
-			...this.focus === "bar" ? { selected: footerSelectionIndex(this.segments, this.barSelection) } : {},
-			hints
-		}));
 		this.tui.requestRender();
 	}
 	/**
@@ -4886,7 +5398,8 @@ var TuiApp = class {
 	}
 	/**
 	* Answer one key while the status bar holds focus. Every key is consumed
-	* here, so nothing typed at the bar reaches the editor.
+	* here, so nothing typed at the bar reaches the editor. `Shift+Left` and
+	* `Shift+Right` move between segments the same way as `Left` and `Right`.
 	* @param data - the raw key bytes.
 	* @returns the consume marker the input listener returns.
 	*/
@@ -4898,11 +5411,11 @@ var TuiApp = class {
 			else this.focusTranscript();
 			return { consume: true };
 		}
-		if (matchesKey(data, "left") || matchesKey(data, "shift+tab")) {
+		if (matchesKey(data, "left") || matchesKey(data, "shift+left") || matchesKey(data, "shift+tab")) {
 			this.moveStatusBar(-1);
 			return { consume: true };
 		}
-		if (matchesKey(data, "right") || matchesKey(data, "tab")) {
+		if (matchesKey(data, "right") || matchesKey(data, "shift+right") || matchesKey(data, "tab")) {
 			this.moveStatusBar(1);
 			return { consume: true };
 		}
@@ -5297,7 +5810,7 @@ var TuiApp = class {
 			"Esc stops the running turn · Ctrl+O expands or collapses tool output",
 			"Shift+Tab cycles the current model's reasoning effort for the next request",
 			"Shift+Up focuses the transcript, Shift+Down the subagent panel or the status bar",
-			"Then ↑ ↓ move between blocks, panel rows, and the bar; ← → move between a block's parts or the bar's segments",
+			"Then ↑ ↓ move between blocks, panel rows, and the bar; ← → move between a block's parts or the bar's segments (Shift+← → also move the bar)",
 			"Enter opens the focused section or segment, Esc returns to the input",
 			"Ctrl+C clears the input (twice quits) · Ctrl+D on an empty input quits"
 		];
@@ -5762,9 +6275,9 @@ var TuiApp = class {
 		this.updateFadeTicker();
 	}
 	/**
-	* Take one reasoning delta, which fades in on its own tail: the reasoning
-	* and the visible text of one message stream at different times and each
-	* brightens from the moment its own words appeared.
+	* Take one reasoning delta, which floats out on its own tail: the reasoning
+	* and the visible text of one message stream at different times, and each
+	* ages from the moment its own words appeared.
 	* @param delta - the streamed reasoning delta.
 	*/
 	appendStreamedReasoning(delta) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@songtonyli/dsh-cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "The dsh terminal agent: an interactive TUI over the DeepSeek Harness, with its whole Node runtime bundled in one install.",
   "license": "MIT",
   "type": "module",