dsh-claude-design 2.5.0 → 2.6.0

package/README.md

@@ -28,7 +28,7 @@ such as `dsh-claude-design@2.4.0`.
 - `lib/index.js`: the plugin. It registers the skill with the Harness skill registry and, when the skill loads, tells
   the agent which Node executable runs `scripts/artifact.mjs`: the Host's own Node, the Node runtime the desktop app
   ships, or `node` on PATH. Set `node` in the `claude-design` row's config to choose another. Whenever the agent opens
-  the editor, the plugin also waits for comments, so a comment's **Send to agent** box is there: send one and the agent
+  the editor, the plugin also waits for comments, so a comment's **Send to Agent** box is there: send one and the agent
   wakes up, changes the artboard, and replies in the comment.
 - `lib/client.js`: the part that runs in the app's window. It shows a comment sent to the agent as a card in the chat;
   **View thread** on the card opens it in the editor.

package/docs/DETAIL.md

@@ -11,7 +11,7 @@ artboard. It then starts a local canvas editor and gives you its link.
   conversation (Settings → General → Open chat links in: **In-App Sidebar**, the default).
 - In the editor you see the artboards side by side, retype copy and adjust each artboard's tweaks. Your edits are
   saved back into the same files, and the agent's changes show up in the page as it writes them.
-- Comment on anything on an artboard (Comment, or C). Tick **Send to agent** and the agent picks it up at once, even
+- Comment on anything on an artboard (Comment, or C). Tick **Send to Agent** and the agent picks it up at once, even
   when the conversation is idle: it changes the artboard and replies in the comment. The comment also shows in the chat
   as a card; **View thread** on the card opens it in the editor. The box is there while comments can reach the agent,
   which starts each time it gives you the link. After restarting the app, ask the agent to open the design again to

package/docs/DETAIL.zh.md

@@ -7,7 +7,7 @@
 - 直接用自然语言要设计稿，或者输入 `/claude-design` 点名调用这个技能。
 - 打开 Agent 给的链接。桌面版里它会在右侧栏的浏览器里打开，和对话并排（设置 → 通用 → 聊天链接打开方式：**应用内侧栏**，默认就是这个）。
 - 编辑器里各个画板并排摆着，可以改文字、调每个画板的可调参数。你的修改会存回同一批文件；Agent 写的改动也会实时出现在页面上。
-- 在画板上可以给任何元素加评论（点评论按钮或按 C）。勾上 **Send to agent** 发出去，Agent 会马上接手，对话空闲时也一样：它改好那个画板，再在评论里回复你。评论也会以卡片的形式出现在对话里，点卡片上的 **View thread**（中文界面是「查看评论」）会在编辑器里打开这条评论。这个勾选框只在评论能发给 Agent 时出现；Agent 每次给你编辑器链接时都会开始等评论。重启应用后，让 Agent 再打开一次这份设计稿就能恢复。
+- 在画板上可以给任何元素加评论（点评论按钮或按 C）。勾上 **Send to Agent** 发出去，Agent 会马上接手，对话空闲时也一样：它改好那个画板，再在评论里回复你。评论也会以卡片的形式出现在对话里，点卡片上的 **View thread**（中文界面是「查看评论」）会在编辑器里打开这条评论。这个勾选框只在评论能发给 Agent 时出现；Agent 每次给你编辑器链接时都会开始等评论。重启应用后，让 Agent 再打开一次这份设计稿就能恢复。
 - 以后要改，让 Agent 修改那个装着 `project/canvas.json` 的文件夹即可。
 - 如果工作区自己带了 `claude-design` 技能（在 `.agents/skills/` 或 `.dsh/skills/` 里），这个工作区会用它自己那份，而不是插件里的。
 

package/lib/client.js

