dsh-codex-subscription 2.3.0 → 2.4.1

package/README.en.md

@@ -16,21 +16,12 @@ No OpenAI API key or Codex CLI. Models, search, quota, and image generation stay
 [![MIT](https://img.shields.io/badge/license-MIT-111111.svg)](LICENSE)
 [![Star](https://img.shields.io/github/stars/WSL043/dsh-codex-subscription?style=flat&logo=github&label=Star)](https://github.com/WSL043/dsh-codex-subscription/stargazers)
 
-[What's new](#whats-new-in-230) · [Features](#feature-overview) · [Install](#install) · [Daily use](#inside-the-plugin) · [Examples](#from-sketch-to-image) · [User guide](docs/GUIDE.en.md) · [Update and uninstall](#update-and-uninstall)
+[Features](#feature-overview) · [Install](#install) · [Daily use](#inside-the-plugin) · [Examples](#from-sketch-to-image) · [User guide](docs/GUIDE.en.md) · [Update and uninstall](#update-and-uninstall)
 
 </div>
 
 <p align="center"><img src="docs/assets/product-account-demo-en.png" width="1100" alt="Codex subscription account and quota interface with model choices, quota windows and alerts; demonstration data"></p>
 
-## What's new in 2.3.0
-
-- **The official desktop app works.** The official DeepSeek Harness desktop app (0.2.0-rc.2) passed a hands-on acceptance run: plugin install, sign-in, model list, hiding models, a chat with a tool call, and image generation. See [Install](#install).
-- **Models come only from your account.** The model list is read entirely from the account catalog; before sign-in or when the read fails no model is shown, and there is no built-in fallback. Under Models & runtime you can show or hide each model in the composer.
-- **Settings reorganised.** Models and search are separate cards, switches use DSH's own control, and dead buttons no longer appear while signed out.
-- **Ultrafast speed tier (Beta).** The new tier from OpenAI's developer event. It appears in the model menu only when your account catalog lists it for that model (today Pro 500 with GPT-6 Astra); other accounts never see it and it is never silently swapped for another tier. It is Beta because it has not been run on a Pro 500 account yet.
-- **Shorter support diagnostics.** "Copy report" now copies the conclusions, recent failures and per-feature status (about 1 KB); the full report can still be copied separately from the details.
-- **Subtasks and stability.** Codex subtasks now really take effect on 0.2.0 and no longer expose the apps connected to your account; image generation being rejected by the host on the desktop app is fixed (2.2.11).
-
 ## Feature overview
 
 Subscription access, model controls, quota management, and image creation in one DSH workflow. Each capability is listed below; model access and quota depend on your account.
@@ -79,7 +70,7 @@ Subscription access, model controls, quota management, and image creation in one
 | **Smoothing and navigation** | Smooth complete strokes after release; pan, zoom, undo, and redo | Shortcuts can be customized or disabled |
 | **Multiple drafts** | Save and reopen up to 20 local drafts | Stored in the current browser |
 | **Import and export** | Export PNG, layered PSD, or native drafts that preserve editable strokes | PSD import supports a limited set of ordinary pixel layers |
-| **Agent drawing** | Ask the agent to draw with `@sketch`, follow progress, and stop it | Beta; off by default, requires the canvas |
+| **Agent drawing** | Ask the agent to draw with `@sketch`, follow progress, and stop it; the agent can draw whole stages in SVG, imported as editable native strokes | Beta; off by default, requires the canvas |
 | **Result preview for the model** | Return a canvas image after drawing for subsequent review | Beta; off by default, adds image input usage |
 
 ### Advanced capabilities and maintenance
@@ -113,7 +104,7 @@ This plugin supports the latest DeepSeek Harness release recorded in its package
 2. Paste this package name, with its version, into the **Package name or address** field:
 
    ```text
-   dsh-codex-subscription@2.3.0
+   dsh-codex-subscription@2.4.1
    ```
 
 3. Click **Install** and wait for completion. Follow the page instructions; save your work before restarting if requested.
@@ -183,59 +174,54 @@ Image generation, editing, and the sketch canvas are **Beta**. The canvas and ag
 Draw by hand with the canvas button, or ask the agent with `@sketch` and your drawing request.
 
 <table>
-<tr><th width="50%">Original sketch</th><th width="50%">Actual plugin output</th></tr>
-<tr><td><img src="docs/assets/sketch-demo-source.png" alt="Mountains and cabin sketch" width="480"></td><td><img src="docs/assets/sketch-demo-result.png" alt="Watercolor mountain cabin generated from the sketch" width="480"></td></tr>
+<tr><th width="50%">Native sketch drawn by the agent</th><th width="50%">Image generated with the sketch as the only reference</th></tr>
+<tr><td><img src="docs/assets/sketch-lighthouse-sketch.webp" alt="Lighthouse sketch drawn by GPT-6.1-Sol" width="480"></td><td><img src="docs/assets/sketch-lighthouse-result.webp" alt="Watercolor lighthouse poster generated from the sketch" width="480"></td></tr>
 </table>
 
-The request keeps the mountain and cabin composition, turning it into a warm watercolor illustration with green peaks, an orange roof, a meadow stream, and soft morning light, without the blue outlines.
+**GPT-6.1-Sol · Xhigh** on the official desktop app 0.2.0-rc.2: one `@sketch` message produced 6 layers and 229 editable native strokes, then called GPT Image 2 (quality: high) once with the sketch as the only reference. About 13 minutes end to end.
+
+The prompt (sent in Chinese): draw "Lighthouse and Homecoming" on a 4:3 canvas — a red-and-white lighthouse on a rocky cape casting a fan of light, an orange-sailed fishing boat heading home with a V-shaped wake, a half-risen sun, three cloud bands, three gulls and surf around the rocks, in six named layers; then turn the sketch into a warm watercolor travel poster with no text, keeping the composition.
 
 <details>
-<summary>Advanced examples · Layered illustration and Mona Lisa</summary>
+<summary>Advanced examples · Mechanical cutaway, blue-green landscape and a reference-copy challenge</summary>
 
-**Someone Behind the Canvas**
+The first two subjects were chosen to expose quality differences: a mechanical cutaway tests structure and detail (meshing gears, pendulum, chains, tiny figures on a staircase), and a Song-dynasty blue-green landscape tests composition and taste (the "three distances", empty space, texture strokes and mineral color). The same prompt went to **GPT-6.1-Sol · Xhigh** and **GPT-6-Astra · Low**, one run each, on the official desktop app, with GPT Image 2 (quality: high).
 
-**Astra draws the sketch; GPT Image 2 generates the illustration.** The editable original has 427 strokes across six layers. The image request retains its composition and adds paper-art and hand-painted detail. The requested model is `gpt-image-2`; the server does not report the executing model.
+**Clock Tower Cutaway**
 
 <table>
-<tr><th width="50%">Native sketch</th><th width="50%">Generated result</th></tr>
-<tr><td><img src="docs/assets/sketch-advanced-source.png" alt="Sketch" width="480"></td><td><img src="docs/assets/sketch-advanced-result.png" alt="Result" width="480"></td></tr>
+<tr><th></th><th width="45%">Native sketch</th><th width="45%">Generated image</th></tr>
+<tr><td><b>Sol<br>Xhigh</b></td><td><img src="docs/assets/sketch-clocktower-sol-sketch.webp" alt="Clock tower sketch by Sol" width="400"></td><td><img src="docs/assets/sketch-clocktower-sol-result.webp" alt="Clock tower illustration from Sol's sketch" width="400"></td></tr>
+<tr><td><b>Astra<br>Low</b></td><td><img src="docs/assets/sketch-clocktower-astra-sketch.webp" alt="Clock tower sketch by Astra" width="400"></td><td><img src="docs/assets/sketch-clocktower-astra-result.webp" alt="Clock tower illustration from Astra's sketch" width="400"></td></tr>
 </table>
 
-<details>
-<summary>Show the reproduction prompt and original image request</summary>
-
-**Sketch reproduction prompt (reconstructed from the artwork, not the original conversation)**
-
-Astra drew the original in stages. This Chinese prompt provides a starting point for the same concept, not a guarantee of an identical result.
-
-```text
-@sketch 用 4:3 横版画板绘制《画布背面有人》：中央偏上是一处撕开的纸洞，洞内是深蓝星空和一位拿颜料桶的小画师；蓝色颜料从桶中流出，形成 S 形河流，流向下方城市。左侧城市保持未上色线稿，右侧城市被暖色点亮，加入纸船与飞鸟。按纸面、洞内世界、颜料河流、城市、画师和细节分层绘制，保留原生可编辑笔画。
-```
+Sol first computed tooth counts (48, 38, 27, 46, 36, 24, 34, 30, 22) and pitch circles for the nine gears with a script, then placed them in mesh; drawing took about an hour. Its first image request failed; it asked, was allowed one retry, and succeeded. Astra Low finished sketch and image in about 5 minutes, with a simpler structure and gears that are not individually calibrated.
 
-**Actual image-generation prompt (original Chinese)**
+**A Thousand Green Peaks**
 
-```text
-请基于本条附加草图实际调用订阅图片工具一次，生成成品插画。quality=low，模型使用当前默认，不切换型号，不额外生成。主题《画布背面有人》：保留4:3横构图、中央偏上的撕纸洞口、洞内拿颜料桶的小画师、流出成为S形河流的蓝色颜料、下方左侧未上色城市与右侧被点亮城市、纸船飞鸟。精修为惊艳的立体纸艺与精细手绘结合的编辑插画，纸张纤维、真实撕边及柔和投影，深靛蓝洞内星月，丰富青蓝颜料层次和流动质感，赭橙画师与暖色建筑，微小清晰的叙事细节。不重构为风景，不添加文字水印。必须使用本条参考图片编辑，不能仅凭文字生成。生成后简短说明完成即可。
-```
-
-</details>
-
-Original example released in: [Beta v2.1.0-beta.2](https://github.com/WSL043/dsh-codex-subscription/releases/tag/v2.1.0-beta.2)
+<table>
+<tr><th></th><th width="45%">Native sketch</th><th width="45%">Generated image</th></tr>
+<tr><td><b>Sol<br>Xhigh</b></td><td><img src="docs/assets/sketch-shanshui-sol-sketch.webp" alt="Landscape sketch by Sol" width="400"></td><td><img src="docs/assets/sketch-shanshui-sol-result.webp" alt="Blue-green landscape from Sol's sketch" width="400"></td></tr>
+<tr><td><b>Astra<br>Low</b></td><td><img src="docs/assets/sketch-shanshui-astra-sketch.webp" alt="Landscape sketch by Astra" width="400"></td><td><img src="docs/assets/sketch-shanshui-astra-result.webp" alt="Blue-green landscape from Astra's sketch" width="400"></td></tr>
+</table>
 
-**Mona Lisa: Astra sketch → GPT image generation**
+Sol Xhigh took about 28 minutes and Astra Low about 5. Both kept the main peak, waterfall, plank path and river in place; Sol's receding ranges and mist bands are more complete.
 
-Example version: [2.1.0-beta.5](https://github.com/WSL043/dsh-codex-subscription/releases/tag/v2.1.0-beta.5)
+**"DeepSeek-chan" · copy a reference image (draw only, no image generation)**
 
-Actual results supplied by the user from another computer: Astra draws on a portrait canvas, then GPT image generation turns the sketch into an oil painting.
+Here the reference image is attached to the message and the model copies it on the canvas, which tests proportions, gradient long hair, lace trim, hand lettering and small motifs. The reference is a community sticker of the DeepSeek mascot girl. Each cell is one run on the official desktop app with no image generation; the native-stroke runs had "return preview when finished" enabled, and the SVG runs added one sentence to the same prompt asking for the svg command on every layer.
 
 <table>
-<tr><th width="50%">Native Astra sketch</th><th width="50%">GPT-generated oil painting</th></tr>
-<tr><td><img src="docs/assets/sketch-mona-lisa-source.png" alt="Mona Lisa sketch drawn by Astra" width="480"></td><td><img src="docs/assets/sketch-mona-lisa-result.png" alt="Mona Lisa oil painting generated from the sketch" width="480"></td></tr>
+<tr><th width="20%">Reference</th><th width="40%">Native strokes</th><th width="40%">SVG</th></tr>
+<tr><td rowspan="2"><img src="docs/assets/sketch-niang-reference.webp" alt="DeepSeek-chan sticker reference" width="220"></td><td><img src="docs/assets/sketch-niang-sol-native.webp" alt="Sol native strokes" width="330"><br><sub><b>Sol Xhigh</b> · 40 min 50 s · 526 strokes</sub></td><td><img src="docs/assets/sketch-niang-sol-svg.webp" alt="Sol SVG" width="330"><br><sub><b>Sol Xhigh</b> · 31 min 48 s · 463 strokes</sub></td></tr>
+<tr><td><img src="docs/assets/sketch-niang-astra-native.webp" alt="Astra native strokes" width="330"><br><sub><b>Astra Medium</b> · about 7 min · 332 strokes</sub></td><td><img src="docs/assets/sketch-niang-astra-svg.webp" alt="Astra SVG" width="330"><br><sub><b>Astra Medium</b> · 10 min 5 s</sub></td></tr>
 </table>
 
-Original sketch prompt: `@sketch 用竖版画板画一幅《蒙娜丽莎》` (Draw the Mona Lisa on a portrait canvas.)
+The SVG runs have finer hair highlights, lace trim and lettering, and Sol was almost 9 minutes faster with SVG than stroke by stroke; Astra spent about 3 extra minutes on SVG for clearly richer detail. Neither model got the face shape right (too long and flat) or the small whale motif on the apron, though Sol's whale looks more like a whale.
+
+The full Chinese prompts for all three subjects are in the [Chinese README](README.md#从草图到作品).
 
-Original image prompt: `帮我变成油画` (Turn it into an oil painting.)
+Each example is a single run, not a measure of consistent quality. Sol Xhigh is much slower; Astra or a lower reasoning level is enough for everyday sketches.
 
 </details>
 

package/README.md

@@ -16,21 +16,12 @@
 [![MIT](https://img.shields.io/badge/license-MIT-111111.svg)](LICENSE)
 [![Star](https://img.shields.io/github/stars/WSL043/dsh-codex-subscription?style=flat&logo=github&label=Star)](https://github.com/WSL043/dsh-codex-subscription/stargazers)
 
-[更新亮点](#230-更新亮点) · [功能](#功能一览) · [安装](#安装) · [日常使用](#界面一览) · [作品案例](#从草图到作品) · [使用指南](docs/GUIDE.zh-CN.md) · [更新与卸载](#更新与卸载)
+[功能](#功能一览) · [安装](#安装) · [日常使用](#界面一览) · [作品案例](#从草图到作品) · [使用指南](docs/GUIDE.zh-CN.md) · [更新与卸载](#更新与卸载)
 
 </div>
 
 <p align="center"><img src="docs/assets/product-account-demo.png" width="1100" alt="Codex 订阅账号与额度界面：模型选择、双周期额度与提醒；使用演示数据"></p>
 
-## 2.3.0 更新亮点
-
-- **官方桌面端可用**：DeepSeek Harness 官方桌面版（0.2.0-rc.2）已完成实机验收——安装插件、登录、模型列表、隐藏模型、带工具调用的对话、图片生成均通过；安装方式见[安装](#安装)。
-- **模型只来自你的账号**：模型列表完全读取账号目录，登录前或读取失败时不显示任何模型，也没有内置兜底；“模型与运行”里可逐个显示 / 隐藏输入框中的模型。
-- **设置页重新整理**：模型与搜索分成两个卡片，开关统一使用 DSH 自带控件，未登录时不再出现无效按钮。
-- **极速档 Ultrafast（Beta）**：OpenAI 发布会新增的速度档。只有账号模型目录明确给出该档位（目前为 Pro 500 的 GPT-6 Astra）才会在模型菜单里出现，其他账号不显示，也不会被悄悄降级到别的档位；由于暂无 Pro 500 账号做实机验证，标为 Beta。
-- **更短的支持诊断**：“复制诊断”现在只复制结论、近期失败和各能力状态（约 1 KB），完整报告仍可在详情里单独复制。
-- **子任务与稳定性**：Codex 子任务在 0.2.0 上真正生效，并且不再暴露账号里连接的应用；修复了图片生成在桌面版上被宿主拒绝的问题（2.2.11）。
-
 ## 功能一览
 
 把订阅接入、模型控制、额度管理和图片创作放在同一个 DSH 工作流里。下面逐项列出插件提供的能力；模型权限和额度以账号实际返回为准。
@@ -79,7 +70,7 @@
 | **笔画平滑与导航** | 抬笔后平滑整条路径；拖动、缩放、撤销重做 | 快捷键可自定义和关闭 |
 | **多份草稿** | 保存并重新编辑最多 20 份本地草稿 | 保存在当前浏览器 |
 | **导入与导出** | 导出 PNG、分层 PSD，或交换保留原生笔画的草稿文件 | PSD 导入仅支持有限的普通像素图层 |
-| **Agent 绘图** | 用 `@sketch` 让 Agent 绘制，查看进度并随时停止 | Beta；默认关闭，需同时开启画板 |
+| **Agent 绘图** | 用 `@sketch` 让 Agent 绘制，查看进度并随时停止；Agent 可用 SVG 整段作画，导入为可编辑原生笔画 | Beta；默认关闭，需同时开启画板 |
 | **绘图结果回看** | 完成后向模型返回画布预览，帮助后续检查 | Beta；默认关闭，会增加图片输入用量 |
 
 ### 进阶能力与维护
@@ -113,7 +104,7 @@
 2. 在 **包名或地址** 输入框中粘贴下面的包名（已带版本号）：
 
    ```text
-   dsh-codex-subscription@2.3.0
+   dsh-codex-subscription@2.4.1
    ```
 
 3. 点击 **安装**，等待安装完成；按页面提示操作，需要重启时先保存工作。
@@ -183,59 +174,77 @@ dsh --profile headless "只回复：ok"
 手动画图时点击画板按钮；让 Agent 绘图时发送 `@sketch` 加绘图要求。
 
 <table>
-<tr><th width="50%">画板原草图</th><th width="50%">插件实际生成结果</th></tr>
-<tr><td><img src="docs/assets/sketch-demo-source.png" alt="山峰与小屋草图" width="480"></td><td><img src="docs/assets/sketch-demo-result.png" alt="根据草图生成的水彩山间小屋" width="480"></td></tr>
+<tr><th width="50%">Agent 绘制的原生草图</th><th width="50%">以草图为唯一参考的生图结果</th></tr>
+<tr><td><img src="docs/assets/sketch-lighthouse-sketch.webp" alt="GPT-6.1-Sol 绘制的灯塔与归航草图" width="480"></td><td><img src="docs/assets/sketch-lighthouse-result.webp" alt="根据草图生成的灯塔水彩海报" width="480"></td></tr>
 </table>
 
-示例要求：保留山峰与小屋的构图，生成温暖的水彩旅行插画，青绿山峰、橙色屋顶、草地小溪与柔和晨光，不保留蓝色线条。
+**GPT-6.1-Sol · Xhigh**，官方桌面版 0.2.0-rc.2 实测：一条 `@sketch` 消息完成 6 个图层、229 笔可编辑原生笔画，再以这张草图为唯一参考调用一次 GPT Image 2（质量：高），全程约 13 分钟。
+
+```text
+@sketch 用 4:3 横版画板绘制《灯塔与归航》：左侧礁石岬角上立一座红白条纹灯塔，塔顶灯室射出扇形光束；右侧海面上一艘挂橙色小帆的渔船正驶回港湾，船后拖出 V 形水痕；地平线上是半个初升的太阳，天空有三条横向云带和三只海鸥，前景礁石间有一圈白色浪花。按天空、太阳与云、海面、礁石与灯塔、渔船、海鸥与浪花分层绘制，保留原生可编辑笔画。画完后，把这张草图作为唯一参考图，调用订阅图片工具一次生成成品：保持构图不变，做成温暖的水彩旅行海报，晨光金橙配靛青海面，有纸纹和柔和晕染，不添加文字。
+```
 
 <details>
-<summary>进阶展示 · 分层插画与蒙娜丽莎</summary>
+<summary>进阶展示 · 机械剖面、青绿山水与 DeepSeek 娘临摹</summary>
 
-**《画布背面有人》**
+前两道题都选了容易暴露差距的题材：机械剖面考结构与细节（齿轮咬合、摆锤、链条、楼梯上的人物），青绿山水考构图与审美（三远法、留白、皴法与设色）。同一条提示词分别交给 **GPT-6.1-Sol · Xhigh** 和 **GPT-6-Astra · Low**，各跑一次，均在官方桌面版上完成，生图统一为 GPT Image 2（质量：高）。
 
-**Astra 绘制草图，GPT Image 2 生成成图。** 原生草图共 6 层、427 笔，可继续编辑；生图请求保留构图，精修纸艺与手绘质感。请求型号为 `gpt-image-2`，服务端未报告实际执行型号。
+**《钟塔剖面图》**
 
 <table>
-<tr><th width="50%">原生草图</th><th width="50%">实际生成结果</th></tr>
-<tr><td><img src="docs/assets/sketch-advanced-source.png" alt="Sketch" width="480"></td><td><img src="docs/assets/sketch-advanced-result.png" alt="Result" width="480"></td></tr>
+<tr><th></th><th width="45%">原生草图</th><th width="45%">生图结果</th></tr>
+<tr><td><b>Sol<br>Xhigh</b></td><td><img src="docs/assets/sketch-clocktower-sol-sketch.webp" alt="Sol 绘制的钟塔剖面草图" width="400"></td><td><img src="docs/assets/sketch-clocktower-sol-result.webp" alt="Sol 草图生成的钟塔剖面插画" width="400"></td></tr>
+<tr><td><b>Astra<br>Low</b></td><td><img src="docs/assets/sketch-clocktower-astra-sketch.webp" alt="Astra 绘制的钟塔剖面草图" width="400"></td><td><img src="docs/assets/sketch-clocktower-astra-result.webp" alt="Astra 草图生成的钟塔剖面插画" width="400"></td></tr>
 </table>
 
-<details>
-<summary>展开复现提示词与原始生图请求</summary>
+Sol 先用脚本算出 9 个齿轮的齿数（48、38、27、46、36、24、34、30、22）与节圆，再按咬合位置排布，绘图约 1 小时；第一次生图请求失败，按它的询问同意重试一次后成功。Astra Low 约 5 分钟完成全部草图与生图，结构更简化，齿轮没有逐一校准。
 
-**草图复现提示词（按原画面整理，非完整原始对话）**
+**《千峰翠色》**
 
-原案例由 Astra 分阶段绘制，下面提供同主题的复现起点，不保证得到完全相同的画面。
+<table>
+<tr><th></th><th width="45%">原生草图</th><th width="45%">生图结果</th></tr>
+<tr><td><b>Sol<br>Xhigh</b></td><td><img src="docs/assets/sketch-shanshui-sol-sketch.webp" alt="Sol 绘制的青绿山水草图" width="400"></td><td><img src="docs/assets/sketch-shanshui-sol-result.webp" alt="Sol 草图生成的青绿山水" width="400"></td></tr>
+<tr><td><b>Astra<br>Low</b></td><td><img src="docs/assets/sketch-shanshui-astra-sketch.webp" alt="Astra 绘制的青绿山水草图" width="400"></td><td><img src="docs/assets/sketch-shanshui-astra-result.webp" alt="Astra 草图生成的青绿山水" width="400"></td></tr>
+</table>
 
-```text
-@sketch 用 4:3 横版画板绘制《画布背面有人》：中央偏上是一处撕开的纸洞，洞内是深蓝星空和一位拿颜料桶的小画师；蓝色颜料从桶中流出，形成 S 形河流，流向下方城市。左侧城市保持未上色线稿，右侧城市被暖色点亮，加入纸船与飞鸟。按纸面、洞内世界、颜料河流、城市、画师和细节分层绘制，保留原生可编辑笔画。
-```
+Sol Xhigh 约 28 分钟，Astra Low 约 5 分钟。两者都保留了主峰、瀑布、栈道与江面的位置；Sol 的远山层次和雾带留白更完整。
 
-**实际生图提示词**
+**《DeepSeek 娘》· 照着参考图临摹（只画不生图）**
 
-```text
-请基于本条附加草图实际调用订阅图片工具一次，生成成品插画。quality=low，模型使用当前默认，不切换型号，不额外生成。主题《画布背面有人》：保留4:3横构图、中央偏上的撕纸洞口、洞内拿颜料桶的小画师、流出成为S形河流的蓝色颜料、下方左侧未上色城市与右侧被点亮城市、纸船飞鸟。精修为惊艳的立体纸艺与精细手绘结合的编辑插画，纸张纤维、真实撕边及柔和投影，深靛蓝洞内星月，丰富青蓝颜料层次和流动质感，赭橙画师与暖色建筑，微小清晰的叙事细节。不重构为风景，不添加文字水印。必须使用本条参考图片编辑，不能仅凭文字生成。生成后简短说明完成即可。
-```
+这道题把一张参考图作为附件发给模型，让它在画板上临摹，考的是比例、渐变长发、蕾丝褶边、手写字和小图案能不能对得上。参考图是社区流传的 DeepSeek 娘表情包。每格都在官方桌面版上跑一次，没有调用生图；原生笔画版开启了“完成后返回预览”，SVG 版在同一条提示词后加了一句“每层用 svg 命令”。
 
-</details>
+<table>
+<tr><th width="20%">参考图</th><th width="40%">原生笔画</th><th width="40%">SVG</th></tr>
+<tr><td rowspan="2"><img src="docs/assets/sketch-niang-reference.webp" alt="DeepSeek 娘表情包参考图" width="220"></td><td><img src="docs/assets/sketch-niang-sol-native.webp" alt="Sol 原生笔画版" width="330"><br><sub><b>Sol Xhigh</b> · 40 分 50 秒 · 526 笔</sub></td><td><img src="docs/assets/sketch-niang-sol-svg.webp" alt="Sol SVG 版" width="330"><br><sub><b>Sol Xhigh</b> · 31 分 48 秒 · 463 笔</sub></td></tr>
+<tr><td><img src="docs/assets/sketch-niang-astra-native.webp" alt="Astra 原生笔画版" width="330"><br><sub><b>Astra Medium</b> · 约 7 分钟 · 332 笔</sub></td><td><img src="docs/assets/sketch-niang-astra-svg.webp" alt="Astra SVG 版" width="330"><br><sub><b>Astra Medium</b> · 10 分 5 秒</sub></td></tr>
+</table>
 
-原案例首发：[Beta v2.1.0-beta.2](https://github.com/WSL043/dsh-codex-subscription/releases/tag/v2.1.0-beta.2)
+SVG 版的发丝高光、蕾丝褶边和手写字更精细，Sol 用 SVG 还比逐笔绘制快了近 9 分钟；Astra 用 SVG 多花约 3 分钟，换来明显更丰富的细节。两个模型都没能画准脸型（偏长偏平）和围裙上的小鲸鱼图案，Sol 的鲸鱼更像鲸。
 
-**《蒙娜丽莎》：Astra 草图 → GPT 生图**
+<details>
+<summary>展开三道题的完整提示词</summary>
 
-案例版本：[2.1.0-beta.5](https://github.com/WSL043/dsh-codex-subscription/releases/tag/v2.1.0-beta.5)
+```text
+@sketch 用 3:4 竖版画板绘制《钟塔剖面图》：蒸汽朋克风格的钟塔纵向剖面技术插图。最上方是圆形大钟面（十二个刻度、两根指针）和一口铜钟；钟面下一层是齿轮机房：至少 9 个大小不同、齿数正确、彼此咬合的齿轮（相邻齿轮转向相反，齿廓要画出锯齿），另有一个锚形擒纵机构；中段是一根贯穿的长摆杆，末端为铜制圆盘摆锤，旁边两条挂着配重铁块的链条；塔壁一侧是沿墙盘旋而上的螺旋楼梯，梯上有三个微小的工匠人物；底部是石砌地基与拱门。剖面用厚实的暗色砖石墙体框出，内部露出黄铜与铁质结构，加入铆钉、管道，以及从小窗透进来的光柱。按背景砖墙、结构框架、齿轮组、摆锤与链条、楼梯与人物、光影与细节分层绘制。画完后，把这张草图作为唯一参考图，调用订阅图片工具一次生成成品：保持每个部件的位置、比例与咬合关系不变，做成精密的蒸汽朋克剖面图插画——黄铜与旧钢的金属质感、细致的机械倒影和铆钉、羊皮纸底色配墨线渲染、暖色灯光，不添加文字。
+```
 
-用户在另一台电脑上的实际效果：先让 Astra 在竖版画板上绘制，再通过 GPT 生图转成油画。
+```text
+@sketch 用 3:4 竖版画板绘制《千峰翠色》：宋代青绿山水的构图，严格运用「三远法」。高远：右侧一座主峰拔地而起，占画面上半部，山体用层叠的块面表现，山腰有横向的云雾留白；深远：主峰后方还有两重淡青色远山，越远越淡，之间隔着大片留白的雾带；平远：下方是舒展的江面，一叶渔舟和两只飞鸟。左侧一挂瀑布从中段峭壁倾泻而下，落入山涧，涧边有三株松树，松针成簇；山腰有一座小亭和一条曲折栈道，栈道上有两个极小的行者；前景是坡石与芦苇，用勾勒加披麻皴式的笔触表现。色彩层次为石青、石绿、赭石，远山用淡青。按远山与天空、雾带留白、主峰、瀑布与松树、亭台栈道与行者、江面舟鸟与前景分层绘制。画完后，把这张草图作为唯一参考图，调用订阅图片工具一次生成成品：保持山体、瀑布、栈道、江面的位置和三远法的层次不变，做成宋代青绿山水绢本设色——石青石绿矿物颜料的沉着厚重、细腻的皴擦与勾勒、绢面纹理与微微泛黄的古意、云雾留白，不添加文字或印章。
+```
 
-<table>
-<tr><th width="50%">Astra 原生草图</th><th width="50%">GPT 生图：油画效果</th></tr>
-<tr><td><img src="docs/assets/sketch-mona-lisa-source.png" alt="Astra 绘制的蒙娜丽莎草图" width="480"></td><td><img src="docs/assets/sketch-mona-lisa-result.png" alt="草图转换后的蒙娜丽莎油画" width="480"></td></tr>
-</table>
+```text
+@sketch 用 1:1 方形画板，尽可能忠实地临摹我附上的这张参考图（一张 Q 版二次元表情包）。画面：白色底；Q 版二头身的蓝发鲸鱼娘跪坐在画面右侧偏中，蓝色渐变长发披肩（发根深蓝、发梢浅蓝），头顶一根呆毛，戴白色蕾丝女仆头饰和蓝色蝴蝶结，头两侧是深蓝色带白色内里的鲸鱼耳鳍，蓝色大眼睛带高光，猫嘴嘟嘴的“ω”表情，脸颊泛红，双手叉腰；穿深蓝色女仆装，白色蕾丝围裙（围裙上有一只蓝色小鲸鱼图案），黑色领结，袖口和裙摆有白色蕾丝褶边；身后露出一条深蓝色的鲸鱼尾巴。左上方是白色对话气泡（黑色描边，尖角指向她），气泡里用黑色粗体写“你这吃白饭的蓝色大肥鱼。”；左侧从画面外伸进来一只黑袖子的手，食指指向她；她的左下方用蓝色描边字写“没吃饱喵！”；她脚边的地上放着一只空的白瓷饭碗，碗内壁印着一只蓝色小鲸鱼。请分层绘制：白色背景、头发与鲸鱼耳鳍与尾巴、身体与服装、脸部五官、饭碗、手臂与对话气泡文字，保留原生可编辑笔画，并特别注意角色比例、头发的渐变与发丝走向、蕾丝褶边和脸部表情的细节。这次只在草图画布上画，不要调用任何生图或图片编辑工具；画完后检查一遍与参考图的差异并修正，最后保存并完成。
+```
 
-草图提示词：`@sketch 用竖版画板画一幅《蒙娜丽莎》`
+SVG 版在“这次只在草图画布上画”之前多加了一句：
+
+```text
+作画方式：每个图层都用 svg 命令整层写成 SVG（路径用贝塞尔曲线，配色手动分层做出渐变感），不要逐点使用原生笔画命令。
+```
+
+</details>
 
-生图提示词：`帮我变成油画`
+每个例子只跑一次，不代表稳定水平；Sol Xhigh 耗时明显更长，日常草图用 Astra 或较低推理档即可。
 
 </details>
 

package/lib/client.js

@@ -2321,6 +2321,799 @@ window.__ModuleLoader__.load({
 				}))
 			};
 		}
+		//#endregion
+		//#region src/sketch-svg.js
+		const MAX_SVG_CHARACTERS = 2e5;
+		const MAX_BEZIER_SEGMENTS = 64;
+		const FLATTEN_STEPS = 10;
+		const NAMED_COLORS = {
+			black: "#000000",
+			white: "#ffffff",
+			red: "#ff0000",
+			green: "#008000",
+			blue: "#0000ff",
+			yellow: "#ffff00",
+			orange: "#ffa500",
+			purple: "#800080",
+			pink: "#ffc0cb",
+			brown: "#a52a2a",
+			gray: "#808080",
+			grey: "#808080",
+			silver: "#c0c0c0",
+			gold: "#ffd700",
+			navy: "#000080",
+			teal: "#008080",
+			maroon: "#800000",
+			olive: "#808000",
+			lime: "#00ff00",
+			aqua: "#00ffff",
+			cyan: "#00ffff",
+			magenta: "#ff00ff",
+			fuchsia: "#ff00ff",
+			ivory: "#fffff0",
+			beige: "#f5f5dc",
+			tan: "#d2b48c",
+			khaki: "#f0e68c",
+			coral: "#ff7f50",
+			salmon: "#fa8072",
+			crimson: "#dc143c",
+			indigo: "#4b0082",
+			violet: "#ee82ee",
+			turquoise: "#40e0d0",
+			skyblue: "#87ceeb",
+			darkgray: "#a9a9a9",
+			darkgrey: "#a9a9a9",
+			lightgray: "#d3d3d3",
+			lightgrey: "#d3d3d3",
+			darkred: "#8b0000",
+			darkgreen: "#006400",
+			darkblue: "#00008b",
+			transparent: "none"
+		};
+		const UNSUPPORTED = /* @__PURE__ */ new Set([
+			"text",
+			"tspan",
+			"image",
+			"foreignObject",
+			"filter",
+			"clipPath",
+			"mask",
+			"pattern",
+			"style",
+			"script",
+			"switch",
+			"marker",
+			"symbol"
+		]);
+		const IGNORED = /* @__PURE__ */ new Set([
+			"title",
+			"desc",
+			"metadata",
+			"defs",
+			"linearGradient",
+			"radialGradient",
+			"stop",
+			"namedview",
+			"sodipodi:namedview"
+		]);
+		const decode = (value) => value.split("&quot;").join("\"").split("&apos;").join("'").split("&lt;").join("<").split("&gt;").join(">").split("&amp;").join("&");
+		function parseXml(text) {
+			const tag = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[[\s\S]*?\]\]>|<!DOCTYPE[^>]*>|<(\/?)([A-Za-z_][\w:.-]*)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/g;
+			const attribute = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+			const root = {
+				name: "#root",
+				attrs: {},
+				children: []
+			};
+			const stack = [root];
+			for (let match = tag.exec(text); match; match = tag.exec(text)) {
+				if (match[2] === void 0) continue;
+				if (match[1] === "/") {
+					if (stack.length > 1 && stack.at(-1).name === match[2]) stack.pop();
+					else throw Error(`SVG is malformed: unexpected </${match[2]}>`);
+					continue;
+				}
+				const attrs = {};
+				for (let item = attribute.exec(match[3]); item; item = attribute.exec(match[3])) attrs[item[1]] = decode(item[2] ?? item[3]);
+				const node = {
+					name: match[2],
+					attrs,
+					children: []
+				};
+				stack.at(-1).children.push(node);
+				if (match[4] !== "/") stack.push(node);
+			}
+			if (stack.length !== 1) throw Error(`SVG is malformed: <${stack.at(-1).name}> is not closed`);
+			return root;
+		}
+		const IDENTITY = [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		];
+		const multiply = (m, n) => [
+			m[0] * n[0] + m[2] * n[1],
+			m[1] * n[0] + m[3] * n[1],
+			m[0] * n[2] + m[2] * n[3],
+			m[1] * n[2] + m[3] * n[3],
+			m[0] * n[4] + m[2] * n[5] + m[4],
+			m[1] * n[4] + m[3] * n[5] + m[5]
+		];
+		const apply$1 = (m, x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+		const NUMBER = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g;
+		const numbers = (text) => (String(text ?? "").match(NUMBER) ?? []).map(Number);
+		function parseTransform(text) {
+			let matrix = IDENTITY;
+			const source = String(text ?? "");
+			const item = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/g;
+			if (source.replace(item, "").replace(/[\s,]/g, "")) throw Error(`Unsupported SVG transform: ${source}`);
+			for (let match = item.exec(source); match; match = item.exec(source)) {
+				const v = numbers(match[2]);
+				let next;
+				if (match[1] === "matrix" && v.length === 6) next = v;
+				else if (match[1] === "translate" && v.length >= 1) next = [
+					1,
+					0,
+					0,
+					1,
+					v[0],
+					v[1] ?? 0
+				];
+				else if (match[1] === "scale" && v.length >= 1) next = [
+					v[0],
+					0,
+					0,
+					v[1] ?? v[0],
+					0,
+					0
+				];
+				else if (match[1] === "rotate" && v.length >= 1) {
+					const a = v[0] * Math.PI / 180, c = Math.cos(a), s = Math.sin(a);
+					const turn = [
+						c,
+						s,
+						-s,
+						c,
+						0,
+						0
+					];
+					next = v.length >= 3 ? multiply(multiply([
+						1,
+						0,
+						0,
+						1,
+						v[1],
+						v[2]
+					], turn), [
+						1,
+						0,
+						0,
+						1,
+						-v[1],
+						-v[2]
+					]) : turn;
+				} else if (match[1] === "skewX" && v.length === 1) next = [
+					1,
+					0,
+					Math.tan(v[0] * Math.PI / 180),
+					1,
+					0,
+					0
+				];
+				else if (match[1] === "skewY" && v.length === 1) next = [
+					1,
+					Math.tan(v[0] * Math.PI / 180),
+					0,
+					1,
+					0,
+					0
+				];
+				else throw Error(`Unsupported SVG transform: ${match[0]}`);
+				matrix = multiply(matrix, next);
+			}
+			return matrix;
+		}
+		function parseColor(value) {
+			const text = String(value ?? "").trim().toLowerCase();
+			if (!text || text === "none") return "none";
+			if (text === "currentcolor") return "#000000";
+			if (Object.hasOwn(NAMED_COLORS, text)) return NAMED_COLORS[text];
+			const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(text);
+			if (hex) return hex[1].length === 3 ? `#${[...hex[1]].map((ch) => ch + ch).join("")}` : text;
+			const rgb = /^rgba?\(([^)]*)\)$/.exec(text);
+			if (rgb) {
+				const parts = rgb[1].split(/[\s,/]+/).filter(Boolean);
+				const channel = (part) => Math.max(0, Math.min(255, Math.round(part.endsWith("%") ? parseFloat(part) * 2.55 : parseFloat(part))));
+				if (parts.length >= 3) return `#${parts.slice(0, 3).map((part) => channel(part).toString(16).padStart(2, "0")).join("")}`;
+			}
+			throw Error(`Unsupported SVG color: ${value}. Use #rrggbb, #rgb, rgb(), a basic color name, none, or a gradient id.`);
+		}
+		function styleOf(node, parent) {
+			const own = { ...node.attrs };
+			if (own.style) for (const rule of own.style.split(";")) {
+				const at = rule.indexOf(":");
+				if (at > 0) own[rule.slice(0, at).trim()] = rule.slice(at + 1).trim();
+			}
+			const pick = (name, fallback) => own[name] === void 0 || own[name] === "inherit" ? fallback : own[name];
+			const number = (name, fallback) => {
+				const value = pick(name, void 0);
+				return value === void 0 ? fallback : Number.parseFloat(value);
+			};
+			return {
+				fill: pick("fill", parent.fill),
+				stroke: pick("stroke", parent.stroke),
+				strokeWidth: number("stroke-width", parent.strokeWidth),
+				fillOpacity: number("fill-opacity", parent.fillOpacity),
+				strokeOpacity: number("stroke-opacity", parent.strokeOpacity),
+				opacity: parent.opacity * number("opacity", 1),
+				display: own.display === "none" || own.visibility === "hidden" ? "none" : "inline"
+			};
+		}
+		function arcToCubics(x1, y1, rx, ry, rotation, large, sweep, x2, y2) {
+			if (x1 === x2 && y1 === y2) return [];
+			rx = Math.abs(rx);
+			ry = Math.abs(ry);
+			if (!rx || !ry) return [[
+				x1,
+				y1,
+				x2,
+				y2,
+				x2,
+				y2
+			]];
+			const phi = rotation * Math.PI / 180, cos = Math.cos(phi), sin = Math.sin(phi);
+			const dx = (x1 - x2) / 2, dy = (y1 - y2) / 2;
+			const x1p = cos * dx + sin * dy, y1p = -sin * dx + cos * dy;
+			const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+			if (lambda > 1) {
+				rx *= Math.sqrt(lambda);
+				ry *= Math.sqrt(lambda);
+			}
+			const sign = large === sweep ? -1 : 1;
+			const numerator = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+			const denominator = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+			const factor = sign * Math.sqrt(Math.max(0, numerator / denominator));
+			const cxp = factor * rx * y1p / ry, cyp = -factor * ry * x1p / rx;
+			const cx = cos * cxp - sin * cyp + (x1 + x2) / 2, cy = sin * cxp + cos * cyp + (y1 + y2) / 2;
+			const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+			const theta = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+			let delta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+			if (!sweep && delta > 0) delta -= 2 * Math.PI;
+			if (sweep && delta < 0) delta += 2 * Math.PI;
+			const count = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 2) - 1e-9));
+			const step = delta / count, k = 4 / 3 * Math.tan(step / 4);
+			const out = [];
+			for (let index = 0; index < count; index++) {
+				const a1 = theta + index * step, a2 = a1 + step;
+				const point = (a, scale) => {
+					const px = rx * Math.cos(a), py = ry * Math.sin(a);
+					const tx = -rx * Math.sin(a) * scale, ty = ry * Math.cos(a) * scale;
+					return [
+						cos * px - sin * py + cx,
+						sin * px + cos * py + cy,
+						cos * tx - sin * ty,
+						sin * tx + cos * ty
+					];
+				};
+				const p1 = point(a1, k), p2 = point(a2, k);
+				out.push([
+					p1[0] + p1[2],
+					p1[1] + p1[3],
+					p2[0] - p2[2],
+					p2[1] - p2[3],
+					p2[0],
+					p2[1]
+				]);
+			}
+			return out;
+		}
+		function parsePathData(data) {
+			const source = String(data ?? "");
+			const subpaths = [];
+			let index = 0, command = "", current, x = 0, y = 0, startX = 0, startY = 0, lastControl, lastCommand = "";
+			const skip = () => {
+				while (index < source.length && /[\s,]/.test(source[index])) index++;
+			};
+			const readNumber = () => {
+				skip();
+				NUMBER.lastIndex = index;
+				const match = NUMBER.exec(source);
+				if (!match || match.index !== index) throw Error(`Malformed SVG path data near "${source.slice(index, index + 12)}"`);
+				index = NUMBER.lastIndex;
+				return Number(match[0]);
+			};
+			const readFlag = () => {
+				skip();
+				const ch = source[index];
+				if (ch !== "0" && ch !== "1") throw Error("Malformed SVG arc flag in path data");
+				index++;
+				return ch === "1";
+			};
+			const begin = (px, py) => {
+				current = {
+					start: [px, py],
+					curves: [],
+					closed: false,
+					straight: true
+				};
+				subpaths.push(current);
+			};
+			const line = (px, py) => {
+				current.curves.push([
+					x,
+					y,
+					px,
+					py,
+					px,
+					py
+				]);
+				x = px;
+				y = py;
+			};
+			const cubic = (c1x, c1y, c2x, c2y, px, py) => {
+				current.curves.push([
+					c1x,
+					c1y,
+					c2x,
+					c2y,
+					px,
+					py
+				]);
+				current.straight = false;
+				lastControl = [c2x, c2y];
+				x = px;
+				y = py;
+			};
+			for (;;) {
+				skip();
+				if (index >= source.length) break;
+				if (/[MmLlHhVvCcSsQqTtAaZz]/.test(source[index])) command = source[index++];
+				else if (!command) throw Error("SVG path data must start with a command");
+				else if (command === "M") command = "L";
+				else if (command === "m") command = "l";
+				else if (command === "Z" || command === "z") throw Error("Unexpected number after Z in SVG path data");
+				const relative = command === command.toLowerCase();
+				const upper = command.toUpperCase();
+				const ox = relative ? x : 0, oy = relative ? y : 0;
+				if (upper === "M") {
+					const px = readNumber() + ox, py = readNumber() + oy;
+					x = startX = px;
+					y = startY = py;
+					begin(px, py);
+					lastControl = void 0;
+				} else if (upper === "Z") {
+					if (current && !current.closed) {
+						if (x !== startX || y !== startY) line(startX, startY);
+						current.closed = true;
+					}
+					x = startX;
+					y = startY;
+					lastControl = void 0;
+					current = void 0;
+				} else {
+					if (!current) {
+						begin(x, y);
+						startX = x;
+						startY = y;
+					}
+					if (upper === "L") line(readNumber() + ox, readNumber() + oy);
+					else if (upper === "H") line(readNumber() + ox, y);
+					else if (upper === "V") line(x, readNumber() + oy);
+					else if (upper === "C") cubic(readNumber() + ox, readNumber() + oy, readNumber() + ox, readNumber() + oy, readNumber() + ox, readNumber() + oy);
+					else if (upper === "S") {
+						const [rx, ry] = lastControl && lastCommand && "CScs".includes(lastCommand) ? [2 * x - lastControl[0], 2 * y - lastControl[1]] : [x, y];
+						cubic(rx, ry, readNumber() + ox, readNumber() + oy, readNumber() + ox, readNumber() + oy);
+					} else if (upper === "Q" || upper === "T") {
+						let qx, qy;
+						if (upper === "Q") {
+							qx = readNumber() + ox;
+							qy = readNumber() + oy;
+						} else [qx, qy] = lastControl && lastCommand && "QTqt".includes(lastCommand) ? [2 * x - lastControl[0], 2 * y - lastControl[1]] : [x, y];
+						const px = readNumber() + ox, py = readNumber() + oy;
+						const from = [x, y];
+						cubic(from[0] + 2 / 3 * (qx - from[0]), from[1] + 2 / 3 * (qy - from[1]), px + 2 / 3 * (qx - px), py + 2 / 3 * (qy - py), px, py);
+						lastControl = [qx, qy];
+					} else if (upper === "A") {
+						const rx = readNumber(), ry = readNumber(), rotation = readNumber(), large = readFlag(), sweep = readFlag();
+						const px = readNumber() + ox, py = readNumber() + oy;
+						const pieces = arcToCubics(x, y, rx, ry, rotation, large, sweep, px, py);
+						for (const piece of pieces) cubic(...piece);
+						if (!pieces.length) {
+							x = px;
+							y = py;
+						}
+						lastControl = void 0;
+					} else throw Error(`Unsupported SVG path command: ${command}`);
+				}
+				lastCommand = command;
+			}
+			return subpaths.filter((subpath) => subpath.curves.length > 0);
+		}
+		const ellipsePath = (cx, cy, rx, ry) => {
+			const k = .5522847498;
+			return {
+				start: [cx + rx, cy],
+				closed: true,
+				straight: false,
+				curves: [
+					[
+						cx + rx,
+						cy + ry * k,
+						cx + rx * k,
+						cy + ry,
+						cx,
+						cy + ry
+					],
+					[
+						cx - rx * k,
+						cy + ry,
+						cx - rx,
+						cy + ry * k,
+						cx - rx,
+						cy
+					],
+					[
+						cx - rx,
+						cy - ry * k,
+						cx - rx * k,
+						cy - ry,
+						cx,
+						cy - ry
+					],
+					[
+						cx + rx * k,
+						cy - ry,
+						cx + rx,
+						cy - ry * k,
+						cx + rx,
+						cy
+					]
+				]
+			};
+		};
+		const polylinePath = (points, closed) => {
+			const path = {
+				start: points[0],
+				curves: [],
+				closed,
+				straight: true
+			};
+			let [x, y] = points[0];
+			for (const [px, py] of points.slice(1)) {
+				path.curves.push([
+					x,
+					y,
+					px,
+					py,
+					px,
+					py
+				]);
+				x = px;
+				y = py;
+			}
+			if (closed && (x !== points[0][0] || y !== points[0][1])) path.curves.push([
+				x,
+				y,
+				points[0][0],
+				points[0][1],
+				points[0][0],
+				points[0][1]
+			]);
+			return path;
+		};
+		const roundedRectPath = (x, y, w, h, rx, ry) => {
+			rx = Math.min(rx, w / 2);
+			ry = Math.min(ry, h / 2);
+			const k = .5522847498;
+			const curves = [];
+			let cx = x + rx, cy = y;
+			const go = (...piece) => {
+				curves.push(piece);
+				cx = piece[4];
+				cy = piece[5];
+			};
+			go(cx, cy, x + w - rx, y, x + w - rx, y);
+			go(x + w - rx + rx * k, y, x + w, y + ry - ry * k, x + w, y + ry);
+			go(x + w, y + ry, x + w, y + h - ry, x + w, y + h - ry);
+			go(x + w, y + h - ry + ry * k, x + w - rx + rx * k, y + h, x + w - rx, y + h);
+			go(x + w - rx, y + h, x + rx, y + h, x + rx, y + h);
+			go(x + rx - rx * k, y + h, x, y + h - ry + ry * k, x, y + h - ry);
+			go(x, y + h - ry, x, y + ry, x, y + ry);
+			go(x, y + ry - ry * k, x + rx - rx * k, y, x + rx, y);
+			return {
+				start: [x + rx, y],
+				curves,
+				closed: true,
+				straight: false
+			};
+		};
+		function svgToSketchCommands(text, { width, height, layer, existingIds = [] }) {
+			if (typeof text !== "string" || !text.trim()) throw Error("svg must be a non-empty SVG document");
+			if (text.length > 2e5) throw Error(`svg is too large: ${text.length} characters, limit ${MAX_SVG_CHARACTERS}. Split it across several svg commands.`);
+			const root = parseXml(text).children.find((node) => node.name === "svg");
+			if (!root) throw Error("svg must contain an <svg> element");
+			const box = numbers(root.attrs.viewBox);
+			const viewWidth = box.length === 4 ? box[2] : Number.parseFloat(root.attrs.width);
+			const viewHeight = box.length === 4 ? box[3] : Number.parseFloat(root.attrs.height);
+			const originX = box.length === 4 ? box[0] : 0, originY = box.length === 4 ? box[1] : 0;
+			if (!(viewWidth > 0 && viewHeight > 0)) throw Error("<svg> needs a viewBox=\"0 0 W H\" (or width and height)");
+			if (Math.abs(viewWidth / viewHeight - width / height) > .01 * (width / height)) throw Error(`SVG viewBox ${viewWidth}x${viewHeight} does not match the ${width}x${height} sketch ratio. Use viewBox="0 0 ${width} ${height}".`);
+			const byId = /* @__PURE__ */ new Map();
+			const index = (node) => {
+				if (node.attrs.id) byId.set(node.attrs.id, node);
+				node.children.forEach(index);
+			};
+			index(root);
+			const warnings = /* @__PURE__ */ new Set();
+			const used = new Set(existingIds);
+			let counter = 0, clamped = 0;
+			const nextId = (suffix) => {
+				for (;;) {
+					counter++;
+					const id = `svg-${counter}${suffix}`;
+					if (!used.has(id)) {
+						used.add(id);
+						return id;
+					}
+				}
+			};
+			const scale = width / viewWidth;
+			const commands = [];
+			const clamp = (value) => {
+				if (value < 0 || value > 1) clamped++;
+				return Math.max(0, Math.min(1, value));
+			};
+			const norm = (matrix, px, py) => {
+				const [tx, ty] = apply$1(matrix, px, py);
+				return {
+					x: clamp((tx - originX) / viewWidth),
+					y: clamp((ty - originY) / viewHeight)
+				};
+			};
+			const gradientColor = (reference) => {
+				const target = byId.get(/^url\(\s*['"]?#([^)'"]+)['"]?\s*\)/.exec(reference)?.[1] ?? "");
+				if (!target || !/Gradient$/.test(target.name)) throw Error(`SVG paint ${reference} does not reference a gradient defined in the same SVG`);
+				const stops = target.children.filter((child) => child.name === "stop");
+				if (!stops.length) throw Error(`Gradient ${target.attrs.id} has no stops`);
+				const channels = stops.map((stop) => parseColor(stop.attrs["stop-color"] ?? /stop-color\s*:\s*([^;]+)/.exec(stop.attrs.style ?? "")?.[1] ?? "#000000")).filter((color) => color !== "none").map((color) => [
+					1,
+					3,
+					5
+				].map((offset) => Number.parseInt(color.slice(offset, offset + 2), 16)));
+				const mean = [
+					0,
+					1,
+					2
+				].map((channel) => Math.round(channels.reduce((sum, item) => sum + item[channel], 0) / channels.length));
+				warnings.add(`Gradient ${target.attrs.id} was flattened to its average color; stack several bands for a real gradient.`);
+				return `#${mean.map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+			};
+			const paint = (value) => String(value).startsWith("url(") ? gradientColor(value) : parseColor(value);
+			const emit = (subpath, matrix, style, id) => {
+				[subpath.start, ...subpath.curves.flatMap((curve) => [
+					[curve[0], curve[1]],
+					[curve[2], curve[3]],
+					[curve[4], curve[5]]
+				])];
+				const fill = style.fill === "none" ? "none" : paint(style.fill);
+				const stroke = style.stroke === "none" ? "none" : paint(style.stroke);
+				const common = layer === void 0 ? {} : { layer };
+				const strokeWidth = Math.max(1, Math.min(256, (style.strokeWidth || 1) * scale * Math.hypot(matrix[0], matrix[1])));
+				const segments = subpath.curves.length;
+				const closed = subpath.closed;
+				const straightPoints = [subpath.start, ...subpath.curves.map((curve) => [curve[4], curve[5]])];
+				const build = (color, opacity, filled, suffix) => {
+					if (subpath.straight && straightPoints.length >= 2) {
+						const vertices = closed ? straightPoints.slice(0, -1) : straightPoints;
+						if (filled || closed) {
+							if (vertices.length >= 3) return [{
+								op: "stroke",
+								...common,
+								id: nextId(suffix),
+								shape: "polygon",
+								color,
+								opacity,
+								fill: filled,
+								width: strokeWidth,
+								points: vertices.map(([px, py]) => norm(matrix, px, py))
+							}];
+						}
+						if (vertices.length === 2 && !filled) return [{
+							op: "stroke",
+							...common,
+							id: nextId(suffix),
+							shape: "line",
+							color,
+							opacity,
+							fill: false,
+							width: strokeWidth,
+							points: vertices.map(([px, py]) => norm(matrix, px, py))
+						}];
+						if (!filled) {
+							const pieces = [];
+							for (let from = 0; from < vertices.length - 1; from += 1900) pieces.push({
+								op: "stroke",
+								...common,
+								id: nextId(suffix),
+								shape: "pen",
+								color,
+								opacity,
+								fill: false,
+								width: strokeWidth,
+								points: vertices.slice(from, from + 1901).map(([px, py]) => norm(matrix, px, py))
+							});
+							return pieces;
+						}
+						return [];
+					}
+					if (filled && segments > MAX_BEZIER_SEGMENTS) {
+						warnings.add(`A filled path with ${segments} curve segments was flattened to a polygon (more than ${MAX_BEZIER_SEGMENTS} segments cannot stay a Bezier).`);
+						const flat = [subpath.start];
+						let [cx, cy] = subpath.start;
+						for (const [a, b, c1, d, e, f] of subpath.curves) {
+							for (let step = 1; step <= FLATTEN_STEPS; step++) {
+								const t = step / FLATTEN_STEPS, u = 1 - t;
+								flat.push([u * u * u * cx + 3 * u * u * t * a + 3 * u * t * t * c1 + t * t * t * e, u * u * u * cy + 3 * u * u * t * b + 3 * u * t * t * d + t * t * t * f]);
+							}
+							cx = e;
+							cy = f;
+						}
+						if (flat.length > 2e3) throw Error("A filled path is too complex to import; simplify it or split it into several paths.");
+						return [{
+							op: "stroke",
+							...common,
+							id: nextId(suffix),
+							shape: "polygon",
+							color,
+							opacity,
+							fill: true,
+							width: strokeWidth,
+							points: flat.map(([px, py]) => norm(matrix, px, py))
+						}];
+					}
+					const pieces = [];
+					for (let from = 0; from < segments; from += MAX_BEZIER_SEGMENTS) {
+						const chunk = subpath.curves.slice(from, from + MAX_BEZIER_SEGMENTS);
+						const chunkPoints = [from === 0 ? subpath.start : [subpath.curves[from - 1][4], subpath.curves[from - 1][5]], ...chunk.flatMap((curve) => [
+							[curve[0], curve[1]],
+							[curve[2], curve[3]],
+							[curve[4], curve[5]]
+						])];
+						pieces.push({
+							op: "stroke",
+							...common,
+							id: nextId(suffix),
+							shape: "bezier",
+							color,
+							opacity,
+							fill: filled,
+							width: strokeWidth,
+							points: chunkPoints.map(([px, py]) => norm(matrix, px, py))
+						});
+					}
+					return pieces;
+				};
+				if (fill !== "none" && style.fillOpacity * style.opacity > 0) commands.push(...build(fill, style.fillOpacity * style.opacity, true, ""));
+				if (stroke !== "none" && style.strokeOpacity * style.opacity > 0 && style.strokeWidth > 0) commands.push(...build(stroke, style.strokeOpacity * style.opacity, false, "-line"));
+			};
+			const walk = (node, matrix, parentStyle, depth) => {
+				if (depth > 24) throw Error("SVG is nested too deeply");
+				if (UNSUPPORTED.has(node.name)) throw Error(`Unsupported SVG element <${node.name}>. Draw with path, rect, circle, ellipse, line, polyline, polygon, g and use; add text with a native text command.`);
+				if (IGNORED.has(node.name)) return;
+				for (const name of [
+					"clip-path",
+					"mask",
+					"filter"
+				]) if (node.attrs[name] && node.attrs[name] !== "none") throw Error(`Unsupported SVG attribute ${name}. Bake it into the shapes instead.`);
+				const style = styleOf(node, parentStyle);
+				if (style.display === "none") return;
+				const local = multiply(matrix, parseTransform(node.attrs.transform));
+				const n = (name) => Number.parseFloat(node.attrs[name] ?? 0);
+				const finish = (subpaths) => subpaths.forEach((subpath) => emit(subpath, local, style, node.attrs.id));
+				switch (node.name) {
+					case "svg":
+					case "g":
+					case "a":
+						for (const child of node.children) walk(child, local, style, depth + 1);
+						return;
+					case "use": {
+						const href = node.attrs.href ?? node.attrs["xlink:href"];
+						const target = href?.startsWith("#") ? byId.get(href.slice(1)) : void 0;
+						if (!target) throw Error(`<use> must reference an element in the same SVG (${href ?? "missing href"})`);
+						walk(target, multiply(local, [
+							1,
+							0,
+							0,
+							1,
+							n("x"),
+							n("y")
+						]), { ...style }, depth + 1);
+						return;
+					}
+					case "path":
+						finish(parsePathData(node.attrs.d));
+						return;
+					case "rect": {
+						const w = n("width"), h = n("height");
+						if (!(w > 0 && h > 0)) return;
+						const rx = node.attrs.rx !== void 0 ? n("rx") : node.attrs.ry !== void 0 ? n("ry") : 0;
+						const ry = node.attrs.ry !== void 0 ? n("ry") : rx;
+						finish([rx > 0 || ry > 0 ? roundedRectPath(n("x"), n("y"), w, h, rx, ry) : polylinePath([
+							[n("x"), n("y")],
+							[n("x") + w, n("y")],
+							[n("x") + w, n("y") + h],
+							[n("x"), n("y") + h]
+						], true)]);
+						return;
+					}
+					case "circle":
+						if (n("r") > 0) finish([ellipsePath(n("cx"), n("cy"), n("r"), n("r"))]);
+						return;
+					case "ellipse":
+						if (n("rx") > 0 && n("ry") > 0) finish([ellipsePath(n("cx"), n("cy"), n("rx"), n("ry"))]);
+						return;
+					case "line":
+						finish([polylinePath([[n("x1"), n("y1")], [n("x2"), n("y2")]], false)]);
+						return;
+					case "polyline":
+					case "polygon": {
+						const values = numbers(node.attrs.points);
+						if (values.length < 4 || values.length % 2) throw Error(`<${node.name}> needs an even number of coordinates, at least two points`);
+						const pts = [];
+						for (let at = 0; at < values.length; at += 2) pts.push([values[at], values[at + 1]]);
+						finish([polylinePath(pts, node.name === "polygon")]);
+						return;
+					}
+					default: throw Error(`Unsupported SVG element <${node.name}>`);
+				}
+			};
+			walk(root, IDENTITY, {
+				fill: "#000000",
+				stroke: "none",
+				strokeWidth: 1,
+				fillOpacity: 1,
+				strokeOpacity: 1,
+				opacity: 1
+			}, 0);
+			if (!commands.length) throw Error("The SVG contained no drawable shapes");
+			return {
+				commands,
+				warnings: [...warnings],
+				clamped
+			};
+		}
+		function expandSvgCommands(commands, doc, report) {
+			if (!commands.some((command) => command?.op === "svg")) return commands;
+			const width = doc.width ?? 1024, height = doc.height ?? 1024;
+			const ids = new Set(doc.layers.flatMap((item) => item.strokes.map((stroke) => stroke.id).filter(Boolean)));
+			const out = [];
+			let clamped = 0;
+			for (const command of commands) {
+				if (command?.op !== "svg") {
+					out.push(command);
+					if (command?.id) ids.add(command.id);
+					continue;
+				}
+				const result = svgToSketchCommands(command.svg, {
+					width,
+					height,
+					layer: command.layer,
+					existingIds: ids
+				});
+				result.commands.forEach((item) => ids.add(item.id));
+				out.push(...result.commands);
+				clamped += result.clamped;
+				if (report) report.warnings = [.../* @__PURE__ */ new Set([...report.warnings ?? [], ...result.warnings])];
+			}
+			if (report && clamped) report.clampedPoints = (report.clampedPoints ?? 0) + clamped;
+			return out;
+		}
+		//#endregion
+		//#region src/sketch-commands.js
+		const MAX_SKETCH_POINTS = 2e5;
 		const SKETCH_COMMAND_HELP = {
 			coordinates: "Assign short meaningful stroke id values for later edits. Text uses two opposite box corners and text content; width is font size in pixels, automatic fitting within the box. Arrow uses two endpoints. Normalized x/y in [0,1]; width is canvas pixels. Read documentId and revision before editing.",
 			shapes: "line: exactly two endpoints; rectangle/circle (ellipse alias accepted): exactly two opposite bounding-box corners (circle draws an ellipse within that box); polygon: three or more vertices, closed automatically; pen: ordered path points. bezier: start point, then groups of control1/control2/end; use 4 points for one cubic curve, max 64 segments. Prefer bezier for smooth designed curves instead of many pen samples. fill:true closes and fills the curve. fill:true fills rectangle/circle/polygon. Layers and strokes paint in list order, later ones on top. All commands needed for drawing are described here; no source-code search is required.",
@@ -2330,19 +3123,22 @@ window.__ModuleLoader__.load({
 				layer: "Add: {op:\"layer\",action:\"add\",value:\"name\"}; optional id is the NEW unique integer ID, otherwise allocated automatically. after is the existing insertion anchor, defaults to active layer. Other actions: {op:\"layer\",action:\"select|rename|visible|duplicate|up|down|delete|clear\",id:1,value:\"name\"}; id targets an existing layer.",
 				curve: "Prefer {op:\"stroke\",shape:\"bezier\",start:{x:0,y:0},segments:[{control1:{x:0.2,y:0},control2:{x:0.8,y:1},end:{x:1,y:1}}],color:\"#123456\"}. Each segment has exactly two controls and an endpoint; no point counting required. Legacy points arrays still accepted. Do not provide both forms.",
 				object: "{op:\"object\",layer:1,id:\"title\",action:\"update|duplicate|delete\",patch:{color:\"#0088ff\",text:\"Title\"},transform:{dx:0.05,dy:0,scaleX:1,scaleY:1}}. All patch and transform fields optional. Inspect returns object IDs and bounds. Prefer targeted edits over redrawing layers.",
-				resize: "{op:\"resize\",ratio:\"1:1|4:3|3:4|16:9|9:16\"}"
+				resize: "{op:\"resize\",ratio:\"1:1|4:3|3:4|16:9|9:16\"}",
+				svg: "{op:\"svg\",svg:\"<svg viewBox=\\\"0 0 1024 768\\\">...</svg>\",layer:1}. Fastest way to draw: send a whole scene as SVG (path with M L H V C S Q T A Z, rect, circle, ellipse, line, polyline, polygon, g, use, transform, fill/stroke/opacity, style=\"...\"); it becomes native editable strokes. The viewBox must match the canvas size (use the width and height from inspect; 4:3 is 1024x768). Gradients are flattened to their average color, so build glows and skies from stacked bands; text, image, filter, clipPath, mask, pattern and CSS classes are refused. Coordinates outside the canvas are clamped. One svg command may hold up to 200000 characters."
 			},
 			limits: {
 				strokes: MAX_SKETCH_STROKES,
 				pointsPerStroke: MAX_STROKE_POINTS,
-				pointsTotal: 2e5,
-				commandsPerBatch: 256
+				pointsTotal: MAX_SKETCH_POINTS,
+				commandsPerBatch: 256,
+				svgCharacters: MAX_SVG_CHARACTERS
 			}
 		};
 		const finite = (value, min, max) => typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
-		function applySketchCommands(source, commands) {
+		function applySketchCommands(source, commands, report) {
 			if (!Array.isArray(commands) || !commands.length || commands.length > 256) throw Error("Expected 1–256 commands");
 			let doc = identifyObjects(source);
+			commands = expandSvgCommands(commands, doc, report);
 			for (let command of commands) {
 				if (!command || typeof command !== "object") throw Error("Invalid command");
 				if (command.op === "stroke") command = expandSketchPreset(command);
@@ -2501,7 +3297,9 @@ window.__ModuleLoader__.load({
 					} : item)
 				};
 			}
-			if (strokeCount(doc) > 2e3 || doc.layers.reduce((n, l) => n + l.strokes.reduce((m, s) => m + s.points.length, 0), 0) > 2e5) throw Error("Sketch resource budget exceeded");
+			const strokes = strokeCount(doc), points = doc.layers.reduce((n, l) => n + l.strokes.reduce((m, s) => m + s.points.length, 0), 0);
+			if (strokes > 2e3) throw Error(`Sketch would hold ${strokes} strokes; the limit is ${MAX_SKETCH_STROKES}. Merge shapes or drop small details, then send this batch again`);
+			if (points > 2e5) throw Error(`Sketch would hold ${points} points; the limit is ${MAX_SKETCH_POINTS}. Use fewer or simpler paths, then send this batch again`);
 			return doc;
 		}
 		function createSketchCommandSession(adapter) {
@@ -2544,11 +3342,12 @@ window.__ModuleLoader__.load({
 				}
 				if (request.revision !== current.revision || adapter.busy()) throw Error("Sketch changed or is being edited; inspect again");
 				let changedObjects;
+				const report = {};
 				if (request.action === "apply") {
 					const before = adapter.document();
 					let next;
 					try {
-						next = applySketchCommands(before, request.commands);
+						next = applySketchCommands(before, request.commands, report);
 					} catch (cause) {
 						const error = new Error(`${cause.message} Correct the batch and retry with the same runId and revision; nothing was applied.`, { cause });
 						error.code = "SKETCH_INVALID_BATCH";
@@ -2574,7 +3373,9 @@ window.__ModuleLoader__.load({
 					...changedObjects ? {
 						changedObjects: changedObjects.slice(0, 100),
 						changedObjectCount: changedObjects.length
-					} : {}
+					} : {},
+					...report?.warnings?.length ? { warnings: report.warnings } : {},
+					...report?.clampedPoints ? { clampedPoints: report.clampedPoints } : {}
 				};
 				completed.set(key, {
 					fingerprint,
@@ -5847,6 +6648,10 @@ window.__ModuleLoader__.load({
 .codexSubscriptionRecover .codexSubscriptionError{flex:1}
 .codexSubscriptionRecover button{flex:0 0 auto}
 .codexSubscriptionDiagnostics{color:var(--dsw-alias-label-secondary)}
+.codexSubscriptionDiagnostics ul{margin:0;padding-left:18px;font-size:13px;line-height:20px}
+.codexSubscriptionDiagnostics li+li{margin-top:6px}
+.codexSubscriptionDiagnostics li strong{font-weight:600;color:var(--dsw-alias-label-primary)}
+.codexSubscriptionDiagnostics [role=status]>p{margin:0;font-size:13px}
 .codexSubscriptionDiagnostics pre{max-height:240px;margin:0;padding:10px 12px;border-radius:8px;background:var(--dsw-alias-bg-module-platform);overflow:auto;white-space:pre-wrap;overflow-wrap:anywhere;font:11px/17px ui-monospace,SFMono-Regular,Consolas,monospace;color:var(--dsw-alias-label-secondary)}
 .codexSubscriptionLink{box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;min-height:32px;padding:0 13px;border:1px solid var(--dsw-alias-border-l2);border-radius:999px;background:transparent;color:var(--dsw-alias-label-primary);font-size:13px;line-height:20px;text-decoration:none;white-space:nowrap}
 .codexSubscriptionLink:hover{background:var(--dsw-alias-bg-module-platform)}
@@ -7676,7 +8481,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/version.js
-		const PACKAGE_VERSION = "2.3.0";
+		const PACKAGE_VERSION = "2.4.1";
 		//#endregion
 		//#region src/client-recovery.js
 		async function recoveryCall(rpc, endpoint, payload = {}, timeoutMs = 1e4) {
@@ -9955,7 +10760,9 @@ window.__ModuleLoader__.load({
 			return {
 				format: "compact-1",
 				plugin: report.version,
-				dsh: report.client?.version,
+				dsh: report.runtime?.dsh,
+				...report.client?.version && report.client.version !== report.version ? { pluginClient: report.client.version } : {},
+				platform: report.runtime ? `${report.runtime.platform}-${report.runtime.arch}` : void 0,
 				generatedAt: report.generatedAt,
 				account: report.account?.status,
 				catalog: report.catalog ? {

package/lib/index.js

@@ -1205,13 +1205,18 @@ const SUPPORTED_RUNTIME_VERSIONS = Object.freeze([
 ]);
 const require = createRequire(import.meta.url);
 const execute = promisify(execFile);
+/** The DSH release this plugin is loaded into, read from the host's own LLM package. */
+function hostDshVersion(resolve = require.resolve, entry = process.argv[1]) {
+	const attempts = [() => resolve("@deepseek-ai/dsh-llm/package.json")];
+	if (typeof entry === "string" && entry) attempts.push(() => require.resolve("@deepseek-ai/dsh-llm/package.json", { paths: [dirname(entry)] }));
+	for (const attempt of attempts) try {
+		const { version } = JSON.parse(readFileSync(attempt(), "utf8"));
+		if (typeof version === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(version)) return version;
+	} catch {}
+}
 function matchingSubagentRuntimeVersion(resolve = require.resolve) {
-	try {
-		const host = JSON.parse(readFileSync(resolve("@deepseek-ai/dsh-llm/package.json"), "utf8"));
-		return SUPPORTED_RUNTIME_VERSIONS.includes(host.version) ? host.version : void 0;
-	} catch {
-		return;
-	}
+	const version = hostDshVersion(resolve, resolve === require.resolve ? process.argv[1] : "");
+	return SUPPORTED_RUNTIME_VERSIONS.includes(version) ? version : void 0;
 }
 function inspectSubagentRuntime(resolve = require.resolve) {
 	try {
@@ -1799,7 +1804,8 @@ const sketchCommandArray = {
 				"stroke",
 				"object",
 				"layer",
-				"resize"
+				"resize",
+				"svg"
 			]
 		},
 		id: {
@@ -1863,6 +1869,10 @@ const sketchCommandArray = {
 				"clear"
 			]
 		},
+		svg: {
+			type: "string",
+			description: "op svg only: a complete <svg viewBox=\"0 0 W H\"> document (W and H equal to the canvas width and height from inspect). Imported as native editable strokes; the fastest way to draw a whole scene. Optional layer sets the target layer."
+		},
 		value: string,
 		ratio: {
 			type: "string",
@@ -1888,7 +1898,7 @@ const sketchCommandArray = {
 function createSketchAgentTool(bridge, attachments) {
 	return defineTool({
 		name: "codex_sketch",
-		description: "Edit the sketch board in this session using native editable strokes and layers. Use for @sketch requests and explicit follow-up edits to that drawing. The toolbar pen button is for manual drawing; do not require the user to open it. Start with inspect for the runId, documentId, revision and command reference. Apply atomic batches, preview between stages, and call finish to save the finished draft and release the editing lock. save is only a checkpoint. finish returns an image only when the user enables experimental preview feedback. Closing the board does not stop drawing. If the user stops drawing, do not retry. Never generates AI images, sends messages or attaches images automatically. Inspect automatically opens the board in the currently viewed session. Do not ask the user to open it first. If the session is not visible in DSH, ask them to switch to it. On timeout inspect before retrying; reuse the exact requestId only for the same request.",
+		description: "Edit the sketch board in this session using native editable strokes and layers. Use for @sketch requests and explicit follow-up edits to that drawing. The toolbar pen button is for manual drawing; do not require the user to open it. Start with inspect for the runId, documentId, revision and command reference. Draw with the svg op whenever possible: one SVG document per stage (paths, shapes, groups, transforms; see the reference from inspect) is far faster and richer than hand-placed strokes, and still becomes native editable strokes. Draw the shapes, hair, clothing and lettering outlines of every layer with svg; use stroke commands only for small corrections and native text. Apply atomic batches, preview between stages, and call finish to save the finished draft and release the editing lock. save is only a checkpoint. finish returns an image only when the user enables experimental preview feedback. Closing the board does not stop drawing. If the user stops drawing, do not retry. Never generates AI images, sends messages or attaches images automatically. Inspect automatically opens the board in the currently viewed session. Do not ask the user to open it first. If the session is not visible in DSH, ask them to switch to it. On timeout inspect before retrying; reuse the exact requestId only for the same request.",
 		parameters: {
 			action: {
 				type: "string",
@@ -3058,7 +3068,7 @@ async function readSubscriptionCredentials(getAuth, readCredential, signal) {
 }
 //#endregion
 //#region src/version.js
-const PACKAGE_VERSION = "2.3.0";
+const PACKAGE_VERSION = "2.4.1";
 const USER_AGENT = `dsh-codex-subscription/${PACKAGE_VERSION}`;
 //#endregion
 //#region src/model-catalog.js
@@ -3551,6 +3561,23 @@ const PATH_LIKE_ATTACHMENT_ID = /[\\/]/u;
 const FILE_NAME_ATTACHMENT_ID = /\.[A-Za-z0-9]{1,16}$/u;
 const record$2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const NETWORK_REASONS = {
+	UND_ERR_HEADERS_TIMEOUT: "the image service sent no response within 5 minutes",
+	UND_ERR_BODY_TIMEOUT: "the image response stalled",
+	UND_ERR_CONNECT_TIMEOUT: "the connection to the image service timed out",
+	UND_ERR_SOCKET: "the connection closed unexpectedly",
+	ECONNRESET: "the connection was reset",
+	ETIMEDOUT: "the connection timed out",
+	ENOTFOUND: "DNS lookup failed",
+	ECONNREFUSED: "the connection was refused",
+	EAI_AGAIN: "DNS lookup failed"
+};
+function requestFailureReason(error) {
+	const code = [(error?.cause ?? error)?.code, error?.code].find((value) => typeof value === "string" && /^[A-Z][A-Z0-9_]{2,39}$/u.test(value));
+	if (code !== void 0) return `: ${NETWORK_REASONS[code] ?? "network error"} (${code})`;
+	if (error?.name === "TimeoutError") return ": the image request timed out";
+	return "";
+}
 function normalizeImageOptions(args) {
 	const quality = nonEmpty(args?.quality) ?? "auto";
 	const background = nonEmpty(args?.background) ?? "auto";
@@ -3955,7 +3982,7 @@ function createCodexImageTool(options) {
 				});
 			} catch (error) {
 				if (exec.signal.aborted) throw exec.signal.reason;
-				throw new Error(`Codex image ${editing ? "edit" : "generation"} request failed`, { cause: error });
+				throw new Error(`Codex image ${editing ? "edit" : "generation"} request failed${requestFailureReason(error)}`, { cause: error });
 			}
 			if (!response.ok) {
 				if (response.status === 401 || response.status === 403) throw new Error("ChatGPT sign-in needs to be renewed");
@@ -4642,7 +4669,8 @@ async function createSubscriptionDiagnostics({ auth, preferences, login = { phas
 		runtime: {
 			node: process.version,
 			platform: process.platform,
-			arch: process.arch
+			arch: process.arch,
+			...hostDshVersion() ? { dsh: hostDshVersion() } : {}
 		},
 		account,
 		login,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-codex-subscription",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "Use ChatGPT and Codex subscriptions in DeepSeek Harness with OAuth, quota, safe resets, web search, images, and Fast mode",
   "type": "module",
   "main": "./lib/index.js",