@itookit/dsht 0.6.7 → 0.6.10

package/README.i18n.yaml

@@ -1,3 +1,3 @@
 # Git blob hashes of the reviewed bilingual pair.
-README.md: 1f5cde21326a6a1056ca90cba9e21e672ee332bb
-README.zh.md: 977cf5defbbe36cf37ca0d999b915a4aa81bfbfd
+README.md: 7bb251fe28755b8230a0988a62f1ce0a1b393065
+README.zh.md: c443fdc10ef24dcc39bc3ed6ff57b8702e995d9f

package/README.md

@@ -374,7 +374,7 @@ Tab completes the leading slash command, extending an ambiguous draft to the sha
 | `/think SEQ` | Toggle one loaded thought; `live` toggles the active attempt |
 | `/help`, `/quit` | List every command with its description, or exit |
 
-Slash commands work in both pickers and the conversation composer. Typing `/` displays matching commands, and once a name is settled and a space follows, the composer shows that command's usage and one-line description under the draft, so an argument never has to be remembered; `/help` lists every command with its description, and PgUp/PgDn changes pages. `/loop` additionally lists its `loop.yaml` records under the composer as soon as the draft names a record, so a run never has to be spelled out flag by flag. The `/help`, `/cost`, and `/status` panels remain open until the next command or Esc; `/history` also expires after ten seconds, so a forgotten lookup releases the composer. Esc leaves the draft in place; while a long operation owns the client — a search, an export, a history page load — it cancels that operation first, and otherwise it cancels whatever a command opened: a picker returns to the conversation it was opened over — without reloading it — and at startup, with no conversation yet, the session list steps back to the workspace list. `/workspace` and `/workspaces` alias `/ws`; `/session` and `/sessions` alias `/resume`. Names may contain spaces; quotes around the complete target are optional. The unquoted target `all` is reserved for `/resume all`; use `/resume "all"` or an ID to open a session titled `all`. Ambiguous targets require a full ID. Switching a workspace opens its sessions and detaches the old transcript; switching sessions updates the workspace label. Neither operation cancels a remote agent.
+Slash commands work in both pickers and the conversation composer. Typing `/` displays matching commands, and once a name is settled and a space follows, the composer shows that command's usage and one-line description under the draft, so an argument never has to be remembered; `/help` lists every command with its description, and PgUp/PgDn changes pages. `/loop` additionally lists its `loop.yaml` records under the composer as soon as the draft names a record, so a run never has to be spelled out flag by flag. The `/help`, `/cost`, and `/status` panels remain open until the next command or Esc; `/history` also expires after ten seconds, so a forgotten lookup releases the composer. The arrows of every list menu — the workspace and session pickers, the record list, `@` completion, the parameter form — wrap around: ↑ on the first row lands on the last and ↓ on the last returns to the first, so neither end is a dead key. A panel that reads no free text — `/model`, `/prompts`, `/queue`, `/history`, `/think`, and the removal confirmations — parks the composer while it is open, so a keystroke aimed at the list can only reach the list; Esc closes the panel and hands the composer back. The startup lists and the conversation composer are unaffected and still accept slash commands. Esc leaves the draft in place; while a long operation owns the client — a search, an export, a history page load — it cancels that operation first, and otherwise it cancels whatever a command opened: a picker returns to the conversation it was opened over — without reloading it — and at startup, with no conversation yet, the session list steps back to the workspace list. `/workspace` and `/workspaces` alias `/ws`; `/session` and `/sessions` alias `/resume`. Names may contain spaces; quotes around the complete target are optional. The unquoted target `all` is reserved for `/resume all`; use `/resume "all"` or an ID to open a session titled `all`. Ambiguous targets require a full ID. Switching a workspace opens its sessions and detaches the old transcript; switching sessions updates the workspace label. Neither operation cancels a remote agent.
 
 `/prompt` opens the shortcut prompts you saved, and `/prompt TEXT` saves TEXT as one; the list takes ↑/↓, Enter uses the selected prompt, `e` edits it, and `d` or the dedicated Delete key removes it. Choosing a prompt puts its text into the composer as an ordinary draft instead of sending it, so it can still be changed before Enter sends it. An edit started with `e` is the opposite: Enter writes the text back to the list and never sends it, and Esc abandons the edit and restores the draft it replaced. The prompts live in one private file (`<state>/prompts.json`, mode 0600) beside the memory log, and that one list is shared by every workspace and every host this client talks to, so a shortcut is written once and used everywhere; an identical text is not saved twice, a prompt is limited to 8 KiB, and the list holds at most 500 entries. A host is not needed to save or list them, and a file this build cannot read leaves the list empty and says so in the panel instead of stopping the client.
 