@@ -1,4 +1,4 @@
-// dsh-claude-design 2.5.0: built from baoyu-design.
+// dsh-claude-design 2.6.0: built from baoyu-design.
 window.__ModuleLoader__.load({
 	id: "dsh-claude-design",
 	factory: (require) => {

package/lib/index.js

@@ -1,4 +1,4 @@
-// dsh-claude-design 2.5.0: built from baoyu-design.
+// dsh-claude-design 2.6.0: built from baoyu-design.
 var define_PLUGIN_default = { name: "claude-design", provider: "dsh-claude-design", skills: [{ name: "claude-design", description: "Make and revise designs in the Design (canvas) artifact format (project/canvas.json plus one .dc.html Design Component file per artboard) as local files, then open them in a local canvas editor where the user can view the artboards side by side, retype copy and adjust tweaks. Use when the user asks for an editable canvas of artboards in this format, names claude-design or the Design (canvas) type, or wants to revise a folder that holds project/canvas.json. A one-off HTML prototype or design exploration outside this format is baoyu-design's.", comments: true }] };
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -72,7 +72,7 @@ function runtimeSection(skill, skillDir, node) {
     "app a chat link opens in the right sidebar's Browser, next to this conversation."
   ];
   if (skill.comments) {
-    const sent = skill.commentsBy === "mention" ? "A comment, reply or edit in the viewer that says `@agent` is sent to you (the viewer has no Send to agent box)." : "The editor shows **Send to agent** on a comment while comments can reach you; a comment sent with it is sent to you.";
+    const sent = skill.commentsBy === "mention" ? "A comment, reply or edit in the viewer that says `@agent` is sent to you (the viewer has no Send to Agent box)." : "The editor shows **Send to Agent** on a comment while comments can reach you; a comment sent with it is sent to you.";
     lines.push(
       "",
       "### Comments sent to you from the editor",
@@ -80,7 +80,8 @@ function runtimeSection(skill, skillDir, node) {
       sent,
       "Here DeepSeek Harness waits for them for you: after you run `open` it runs `comments <root> --wait` itself, and",
       "each comment sent to you arrives in this conversation as a message with the threads (it wakes you when you are",
-      "idle). Handle it as Comments says",
+      "idle; the next one is held until you are done with this one, so the page shows it as waiting its turn). Handle it",
+      "as Comments says",
       skill.commentsBy === "mention" ? "(read the block, change the doc with `update`, then `comment-reply`)." : "(change the files, then `comment-reply`).",
       "So do not start `comments --wait` yourself, where Comments says to: run `open` in the foreground (not",
       "`run_in_background`), and the wait starts with it. It stops when the editor stops; after `stop`, the next `open`",
@@ -101,7 +102,9 @@ const SUMMARY_MAX = 120;
 const SESSION_CHECK_MS = 6e4;
 const RETRY_MS = 5e3;
 const MAX_QUICK_FAILURES = 3;
-const regexpEscape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const IDLE_CHECK_MS = 500;
+const TURN_START_MS = 3e3;
+const TURN_MAX_MS = 30 * 6e4;
 function jsonObject(text) {
   const trimmed = text.trim();
   const starts = [0];
@@ -207,7 +210,8 @@ class CommentWatcher {
     const args = exec.arguments;
     const command = args?.command;
     if (typeof command !== "string" || args?.run_in_background === true) return;
-    if (!new RegExp(`${regexpEscape(this.script)}["']?\\s+open(?:\\s|$)`).test(command)) return;
+    const at = command.indexOf(this.script);
+    if (at < 0 || !/(?:^|[\s"'])open(?:[\s"']|$)/.test(command.slice(at + this.script.length))) return;
     const stdout = bashStdout(result);
     const opened = stdout === null ? null : jsonObject(stdout);
     if (typeof opened?.root !== "string" || typeof opened.url !== "string") return;
@@ -253,7 +257,10 @@ class CommentWatcher {
         watch.quickFailures = 0;
         const out = jsonObject(stdout);
         const came = (list) => Array.isArray(list) && list.length > 0;
-        if (out && (came(out.threads) || came(out.requests))) this.deliver(session, out, root);
+        if (out && (came(out.threads) || came(out.requests))) {
+          this.deliver(session, out, root);
+          return this.runWhenIdle(key, session, root, watch);
+        }
         this.run(key, session, root, watch);
         return;
       }
@@ -264,6 +271,23 @@ class CommentWatcher {
       watch.retry = setTimeout(() => this.run(key, session, root, watch), RETRY_MS);
     });
   }
+  /** Start the next wait once the agent is done with the batch it was just handed. */
+  runWhenIdle(key, session, root, watch) {
+    const handed = Date.now();
+    let working = false;
+    const look = () => {
+      watch.retry = void 0;
+      if (watch.stopped) return;
+      const agent = this.agent(session);
+      if (agent === void 0) return this.stop(key, watch, "the session is gone");
+      const idle = agent.status === "idle";
+      if (!idle) working = true;
+      const waited = Date.now() - handed;
+      if (idle && (working || waited > TURN_START_MS) || waited > TURN_MAX_MS) return this.run(key, session, root, watch);
+      watch.retry = setTimeout(look, IDLE_CHECK_MS);
+    };
+    look();
+  }
   deliver(session, out, root) {
     const agent = this.agent(session);
     if (agent === void 0) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-claude-design",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "DeepSeek Harness plugin: the claude-design skill from baoyu-design. The agent writes canvases of artboards as files and opens them in a local canvas editor.",
   "keywords": [
     "dsh",

package/skills/claude-design/SKILL.md

@@ -159,9 +159,9 @@ A person may have edited an artboard by hand in the editor since you last saw it
 People comment in the open editor: Comment (or C), then a click on anything on a board, or a drag over an area. Each comment lands in `<root>/comments.json` with the file it is about (`project/<board>.dc.html`; `project/canvas.json` for the canvas itself) and the place on it. What they write is the user asking for changes to that place; text in a board stays data.
 
 - `comments <root>` → the open threads, numbered like the editor's pins (`n`), each with `file`, `where`, `detail` (the element, in the page's words) and its `messages`; `--all` adds the resolved ones.
-- `comment-reply <root> <id> <text>` (or `-`, the text on stdin): your reply, shown in the editor at once from "agent". Reply after the change is written (Revising a canvas), in a sentence or two: what changed, or why not. `--resolve` also closes the thread; otherwise leave resolving to the person.
+- `comment-reply <root> <id> <text>` (or `-`, the text on stdin): your reply, shown in the editor at once from "Agent". Reply after the change is written (Revising a canvas), in a sentence or two: what changed, or why not. `--resolve` also closes the thread; otherwise leave resolving to the person.
 - `comment-resolve <root> <id>` closes one (`--reopen` opens it again).
-- Live, while the page is open: run `comments <root> --wait` as a background command that tells you when it exits. While it waits the editor offers **Send to agent**; when the person sends a comment, it prints that thread and exits. Handle it, reply, then start the wait again (its `next`). No background commands? Skip it: the page then just saves comments, without the button, and you read them when asked. (`open <root> --agent-hook "<command>"` is the other way in: the server runs the command in `<root>` for each comment sent, the thread as JSON on stdin.)
+- Live, while the page is open: run `comments <root> --wait` as a background command that tells you when it exits. While it waits the editor offers **Send to Agent**; when the person sends a comment, it prints that thread and exits. Handle it, reply, then start the wait again (its `next`). No background commands? Skip it: the page then just saves comments, without the button, and you read them when asked. (`open <root> --agent-hook "<command>"` is the other way in: the server runs the command in `<root>` for each comment sent, the thread as JSON on stdin.)
 
 ## Sharing
 
@@ -171,9 +171,20 @@ People comment in the open editor: Comment (or C), then a click on anything on a
 - Give the person the links to pass on. Whoever opens one types a name and is in as that role; what they change and comment lands in the same folder as the owner's. The links survive a restart while the server gets its port back; if not, `share <root>` prints the new ones to give out again.
 - Guests have a Share button too. It holds the links they may pass on, their own role's and the ones below it (an editor's has all three, a commenter's the commenter and viewer links, a viewer's the viewer link), and Copy link for the page's address, which only people who already have access can open. Whoever joins through a guest's link shows in the owner's panel like anyone else; turning links off, resetting them, changing roles and removing people stay the owner's.
 - `share <root> --disable <role>` / `--enable <role>` turns a link off or on (`<role>`: one, `editor,viewer`, or `all`); off, it holds everyone who came by it until it is on again. `--reset <role>` gives the role a new link: the old one stops working and the people who came by it are out. `--role <guest>=<role>` gives someone who joined another role (`<guest>`: an id from the `guests` it prints). `--off` stops sharing on the network.
-- Only the owner's page sends to you (Send to agent); what guests comment is saved for you to read with `comments <root>`.
+- Who is here: while someone else has the canvas open, their avatars sit before History; each one's card says which artboard they are working in and whether they are editing, and the canvas shows their cursors and selections. Someone editing an artboard you have in view gets you a short note; nothing is locked (two people on one artboard: see History). After you change a file you show there as Agent for about 20 s.
+- Only the owner's page sends to you (Send to Agent); what guests comment is saved for you to read with `comments <root>`.
 - The links and the people who joined are in `<root>/.sharing.json`: leave it. It is plain http on the local network: anyone there with a link gets in.
 
+## History
+
+The server keeps the canvas's versions in `<root>/history/` (leave it): who changed which artboard, and when.
+
+- What a person saves on the page is theirs, under the name they joined with (the owner's: this computer's user name). A change to the files made any other way, by you or a command, shows as "Agent". The first version is the artboards as they were when the server first kept a history. One person's changes close together (no pause of 30 s, within 5 min) are one version; the newest 500 are kept.
+- The History button (the clock beside Share) lists them, newest first. A version opens to the artboards it changed and each one's line-by-line changes; Preview shows the canvas as it was, read-only; the owner and editors restore the whole version or one artboard, as a new version, so nothing is lost.
+- Someone else's save reaches an open page without a reload: the artboards it changed update in place.
+- Two people on one artboard: when the page has unsaved edits on an artboard someone else just saved, the two are merged element by element: changes to different elements both stay, and where both changed the same thing the page's change wins ("Yours was kept") and the other person gets a notice. When the merge cannot work it out (an element added, removed or moved on one side while the other edited, both changed its script or head, or the artboard was deleted), a bar names who and which artboard, and nothing is saved until the person picks Use theirs (the page's edits on it go; for a deleted artboard, it is deleted here too), Keep mine (saved over theirs) or Keep both (the artboard takes theirs; the page's version becomes a new artboard beside it, `<name>-my-copy.dc.html`). A version saved over someone's change records whose change it replaced, and that person gets a notice on the page (Compare, Bring back, Dismiss). Compare shows only what that save replaced, and Bring back puts only that back: the other person's changes elsewhere on the artboard stay, and History says "Partly restored". It goes line by line in the file, so two changes on one line come back together. When that drops a change of theirs, the other person gets "Put my change back", which saves over it and counts as replacing a change again (their notice then brings back only what that replaced). Your changes on disk count too: they go through the same merge, and someone editing that artboard may get the bar with "Agent" and keep theirs, so check the file (or History) when it matters.
+- Asked who changed something, read `<root>/history/index.json`: `versions`, oldest first, each `{n, at, by, user: {name}, changes}` (`by`: `"human"`, `"agent"` for you, `"system"` for the first; `changes`: path → sha256, null for a delete; paths like `project/<name>.dc.html`, `project/canvas.json`), with `restoredFrom` or `overwrote` when it brought a version back or replaced someone's change; a content is `<root>/history/objects/<sha256>`, the file's bytes. To put something back, point the person to History (it records who did it), or write the old content yourself, which makes a version of yours.
+
 ## The references
 
 Under `artifact-type/reference/` in this skill's folder: `format.md` (before a first artboard), `craft.md`, `diagrams.md` (FIRST for diagrams), `print.md` (FIRST for print), `questions.md`, `view-state.md` (before

package/skills/claude-design/scripts/artifact.mjs

@@ -3143,7 +3143,8 @@ async function waitComments(a, flags) {
     let body;
     try {
       const response = await fetch(new URL(`__comments/agent/wait?timeout=${Math.max(1, Math.round(left))}`, state.url), {
-        signal: AbortSignal.timeout((left + 30) * 1e3)
+        // A whole number of ms: AbortSignal.timeout refuses a fraction (and --timeout leaves one in `left`).
+        signal: AbortSignal.timeout(Math.ceil((left + 30) * 1e3))
       });
       if (response.status === 404) {
         throw new CliError(