@songtonyli/dsh-cli 0.1.72 → 0.1.74

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -26,7 +26,7 @@ workspace and no build step. Native packages that ship one build per platform
26
26
  ripgrep, the PTY backend's addons, sharp, koffi, and the Landlock launcher — are
27
27
  ordinary optional dependencies, so npm resolves the right one for your machine.
28
28
 
29
- Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.72; `dsh --version`
29
+ Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.74; `dsh --version`
30
30
  also reports the harness build the package was assembled from.
31
31
 
32
32
  ## License
package/bin/dsh.mjs CHANGED
@@ -18,7 +18,7 @@ const argv = process.argv.slice(2)
18
18
  // version this package publishes. Reporting only one of the two would make an
19
19
  // ordinary `npm install @songtonyli/dsh-cli@x` look like it installed something else.
20
20
  if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V')) {
21
- console.log('@songtonyli/dsh-cli 0.1.72 (deepseek-harness 0.2.1-alpha.2)')
21
+ console.log('@songtonyli/dsh-cli 0.1.74 (deepseek-harness 0.2.1-alpha.2)')
22
22
  process.exit(0)
23
23
  }
24
24
 
@@ -167,7 +167,7 @@ window.__ModuleLoader__.load({
167
167
  const SCROLLBAR_LINGER_MS = 2e3;
168
168
  /** Format complete-build metadata for the local brand badge. */
169
169
  function localBuildVersion() {
170
- return `0.2.1-alpha.2-a93f939` + ({}.DSH_CLIENT_GIT_DIRTY === "true" ? "-dirty" : "");
170
+ return `0.2.1-alpha.2-6bbe5c1` + ({}.DSH_CLIENT_GIT_DIRTY === "true" ? "-dirty" : "");
171
171
  }
172
172
  /** Each panel row subscribes only to its own selection state. */
173
173
  function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {
@@ -18,11 +18,11 @@
18
18
  en: 192bbbb187278f91
19
19
  zh: 1f7e5632c15bdcf7
20
20
  /deepseek-ai-dsh-tui-app/use-this-package/starting-and-resuming:
21
- en: 19374746e69c8ca0
22
- zh: 211dac2851029319
21
+ en: 58a8cf392bd6a90b
22
+ zh: ff147492c5baf643
23
23
  /deepseek-ai-dsh-tui-app/use-this-package/the-screen:
24
- en: 400dece292a9030c
25
- zh: 268192e1a03ebf3e
24
+ en: 7c7e0622465bd9dd
25
+ zh: 4bada28f846ad050
26
26
  /deepseek-ai-dsh-tui-app/use-this-package/keys-and-commands:
27
27
  en: e3650a069cc84840
28
28
  zh: b8428946ec8beab1
@@ -36,7 +36,7 @@ dsh tui --resume <session-id> # continue an earlier session
36
36
  dsh tui --no-open # print sign-in URLs without opening a browser
37
37
  ```
38
38
 
39
- On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>` on stderr for the session bound at that moment. A resumed session redraws its persisted history before accepting input and continues with that session's last model, or the launch default when the log has no request header; inside the terminal, `/resume` and `/sessions` open the same picker over every persisted root session and resume the selected previous session, `/new` starts a fresh empty session with the launch default model, while `/clear` starts a fresh empty session that retains the current model and reasoning effort; the previous session stays on disk for `/resume`, and `/fork` copies the current session up to its last completed turn into a new one, the same cut the browser's fork takes. Switching releases the previous Agent and redraws the transcript of the next.
39
+ On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>` on stderr for the session bound at that moment. A resumed session redraws its persisted history before accepting input and continues with that session's last model, or the launch default when the log has no request header; inside the terminal, `/resume` and `/sessions` open the same picker over persisted root sessions other than the current session, newest first, and resume the selected previous session, `/new` starts a fresh empty session with the launch default model, while `/clear` starts a fresh empty session that retains the current model and reasoning effort; the previous session stays on disk for `/resume`, and `/fork` copies the current session up to its last completed turn into a new one, the same cut the browser's fork takes. Switching releases the previous Agent and redraws the transcript of the next.
40
40
 
41
41
  ### The screen
42
42
 
@@ -54,9 +54,9 @@ Transient key feedback floats as a dim framed line in the top-right corner of th
54
54
 
55
55
  Motion reaches past streamed text: every lift and float rides the same fade tick, and every working animation one spinner tick. The keyboard landing on the conversation, the subagent panel, or the status bar lifts that surface's frame, its chip, and the mark it holds for twelve ticks of `streamFadeStepMs`; a step of the conversation walk lifts the newly focused gutter for six; and a step along the bar lifts the selected label for eight. A new or status-changed activity-board todo row, and a replaced descendant line, float out on the fade tick the same way a tool card does; replay and `reducedMotion` draw the settled board. Every working animation has eight frames, takes the one it draws from the clock, and steps on the spinner tick of `spinnerMs`, 100 ms by default, so everything that spins advances at the same instant and speed, a label change keeps the beat, and the tick is armed only while one of them is drawn. The working spinner alone draws braille, its animation following its status, so it never repeats a card's glyph. A running tool card and a folded subagent row draw the animation of that tool's family, and an in-progress todo row draws the planning family's. Each of those animations mixes flowers, blooms, and stars, no two families share a glyph, and every frame of one family is different, so two indicators of one family at different phases never draw the same glyph. An indicator that starts while others of its family spin takes a phase at which it never draws their glyph at the same instant, for up to eight of that family spinning together; beyond eight, it takes the phase the fewest indicators of that family hold. A card whose header has scrolled above the part of the screen the renderer can repaint draws the static `◆` from then on, and `reducedMotion` draws every one of them still — the card's `◆`, the todo's `▸`, and the working spinner's label without a glyph — with no spinner tick. The reader arrives complete on the screen it owns, and what it newly shows floats out on the fade tick the way a tool card does: opening it and showing another turn float out the whole turn, and stepping the list to another section of the same turn floats out that section, over `streamFadeSteps` ticks; scrolling, live growth, and a rewrap float nothing out. No lift changes how many lines anything draws, and `reducedMotion` — like `NO_COLOR`, a disabled palette, and `TERM=dumb` — turns every lift and float off and arms no repaint for them.
56
56
 
57
- The subagent panel is drawn while a local subagent session under the bound one is resident, or the listing carries a candidate it could not read; an external task has no local session and stays out of the panel. 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 ends on the keys it answers, `↑↓ children · Enter opens · Tab regions · Esc input`, narrowed to `↑↓ children · Esc input` and then to `Esc input` on a terminal that cannot hold them, 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`, `completed` after its latest settled turn, 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; `/subagents` shows an external task as `external task · no local session` and shows its no-local-session detail instead of opening a Session, a candidate the listing could not interpret draws as `unreadable: <reason>` and shows its reason instead of opening a Session, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row. `Enter` or `Right` on a readable row, like `Enter` on a readable `/subagents` row, opens that child as a subagent view: the terminal draws the child session in place of the bound one — its transcript, live stream, conversation walk, inspector, reader, and its own subagent panel — while the session it was entered from stays open. A resident child is read live, and any other is resumed. The entry's detail rows print as notices under `subagent <label> · Ctrl+P or /parent returns to session <id>`, the header ends on `◆ subagent view ›` with one `›` per level entered and `· Ctrl+P returns`, a shaded line directly above the input reads `◆ subagent view · main › <label> · Ctrl+P back to <parent>` for as long as the view is open, whatever the transcript has scrolled to, and `Ctrl+P` or `/parent` goes back one level, redrawing the parent from its log as it stands then. A one-shot child opens read-only: its banner opens with `◆ subagent view · one-shot, read-only`, a prompt or `!` line typed there is refused with a notice and stays in the editor, `Esc` does not stop its turn, and commands such as `/parent` still run, while a continuable child takes prompts and a stop as any session does. `/new`, `/clear`, `/resume`, `/sessions`, and `/fork` refuse while any session in that chain runs a turn, and otherwise release every view with the session they leave; quitting releases every view and saves the root session.
57
+ The subagent panel is drawn while a local subagent session under the bound one is resident, or the listing carries a candidate it could not read; an external task has no local session and stays out of the panel. 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 ends on the keys it answers, `↑↓ children · Enter opens · Tab regions · Esc input`, narrowed to `↑↓ children · Esc input` and then to `Esc input` on a terminal that cannot hold them, 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`, `completed` after its latest settled turn, 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; `/subagents` shows an external task as `external task · no local session` and shows its no-local-session detail instead of opening a Session, a candidate the listing could not interpret draws as `unreadable: <reason>` and shows its reason instead of opening a Session, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row. `Enter` or `Right` on a readable row, like `Enter` on a readable `/subagents` row, opens that child as a subagent view: the terminal draws the child session in place of the bound one — its transcript, live stream, conversation walk, inspector, reader, and its own subagent panel — while the session it was entered from stays open. A resident child is read live, and any other is resumed. The entry's detail rows print as notices under `subagent <label> · Ctrl+P or /parent returns to session <id>`, the header ends on `◆ subagent view ›` with one `›` per level entered and `· Ctrl+P returns`, a shaded line directly above the input reads `◆ subagent view · main › <label> · Ctrl+P back to <parent>` for as long as the view is open, whatever the transcript has scrolled to, and `Ctrl+P` or `/parent` goes back one level, redrawing the parent from its log as it stands then. A one-shot child opens read-only: its banner opens with `◆ subagent view · one-shot, read-only`, a prompt or `!` line typed there is refused with a notice and stays in the editor, `Esc` does not stop its turn, and commands such as `/parent` still run, while a continuable child takes prompts and a stop as any session does. `/new`, `/clear`, `/resume`, `/sessions`, and `/fork` refuse while any session in that chain runs a turn or a background job, since releasing a session ends its jobs, and otherwise release every view with the session they leave; quitting releases every view and saves the root session.
58
58
 
59
- `/btw` opens a temporary side agent as a view over the session on screen, so the user can ask questions while that session's agent keeps working. The side agent is a new Agent seeded with every event the session has logged so far, an unfinished turn included: a tool call still waiting for its result gets the fork's error result, and reply text that is still streaming is not included. It runs on the session's last logged model, else its current selection, and it can only read: its session runs in the `read-only` sandbox mode with the `never` approval policy, so a write fails and cannot be approved, and it sees only the tools named in `btwTools`, plus the command tools in `btwSandboxedTools` when the command executor confines commands. Every other tool is hidden from it and refused if called. It runs its own turns: the question after `/btw` is its first prompt, and every line typed while it is on screen goes to it, `/btw <question>` included. The view is drawn like a subagent view: the header ends on `◆ btw side agent · Ctrl+P ends it and returns`, the shaded line above the input reads `◆ btw side agent · main › btw · Ctrl+P back to main`, and the transcript starts empty instead of repeating the inherited conversation. `Ctrl+P` or `/parent` ends the side agent, cancelling a turn it is running, and redraws the session it was opened from under `btw ended · back in session <id>`. The working session is only read: nothing is appended to its log, its inbox is untouched, and neither its subagent panel, `/subagents`, nor its model-facing subagent listing shows the side agent, which also cannot message it. An approval or question that a session held behind any view raises is shown on screen after `session <id>, behind this view, asks:` instead of being refused.
59
+ `/btw` opens a temporary side agent as a view over the session on screen, so the user can ask questions while that session's agent keeps working. The side agent is a new Agent seeded with every event the session has logged so far, an unfinished turn included: a tool call still waiting for its result gets the fork's error result, and reply text that is still streaming is not included. Input still queued for the session, prompts and next-step context alike, stays with that session's agent and is not carried into the side agent. It runs on the session's last logged model, else its current selection, and it can only read: its session runs in the `read-only` sandbox mode with the `never` approval policy, so a write fails and cannot be approved, and it sees only the tools named in `btwTools`, plus the command tools in `btwSandboxedTools` when the command executor confines commands. Every other tool is hidden from it and refused if called. It runs its own turns: the question after `/btw` is its first prompt, and every line typed while it is on screen goes to it, `/btw <question>` included. The view is drawn like a subagent view: the header ends on `◆ btw side agent · Ctrl+P ends it and returns`, the shaded line above the input reads `◆ btw side agent · main › btw · Ctrl+P back to main`, and the transcript starts empty instead of repeating the inherited conversation. `Ctrl+P` or `/parent` ends the side agent, cancelling a turn it is running, and redraws the session it was opened from under `btw ended · back in session <id>`. The working session is only read: nothing is appended to its log, its inbox is untouched, and neither its subagent panel, `/subagents`, nor its model-facing subagent listing shows the side agent, which also cannot message it. An approval or question that a session held behind any view raises is shown on screen after `session <id>, behind this view, asks:` instead of being refused.
60
60
 
61
61
  ### Keys and commands
62
62
 
@@ -36,7 +36,7 @@ dsh tui --resume <session-id> # continue an earlier session
36
36
  dsh tui --no-open # print sign-in URLs without opening a browser
37
37
  ```
38
38
 
39
- 退出时应用在 stderr 为当时绑定的会话打印 `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>`。恢复的会话会在接受输入前先重绘其持久化历史,并沿用该会话上次使用的模型;日志里还没有请求头时则使用启动默认模型。在终端内,`/resume` 与 `/sessions` 打开覆盖所有持久化根会话的同一个选择器,并恢复选中的先前会话,`/new` 使用启动默认模型开始新的空会话,而 `/clear` 开始新的空会话并保留当前模型和推理强度;先前会话仍留在磁盘上可用 `/resume` 恢复,`/fork` 把当前会话复制到其最后一个完成轮次并作为新会话,切割点与浏览器的 fork 相同。切换会释放先前的 Agent 并重绘下一个会话的对话记录。
39
+ 退出时应用在 stderr 为当时绑定的会话打印 `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>`。恢复的会话会在接受输入前先重绘其持久化历史,并沿用该会话上次使用的模型;日志里还没有请求头时则使用启动默认模型。在终端内,`/resume` 与 `/sessions` 打开同一个选择器,按从新到旧列出当前会话以外的持久化根会话,并恢复选中的先前会话,`/new` 使用启动默认模型开始新的空会话,而 `/clear` 开始新的空会话并保留当前模型和推理强度;先前会话仍留在磁盘上可用 `/resume` 恢复,`/fork` 把当前会话复制到其最后一个完成轮次并作为新会话,切割点与浏览器的 fork 相同。切换会释放先前的 Agent 并重绘下一个会话的对话记录。
40
40
 
41
41
  ### 屏幕布局
42
42
 
@@ -54,9 +54,9 @@ dsh tui --no-open # print sign-in URLs without opening a
54
54
 
55
55
  动效不止于流式文本:每种抬亮与浮出都乘着同一个淡入时钟,每种工作动画则乘着同一个旋转时钟。键盘落到对话记录、子 agent 面板或状态栏上时,会把该表层的边框、其徽标与它持有的标记抬亮十二拍(每拍一个 `streamFadeStepMs`);对话记录走查中的一步把新聚焦的标记条抬亮六拍;状态栏上的一步把所选标签抬亮八拍。活动板上新出现或状态已变的 todo 行,以及被替换的后代行,也在淡入时钟上像工具卡片一样浮出;重放与 `reducedMotion` 则画出已稳定的活动板。每种工作动画都有八帧,由时钟决定当前画哪一帧,并在周期为 `spinnerMs`(默认 100 ms)的旋转时钟上步进,因此一切旋转中的指示都在同一时刻、以同一速度前进,标签变化也不打乱节拍,而该时钟只在其中之一被绘制时才启动。只有工作时的旋转指示画盲文,其动画随状态而变,因此它从不与卡片的符号重复。运行中的工具卡片与折叠的子 agent 行画该工具族的动画,进行中的 todo 行画规划族的动画。这些动画都把花朵、绽放与星形混在同一组帧里,族与族之间不共用符号,同一族的每一帧也各不相同,因此同一族里相位不同的两个指示在任何时刻都不会画出相同的符号。某个指示开始旋转时若同族已有其他指示在转,它会取一个相位,使它在任何时刻都不与它们画出相同的符号,同族同时旋转的不超过八个时都能做到;超过八个后,它取同族中被持有指示最少的那个相位。标题行已滚动到渲染器可重绘区域之上的卡片自此画出静态的 `◆`,而 `reducedMotion` 把它们全部画成静止的——卡片的 `◆`、todo 的 `▸`,以及不带符号、只剩标签的工作旋转指示——且不启动旋转时钟。阅读器在自己占据的屏幕上一次性完整出现,而它新显示的内容会像工具卡片一样在淡入时钟上浮出:打开它与显示另一个轮次时浮出整个轮次,在列表中步进到同一轮次的另一个小节时浮出该小节,历时 `streamFadeSteps` 拍;滚动、实时增长与重新换行都不浮出任何内容。任何抬亮都不改变任何东西绘制的行数,而 `reducedMotion`——与 `NO_COLOR`、被禁用的调色板和 `TERM=dumb` 一样——会关闭每一种抬亮与浮出,并且不为它们安排任何重绘。
56
56
 
57
- 子 agent 面板在绑定会话之下有常驻的本地子 agent 会话、或列表中带有无法读取的候选者时绘制;外部任务没有本地会话,因此不在面板中出现。未聚焦时它是一行摘要,含列出的数量与第一个子会话的关键标签;聚焦时其标题统计所列出的条目,并以它所应答的按键 `↑↓ children · Enter opens · Tab regions · Esc input` 结尾,在容纳不下时收缩为 `↑↓ children · Esc input`,再收缩为 `Esc input`;每一行给出该子会话的层级缩进、其标签或 id、其模式(`one-shot` 或 `continuable`)、`resident`、其 agent 处于 `running`、最新已结束轮次后为 `completed`,还是 `idle`、其已用时间——进行中轮次的用时,否则是已结束轮次的合计——以及其 token 用量,以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行,其下是 `+<n> more · /subagents lists them all`;`/subagents` 把外部任务显示为 `external task · no local session`,并显示其没有本地会话的详情而不打开会话,列表无法解读的候选者绘制为 `unreadable: <reason>`,并显示其原因而不打开会话,读取失败的列表则保留上一次成功读取产生的各行,并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。在可读的行上按 `Enter` 或 `Right`,与在可读的 `/subagents` 行上按 `Enter` 一样,会把该子会话作为子 agent 视图打开:终端在已绑定会话的位置绘制子会话——其对话记录、实时流、对话记录走查、检查器、阅读器以及它自己的子 agent 面板——而进入它之前的会话保持打开。常驻的子会话被实时读取,其他子会话则被恢复。条目的详情行作为通知打印在 `subagent <label> · Ctrl+P or /parent returns to session <id>` 之下,页眉以 `◆ subagent view ›`(每进入一层一个 `›`)与 `· Ctrl+P returns` 结尾,只要视图打开,输入框正上方就有一条着色行写着 `◆ subagent view · main › <label> · Ctrl+P back to <parent>`,无论对话记录滚动到哪里,`Ctrl+P` 或 `/parent` 返回上一层,并按父会话此刻的日志重绘它。`one-shot` 子会话以只读方式打开:其横幅以 `◆ subagent view · one-shot, read-only` 开头,在其中输入的提示词或 `!` 行会被通知拒绝并留在编辑器中,`Esc` 不会停止它的轮次,而 `/parent` 等命令仍可运行;`continuable` 子会话则像任何会话一样接受提示词与停止。只要这条链中任一会话正在运行轮次,`/new`、`/clear`、`/resume`、`/sessions` 与 `/fork` 都会拒绝,否则它们会随所离开的会话释放每一个视图;退出会释放每一个视图并保存根会话。
57
+ 子 agent 面板在绑定会话之下有常驻的本地子 agent 会话、或列表中带有无法读取的候选者时绘制;外部任务没有本地会话,因此不在面板中出现。未聚焦时它是一行摘要,含列出的数量与第一个子会话的关键标签;聚焦时其标题统计所列出的条目,并以它所应答的按键 `↑↓ children · Enter opens · Tab regions · Esc input` 结尾,在容纳不下时收缩为 `↑↓ children · Esc input`,再收缩为 `Esc input`;每一行给出该子会话的层级缩进、其标签或 id、其模式(`one-shot` 或 `continuable`)、`resident`、其 agent 处于 `running`、最新已结束轮次后为 `completed`,还是 `idle`、其已用时间——进行中轮次的用时,否则是已结束轮次的合计——以及其 token 用量,以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行,其下是 `+<n> more · /subagents lists them all`;`/subagents` 把外部任务显示为 `external task · no local session`,并显示其没有本地会话的详情而不打开会话,列表无法解读的候选者绘制为 `unreadable: <reason>`,并显示其原因而不打开会话,读取失败的列表则保留上一次成功读取产生的各行,并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。在可读的行上按 `Enter` 或 `Right`,与在可读的 `/subagents` 行上按 `Enter` 一样,会把该子会话作为子 agent 视图打开:终端在已绑定会话的位置绘制子会话——其对话记录、实时流、对话记录走查、检查器、阅读器以及它自己的子 agent 面板——而进入它之前的会话保持打开。常驻的子会话被实时读取,其他子会话则被恢复。条目的详情行作为通知打印在 `subagent <label> · Ctrl+P or /parent returns to session <id>` 之下,页眉以 `◆ subagent view ›`(每进入一层一个 `›`)与 `· Ctrl+P returns` 结尾,只要视图打开,输入框正上方就有一条着色行写着 `◆ subagent view · main › <label> · Ctrl+P back to <parent>`,无论对话记录滚动到哪里,`Ctrl+P` 或 `/parent` 返回上一层,并按父会话此刻的日志重绘它。`one-shot` 子会话以只读方式打开:其横幅以 `◆ subagent view · one-shot, read-only` 开头,在其中输入的提示词或 `!` 行会被通知拒绝并留在编辑器中,`Esc` 不会停止它的轮次,而 `/parent` 等命令仍可运行;`continuable` 子会话则像任何会话一样接受提示词与停止。只要这条链中任一会话正在运行轮次或后台任务,`/new`、`/clear`、`/resume`、`/sessions` 与 `/fork` 都会拒绝(释放会话会结束它的后台任务),否则它们会随所离开的会话释放每一个视图;退出会释放每一个视图并保存根会话。
58
58
 
59
- `/btw` 在屏幕上的会话之上打开一个临时的旁路 agent 视图,让用户在该会话的 agent 继续工作时提问。旁路 agent 是一个新的 Agent,以该会话迄今记录的全部事件为种子,包括尚未结束的轮次:仍在等待结果的工具调用会得到分叉产生的错误结果,仍在流式输出的回复文本不包含在内。它使用该会话最后记录的模型(否则使用其当前选择),并且只能读取:它的会话运行在 `read-only` 沙箱模式与 `never` 审批策略下,因此写入会失败且无法获批;它只看得到 `btwTools` 中列出的工具,以及在命令执行器会约束命令时 `btwSandboxedTools` 中的命令工具。其他工具对它隐藏,被调用时也会被拒绝。它运行自己的轮次:`/btw` 之后的问题是它的第一条提示,它在屏幕上时输入的每一行都交给它,`/btw <question>` 也一样。该视图的绘制方式与子 agent 视图相同:页眉以 `◆ btw side agent · Ctrl+P ends it and returns` 结尾,输入框上方的着色行写着 `◆ btw side agent · main › btw · Ctrl+P back to main`,对话记录从空开始,而不是重复继承来的对话。`Ctrl+P` 或 `/parent` 结束旁路 agent(取消它正在运行的轮次),并在 `btw ended · back in session <id>` 之下重绘打开它之前的会话。工作中的会话只被读取:不向其日志追加任何内容,不触碰其收件箱,其子 agent 面板、`/subagents` 与面向模型的子 agent 列表都不显示旁路 agent,旁路 agent 也不能给它发消息。被任一视图挡在后面的会话发起的审批或提问,会在 `session <id>, behind this view, asks:` 之后显示在屏幕上,而不是被拒绝。
59
+ `/btw` 在屏幕上的会话之上打开一个临时的旁路 agent 视图,让用户在该会话的 agent 继续工作时提问。旁路 agent 是一个新的 Agent,以该会话迄今记录的全部事件为种子,包括尚未结束的轮次:仍在等待结果的工具调用会得到分叉产生的错误结果,仍在流式输出的回复文本不包含在内。该会话仍在排队的输入,无论是提示还是下一步上下文,都留给该会话的 agent,不会带进旁路 agent。它使用该会话最后记录的模型(否则使用其当前选择),并且只能读取:它的会话运行在 `read-only` 沙箱模式与 `never` 审批策略下,因此写入会失败且无法获批;它只看得到 `btwTools` 中列出的工具,以及在命令执行器会约束命令时 `btwSandboxedTools` 中的命令工具。其他工具对它隐藏,被调用时也会被拒绝。它运行自己的轮次:`/btw` 之后的问题是它的第一条提示,它在屏幕上时输入的每一行都交给它,`/btw <question>` 也一样。该视图的绘制方式与子 agent 视图相同:页眉以 `◆ btw side agent · Ctrl+P ends it and returns` 结尾,输入框上方的着色行写着 `◆ btw side agent · main › btw · Ctrl+P back to main`,对话记录从空开始,而不是重复继承来的对话。`Ctrl+P` 或 `/parent` 结束旁路 agent(取消它正在运行的轮次),并在 `btw ended · back in session <id>` 之下重绘打开它之前的会话。工作中的会话只被读取:不向其日志追加任何内容,不触碰其收件箱,其子 agent 面板、`/subagents` 与面向模型的子 agent 列表都不显示旁路 agent,旁路 agent 也不能给它发消息。被任一视图挡在后面的会话发起的审批或提问,会在 `session <id>, behind this view, asks:` 之后显示在屏幕上,而不是被拒绝。
60
60
 
61
61
  ### 按键与命令
62
62
 
@@ -12531,7 +12531,7 @@ var GuardedMainScreen = class extends TuiMainScreen {
12531
12531
  * @module @deepseek-ai/dsh-tui-app/sessions
12532
12532
  */
12533
12533
  /**
12534
- * List persisted sessions newest first, with their titles; subagent sessions are excluded.
12534
+ * List persisted sessions newest first, with their titles; the current session and subagents are excluded.
12535
12535
  *
12536
12536
  * Titles come from the live `title` projection or the durable projection
12537
12537
  * cache, the same values the browser list uses. The picker does not load
@@ -12540,19 +12540,18 @@ var GuardedMainScreen = class extends TuiMainScreen {
12540
12540
  * listing after the cache has the row.
12541
12541
  *
12542
12542
  * @param ctx - plugin context carrying the session query engine.
12543
- * @param currentId - the session the terminal drives, marked in the result.
12543
+ * @param currentId - the session the terminal drives, excluded from the result.
12544
12544
  * @param signal - cancels the listing.
12545
12545
  * @returns the choices, or an empty list when no query engine is composed.
12546
12546
  */
12547
12547
  async function listSessionChoices(ctx, currentId, signal) {
12548
12548
  const query = ctx.get("sessionQuery");
12549
12549
  if (query === void 0) return [];
12550
- return (await query.listSessions(signal)).filter((record) => record.header.origin === void 0).sort((left, right) => right.header.createdAt - left.header.createdAt).map((record) => ({
12550
+ return (await query.listSessions(signal)).filter((record) => record.header.origin === void 0 && record.header.id !== currentId).sort((left, right) => right.header.createdAt - left.header.createdAt).map((record) => ({
12551
12551
  id: record.header.id,
12552
12552
  title: sessionListTitle(ctx, record.header),
12553
12553
  cwd: record.header.cwd,
12554
- createdAt: record.header.createdAt,
12555
- current: record.header.id === currentId
12554
+ createdAt: record.header.createdAt
12556
12555
  }));
12557
12556
  }
12558
12557
  /**
@@ -12563,7 +12562,6 @@ async function listSessionChoices(ctx, currentId, signal) {
12563
12562
  function describeSession(choice) {
12564
12563
  const parts = [formatTimestamp(choice.createdAt)];
12565
12564
  if (choice.cwd !== void 0) parts.push(choice.cwd);
12566
- if (choice.current) parts.push("current");
12567
12565
  return {
12568
12566
  label: choice.title ?? choice.id,
12569
12567
  description: parts.join(" · ")
@@ -14149,6 +14147,11 @@ var TuiApp = class {
14149
14147
  this.notice("stop the running turn (Esc twice) before switching sessions", "error");
14150
14148
  return;
14151
14149
  }
14150
+ const live = this.liveChainJobs();
14151
+ if (live.length > 0) {
14152
+ this.notice(`wait for or stop the background jobs still running (${live.map((job) => job.id).join(", ")}) before switching sessions · /jobs lists them`, "error");
14153
+ return;
14154
+ }
14152
14155
  if (this.compacting !== void 0) {
14153
14156
  this.notice(COMPACTION_SWITCH_WAIT, "error");
14154
14157
  return;
@@ -14937,6 +14940,17 @@ var TuiApp = class {
14937
14940
  this.showToast(settledToast(job, !event.awaited && event.cause === "producer"));
14938
14941
  }
14939
14942
  /**
14943
+ * The background jobs still running for the bound session and every session
14944
+ * its views were entered from. A job a running call registered for itself
14945
+ * is that call's own work and is left out.
14946
+ * @returns the live jobs, bound session first.
14947
+ */
14948
+ liveChainJobs() {
14949
+ const jobs = this.deps.ctx.get("jobs");
14950
+ if (jobs === void 0) return [];
14951
+ return [this.bound, ...this.parents].flatMap((bound) => jobs.list(bound.agent.session.id)).filter((job) => isLive(job) && !this.backgrounder.isInner(job.id));
14952
+ }
14953
+ /**
14940
14954
  * Re-read the bound session's background jobs and redraw the live line
14941
14955
  * above the editor. A job a running call registered for itself is that
14942
14956
  * call's own work, not background work, and is left out while it runs.
@@ -16978,7 +16992,7 @@ var TuiApp = class {
16978
16992
  const picked = await this.showModal(new PickPrompt(this.deps.palette, "Switch to a session", items), signal);
16979
16993
  if (picked === void 0 || this.operationAbandoned(bound, signal)) return;
16980
16994
  const target = choices.find((choice) => choice.id === picked.value);
16981
- if (target === void 0 || target.current) return;
16995
+ if (target === void 0) return;
16982
16996
  await this.switchSession(() => this.deps.host.resume(target.id), "resumed");
16983
16997
  }
16984
16998
  renameSession(title) {
@@ -18543,7 +18557,7 @@ function sessionHost(ctx, core, cwd, btw) {
18543
18557
  }
18544
18558
  const { seed, inheritedEventCount } = btwSeed(events);
18545
18559
  const model = resumeModelSelection(session.requestHeader(), parent.selection.current ?? defaultModel.currentSelection());
18546
- return bind((selection, installSelection) => {
18560
+ const aside = await bind((selection, installSelection) => {
18547
18561
  selection.current = model;
18548
18562
  /* v8 ignore next -- TUI sessions record cwd on create; process cwd is the fallback when a header omitted it */
18549
18563
  const workdir = session.header.cwd ?? cwd;
@@ -18570,6 +18584,8 @@ function sessionHost(ctx, core, cwd, btw) {
18570
18584
  }
18571
18585
  });
18572
18586
  }, []);
18587
+ aside.agent.inbox.clear();
18588
+ return aside;
18573
18589
  },
18574
18590
  observe: async (id, options) => {
18575
18591
  const resident = agents.get(id);
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "zod",
3
- "version": "4.6.5",
3
+ "version": "4.6.6",
4
4
  "type": "module",
5
5
  "license": "MIT",
6
6
  "author": "Colin McDonnell <zod@colinhacks.com>",
@@ -140,6 +140,33 @@ test("continue parsing despite array size error", () => {
140
140
  `);
141
141
  });
142
142
 
143
+ test("an upper size bound fails before any element is parsed", () => {
144
+ let parsed = 0;
145
+ const el = z.string().refine(() => ++parsed);
146
+ let refined = 0;
147
+ const schema = z
148
+ .array(el)
149
+ .max(2, "too many")
150
+ .refine(() => ++refined);
151
+ expect(schema.safeParse([1, 2, 3]).error!.issues).toMatchObject([{ code: "too_big", path: [], message: "too many" }]);
152
+ expect(z.array(el).length(2).safeParse(["a", "b", "c"]).error!.issues).toMatchObject([
153
+ { code: "too_big", exact: true },
154
+ ]);
155
+ expect(z.object({ a: z.array(el).max(1) }).safeParse({ a: [1, 2] }).error!.issues).toMatchObject([
156
+ { code: "too_big", path: ["a"] },
157
+ ]);
158
+ expect([parsed, refined]).toEqual([0, 0]);
159
+
160
+ // a check that may rewrite the value ends the gate
161
+ expect(
162
+ z
163
+ .array(z.number())
164
+ .overwrite((a) => a.slice(0, 2))
165
+ .max(2)
166
+ .parse([1, 2, 3])
167
+ ).toEqual([1, 2]);
168
+ });
169
+
143
170
  test("parse should fail given sparse array", () => {
144
171
  const schema = z.array(z.string()).nonempty().min(1).max(3);
145
172
  const result = schema.safeParse(new Array(3));
@@ -97,6 +97,13 @@ test("failing when map is bigger than max() ", () => {
97
97
  expect(result.success).toEqual(false);
98
98
  expect(result.error!.issues.length).toEqual(1);
99
99
  expect(result.error!.issues[0].code).toEqual("too_big");
100
+ const bad = new Map([
101
+ [1, 1],
102
+ [2, 2],
103
+ ]);
104
+ const capped = z.map(z.string(), z.string()).max(1);
105
+ expect(capped.safeParse(bad).error!.issues).toMatchObject([{ code: "too_big" }]);
106
+ expect(capped.safeParse(new Set([1, 2])).error!.issues[0]).toMatchObject({ code: "invalid_type", expected: "map" });
100
107
  });
101
108
 
102
109
  test("failing when map does not match size() ", () => {
@@ -83,6 +83,12 @@ test("failing when set is bigger than max() ", () => {
83
83
  expect(result.success).toEqual(false);
84
84
  expect(result.error!.issues.length).toEqual(1);
85
85
  expect(result.error!.issues[0].code).toEqual("too_big");
86
+ expect(
87
+ z
88
+ .set(z.string())
89
+ .max(1)
90
+ .safeParse(new Set([1, 2])).error!.issues
91
+ ).toMatchObject([{ code: "too_big" }]);
86
92
  });
87
93
 
88
94
  test("failing when set does not match size() ", () => {
@@ -1551,6 +1551,12 @@ function generateNullableCheck(
1551
1551
  return outputVar;
1552
1552
  }
1553
1553
 
1554
+ function generateSizeGate(doc: Doc, schema: SomeType, size: string): void {
1555
+ for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
1556
+ doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
1557
+ }
1558
+ }
1559
+
1554
1560
  function generateArrayCheck(
1555
1561
  doc: Doc,
1556
1562
  ctx: CompileContext,
@@ -1560,6 +1566,7 @@ function generateArrayCheck(
1560
1566
  ): string | null {
1561
1567
  const def = schema._zod.def as unknown as { element: SomeType };
1562
1568
  doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
1569
+ generateSizeGate(doc, schema, `${accessor}.length`);
1563
1570
 
1564
1571
  // Build a new array with validated/transformed elements.
1565
1572
  const outputVar = buildsValue ? newVar(ctx) : null;
@@ -2094,6 +2101,7 @@ function generateMapCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
2094
2101
  const def = schema._zod.def as unknown as { keyType: SomeType; valueType: SomeType };
2095
2102
 
2096
2103
  doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
2104
+ generateSizeGate(doc, schema, `${accessor}.size`);
2097
2105
 
2098
2106
  const outputVar = newVar(ctx);
2099
2107
  const kVar = newVar(ctx);
@@ -2115,6 +2123,7 @@ function generateSetCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
2115
2123
  const def = schema._zod.def as unknown as { valueType: SomeType };
2116
2124
 
2117
2125
  doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
2126
+ generateSizeGate(doc, schema, `${accessor}.size`);
2118
2127
 
2119
2128
  const outputVar = newVar(ctx);
2120
2129
  const valVar = newVar(ctx);
@@ -1844,6 +1844,34 @@ export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$Zod
1844
1844
 
1845
1845
  export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
1846
1846
 
1847
+ // an oversized container fails its leading size checks before any element is parsed
1848
+ function capSize(inst: $ZodType, size: (input: any) => number): void {
1849
+ const caps = util.sizeCaps(inst._zod.def.checks);
1850
+ if (!caps.length) return;
1851
+ const cap = Math.min(...caps.map((c) => c[0]));
1852
+ const parse = inst._zod.parse;
1853
+ inst._zod.parse = (payload, ctx) => {
1854
+ const n = size(payload.value);
1855
+ if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
1856
+ for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
1857
+ if (n > max && ch._zod.def.when!(payload)) {
1858
+ const start = payload.issues.length;
1859
+ ch._zod.check(payload as ParsePayload<never>);
1860
+ // the value is still the raw input, so no later check may read it
1861
+ (payload.issues[start] as { continue?: boolean }).continue = false;
1862
+ util.attachSchema(payload.issues, start, inst);
1863
+ return payload;
1864
+ }
1865
+ }
1866
+ }
1867
+ return parse(payload, ctx);
1868
+ };
1869
+ }
1870
+
1871
+ const arraySize = (input: unknown): number => (Array.isArray(input) ? input.length : -1);
1872
+ const mapSize = (input: unknown): number => (input instanceof Map ? input.size : -1);
1873
+ const setSize = (input: unknown): number => (input instanceof Set ? input.size : -1);
1874
+
1847
1875
  function handleArrayResult(result: ParsePayload<any>, final: ParsePayload<any[]>, index: number) {
1848
1876
  if (result.issues.length) {
1849
1877
  final.issues.push(...util.prefixIssues(index, result.issues));
@@ -1899,6 +1927,7 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
1899
1927
 
1900
1928
  return payload; //handleArrayResultsAsync(parseResults, final);
1901
1929
  };
1930
+ capSize(inst, arraySize);
1902
1931
  });
1903
1932
 
1904
1933
  //////////////////////////////////////////
@@ -3218,8 +3247,11 @@ export type $InferZodRecordInput<
3218
3247
  : Record<core.input<Key> & PropertyKey, core.input<Value>>;
3219
3248
 
3220
3249
  export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType>
3221
- extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
3250
+ extends $ZodTypeInternals {
3222
3251
  def: $ZodRecordDef<Key, Value>;
3252
+ // members rather than base type arguments, which TypeScript 7.1 reports as circular for `z.json()`
3253
+ output: $InferZodRecordOutput<Key, Value>;
3254
+ input: $InferZodRecordInput<Key, Value>;
3223
3255
  isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
3224
3256
  optin?: "optional" | undefined;
3225
3257
  optout?: "optional" | undefined;
@@ -3480,6 +3512,7 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
3480
3512
  if (proms.length) return Promise.all(proms).then(() => payload);
3481
3513
  return payload;
3482
3514
  };
3515
+ capSize(inst, mapSize);
3483
3516
  });
3484
3517
 
3485
3518
  function handleMapResult(
@@ -3582,6 +3615,7 @@ export const $ZodSet: core.$constructor<$ZodSet> = /*@__PURE__*/ core.$construct
3582
3615
  if (proms.length) return Promise.all(proms).then(() => payload);
3583
3616
  return payload;
3584
3617
  };
3618
+ capSize(inst, setSize);
3585
3619
  });
3586
3620
 
3587
3621
  function handleSetResult(result: ParsePayload, final: ParsePayload<Set<any>>) {
@@ -935,6 +935,19 @@ export function unwrapMessage(message: string | { message: string } | undefined
935
935
  }
936
936
 
937
937
  /* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
938
+ /** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
939
+ export function sizeCaps(defChecks: checks.$ZodCheck<never>[] | undefined): [number, checks.$ZodCheck<never>][] {
940
+ const caps: [number, checks.$ZodCheck<never>][] = [];
941
+ for (const ch of defChecks ?? []) {
942
+ const d = ch._zod.def as any;
943
+ // a later check may rewrite the value
944
+ if (!/_(length|size)$|_equals$/.test(d.check)) break;
945
+ const max = d.maximum ?? d.length ?? d.size;
946
+ if (max >= 0) caps.push([max, ch]);
947
+ }
948
+ return caps;
949
+ }
950
+
938
951
  export function attachSchema(issues: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void {
939
952
  for (let i = start; i < issues.length; i++) {
940
953
  (issues[i] as any).schema ??= inst;
@@ -1,5 +1,5 @@
1
1
  export const version = {
2
2
  major: 4,
3
3
  minor: 6,
4
- patch: 5 as number,
4
+ patch: 6 as number,
5
5
  } as const;
@@ -1241,9 +1241,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
1241
1241
  doc.write(`}`);
1242
1242
  return outputVar;
1243
1243
  }
1244
+ function generateSizeGate(doc, schema, size) {
1245
+ for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
1246
+ doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
1247
+ }
1248
+ }
1244
1249
  function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
1245
1250
  const def = schema._zod.def;
1246
1251
  doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
1252
+ generateSizeGate(doc, schema, `${accessor}.length`);
1247
1253
  // Build a new array with validated/transformed elements.
1248
1254
  const outputVar = buildsValue ? newVar(ctx) : null;
1249
1255
  const iVar = newVar(ctx);
@@ -1707,6 +1713,7 @@ function literalPropertyKey(ctx, key) {
1707
1713
  function generateMapCheck(doc, ctx, schema, accessor) {
1708
1714
  const def = schema._zod.def;
1709
1715
  doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
1716
+ generateSizeGate(doc, schema, `${accessor}.size`);
1710
1717
  const outputVar = newVar(ctx);
1711
1718
  const kVar = newVar(ctx);
1712
1719
  const valVar = newVar(ctx);
@@ -1723,6 +1730,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
1723
1730
  function generateSetCheck(doc, ctx, schema, accessor) {
1724
1731
  const def = schema._zod.def;
1725
1732
  doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
1733
+ generateSizeGate(doc, schema, `${accessor}.size`);
1726
1734
  const outputVar = newVar(ctx);
1727
1735
  const valVar = newVar(ctx);
1728
1736
  doc.write(`const ${outputVar} = new Set();`);
@@ -1210,9 +1210,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
1210
1210
  doc.write(`}`);
1211
1211
  return outputVar;
1212
1212
  }
1213
+ function generateSizeGate(doc, schema, size) {
1214
+ for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
1215
+ doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
1216
+ }
1217
+ }
1213
1218
  function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
1214
1219
  const def = schema._zod.def;
1215
1220
  doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
1221
+ generateSizeGate(doc, schema, `${accessor}.length`);
1216
1222
  // Build a new array with validated/transformed elements.
1217
1223
  const outputVar = buildsValue ? newVar(ctx) : null;
1218
1224
  const iVar = newVar(ctx);
@@ -1676,6 +1682,7 @@ function literalPropertyKey(ctx, key) {
1676
1682
  function generateMapCheck(doc, ctx, schema, accessor) {
1677
1683
  const def = schema._zod.def;
1678
1684
  doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
1685
+ generateSizeGate(doc, schema, `${accessor}.size`);
1679
1686
  const outputVar = newVar(ctx);
1680
1687
  const kVar = newVar(ctx);
1681
1688
  const valVar = newVar(ctx);
@@ -1692,6 +1699,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
1692
1699
  function generateSetCheck(doc, ctx, schema, accessor) {
1693
1700
  const def = schema._zod.def;
1694
1701
  doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
1702
+ generateSizeGate(doc, schema, `${accessor}.size`);
1695
1703
  const outputVar = newVar(ctx);
1696
1704
  const valVar = newVar(ctx);
1697
1705
  doc.write(`const ${outputVar} = new Set();`);
@@ -860,6 +860,33 @@ exports.$ZodDate = core.$constructor("$ZodDate", (inst, def) => {
860
860
  return payload;
861
861
  };
862
862
  });
863
+ // an oversized container fails its leading size checks before any element is parsed
864
+ function capSize(inst, size) {
865
+ const caps = util.sizeCaps(inst._zod.def.checks);
866
+ if (!caps.length)
867
+ return;
868
+ const cap = Math.min(...caps.map((c) => c[0]));
869
+ const parse = inst._zod.parse;
870
+ inst._zod.parse = (payload, ctx) => {
871
+ const n = size(payload.value);
872
+ if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
873
+ for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
874
+ if (n > max && ch._zod.def.when(payload)) {
875
+ const start = payload.issues.length;
876
+ ch._zod.check(payload);
877
+ // the value is still the raw input, so no later check may read it
878
+ payload.issues[start].continue = false;
879
+ util.attachSchema(payload.issues, start, inst);
880
+ return payload;
881
+ }
882
+ }
883
+ }
884
+ return parse(payload, ctx);
885
+ };
886
+ }
887
+ const arraySize = (input) => (Array.isArray(input) ? input.length : -1);
888
+ const mapSize = (input) => (input instanceof Map ? input.size : -1);
889
+ const setSize = (input) => (input instanceof Set ? input.size : -1);
863
890
  function handleArrayResult(result, final, index) {
864
891
  if (result.issues.length) {
865
892
  final.issues.push(...util.prefixIssues(index, result.issues));
@@ -905,6 +932,7 @@ exports.$ZodArray = core.$constructor("$ZodArray", (inst, def) => {
905
932
  }
906
933
  return payload; //handleArrayResultsAsync(parseResults, final);
907
934
  };
935
+ capSize(inst, arraySize);
908
936
  });
909
937
  function handlePropertyResult(result, final, key, input, optin, optout) {
910
938
  const isPresent = key in input;
@@ -1942,6 +1970,7 @@ exports.$ZodMap = core.$constructor("$ZodMap", (inst, def) => {
1942
1970
  return Promise.all(proms).then(() => payload);
1943
1971
  return payload;
1944
1972
  };
1973
+ capSize(inst, mapSize);
1945
1974
  });
1946
1975
  function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
1947
1976
  if (keyResult.issues.length) {
@@ -2011,6 +2040,7 @@ exports.$ZodSet = core.$constructor("$ZodSet", (inst, def) => {
2011
2040
  return Promise.all(proms).then(() => payload);
2012
2041
  return payload;
2013
2042
  };
2043
+ capSize(inst, setSize);
2014
2044
  });
2015
2045
  function handleSetResult(result, final) {
2016
2046
  if (result.issues.length) {
@@ -816,6 +816,33 @@ export const $ZodDate = /*@__PURE__*/ core.$constructor("$ZodDate", (inst, def)
816
816
  return payload;
817
817
  };
818
818
  });
819
+ // an oversized container fails its leading size checks before any element is parsed
820
+ function capSize(inst, size) {
821
+ const caps = util.sizeCaps(inst._zod.def.checks);
822
+ if (!caps.length)
823
+ return;
824
+ const cap = Math.min(...caps.map((c) => c[0]));
825
+ const parse = inst._zod.parse;
826
+ inst._zod.parse = (payload, ctx) => {
827
+ const n = size(payload.value);
828
+ if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
829
+ for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
830
+ if (n > max && ch._zod.def.when(payload)) {
831
+ const start = payload.issues.length;
832
+ ch._zod.check(payload);
833
+ // the value is still the raw input, so no later check may read it
834
+ payload.issues[start].continue = false;
835
+ util.attachSchema(payload.issues, start, inst);
836
+ return payload;
837
+ }
838
+ }
839
+ }
840
+ return parse(payload, ctx);
841
+ };
842
+ }
843
+ const arraySize = (input) => (Array.isArray(input) ? input.length : -1);
844
+ const mapSize = (input) => (input instanceof Map ? input.size : -1);
845
+ const setSize = (input) => (input instanceof Set ? input.size : -1);
819
846
  function handleArrayResult(result, final, index) {
820
847
  if (result.issues.length) {
821
848
  final.issues.push(...util.prefixIssues(index, result.issues));
@@ -861,6 +888,7 @@ export const $ZodArray = /*@__PURE__*/ core.$constructor("$ZodArray", (inst, def
861
888
  }
862
889
  return payload; //handleArrayResultsAsync(parseResults, final);
863
890
  };
891
+ capSize(inst, arraySize);
864
892
  });
865
893
  function handlePropertyResult(result, final, key, input, optin, optout) {
866
894
  const isPresent = key in input;
@@ -1898,6 +1926,7 @@ export const $ZodMap = /*@__PURE__*/ core.$constructor("$ZodMap", (inst, def) =>
1898
1926
  return Promise.all(proms).then(() => payload);
1899
1927
  return payload;
1900
1928
  };
1929
+ capSize(inst, mapSize);
1901
1930
  });
1902
1931
  function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
1903
1932
  if (keyResult.issues.length) {
@@ -1967,6 +1996,7 @@ export const $ZodSet = /*@__PURE__*/ core.$constructor("$ZodSet", (inst, def) =>
1967
1996
  return Promise.all(proms).then(() => payload);
1968
1997
  return payload;
1969
1998
  };
1999
+ capSize(inst, setSize);
1970
2000
  });
1971
2001
  function handleSetResult(result, final) {
1972
2002
  if (result.issues.length) {
@@ -46,6 +46,7 @@ exports.aborted = aborted;
46
46
  exports.explicitlyAborted = explicitlyAborted;
47
47
  exports.prefixIssues = prefixIssues;
48
48
  exports.unwrapMessage = unwrapMessage;
49
+ exports.sizeCaps = sizeCaps;
49
50
  exports.attachSchema = attachSchema;
50
51
  exports.finalizeIssue = finalizeIssue;
51
52
  exports.getSizableOrigin = getSizableOrigin;
@@ -620,6 +621,20 @@ function unwrapMessage(message) {
620
621
  return typeof message === "string" ? message : message?.message;
621
622
  }
622
623
  /* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
624
+ /** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
625
+ function sizeCaps(defChecks) {
626
+ const caps = [];
627
+ for (const ch of defChecks ?? []) {
628
+ const d = ch._zod.def;
629
+ // a later check may rewrite the value
630
+ if (!/_(length|size)$|_equals$/.test(d.check))
631
+ break;
632
+ const max = d.maximum ?? d.length ?? d.size;
633
+ if (max >= 0)
634
+ caps.push([max, ch]);
635
+ }
636
+ return caps;
637
+ }
623
638
  function attachSchema(issues, start, inst) {
624
639
  var _a;
625
640
  for (let i = start; i < issues.length; i++) {
@@ -550,6 +550,20 @@ export function unwrapMessage(message) {
550
550
  return typeof message === "string" ? message : message?.message;
551
551
  }
552
552
  /* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
553
+ /** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
554
+ export function sizeCaps(defChecks) {
555
+ const caps = [];
556
+ for (const ch of defChecks ?? []) {
557
+ const d = ch._zod.def;
558
+ // a later check may rewrite the value
559
+ if (!/_(length|size)$|_equals$/.test(d.check))
560
+ break;
561
+ const max = d.maximum ?? d.length ?? d.size;
562
+ if (max >= 0)
563
+ caps.push([max, ch]);
564
+ }
565
+ return caps;
566
+ }
553
567
  export function attachSchema(issues, start, inst) {
554
568
  var _a;
555
569
  for (let i = start; i < issues.length; i++) {
@@ -4,7 +4,7 @@ exports.version = void 0;
4
4
  exports.version = {
5
5
  major: 4,
6
6
  minor: 6,
7
- patch: 5,
7
+ patch: 6,
8
8
  };
9
9
 
10
10
  // seal-cjs-exports
@@ -1,5 +1,5 @@
1
1
  export const version = {
2
2
  major: 4,
3
3
  minor: 6,
4
- patch: 5,
4
+ patch: 6,
5
5
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@songtonyli/dsh-cli",
3
- "version": "0.1.72",
3
+ "version": "0.1.74",
4
4
  "description": "The dsh terminal agent: an interactive TUI over the DeepSeek Harness, with its whole Node runtime bundled in one install.",
5
5
  "license": "MIT",
6
6
  "type": "module",
@@ -602,7 +602,7 @@
602
602
  "xmlchars": "2.2.0",
603
603
  "yaml": "2.9.1",
604
604
  "yoctocolors": "2.2.0",
605
- "zod": "4.6.5",
605
+ "zod": "4.6.6",
606
606
  "zwitch": "2.0.4"
607
607
  },
608
608
  "optionalDependencies": {