@@ -396,9 +396,9 @@ Pending ordinary messages appear inside the composer, with up to two previews. `
 
 Below 62 terminal columns, active streaming reasoning defaults to one folded row. Wider terminals expand active reasoning and fold it on completion. `/think live` toggles the current reasoning; a new response restores the default.
 
-Approvals offer 1. Allow once, 2. Deny, and 3. Stop turn. With an empty composer, use 1–3 or ↑/↓ to select, then Enter to confirm; no action is selected initially, Escape clears the highlight, and a replayed request starts unselected again. Existing drafts keep normal typing, and `/allow`, `/deny`, and `/cancel` remain available.
+Approvals offer 1. Allow once, 2. Deny, and 3. Stop turn. With an empty composer, 1–3 answers outright, or ↑/↓ selects and Enter confirms; no action is selected initially, Escape clears the highlight, and a replayed request starts unselected again. Existing drafts keep normal typing, and `/allow`, `/deny`, and `/cancel` remain available.
 
-User questions show progress, numbered options, and descriptions. Selection lists, pending questions, approvals, and file completions share the composer border with the text input. Pending questions and approvals retain recent conversation history above the composer. The history viewport fits the remaining height, removes extra vertical margins while a dialog is open, and refreshes on explicit scrolling or viewport resizing. The visible option window adapts to terminal height and follows the highlighted choice. With an empty composer, ↑/↓ or 1–9 selects an option and Enter confirms; numbers only select and do not submit. For multi-select questions, Space or 1–9 toggles checkboxes, and Enter confirms the selection. Options beyond nine remain reachable with arrows. Choose Other answer to type numeric free text; ordinary text answers remain supported. Existing drafts keep normal typing, and Escape leaves the question: with the options showing it dismisses the whole set, which the host records as a cancellation, while inside Other the first Escape only returns to the options. All questions are submitted together as structured selected labels and optional custom text; a failed submission preserves the answers for retry. Recognized question and approval events are retained by event ID for the connection, including replay before session selection; only the selected session displays them. Switching pickers does not decline those requests. Unrecognized waterfalls still delegate with `next`. The live host replays pending events after client reconnection; client restart does not preserve unsubmitted answer drafts. Normal TUI shutdown cancels a running turn. A cancelled/failed tool call or a host restart cannot restore the original wait from local UI state; send a new prompt requesting the questions again. Failed submissions retain their input; an interrupted HTTP response can leave delivery uncertain, so check the transcript before manually resending. The client never retries a mutation automatically.
+User questions show progress, numbered options, and descriptions. Selection lists, pending questions, approvals, and file completions share the composer border with the text input. Pending questions and approvals retain recent conversation history above the composer. The history viewport fits the remaining height, removes extra vertical margins while a dialog is open, and refreshes on explicit scrolling or viewport resizing. The visible option window adapts to terminal height and follows the highlighted choice. With an empty composer, ↑/↓ moves the highlight and Enter confirms, while 1–9 answers a single-choice question outright — the number is the choice, with no second Enter. For multi-select questions, Space or 1–9 toggles checkboxes, and Enter confirms the selection. Options beyond nine remain reachable with arrows. Only the fixed choices are numbered: Other answer is an input row, so it carries no number and is reached with the arrows and Enter. Choose Other answer to type numeric free text; ordinary text answers remain supported. Existing drafts keep normal typing, and Escape leaves the question: with the options showing it dismisses the whole set, which the host records as a cancellation, while inside Other the first Escape only returns to the options. All questions are submitted together as structured selected labels and optional custom text; a failed submission preserves the answers for retry. Recognized question and approval events are retained by event ID for the connection, including replay before session selection; only the selected session displays them. Switching pickers does not decline those requests. Unrecognized waterfalls still delegate with `next`. The live host replays pending events after client reconnection; client restart does not preserve unsubmitted answer drafts. Normal TUI shutdown cancels a running turn. A cancelled/failed tool call or a host restart cannot restore the original wait from local UI state; send a new prompt requesting the questions again. Failed submissions retain their input; an interrupted HTTP response can leave delivery uncertain, so check the transcript before manually resending. The client never retries a mutation automatically.
 
 The header stays above the scrollable conversation while the composer and status stay below it. The always-visible keyboard legend is removed; `/help` contains the full shortcuts and pickers retain their local navigation hints. The single-line header prioritizes the latest session title (falling back to the ID), with the workspace name after it on wider terminals; host and connection labels are omitted. Without a selected session, it shows the workspace name or All workspaces. A divider sits below the title; `/status` retains the complete session ID. The cancellation acknowledgement stays visible through incoming history until the host reports idle; acceptance does not mean a tool process has already exited.
 
@@ -418,7 +418,7 @@ The footer groups `◐ Working · 8s · Ctrl+C Stop`, `● Ready`, or `? Needs y
 
 Working time uses the retained `turn/start` timestamp. If that timestamp is unavailable, `(observed)` in the details panel means time since this client observed the run; reconnecting can reset this fallback. The clock stops when the host reports idle. The status includes model generation, tool execution, and approval waits, not just streamed text. Offline status is explicitly marked as last known. The expanded panel merges related values onto one row and prints counts in the compact form the single-row bar already uses (`Context ~40% (400.6K/1M) · 229.7M tok`), so a 24-row terminal shows every detail on one screen; ↑/↓ scroll it one line at a time, PgUp/PgDn one screen, and the footer names the visible range and the total.
 
-The single-row bar keeps its groups by value rather than by column: `◐ 6:18 · bash 1:08 · ^C │ v4-flash · high · ctx 30% · S¥2.49* · ¥: 5.00 (12.34) · 2 turns · 34.5M tok · hit 92%`. The live phase is reported as a fact — `think 28s` while reasoning, the tool name with its age while a tool runs, and `write 12s` while the answer streams — and never inferred from silence, because a long reasoning step and a quiet tool are not stalls. It names the newest event and keeps its age until another stripe of work starts or the turn closes, so the quiet stretch after a command is still time the turn spent working, and `● Ready` drops the phase because only the host knows the turn ended. The two cost groups never substitute for each other: `S¥2.49*` is this session, and reports `S?` while the ledger has not priced it, while `¥: 5.00 (12.34)` is today's spend with the all-time total. When the width runs out the least valuable group is dropped first (the cache-hit share, tokens, turns, effort, model, today's spend, then context); the session cost is never dropped but moves to a second row, and the state cluster gives up the phase and the stop hint only below about twenty columns. A paused clock names its reason (`⏸ copy`, `⏸ dialog`, `⏸ history`) instead of freezing silently, and `! Offline` or `⚠ Error` replaces the state token entirely. While this client still owes an approval or an answer, `? Needs you` takes the token over instead — including while a dialog has paused the clock, because the owed answer is the thing to act on.
+The single-row bar keeps its groups by value rather than by column: `◐ 6:18 · bash 1:08 · ^C │ v4-flash · high · ctx 30% · S¥2.49* · ¥: 5.00 (12.34) · 2 turns · 34.5M tok · hit 92%`. The live phase is reported as a fact — `think 28s` while reasoning, the tool name with its age while a tool runs, and `write 12s` while the answer streams — and never inferred from silence, because a long reasoning step and a quiet tool are not stalls. It names the newest event and keeps its age until another stripe of work starts or the turn closes, so the quiet stretch after a command is still time the turn spent working, and `● Ready` drops the phase because only the host knows the turn ended. The two cost groups never substitute for each other: `S¥2.49*` is this session, and reports `S?` while the ledger has not priced it, while `¥: 5.00 (12.34)` is today's spend with the all-time total. When the width runs out the least valuable group is dropped first (the cache-hit share, tokens, turns, effort, model, today's spend, then context); the session cost is never dropped but moves to a second row, and the state cluster gives up the phase and the stop hint only below about twenty columns. A paused clock names its reason (`⏸ copy`, `⏸ dialog`, `⏸ history`) instead of freezing silently, and `! Offline` or a named degradation replaces the state token entirely: `⚠ Metrics` when the live-control stream is unavailable or undecodable, `⚠ Models` when the model catalog could not be read, and `⚠ Presets` when the preset roster could not be read. The name says which subsystem broke; `/status` carries the message, and a degradation that recovers (a control frame that decodes again) clears itself. While this client still owes an approval or an answer, `? Needs you` takes the token over instead — including while a dialog has paused the clock, because the owed answer is the thing to act on.
 
 Turns come from the complete session's `sessionStats.turns` projection. Context occupancy is marked `~`: Harness combines provider usage with estimated surface changes and the latest route capacity. Token totals come from the complete session's `tokenUsage` projection, with separate uncached input, output, cache-read, and cache-write buckets; reasoning is already included in output. The cache-hit share is the cache-read bucket over all three billed prompt buckets, and it gains decimal places rather than reporting a partial hit as `100%`. Session and day costs come from the ledger's per-session slices, so a session with no slice yet is unknown, not the day's spend. Totals update when the host publishes usage, not on every streamed character. Missing measurements display `unknown` or `?`. Control-stream baselines replace state on reconnect, and per-key watermarks prevent an older follow snapshot from overwriting newer metrics.
 

package/README.zh.md

@@ -374,7 +374,7 @@ Tab 补全开头的 slash 命令，多个候选时补到公共前缀；回车也
 | `/think SEQ` | 切换一条已加载思考的展开状态；`live` 表示当前尝试 |
 | `/help`, `/quit` | 列出每条命令及其说明，或退出 |
 
-Slash 命令在选择器和对话输入框中均可使用。输入 `/` 会显示匹配命令；命令名确定并跟一个空格后，输入框下方会显示该命令的用法和单行说明，因此参数不必靠记忆；`/help` 分页列出命令及其单行说明，PgUp／PgDn 翻页。`/loop` 还会在草稿仍在写记录名时，把 `loop.yaml` 的记录列表显示在输入框下方，因此运行一次循环不必逐个敲出旗标。`/help`、`/cost`、`/status` 面板保持打开，直到下一条命令或 Esc；`/history` 还会在十秒后自动关闭，避免遗留列表一直占用输入框。Esc 保留输入内容；当有长操作占用客户端时（搜索、导出、加载历史页），它先取消那个操作，其余情况才去取消命令打开的面板：选择器会回到打开它的那个对话（不重新加载），启动阶段还没有对话时，会话列表则退回工作区列表。`/workspace`、`/workspaces` 是 `/ws` 的别名；`/session`、`/sessions` 是 `/resume` 的别名。名称可以包含空格，完整目标两侧的引号可选。不带引号的目标 `all` 保留给 `/resume all`；打开标题为 `all` 的会话时，使用 `/resume "all"` 或其 ID。目标有歧义时必须提供完整 ID。切换工作区会打开其会话列表并解除旧对话订阅；切换会话会同步工作区标签。两种操作均不会取消远程代理。
+Slash 命令在选择器和对话输入框中均可使用。输入 `/` 会显示匹配命令；命令名确定并跟一个空格后，输入框下方会显示该命令的用法和单行说明，因此参数不必靠记忆；`/help` 分页列出命令及其单行说明，PgUp／PgDn 翻页。`/loop` 还会在草稿仍在写记录名时，把 `loop.yaml` 的记录列表显示在输入框下方，因此运行一次循环不必逐个敲出旗标。`/help`、`/cost`、`/status` 面板保持打开，直到下一条命令或 Esc；`/history` 还会在十秒后自动关闭，避免遗留列表一直占用输入框。列表类菜单（工作区／会话列表、记录列表、`@` 补全、参数表单等）的方向键是循环的：在首行继续向上回到末行，在末行继续向下回到首行，两端都不是死键。不读取自由文本的面板（`/model`、`/prompts`、`/queue`、`/history`、`/think` 与删除确认等）打开期间输入框停用，按键只归该面板，Esc 关闭后才恢复输入；启动列表与对话输入框不受影响，仍可直接输入 slash 命令。Esc 保留输入内容；当有长操作占用客户端时（搜索、导出、加载历史页），它先取消那个操作，其余情况才去取消命令打开的面板：选择器会回到打开它的那个对话（不重新加载），启动阶段还没有对话时，会话列表则退回工作区列表。`/workspace`、`/workspaces` 是 `/ws` 的别名；`/session`、`/sessions` 是 `/resume` 的别名。名称可以包含空格，完整目标两侧的引号可选。不带引号的目标 `all` 保留给 `/resume all`；打开标题为 `all` 的会话时，使用 `/resume "all"` 或其 ID。目标有歧义时必须提供完整 ID。切换工作区会打开其会话列表并解除旧对话订阅；切换会话会同步工作区标签。两种操作均不会取消远程代理。
 
 `/prompt` 打开你保存的快捷提示词列表，`/prompt TEXT` 则把 TEXT 保存为一条；列表支持 ↑/↓ 选择、Enter 使用、`e` 编辑、`d` 或独立 Delete 键删除。选择一条提示词只会把文本放进输入框作为普通草稿，不会立即发送，因此还能继续修改后再按 Enter 发送；用 `e` 进入的编辑相反：Enter 把文本写回列表而绝不发送，Esc 放弃编辑并恢复此前的草稿。提示词保存在与内存日志同级的单个私有文件（`<state>/prompts.json`，权限 0600）中，该列表在本客户端连接的所有工作区与主机间共用，因此写一次即可到处使用；相同文本不会重复保存，单条上限 8 KiB，列表最多 500 条。保存和列出都不需要连接服务端；本版本无法读取的文件只会让列表为空并在面板中说明，而不会阻止客户端启动。
 
@@ -396,9 +396,9 @@ Slash 命令在选择器和对话输入框中均可使用。输入 `/` 会显示
 
 终端少于 62 列时，最新流式思考也默认折叠为一行；宽屏保持流式展开、完成后折叠。`/think live` 可手动展开或折叠当前思考，新回复恢复默认行为。
 
-审批提供 1. 允许一次、2. 拒绝、3. 停止当前轮次。输入框为空时，按 1–3 或 ↑／↓ 选择，再按 Enter 确认；初始不选中任何操作，Esc 清除高亮，请求重放时重新回到未选中。已有草稿时仍按正常文字输入处理，也保留 `/allow`、`/deny` 和 `/cancel` 命令。
+审批提供 1. 允许一次、2. 拒绝、3. 停止当前轮次。输入框为空时，按 1–3 直接作答，或用 ↑／↓ 选中后按 Enter 确认；初始不选中任何操作，Esc 清除高亮，请求重放时重新回到未选中。已有草稿时仍按正常文字输入处理，也保留 `/allow`、`/deny` 和 `/cancel` 命令。
 
-用户问题显示题目进度、编号选项和说明。选择列表、待答问题、审批和文件补全与文本输入共用一个输入框边框。待答问题和审批会在输入框上方保留最近对话历史，历史视口使用剩余高度；对话框打开时减少上下留白，并在手动滚动或视口高度变化时刷新；可见选项数量按终端高度调整，并跟随当前高亮项滚动。输入框为空时，↑／↓ 或 1–9 定位选项，Enter 确认；数字键只选择、不提交。多选题用空格或 1–9 勾选／取消勾选，Enter 确认，超过九个选项仍可通过方向键访问。选择 Other answer 后可输入纯数字自由文本，也保留普通文本回答。已有草稿时按正常文字输入处理；Esc 可退出提问：选项模式下放弃整组问题（服务端记为取消），Other 模式下第一次 Esc 只返回选项。全部题目回答完成后，一次提交结构化选项标签及可选自定义文本；失败时保留答案以便重试。已识别的提问和审批事件在本次连接中按事件 ID 保留，包括早于会话选择到达的重放事件；只展示当前会话对应的请求。切换列表不会退回这些请求，不识别的 waterfall 仍通过 `next` 委托后续处理。存活服务端在客户端重连后重发待答事件；客户端重启不保留尚未提交的回答草稿。正常退出 TUI 会取消正在运行的轮次。调用已取消／失败或服务端已重启时，无法靠本地 UI 状态恢复原等待，需要发送新提示词要求重新提问。提交失败时保留输入；HTTP 响应中断可能导致投递状态不确定，手动重发前应检查会话记录。客户端不会自动重试修改请求。
+用户问题显示题目进度、编号选项和说明。选择列表、待答问题、审批和文件补全与文本输入共用一个输入框边框。待答问题和审批会在输入框上方保留最近对话历史，历史视口使用剩余高度；对话框打开时减少上下留白，并在手动滚动或视口高度变化时刷新；可见选项数量按终端高度调整，并跟随当前高亮项滚动。输入框为空时，↑／↓ 移动高亮、Enter 确认，单选题按 1–9 直接作答（数字键就是选择，不再需要再按一次回车），多选题用空格或 1–9 勾选／取消勾选、Enter 确认，超过九个选项仍可通过方向键访问。只有固定选项带编号；Other answer 是一个输入行，因此不编号，用方向键选中后回车进入。选择 Other answer 后可输入纯数字自由文本，也保留普通文本回答。已有草稿时按正常文字输入处理；Esc 可退出提问：选项模式下放弃整组问题（服务端记为取消），Other 模式下第一次 Esc 只返回选项。全部题目回答完成后，一次提交结构化选项标签及可选自定义文本；失败时保留答案以便重试。已识别的提问和审批事件在本次连接中按事件 ID 保留，包括早于会话选择到达的重放事件；只展示当前会话对应的请求。切换列表不会退回这些请求，不识别的 waterfall 仍通过 `next` 委托后续处理。存活服务端在客户端重连后重发待答事件；客户端重启不保留尚未提交的回答草稿。正常退出 TUI 会取消正在运行的轮次。调用已取消／失败或服务端已重启时，无法靠本地 UI 状态恢复原等待，需要发送新提示词要求重新提问。提交失败时保留输入；HTTP 响应中断可能导致投递状态不确定，手动重发前应检查会话记录。客户端不会自动重试修改请求。
 
 标题固定在可滚动对话区域上方，输入框和状态栏保留在下方。底部不再常驻快捷键说明，完整快捷键放在 `/help`，选择器只显示当前需要的导航提示。顶部单行优先显示最新会话标题（无标题时回退到 ID），宽屏时在其后附上工作区名称，不再显示主机地址和连接状态。未选择会话时显示工作区名称或 All workspaces，下方为分隔线；`/status` 保留完整会话 ID。取消回执在后续历史消息到达时保持可见，直到服务端报告空闲；接受取消不表示工具进程已经退出。
 
@@ -418,7 +418,7 @@ Slash 命令在选择器和对话输入框中均可使用。输入 `/` 会显示
 
 工作计时使用已加载日志的 `turn/start` 时间戳。缺少该时间戳时，详情面板中的 `(observed)` 表示从客户端观察到运行开始计时；重连可能重置此备用计时。服务端报告空闲后停止计时。运行状态涵盖模型生成、工具执行及审批等待，不仅是文本输出。断线时明确标注为最后已知状态。展开面板把相关值合并到一行，并用单行状态栏已有的紧凑计数（`Context ~40% (400.6K/1M) · 229.7M tok`），因此 24 行终端可以一屏看到全部详情；`↑`/`↓` 逐行滚动，`PgUp`/`PgDn` 翻屏，页脚标出可见区间与总数。
 
-单行状态栏按价值而不是按列来保留分组：`◐ 6:18 · bash 1:08 · ^C │ v4-flash · high · ctx 30% · S¥2.49* · ¥: 5.00 (12.34) · 2 turns · 34.5M tok · hit 92%`。当前阶段只报事实——推理时是 `think 28s`，工具运行时是工具名加已等待时长，回答流式输出时是 `write 12s`——绝不从静默推断异常，因为长时间推理与安静运行的工具都不是卡住。它显示的是**当前事件**的名字与年龄，并在下一段工作开始或回合关闭前保持不变：命令返回之后、下一次增量到达之前的静默期仍被算作这个回合的工作时间；`● Ready` 不显示阶段，因为只有宿主知道回合已经结束。两个费用分组互不替代：`S¥2.49*` 只报本会话，账本还没为它定价时如实写 `S?`；`¥: 5.00 (12.34)` 只报今天花费与历史总计。宽度不足时先丢价值最低的分组（缓存命中率、token、回合、effort、模型、当天花费，然后 ctx）；本会话费用永不丢弃，只会挪到第二行；状态簇只在约二十列以下才让出阶段与停止提示。暂停的时钟会说明原因（`⏸ copy`、`⏸ dialog`、`⏸ history`）而不是无声冻结；`! Offline` 或 `⚠ Error` 会整体替换状态标记。本客户端还欠一个审批或回答时，`? Needs you` 会接管状态标记（对话框暂停时钟时也一样），因为需要动手的正是这个欠下的回答。
+单行状态栏按价值而不是按列来保留分组：`◐ 6:18 · bash 1:08 · ^C │ v4-flash · high · ctx 30% · S¥2.49* · ¥: 5.00 (12.34) · 2 turns · 34.5M tok · hit 92%`。当前阶段只报事实——推理时是 `think 28s`，工具运行时是工具名加已等待时长，回答流式输出时是 `write 12s`——绝不从静默推断异常，因为长时间推理与安静运行的工具都不是卡住。它显示的是**当前事件**的名字与年龄，并在下一段工作开始或回合关闭前保持不变：命令返回之后、下一次增量到达之前的静默期仍被算作这个回合的工作时间；`● Ready` 不显示阶段，因为只有宿主知道回合已经结束。两个费用分组互不替代：`S¥2.49*` 只报本会话，账本还没为它定价时如实写 `S?`；`¥: 5.00 (12.34)` 只报今天花费与历史总计。宽度不足时先丢价值最低的分组（缓存命中率、token、回合、effort、模型、当天花费，然后 ctx）；本会话费用永不丢弃，只会挪到第二行；状态簇只在约二十列以下才让出阶段与停止提示。暂停的时钟会说明原因（`⏸ copy`、`⏸ dialog`、`⏸ history`）而不是无声冻结；`! Offline` 或具名降级会整体替换状态标记：实时控制流不可用或无法解码时是 `⚠ Metrics`，模型目录读不到时是 `⚠ Models`，preset 名册读不到时是 `⚠ Presets`。名字说明是哪个子系统坏了，具体信息在 `/status` 里，而已经恢复的降级（又有帧能解码）会自行清除。本客户端还欠一个审批或回答时，`? Needs you` 会接管状态标记（对话框暂停时钟时也一样），因为需要动手的正是这个欠下的回答。
 
 轮次数来自完整会话的 `sessionStats.turns` 投影。上下文占用标为 `~`：Harness 将供应商用量与对话变化估算值、最新模型容量结合。Token 总量来自完整会话的 `tokenUsage` 投影，分别显示非缓存输入、输出、缓存读取和缓存写入；思考 token 已包含在输出中。缓存命中率是缓存读取占三个互斥提示侧桶（非缓存输入、缓存读取、缓存写入）之和的比例，遇到部分命中时增加小数位而不是报成 `100%`。本会话与当天费用来自账本按会话保存的切片，因此还没有切片的会话显示为未知，而不是当天的花费。总量随服务端用量投影更新，不按流式字符计数。缺失数据显示 `unknown` 或 `?`。重连时控制流基线整体替换状态，每个投影键的序号防止旧 follow 快照覆盖较新的指标。
 

package/dist/controller/connection-streams.d.ts

@@ -5,7 +5,8 @@ export interface StreamHost {
     identified(clientId: string): void;
     event(event: HostEvent): boolean;
     changed(): void;
-    degraded(message: string): void;
+    /** Publish a live-metrics degradation, or clear it when a frame decodes again. */
+    degraded(message: string | undefined): void;
     fail(error: Error): void;
 }
 export declare class ConnectionStreams {
@@ -14,6 +15,8 @@ export declare class ConnectionStreams {
     private readonly subscriptions;
     private readonly abort;
     private readonly signal;
+    /** Whether a control frame failed to decode in this generation, so recovery can clear it once. */
+    private degradedFrame;
     constructor(client: Client, host: StreamHost, signal: AbortSignal);
     start(): Promise<void>;
     close(): void;

package/dist/controller/connection-streams.js

@@ -8,6 +8,8 @@ export class ConnectionStreams {
     subscriptions = new Set();
     abort = new AbortController();
     signal;
+    /** Whether a control frame failed to decode in this generation, so recovery can clear it once. */
+    degradedFrame = false;
     constructor(client, host, signal) {
         this.client = client;
         this.host = host;
@@ -34,10 +36,21 @@ export class ConnectionStreams {
             try {
                 this.host.event({ kind: 'control', frame: controlFrame(value) });
                 this.host.changed();
+                // One undecodable frame is not a permanent condition: a frame that decodes proves live
+                // metrics work again, so the degradation raised earlier in this generation ends here.
+                if (this.degradedFrame) {
+                    this.degradedFrame = false;
+                    this.host.degraded(undefined);
+                }
             }
             catch (error) {
-                // Missing live metrics must not blind a running conversation.
-                this.host.degraded(`Live metrics degraded: ${errorText(error)}`);
+                // Missing live metrics must not blind a running conversation. Only the first failure of an
+                // episode is published: a baseline this client could not apply leaves every later update
+                // reporting "before baseline", and that follow-up must not bury the error that caused it.
+                if (!this.degradedFrame) {
+                    this.degradedFrame = true;
+                    this.host.degraded(`Live metrics degraded: ${errorText(error)}`);
+                }
             }
             return true;
         }, error => {

package/dist/transport/events.js

@@ -44,10 +44,13 @@ export function controlFrame(value) {
     const frame = object(value);
     if (frame.type === 'baseline') {
         const baseline = object(frame.value);
-        const projections = Object.entries(object(baseline.projections))
+        // The baseline's sections are capabilities, not a fixed schema: a host that reports no queue or
+        // job stream simply omits them, and demanding the newer three-section shape would discard the
+        // projection snapshot those hosts do send. An absent section is empty, not an error.
+        const projections = optionalRows(baseline.projections)
             .map(([id, snapshot]) => [id, projectionSnapshot(snapshot)]);
-        const queues = Object.entries(object(baseline.queues)).map(([id, items]) => [id, queuedInputs(items)]);
-        const jobs = Object.entries(object(baseline.jobs)).map(([id, items]) => [id, activeJobs(items)]);
+        const queues = optionalRows(baseline.queues).map(([id, items]) => [id, queuedInputs(items)]);
+        const jobs = optionalRows(baseline.jobs).map(([id, items]) => [id, activeJobs(items)]);
         return { kind: 'baseline', projections: new Map(projections), queues: new Map(queues), jobs: new Map(jobs) };
     }
     if (frame.type === 'projection' || frame.type === 'queue' || frame.type === 'jobs') {
@@ -64,6 +67,10 @@ export function controlFrame(value) {
     }
     throw new Error('Unknown session control frame');
 }
+/** Read a baseline section that a host may not provide, as an empty list rather than a throw. */
+function optionalRows(value) {
+    return value === undefined ? [] : Object.entries(object(value));
+}
 /** Read a possibly-absent string field without turning protocol drift into a throw. */
 function optionalString(value) {
     return typeof value === 'string' ? value : undefined;

package/dist/ui/app.js

@@ -21,6 +21,7 @@ import { plainRows } from "./chat/shell-view.js";
 import { useHistoryView } from "./chat/use-history-view.js";
 import { Frozen } from "./frozen.js";
 import { CopyMode } from "./copy-mode.js";
+import { cycle } from "./dialogs/picker.js";
 import { HelpPanel, HistoryDialog, ModelDialog, OfflinePanel, PickerScreen, PromptsDialog, QueueDialog, QueuedPreview, RemovalDialog, SearchResultsDialog, ThoughtsDialog } from "./dialogs/index.js";
 import { offlineGuidance } from "./offline.js";
 import { LoopDialog, LoopMenu } from "./dialogs/loop.js";
@@ -191,10 +192,17 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     const loopMenuOpen = loopCandidates.length > 0 && loopForm === undefined && dismissedLoopMenu !== input;
     const loopMenuCursor = Math.min(loopMenuIndex, Math.max(0, loopCandidates.length - 1));
     const { openSurfaces, reservedKeys: surfaceReservedKeys } = panelState;
-    const dialogOpen = !!(openSurfaces.length || pending || referenceOpen || state.screen !== 'chat');
+    // A modal owns the screen: a panel, an interaction the operator still owes an answer to, or a
+    // startup screen. Only a modal pauses the clock — and says so — because only a modal is somewhere
+    // the reader stopped to look rather than somewhere they are still writing.
+    const modalOpen = !!(openSurfaces.length || pending || state.screen !== 'chat');
+    // The composer's `@` menu is a completion list under the draft, not a dialog: it needs the layout
+    // room a panel gets, but calling it a dialog made the status bar report a pause that was not there
+    // and hid the one surface that could explain a key which the menu itself was holding.
+    const dialogOpen = modalOpen || referenceOpen;
     const displayPaused = copyMode || dialogOpen;
     // Startup screens need live connection feedback even while their picker remains open.
-    const statusPaused = copyMode || (state.screen === 'chat' && dialogOpen);
+    const statusPaused = copyMode || (state.screen === 'chat' && modalOpen);
     const matches = referenceOpen && lookup?.draft === input && lookup.sessionId === state.sessionId ? lookup : undefined;
     useEffect(() => {
         if (!referenceOpen)
@@ -238,6 +246,9 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     // One open surface owns the arrow and digit keys; the picker screens and the composer are not
     // keyboard owners. The traits live in `surfaces`, so no panel is named here.
     const panelBlocksKeys = openSurfaces.some(surface => surface.blocksKeys);
+    // A menu that reads no free text parks the composer it covers: the draft below is neither a field
+    // of that menu nor something it can submit, so a keystroke aimed at the list must not land in it.
+    const panelParksComposer = openSurfaces.some(surface => surface.parksComposer);
     // Composer recall yields only to a surface that uses the arrows itself: the pickers, and a status
     // panel with more lines than the view holds. The help and cost panels and a fitting status panel
     // leave the arrows with the history, and Ctrl+P/N reach it from every surface.
@@ -480,10 +491,16 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         if (approvalKeysActive && !input && controller.state.online && controller.queries.foreground === undefined
             && controller.state.pending[0]?.eventId === eventId && !key.ctrl && !key.meta) {
             const digit = /^[1-3]$/.test(_value) ? Number(_value) - 1 : -1;
-            if (digit >= 0 || key.upArrow || key.downArrow) {
+            // A numbered approval is answered by its number: each row *is* the decision, so 1–3 settles it
+            // at once instead of leaving a highlight that still needs an Enter.
+            if (digit >= 0) {
+                controller.actions.setApproval({ eventId, index: digit });
+                operate(() => digit === 2 ? controller.actions.cancelTurn() : controller.actions.approve(digit === 0));
+                return;
+            }
+            if (key.upArrow || key.downArrow) {
                 // An unselected list enters at the first, non-destructive choice, so a stray arrow plus Enter cannot cancel.
-                const index = digit >= 0 ? digit : approvalIndex < 0 ? 0
-                    : Math.max(0, Math.min(2, approvalIndex + (key.upArrow ? -1 : 1)));
+                const index = approvalIndex < 0 ? 0 : cycle(approvalIndex, key.upArrow ? -1 : 1, 3);
                 controller.actions.setApproval({ eventId, index });
                 return;
             }
@@ -497,16 +514,23 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         if (questionKeysActive && !input && controller.queries.foreground === undefined && !key.ctrl && !key.meta) {
             const digit = /^[1-9]$/.test(_value) ? Number(_value) - 1 : -1;
             if (key.upArrow || key.downArrow) {
-                controller.actions.setOption({ ...choiceState, cursor: Math.max(0, Math.min(options.length, optionCursor + (key.upArrow ? -1 : 1))) });
+                // The input row is one more stop after the options, so the ring is one longer than the list.
+                controller.actions.setOption({ ...choiceState, cursor: cycle(optionCursor, key.upArrow ? -1 : 1, options.length + 1) });
                 return;
             }
-            if (digit >= 0 && digit <= options.length || _value === ' ' && question.multiSelect === true && optionCursor < options.length) {
+            if ((digit >= 0 && digit < options.length) || _value === ' ' && question.multiSelect === true && optionCursor < options.length) {
                 const index = digit >= 0 ? digit : optionCursor;
-                const label = index < options.length ? string(options[index].label) : undefined;
-                const selected = question.multiSelect === true && label
-                    ? choiceState.selected.includes(label) ? choiceState.selected.filter(item => item !== label) : [...choiceState.selected, label]
-                    : choiceState.selected;
-                controller.actions.setOption({ ...choiceState, cursor: index, selected });
+                const label = string(options[index].label);
+                if (question.multiSelect === true) {
+                    const selected = choiceState.selected.includes(label)
+                        ? choiceState.selected.filter(item => item !== label) : [...choiceState.selected, label];
+                    controller.actions.setOption({ ...choiceState, cursor: index, selected });
+                    return;
+                }
+                // A single choice is answered by its number: the option is the whole answer, so only a second
+                // question — not a second keypress — stands between the number and the submission.
+                controller.actions.setOption({ ...choiceState, cursor: index });
+                operate(() => controller.actions.answerQuestion({ selected: [label] }));
                 return;
             }
             if (key.return) {
@@ -547,11 +571,11 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 return;
             }
             if (key.upArrow) {
-                setLoopMenuIndex(Math.max(0, loopMenuCursor - 1));
+                setLoopMenuIndex(cycle(loopMenuCursor, -1, loopCandidates.length));
                 return;
             }
             if (key.downArrow) {
-                setLoopMenuIndex(Math.min(loopCandidates.length - 1, loopMenuCursor + 1));
+                setLoopMenuIndex(cycle(loopMenuCursor, 1, loopCandidates.length));
                 return;
             }
         }
@@ -559,9 +583,9 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
             if (key.tab)
                 pickReference();
             else if (key.upArrow)
-                setReferenceIndex(Math.max(0, referenceIndex - 1));
+                setReferenceIndex(cycle(referenceIndex, -1, matches?.items.length ?? 1));
             else if (key.downArrow)
-                setReferenceIndex(Math.max(0, Math.min((matches?.items.length ?? 1) - 1, referenceIndex + 1)));
+                setReferenceIndex(cycle(referenceIndex, 1, matches?.items.length ?? 1));
             return;
         }
         const recallPrevious = key.upArrow || key.ctrl && _value === 'p';
@@ -649,8 +673,14 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 candidates: loopCandidates.length, chosen: highlighted.name });
         }
         const line = highlighted === undefined ? raw : `/loop ${highlighted.name}`;
+        // A mention menu with nothing left to insert owns no key: its Enter can only mean "accept the
+        // highlighted candidate", and with no candidate it meant nothing at all — a dead Enter on a draft
+        // that was perfectly sendable. The menu stays on screen (its "No matching host files" line is the
+        // feedback), but the draft is submitted. While the lookup is still in flight `matches` is
+        // undefined and the menu keeps Enter, so a slow listing cannot be raced by a send.
+        const referenceEmpty = referenceOpen && matches !== undefined && matches.items.length === 0;
         // The pipeline decides what the line means; the root only carries out the three stages' results.
-        const submission = interpret({ line, referenceOpen, copyMode, screen: state.screen });
+        const submission = interpret({ line, referenceOpen: referenceOpen && !referenceEmpty, copyMode, screen: state.screen });
         if (submission.kind === 'mode') {
             if (submission.action.kind === 'ignore')
                 return;
@@ -991,7 +1021,7 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     // Reading older history pauses the clock without freezing the connection state on picker screens.
     // A paused clock is named rather than left frozen: a stopped number looks like a stall.
     const pauseReason = copyMode ? 'copy'
-        : state.screen === 'chat' && dialogOpen ? 'dialog'
+        : state.screen === 'chat' && modalOpen ? 'dialog'
             : state.screen === 'chat' && position > 0 ? 'history'
                 : undefined;
     const statusFrozen = pauseReason !== undefined;
@@ -1054,7 +1084,13 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                                                 // A rollup of badges is read through the key beside it; spelled-out states need no key, and a
                                                 // terminal too narrow for the whole key gets the badges alone rather than half a legend.
                                                 legend: state.screen === 'workspaces' && rollupStyle === 'badges' && pickerWidth >= 40 ? ROLLUP_LEGEND : undefined, enabled: state.online && foreground === undefined && !input, canSelect: () => !input && controller.state.online && controller.queries.foreground === undefined })
-                                                : _jsx(OfflinePanel, { guidance: offline }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined }), promptsOpen && state.screen === 'chat' && _jsx(PromptsDialog, { identity: "prompts", prompts: controller.queries.prompts, error: controller.queries.promptsError, width: width, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined, onChoose: text => { setInput(text); openPrompts(false); }, onEdit: prompt => {
+                                                : _jsx(OfflinePanel, { guidance: offline }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined }), promptsOpen && state.screen === 'chat' && _jsx(PromptsDialog, { identity: "prompts", prompts: controller.queries.prompts, error: controller.queries.promptsError, width: width, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined, onChoose: text => {
+                                                            setInput(text);
+                                                            // A shortcut is a finished line, not a draft being written: if it ends in a mention, the
+                                                            // completion menu must not open and own Enter, or choosing it would dead-key the composer.
+                                                            setDismissedReference(text);
+                                                            openPrompts(false);
+                                                        }, onEdit: prompt => {
                                                             setComposerIntent({
                                                                 hint: 'Editing saved prompt · Enter saves · Esc cancels',
                                                                 emptyNotice: 'Type the prompt text; Enter then saves it',
@@ -1064,10 +1100,10 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                                                             setInput(prompt.text);
                                                             openPrompts(false);
                                                         }, onRemove: id => operate(async () => { if (await controller.actions.deletePrompt(id))
-                                                            setNotice('Deleted saved prompt'); }) }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => setHistoryPanel(undefined) }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(question.header)}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? question.question : pending.kind === 'approval' ? pending.description : '') }), question?.detail && _jsx(Text, { children: safeText(question.detail) }), pending.kind === 'approval' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "\u2191 \u2193 / 1\u20133 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
-                                                                        .slice(optionStart, optionStart + optionPageSize).map(({ option, index }) => _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { color: index === optionCursor ? theme.accent : undefined, wrap: "truncate-end", children: [index === optionCursor ? '❯ ' : '  ', index + 1, ". ", question?.multiSelect === true && index < options.length ? choiceState.selected.includes(option.label) ? '[x] ' : '[ ] ' : '', safeText(option.label)] }), option.description && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['     ', safeText(option.description)] })] }, index)), _jsx(Text, { dimColor: true, children: choiceState.custom ? 'Type your answer below · Esc returns to options' : question?.multiSelect === true
-                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm · Esc dismisses' : '↑ ↓ / 1–9 select · Enter confirm · Esc dismisses' })] }), _jsx(Text, { dimColor: true, children: question ? options.length > 0
+                                                            setNotice('Deleted saved prompt'); }) }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && foreground === undefined, canSelect: () => !input && controller.queries.foreground === undefined, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => setHistoryPanel(undefined) }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(question.header)}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? question.question : pending.kind === 'approval' ? pending.description : '') }), question?.detail && _jsx(Text, { children: safeText(question.detail) }), pending.kind === 'approval' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "1\u20133 answer \u00B7 \u2191 \u2193 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
+                                                                        .slice(optionStart, optionStart + optionPageSize).map(({ option, index }) => _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { color: index === optionCursor ? theme.accent : undefined, wrap: "truncate-end", children: [index === optionCursor ? '❯ ' : '  ', index < options.length ? `${index + 1}. ` : '', question?.multiSelect === true && index < options.length ? choiceState.selected.includes(option.label) ? '[x] ' : '[ ] ' : '', safeText(option.label)] }), option.description && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['     ', safeText(option.description)] })] }, index)), _jsx(Text, { dimColor: true, children: choiceState.custom ? 'Type your answer below · Esc returns to options' : question?.multiSelect === true
+                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm · Esc dismisses' : '↑ ↓ move · 1–9 answer · Enter confirm · Esc dismisses' })] }), _jsx(Text, { dimColor: true, children: question ? options.length > 0
                                                                     ? 'Choose "Other answer" to type · the draft is kept while this is open'
                                                                     : 'Esc dismisses the question · the draft is kept while this is open'
-                                                                    : 'Esc keeps this pending · the draft is kept while this is open' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(input); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : surfaceReservedKeys.length ? surfaceReservedKeys : undefined, width: draftWidth, maxRows: composerRows, promptColor: answerPending ? theme.colors.muted : theme.accent, focus: !copyMode && !answerPending && !loopForm, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex }), loopMenuOpen && _jsx(LoopMenu, { records: loopCandidates, index: loopMenuCursor, source: controller.queries.loopSource })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), commandHint && _jsxs(Text, { dimColor: true, children: [_jsxs(Text, { color: theme.accent, children: [commandHint.command, commandHint.usage === undefined ? '' : ` ${commandHint.usage}`] }), " \u00B7 ", commandHint.description] }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { source: costSource }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { source: statusSource, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
+                                                                    : 'Esc keeps this pending · the draft is kept while this is open' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(input); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : surfaceReservedKeys.length ? surfaceReservedKeys : undefined, width: draftWidth, maxRows: composerRows, promptColor: answerPending || panelParksComposer ? theme.colors.muted : theme.accent, focus: !copyMode && !answerPending && !loopForm && !panelParksComposer, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex }), loopMenuOpen && _jsx(LoopMenu, { records: loopCandidates, index: loopMenuCursor, source: controller.queries.loopSource })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), commandHint && _jsxs(Text, { dimColor: true, children: [_jsxs(Text, { color: theme.accent, children: [commandHint.command, commandHint.usage === undefined ? '' : ` ${commandHint.usage}`] }), " \u00B7 ", commandHint.description] }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { source: costSource }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { source: statusSource, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
 }

package/dist/ui/chat/status.js

@@ -273,10 +273,16 @@ export const StatusBar = memo(function StatusBar({ source, expanded = false, wid
         // The state token reports a fact and never guesses: a paused clock is named, offline and errors
         // take the token over, and an unknown phase simply leaves the phase group empty. An answer this
         // client still owes outranks the paused reason, because that reason is only why the clock stopped.
+        // A degraded metadata load names the subsystem it broke, so the bar itself answers "what is
+        // wrong" and the expanded panel only has to add the message. Live metrics lead because the rest
+        // of the bar reads them; presets are the quietest of the three and never hide a louder failure.
+        const degraded = source.controlError !== undefined ? '⚠ Metrics'
+            : source.modelError !== undefined ? '⚠ Models'
+                : source.presetError !== undefined ? '⚠ Presets' : undefined;
         const stateToken = !source.online
             ? { text: '! Offline', color: theme.status.offline }
-            : source.controlError || source.modelError
-                ? { text: '⚠ Error', color: theme.status.warning }
+            : degraded !== undefined
+                ? { text: degraded, color: theme.status.warning }
                 : source.pendingCount > 0
                     ? { text: '? Needs you', color: theme.status.critical }
                     : pauseReason !== undefined

package/dist/ui/dialogs/loop.js

@@ -6,6 +6,7 @@ import { validLoopOption } from "../../slash/parse.js";
 import { safeText } from "../../text.js";
 import { useCopyMode } from "../copy-mode.js";
 import { useTheme } from "../theme/index.js";
+import { cycle } from "./picker.js";
 const FIELDS = [
     { field: 'from', label: 'From', hint: 'first round, 1 or more' },
     { field: 'to', label: 'To', hint: 'last round, at least From' },
@@ -137,10 +138,10 @@ export function LoopDialog({ record, enabled, onStart, onBack, onClose }) {
         setError(undefined);
         return true;
     };
-    const move = (next) => {
+    const move = (delta) => {
         if (!applyEdit())
             return;
-        setRow(Math.max(0, Math.min(rows.length - 1, next)));
+        setRow(cycle(row, delta, rows.length));
         setEdit(undefined);
         setError(undefined);
     };
@@ -157,11 +158,11 @@ export function LoopDialog({ record, enabled, onStart, onBack, onClose }) {
             return;
         }
         if (key.upArrow) {
-            move(row - 1);
+            move(-1);
             return;
         }
         if (key.downArrow) {
-            move(row + 1);
+            move(1);
             return;
         }
         if (current.kind === 'var') {
@@ -179,7 +180,7 @@ export function LoopDialog({ record, enabled, onStart, onBack, onClose }) {
                 return;
             }
             if (key.return)
-                move(row + 1);
+                move(1);
             return;
         }
         if (current.kind === 'field') {
@@ -195,7 +196,7 @@ export function LoopDialog({ record, enabled, onStart, onBack, onClose }) {
                 return;
             }
             if (key.return)
-                move(row + 1);
+                move(1);
             return;
         }
         if (!key.return)

package/dist/ui/dialogs/picker.d.ts

@@ -23,6 +23,17 @@ export interface Choice {
     edit?(): void;
     remove?(): void;
 }
+/** One step around a closed ring, so a list has no dead end at either edge.
+ *
+ * Every menu in the client moves this way: holding ↑ on the first row lands on the last, and ↓ on
+ * the last wraps to the first. A menu therefore never needs an extra key to reach a row the arrows
+ * cannot pass, and an empty list stays on index 0 rather than producing a negative one.
+ * @param index - Current row.
+ * @param delta - Rows to move, positive for down.
+ * @param length - Number of rows in the ring.
+ * @returns The wrapped index.
+ */
+export declare function cycle(index: number, delta: number, length: number): number;
 /** Keyboard-driven list with paging and optional removal.
  * @param props - Choices, availability, page size, hint text and the usable column count.
  * @returns The rendered list rows and its navigation hint.

package/dist/ui/dialogs/picker.js

@@ -10,6 +10,21 @@ import { useTheme } from "../theme/index.js";
 function cellsWidth(cells) {
     return (cells ?? []).reduce((sum, cell) => sum + stringWidth(cell.text), 0);
 }
+/** One step around a closed ring, so a list has no dead end at either edge.
+ *
+ * Every menu in the client moves this way: holding ↑ on the first row lands on the last, and ↓ on
+ * the last wraps to the first. A menu therefore never needs an extra key to reach a row the arrows
+ * cannot pass, and an empty list stays on index 0 rather than producing a negative one.
+ * @param index - Current row.
+ * @param delta - Rows to move, positive for down.
+ * @param length - Number of rows in the ring.
+ * @returns The wrapped index.
+ */
+export function cycle(index, delta, length) {
+    if (length <= 0)
+        return 0;
+    return ((index + delta) % length + length) % length;
+}
 /** Keyboard-driven list with paging and optional removal.
  * @param props - Choices, availability, page size, hint text and the usable column count.
  * @returns The rendered list rows and its navigation hint.
@@ -31,9 +46,9 @@ export function Picker({ choices, enabled, canSelect, pageSize = 12, hint, width
         if (!canSelect() || key.eventType === 'release')
             return;
         if (key.upArrow)
-            setSelected(Math.max(0, current - 1));
+            setSelected(cycle(current, -1, choices.length));
         else if (key.downArrow)
-            setSelected(Math.min(choices.length - 1, current + 1));
+            setSelected(cycle(current, 1, choices.length));
         else if (_input === 'e' && !key.ctrl && !key.meta)
             choices[current]?.edit?.();
         else if (_input === 'd' && !key.ctrl && !key.meta || key.delete && /^\x1b\[3(?:;\d+)?~$/.test(rawKey.current))

package/dist/ui/dialogs/use-panels.d.ts

@@ -22,6 +22,8 @@ interface Surface {
     open: boolean;
     arrows?: boolean;
     blocksKeys?: boolean;
+    /** The panel reads no free text, so the composer behind it is parked until the panel closes. */
+    parksComposer?: boolean;
     reserved?: readonly string[];
 }
 /** The externally owned peek view participates in routing without duplicating its state. */

package/dist/ui/dialogs/use-panels.js

@@ -2,9 +2,9 @@
 import { useEffect, useState } from 'react';
 const EMPTY = { thoughts: false, queue: false, prompts: false, help: false, cost: false, status: false };
 const TRAITS = [
-    { name: 'queue', reserved: ['d'] },
-    { name: 'prompts', arrows: true, blocksKeys: true, reserved: ['d', 'e'] },
-    ...['removal', 'model', 'loop', 'thoughts', 'history', 'search'].map(name => ({ name, arrows: true, blocksKeys: true })),
+    { name: 'queue', reserved: ['d'], parksComposer: true },
+    { name: 'prompts', arrows: true, blocksKeys: true, reserved: ['d', 'e'], parksComposer: true },
+    ...['removal', 'model', 'loop', 'thoughts', 'history', 'search'].map(name => ({ name, arrows: true, blocksKeys: true, parksComposer: true })),
     ...['help', 'cost', 'status'].map(name => ({ name, blocksKeys: true })),
 ];
 /** The externally owned peek view participates in routing without duplicating its state. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itookit/dsht",
-  "version": "0.6.7",
+  "version": "0.6.10",
   "type": "module",
   "description": "Remote-first TUI for DeepSeek Harness with SSH-friendly mobile access and request-level cost tracking",
   "engines": {