npm - @alpacachen/dsh-kanban - Versions diffs - 1.3.0 → 1.3.1 - Mend

@alpacachen/dsh-kanban 1.3.0 → 1.3.1

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.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -2,171 +2,105 @@
 # dsh-kanban
-**Plan with your AI. See the work move.**
+### Plan with AI. Move work forward visually.
-A shared kanban board for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness), built for both people and agents.
+A collaborative kanban board where you and your AI agent plan, organize, and ship work together—without leaving DeepSeek Harness.
-[简体中文](README.zh.md) · English
+[![npm version](https://img.shields.io/npm/v/@alpacachen/dsh-kanban?color=5b8def&label=npm)](https://www.npmjs.com/package/@alpacachen/dsh-kanban)
+![DeepSeek Harness Plugin](https://img.shields.io/badge/DeepSeek%20Harness-Plugin-7c5cff)
+![License](https://img.shields.io/badge/license-MIT-22c55e)
-</div>
+[简体中文](README.zh.md) · **English**
-Turn a conversation into an actionable plan without copying tasks between your AI assistant and a project tracker. Ask the agent to break down a feature, prioritize a bug, or move finished work—the same changes appear instantly in the **Board** tab, where you can continue organizing everything by hand.
+</div>
 <p align="center">
   <img src="./image.png" alt="dsh-kanban board inside DeepSeek Harness" width="100%">
 </p>
-## Why dsh-kanban?
+## ✨ From conversation to action
+Stop copying AI-generated plans into a separate project tracker. Tell your agent what you want to build, and watch it turn the plan into cards, priorities, labels, and workflow updates on the **Board** tab.
-- **Plan in conversation** — 14 `kanban_*` tools let the agent create and manage cards, lists, and labels.
-- **Stay in control** — edit cards, drag work between lists, reorder your workflow, and filter by priority from the UI.
-- **Keep projects separate** — every DSH workspace gets its own board and persisted data.
-- **Feel at home in DSH** — the board follows the active language and theme, including dark mode.
-- **Install and go** — the browser bundle is prebuilt; no frontend toolchain or native build step is required.
+You can take over at any time—drag a card, refine a note, reorder a list—and the agent immediately works from the same board.
-## Quick start
+| 💬 Plan naturally | 🧭 Stay in control | ⚡ Start instantly |
+| --- | --- | --- |
+| Manage the board with 14 built-in `kanban_*` tools. | Edit, drag, prioritize, label, and filter from the UI. | Install the prebuilt plugin—no frontend setup required. |
+| **🗂️ Keep work separate** | **🌓 Feel at home** | **🤝 Share one source of truth** |
+| Every DSH workspace gets its own board. | Follows your DSH language, theme, and dark mode. | You and the agent always see the same tasks and status. |
-### 1. Install the plugin
+## 🚀 Get started
-Install the published npm package:
+### 1. Install
 ```sh
 dsh plugin --profile web add @alpacachen/dsh-kanban
 ```
-GitHub source checkouts are not a supported installation method because the generated browser bundle is created only by CI for the npm package.
-Restart `dsh web` after installation so the plugin bundle is loaded. To confirm that it was added successfully:
+Restart `dsh web` so the plugin bundle is loaded. You can confirm the installation with:
 ```sh
 dsh --profile web --dump-config
 ```
-The output should include a `dsh-kanban` layer.
+Look for a `dsh-kanban` layer in the output.
+### 2. Open your board
-### 2. Open the board
+Enter any workspace and choose the **Board** tab beside the conversation views. A fresh board starts with four familiar stages:
-Open a workspace and select the **Board** tab next to the conversation views. A new board starts with **Todo**, **In Progress**, **Review**, and **Done**.
+`Todo` → `In Progress` → `Review` → `Done`
-### 3. Plan with the agent
+### 3. Ask your agent to plan
-Try a prompt like:
+Try this:
-> Break the authentication feature into implementation tasks, add one card per step, and mark the security review as P0.
+> Break the authentication feature into implementation tasks, create one card per step, and mark the security review as P0.
-The agent updates the board directly. You can then refine the plan in the UI, or keep working through conversation.
+The cards appear directly on your board. Continue in conversation, or switch to the Board tab and shape the plan by hand.
-## What you can do
+## 🧩 Everything you need to keep work moving
-### From the Board tab
+### On the Board
 - Create, edit, delete, and drag cards between lists
 - Add notes, labels, and P0 / P1 / P2 priorities
-- View a card's activity history: when it was created and by whom, plus label / priority / status changes
-- Create, rename, reorder, and remove lists
-- Create labels and customize their colors
-- Filter the board by priority
-### From a conversation
-The plugin makes these tools available automatically in every workspace conversation:
-| Area | Tools |
-| --- | --- |
-| Board | `kanban_get` |
-| Cards | `kanban_get_card`, `kanban_add_card`, `kanban_update_card`, `kanban_delete_card`, `kanban_move_card` |
-| Lists | `kanban_add_column`, `kanban_rename_column`, `kanban_delete_column`, `kanban_move_column` |
-| Labels | `kanban_get_label`, `kanban_add_label`, `kanban_update_label`, `kanban_delete_label` |
+- Open a card's activity timeline to see when it changed, what changed, and whether you or the agent made the change
+- Track card creation, moves, title and note edits, label changes, and priority changes
+- Send any card to the agent in your current conversation or a new one
+- Create, rename, reorder, and remove workflow lists
+- Create color-coded labels for fast visual scanning
+- Filter the entire board by priority, or manually refresh it whenever needed
-A few more things you can ask:
+### Continue any card with your agent
-- “Summarize what is currently in progress.”
-- “Move ‘Fix login redirect’ to In Progress and set it to P0.”
-- “Add a Blocked list after In Progress.”
-- “Create a red Urgent label and apply it to the release card.”
-## Data and persistence
-Boards are isolated by workspace and stored through the DSH filesystem service as `kanban-board-<workspaceId>.json`. They survive browser refreshes and DSH restarts, and uninstalling the plugin does not delete existing board data.
-### Schema versioning and safe migration
-Persisted files carry a `schemaVersion` field (currently `1`). Files written by older versions (without a version field) are treated as `v0` and are **automatically upgraded the first time the workspace board is opened** — the pre-upgrade file is copied to `kanban-board-<workspaceId>.json.bak-v0` first, then the upgraded file is written back. Future format changes simply bump `SCHEMA_VERSION` and register a step-by-step migration function in `MIGRATIONS` (`index.js`).
-#### Adding a future format version (e.g. v2)
-Migration functions live in `MIGRATIONS` in `index.js` and are pure functions — they transform data only, never touch the filesystem or runtime state. Each step upgrades by exactly one version; `migrateBoard` chains them automatically, so a `v0` file walks `v0 → v1 → v2`. Backups and write-back are handled by the load pipeline.
-```js
-export const SCHEMA_VERSION = 2 // 1) bump the version
-export const MIGRATIONS = {
-  0: (data) => ({ /* existing v0 → v1, unchanged */ }),
-  1: (data) => ({
-    schemaVersion: 2, // 2) output must declare the new version
-    columns: data.columns,
-    labels: data.labels,
-    cards: data.cards.map((c) => ({ ...c, labelId: c.label ?? null })), // e.g. label → labelId
-  }),
-}
-```
+Open a card and choose **Chat with agent**. dsh-kanban carries its ID, title, label, and notes into either the current conversation or a fresh one, so the agent has the context it needs immediately. The content is inserted as an editable draft—it is never sent until you choose to send it.
-If the on-disk shape changes, update `validateBoard` in `index.js` and the client types in `src/client/lib/types.ts` accordingly, and extend the self-checks in `scripts/check-schema.mjs` / `scripts/check-pipeline.mjs`.
+### In conversation
-Abnormal data never makes the board unusable:
+The plugin automatically gives the agent these tools in every workspace:
-- **Corrupt/unparseable files** are backed up to `kanban-board-<workspaceId>.json.corrupt-<timestamp>` and the board opens empty, with a clear notice.
-- **Files from a newer plugin version** (higher `schemaVersion`) are backed up to `kanban-board-<workspaceId>.json.unsupported-v<version>` and left untouched, so no data is destroyed by a downgraded plugin.
-- At plugin startup a **validation scan** checks every board file (parse + version + structure), backs up any corrupt files, and logs a summary.
-Notices from migrations, corruption, or unsupported versions are surfaced both in the agent tool results (`warnings`) and as a banner in the Board tab.
-## How it works
-`dsh-kanban` uses the standard DSH bundle format:
-- `index.js` registers the agent tools and the `/api/kanban` browser endpoint.
-- Both interfaces share one data layer, so the agent and the Board tab always operate on the same board.
-- `cordis.patch.yml` adds the plugin to the selected DSH profile.
-- `lib/client.js` is the prebuilt web client loaded by DSH.
-The client is built with React, TypeScript, Tailwind CSS, shadcn/ui, Radix UI, and dnd-kit. React itself is provided by DSH, keeping the distributed bundle smaller and avoiding duplicate runtimes.
-## Development
-Requirements: Node.js and pnpm.
-```sh
-pnpm install
-pnpm build
-pnpm typecheck
-```
+| Area | Tools |
+| --- | --- |
+| **Board** | `kanban_get` |
+| **Cards** | `kanban_get_card`, `kanban_add_card`, `kanban_update_card`, `kanban_delete_card`, `kanban_move_card` |
+| **Lists** | `kanban_add_column`, `kanban_rename_column`, `kanban_delete_column`, `kanban_move_column` |
+| **Labels** | `kanban_get_label`, `kanban_add_label`, `kanban_update_label`, `kanban_delete_label` |
-For an unminified client bundle while debugging:
+## 💡 Things to ask your agent
-```sh
-node build.mjs --no-minify
-```
+> “Summarize what is currently in progress.”
-Project layout:
+> “Move ‘Fix login redirect’ to In Progress and set it to P0.”
-```text
-index.js              # Host plugin, tools, persistence, and HTTP endpoint
-cordis.patch.yml      # DSH bundle patch
-build.mjs             # Client build script
-src/client/           # React and TypeScript source
-lib/client.js         # Generated locally or by CI; included only in the npm package
-```
-## Contributing
+> “Add a Blocked list after In Progress.”
-Issues and pull requests are welcome. If you are planning a larger change, opening an issue first is a good way to align on the approach before implementation.
+> “Create a red Urgent label and apply it to the release card.”
-## Uninstall
+> “I'm a lawyer. Set up a board for my day-to-day casework, create the workflow stages and labels I’ll need, and keep them up to date as my work evolves.”
-```sh
-dsh plugin --profile web remove @alpacachen/dsh-kanban
-```
+You do not need to design the workflow first. Tell the agent your role, situation, or goal, and it can create suitable stages and labels—then keep refining them as you work.
 ## License

package/README.zh.md CHANGED Viewed

@@ -2,171 +2,105 @@
 # dsh-kanban
-**和 AI 一起规划，在看板上看到进展。**
+### 和 AI 一起规划，让每一步进展清晰可见。
-一个为 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 打造、由你和 Agent 共同维护的项目看板。
+一块真正由你和 AI Agent 共同维护的项目看板——从想法、任务拆解到推进交付，全程无需离开 DeepSeek Harness。
-简体中文 · [English](README.md)
+[![npm version](https://img.shields.io/npm/v/@alpacachen/dsh-kanban?color=5b8def&label=npm)](https://www.npmjs.com/package/@alpacachen/dsh-kanban)
+![DeepSeek Harness Plugin](https://img.shields.io/badge/DeepSeek%20Harness-Plugin-7c5cff)
+![License](https://img.shields.io/badge/license-MIT-22c55e)
-</div>
+**简体中文** · [English](README.md)
-不用再把 AI 给出的计划手动搬进项目管理工具。让 Agent 拆解功能、调整优先级或推进任务，变更会立即出现在 **「看板」**标签页；你也可以随时接手，通过拖拽和编辑继续整理工作。
+</div>
 <p align="center">
   <img src="./image.png" alt="DeepSeek Harness 中的 dsh-kanban 看板界面" width="100%">
 </p>
-## 为什么是 dsh-kanban？
+## ✨ 从一句话，到一块能执行的看板
+不必再把 AI 生成的计划手动搬进项目管理工具。告诉 Agent 你想完成什么，它就能在 **「看板」** 标签页中拆分任务、创建卡片、设置优先级和更新进度。
-- **在对话里完成规划**：14 个 `kanban_*` 工具让 Agent 能直接管理卡片、列表和标签。
-- **一切仍由你掌控**：编辑卡片、跨列拖拽、调整工作流，或按优先级筛选任务。
-- **项目之间互不干扰**：每个 DSH 工作区都有独立看板，并自动持久化数据。
-- **自然融入 DSH**：界面跟随当前语言和主题，也支持暗色模式。
-- **安装后即可使用**：浏览器端已预构建，不需要额外配置前端工具链，也没有原生构建步骤。
+你也可以随时接手：拖动卡片、补充备注、调整列表。你和 Agent 始终面对同一块看板、同一份进度。
-## 快速开始
+| 💬 自然对话 | 🧭 随时掌控 | ⚡ 开箱即用 |
+| --- | --- | --- |
+| 通过 14 个 `kanban_*` 工具直接管理任务。 | 在界面中编辑、拖拽、标记和筛选卡片。 | 浏览器端已预构建，无需配置前端环境。 |
+| **🗂️ 项目隔离** | **🌓 原生体验** | **🤝 实时协作** |
+| 每个 DSH 工作区都有自己的独立看板。 | 自动跟随 DSH 的语言、主题与暗色模式。 | 你做的调整，Agent 立即可见；反之亦然。 |
-### 1. 安装插件
+## 🚀 三步开始使用
-从 npm 安装已发布的包：
+### 1. 安装
 ```sh
 dsh plugin --profile web add @alpacachen/dsh-kanban
 ```
-项目不支持从 GitHub 源码安装，因为生成的浏览器 bundle 只会由 CI 构建并放入 npm 包。
-安装后重启 `dsh web`，让插件 bundle 在启动时加载。可以通过下面的命令确认配置：
+安装后重启 `dsh web`，让插件 bundle 完成加载。你可以用下面的命令确认安装结果：
 ```sh
 dsh --profile web --dump-config
 ```
-如果安装成功，输出中会包含 `dsh-kanban` 配置层。
+如果输出中包含 `dsh-kanban` 配置层，就说明安装成功。
 ### 2. 打开看板
-进入任意工作区，在会话视图旁打开**「看板」**标签页。新看板默认包含 **Todo**、**In Progress**、**Review** 和 **Done** 四个列表。
+进入任意工作区，点击会话视图旁的 **「看板」** 标签页。新看板已经准备好四个常用阶段：
+`Todo` → `In Progress` → `Review` → `Done`
 ### 3. 让 Agent 开始规划
 试试这样说：
-> 把登录功能拆成具体的实现任务，每一步建一张卡片，并把安全审查标为 P0。
+> 把登录功能拆成具体的实现任务，每一步创建一张卡片，并把安全审查标为 P0。
-Agent 会直接更新当前看板。之后你可以在界面中继续调整，也可以留在对话里推进任务。
+任务会直接出现在看板中。你可以继续通过对话推进，也可以切换到看板，用拖拽和编辑完善计划。
-## 你可以做什么
+## 🧩 推进工作需要的能力，都在这里
 ### 在「看板」标签页中
 - 创建、编辑、删除卡片，并将卡片拖到其他列表
 - 为卡片补充备注、标签和 P0 / P1 / P2 优先级
-- 查看卡片的活动记录：创建时间与来源，以及标签、优先级、状态的变更历史
-- 创建、重命名、排序和删除列表
-- 创建标签并自定义颜色
-- 按优先级筛选整个看板
+- 打开卡片活动时间线，查看变更时间、具体内容，以及操作来自你还是 Agent
+- 追踪卡片创建、移动、标题与备注编辑、标签变化和优先级变化
+- 从任意卡片发起对话，在当前会话或新会话中让 Agent 接着处理
+- 创建、重命名、排序和删除工作流列表
+- 创建彩色标签，让不同任务一眼可辨
+- 按优先级筛选整个看板，也可以随时手动刷新
+### 从任意卡片继续与 Agent 协作
+打开卡片并选择 **「与 Agent 聊一聊」**，dsh-kanban 会把卡片 ID、标题、标签和备注带入当前会话或一个新会话，让 Agent 立即获得完整上下文。内容只会填入输入框作为可编辑草稿，由你确认后发送，不会自动提交。
 ### 在对话中
-插件会自动为工作区内的对话提供以下工具：
+插件会自动为每个工作区中的 Agent 提供以下工具：
 | 范围 | 工具 |
 | --- | --- |
-| 看板 | `kanban_get` |
-| 卡片 | `kanban_get_card`、`kanban_add_card`、`kanban_update_card`、`kanban_delete_card`、`kanban_move_card` |
-| 列表 | `kanban_add_column`、`kanban_rename_column`、`kanban_delete_column`、`kanban_move_column` |
-| 标签 | `kanban_get_label`、`kanban_add_label`、`kanban_update_label`、`kanban_delete_label` |
-你还可以这样使用：
-- 「总结一下目前正在进行的任务。」
-- 「把『修复登录跳转』移到进行中，并设为 P0。」
-- 「在进行中后面新增一个阻塞列表。」
-- 「创建一个红色的『紧急』标签，并加到发布卡片上。」
-## 数据与持久化
-看板按工作区隔离，并通过 DSH 文件系统服务保存为 `kanban-board-<workspaceId>.json`。刷新页面或重启 DSH 都不会丢失数据；卸载插件时，已有的看板数据也会保留。
-### 版本化与安全迁移
-持久化文件带 `schemaVersion` 字段（当前为 `1`）。旧版本插件写入的文件（无版本字段）按 `v0` 处理，在**该工作区看板首次打开时自动升级**——先复制出 `kanban-board-<workspaceId>.json.bak-v0` 备份，再写回升级后的文件。后续格式演进只需递增 `SCHEMA_VERSION` 并在 `MIGRATIONS`（`index.js`）里注册逐版本迁移函数。
-#### 新增一个格式版本（以 v2 为例）
-迁移函数写在 `index.js` 的 `MIGRATIONS` 注册表里，必须是**纯函数**——只做数据变换，不触碰文件系统或运行时状态。每步只升级一个版本，`migrateBoard` 会自动串联，v0 文件会依次走 `v0 → v1 → v2`；备份与写回由加载管线处理，无需手写脚本。
-```js
-export const SCHEMA_VERSION = 2 // 1) 递增版本号
-export const MIGRATIONS = {
-  0: (data) => ({ /* 现有 v0 → v1，保持不变 */ }),
-  1: (data) => ({
-    schemaVersion: 2, // 2) 输出必须声明新版本号
-    columns: data.columns,
-    labels: data.labels,
-    cards: data.cards.map((c) => ({ ...c, labelId: c.label ?? null })), // 例如 label → labelId
-  }),
-}
-```
-如果磁盘形状发生变化，同步更新 `index.js` 里的 `validateBoard` 与 `src/client/lib/types.ts` 的客户端类型，并在 `scripts/check-schema.mjs` / `scripts/check-pipeline.mjs` 中补充自检用例。
+| **看板** | `kanban_get` |
+| **卡片** | `kanban_get_card`、`kanban_add_card`、`kanban_update_card`、`kanban_delete_card`、`kanban_move_card` |
+| **列表** | `kanban_add_column`、`kanban_rename_column`、`kanban_delete_column`、`kanban_move_column` |
+| **标签** | `kanban_get_label`、`kanban_add_label`、`kanban_update_label`、`kanban_delete_label` |
-异常数据不会让看板不可用：
+## 💡 你可以直接这样说
-- **损坏/无法解析的文件**：备份为 `kanban-board-<workspaceId>.json.corrupt-<时间戳>`，看板以空板打开，并给出清晰提示。
-- **来自更新版本插件的文件**（`schemaVersion` 更高）：备份为 `kanban-board-<workspaceId>.json.unsupported-v<版本>` 且不改动原文件，避免降级插件破坏新数据。
-- 插件启动时会执行**全量校验扫描**：逐一检查看板文件（解析 + 版本 + 结构），损坏文件立即备份并汇总记录。
+> 「总结一下目前正在进行的任务。」
-迁移、损坏或版本超前的提示会同时出现在 Agent 工具结果（`warnings`）和「看板」标签页的提示横幅中。
+> 「把『修复登录跳转』移到进行中，并设为 P0。」
-## 工作原理
+> 「在进行中后面新增一个阻塞列表。」
-`dsh-kanban` 使用标准的 DSH bundle 格式：
+> 「创建一个红色的『紧急』标签，并加到发布卡片上。」
-- `index.js` 注册 Agent 工具和浏览器端使用的 `/api/kanban` 接口。
-- Agent 与「看板」标签页共享同一套数据层，双方看到的始终是同一块看板。
-- `cordis.patch.yml` 将插件加入指定的 DSH profile。
-- `lib/client.js` 是由 DSH 直接加载的预构建 Web 客户端。
+> 「我是一名律师，请帮我初始化一套适合日常办案的看板，根据工作流程创建阶段列表和常用标签，并随着工作变化持续帮我维护。」
-客户端使用 React、TypeScript、Tailwind CSS、shadcn/ui、Radix UI 和 dnd-kit 构建。React 由 DSH 提供，以减少发布体积并避免重复运行时。
-## 本地开发
-需要准备 Node.js 和 pnpm。
-```sh
-pnpm install
-pnpm build
-pnpm typecheck
-```
-调试时可以生成未压缩的客户端 bundle：
-```sh
-node build.mjs --no-minify
-```
-项目结构：
-```text
-index.js              # 宿主插件、Agent 工具、持久化与 HTTP 接口
-cordis.patch.yml      # DSH bundle 补丁
-build.mjs             # 客户端构建脚本
-src/client/           # React 与 TypeScript 源码
-lib/client.js         # 本地或 CI 生成，仅随 npm 包发布
-```
-## 参与贡献
-欢迎提交 Issue 和 Pull Request。如果准备进行较大的改动，建议先开一个 Issue 讨论目标和实现方式，避免重复工作。
-## 卸载
-```sh
-dsh plugin --profile web remove @alpacachen/dsh-kanban
-```
+不必提前设计好工作流。只需告诉 Agent 你的职业、场景或目标，它就能为你创建合适的阶段和标签，并在后续协作中持续调整。
 ## 开源许可

package/index.js CHANGED Viewed

@@ -6,7 +6,7 @@
  *
  * 职责：
  *  - 按工作区（项目）隔离：boards 以 workspaceId 为键，每个工作区一块独立看板
- *  - 磁盘持久化：经 ctx.fs 写入 <workspaceRoot>/kanban-board-<workspaceId>.json
+ *  - 磁盘持久化：经 ctx.fs 写入 <workspace.path>/.dsh-kanban.json
  *  - 模型工具：经 ctx.tools.register 注册 14 个 kanban_* 工具
  *  - 浏览器数据层：经 ctx.get('webServer') 注册 /api/kanban 前缀路由
  *
@@ -275,41 +275,53 @@ export function apply(ctx) {
   ]
   // ---- 持久化定位 ----
-  const root = () => {
-    const p = getPolicy()
-    return p && typeof p.workspaceRoot === 'string' ? p.workspaceRoot : undefined
+  const BOARD_FILE = '.dsh-kanban.json'
+  const workspaceKey = (workspace) => String(workspace.id || workspace.path)
+  const writePolicyFor = (workspace, session) => {
+    const policy = getPolicy()
+    const resolved =
+      policy && typeof policy.resolve === 'function'
+        ? policy.resolve(session ? { session } : {})
+        : { mode: (policy && policy.defaultMode) || 'workspace-write' }
+    return { ...resolved, workspaceRoot: workspace.path }
   }
-  const fileName = (wsid) => 'kanban-board-' + wsid + '.json'
-  const resolveFile = async (wsid) => {
+  const resolveFile = async (workspace) => {
     const fs = getFs()
     if (!fs) return null
     try {
-      return await fs.resolve(fileName(wsid), root() ? { cwd: root() } : {})
+      return await fs.resolve(BOARD_FILE, { cwd: workspace.path })
     } catch (err) {
-      console.log('dsh-kanban: 解析看板文件失败，退回内存模式：' + ((err && err.message) || err))
+      console.log(
+        'dsh-kanban: 解析工作区看板文件失败 ' + workspaceKey(workspace) + '：' + ((err && err.message) || err),
+      )
       return null
     }
   }
-  const targetOf = async (wsid) => {
-    if (!fileTargets.has(wsid)) fileTargets.set(wsid, await resolveFile(wsid))
-    return fileTargets.get(wsid)
+  const targetOf = async (workspace) => {
+    const key = workspaceKey(workspace)
+    if (!fileTargets.has(key)) fileTargets.set(key, await resolveFile(workspace))
+    return fileTargets.get(key)
+  }
+  const persistedFlag = (workspace) => {
+    const key = workspaceKey(workspace)
+    return fileTargets.has(key) && fileTargets.get(key) !== null
   }
-  const persistedFlag = (wsid) => fileTargets.has(wsid) && fileTargets.get(wsid) !== null
   // ---- 看板读写 ----
-  // 备份原文件为 <文件名>.<suffix>（复制而非移动，保证原文件在写回前始终存在）
-  const backupFile = async (wsid, suffix) => {
+  // 备份原文件为 .dsh-kanban.json.<suffix>（复制而非移动，保证原文件在写回前始终存在）
+  const backupFile = async (workspace, suffix, session) => {
     const fs = getFs()
-    const target = await targetOf(wsid)
+    const target = await targetOf(workspace)
     if (!fs || !target) return null
+    const key = workspaceKey(workspace)
     try {
       const text = await fs.readText(target)
-      const backupTarget = await fs.resolve(fileName(wsid) + '.' + suffix, root() ? { cwd: root() } : {})
-      await fs.writeText(backupTarget, text)
+      const backupTarget = await fs.resolve(BOARD_FILE + '.' + suffix, { cwd: workspace.path })
+      await fs.writeText(backupTarget, text, undefined, undefined, writePolicyFor(workspace, session))
       return backupTarget
     } catch (err) {
-      console.log('dsh-kanban: 备份失败 ' + wsid + ' (' + suffix + ')：' + ((err && err.message) || err))
+      console.log('dsh-kanban: 备份失败 ' + key + ' (' + suffix + ')：' + ((err && err.message) || err))
       return null
     }
   }
@@ -326,14 +338,15 @@ export function apply(ctx) {
   }
   const timestamp = () => new Date().toISOString().replace(/[:.]/g, '-')
-  // 首次访问某工作区时从磁盘加载；异常数据一律不阻塞看板可用性
-  const boardOf = async (wsid) => {
-    let board = boards.get(wsid)
+  // 首次访问某工作区时从该工作区根目录加载；异常数据一律不阻塞看板可用性
+  const boardOf = async (workspace, session) => {
+    const key = workspaceKey(workspace)
+    let board = boards.get(key)
     if (board) return board
     board = { schemaVersion: SCHEMA_VERSION, columns: [], labels: [], cards: [], activities: [], warnings: [] }
-    boards.set(wsid, board)
+    boards.set(key, board)
     const fs = getFs()
-    const target = await targetOf(wsid)
+    const target = await targetOf(workspace)
     let migrated = false
     if (fs && target) {
       try {
@@ -346,19 +359,19 @@ export function apply(ctx) {
           board.cards = parsed.data.cards
           board.activities = Array.isArray(parsed.data.activities) ? parsed.data.activities : []
           migrated = parsed.migrated
-          // 迁移场景：写回前先把迁移前的原文件备份下来，保证可回滚
+          // schema 迁移场景：写回前先把迁移前的原文件备份下来，保证可回滚
           if (parsed.migrated) {
-            await backupFile(wsid, 'bak-v' + parsed.fromVersion)
+            await backupFile(workspace, 'bak-v' + parsed.fromVersion, session)
           }
         } else {
           // 损坏 / 结构无效 / 版本超前：原文件已无法安全读取，先备份再以空板继续
           const suffix =
             parsed.kind === 'unsupported' ? 'unsupported-v' + parsed.version : 'corrupt-' + timestamp()
-          await backupFile(wsid, suffix)
+          await backupFile(workspace, suffix, session)
         }
       } catch (err) {
         // 尚无看板文件（首次使用）或 fs 读取异常，保留默认空板
-        console.log('dsh-kanban: 读取看板失败 ' + wsid + '：' + ((err && err.message) || err))
+        console.log('dsh-kanban: 读取看板失败 ' + key + '：' + ((err && err.message) || err))
       }
     }
     for (const col of board.columns) bumpSeq(col.id)
@@ -370,14 +383,15 @@ export function apply(ctx) {
     if (board.labels.length === 0) {
       board.labels = DEFAULT_LABELS.map((l) => ({ ...l }))
     }
-    // 升级写回：迁移成功即落盘新版本，保证每个文件只迁移一次
-    if (migrated && fs && target) await save(wsid)
+    // schema 升级写回：迁移成功即落盘新版本，保证每个文件只迁移一次
+    if (migrated && fs && target) await save(workspace, session)
     return board
   }
-  const save = async (wsid) => {
+  const save = async (workspace, session) => {
     const fs = getFs()
-    const target = await targetOf(wsid)
-    const board = boards.get(wsid)
+    const target = await targetOf(workspace)
+    const key = workspaceKey(workspace)
+    const board = boards.get(key)
     if (!fs || !target || !board) return
     try {
       await fs.writeText(
@@ -389,9 +403,12 @@ export function apply(ctx) {
           cards: board.cards,
           activities: Array.isArray(board.activities) ? board.activities : [],
         }),
+        undefined,
+        undefined,
+        writePolicyFor(workspace, session),
       )
     } catch (err) {
-      console.log('dsh-kanban: 保存失败 ' + wsid + '：' + ((err && err.message) || err))
+      console.log('dsh-kanban: 保存失败 ' + key + '：' + ((err && err.message) || err))
     }
   }
@@ -449,11 +466,11 @@ export function apply(ctx) {
   }
   // ---- 核心数据操作：工具与浏览器 HTTP 共用同一份逻辑 ----
-  const dispatch = async (wsid, method, args, source) => {
-    const board = await boardOf(wsid)
+  const dispatch = async (workspace, method, args, source, session) => {
+    const board = await boardOf(workspace, session)
     const a = args || {}
     const actor = source === 'agent' ? 'agent' : 'human'
-    const persisted = () => persistedFlag(wsid)
+    const persisted = () => persistedFlag(workspace)
     const result = (extra) => ({ board: cloneBoard(board), persisted: persisted(), warnings: takeWarnings(board), ...extra })
     switch (method) {
@@ -491,7 +508,7 @@ export function apply(ctx) {
             priority: card.priority ?? null,
           },
         })
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Card added to "' + col.title + '"' })
       }
@@ -526,7 +543,7 @@ export function apply(ctx) {
           if (after.priority !== before.priority) {
             record(board, { cardId: card.id, type: 'card_priority_changed', source: actor, field: 'priority', from: before.priority, to: after.priority })
           }
-          await save(wsid)
+          await save(workspace, session)
         }
         return card
           ? result({ message: 'Card updated' })
@@ -540,7 +557,7 @@ export function apply(ctx) {
         if (card) {
           record(board, { cardId: id, type: 'card_deleted', source: actor, meta: { title: card.title } })
         }
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Card deleted' })
       }
@@ -562,7 +579,7 @@ export function apply(ctx) {
         if (fromTitle !== target.title) {
           record(board, { cardId: card.id, type: 'card_moved', source: actor, field: 'columnId', from: fromTitle, to: target.title, meta: { title: card.title } })
         }
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Moved to "' + target.title + '"' })
       }
@@ -570,7 +587,7 @@ export function apply(ctx) {
         const title = str(a.title, '').slice(0, 40) || 'New list'
         board.columns.push({ id: nextId('c'), title })
         record(board, { cardId: null, type: 'column_added', source: actor, meta: { column: title } })
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'List added: "' + title + '"' })
       }
@@ -582,7 +599,7 @@ export function apply(ctx) {
           if (col.title !== before) {
             record(board, { cardId: null, type: 'column_renamed', source: actor, field: 'title', from: before, to: col.title, meta: { column: col.title } })
           }
-          await save(wsid)
+          await save(workspace, session)
         }
         return col ? result({ message: 'List renamed' }) : result({ error: 'List not found' })
       }
@@ -602,7 +619,7 @@ export function apply(ctx) {
           }
         }
         record(board, { cardId: null, type: 'column_deleted', source: actor, meta: { column: deleted.title } })
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'List deleted, cards moved to "' + board.columns[0].title + '"' })
       }
@@ -615,7 +632,7 @@ export function apply(ctx) {
           ? Math.max(0, Math.min(Math.floor(a.toIndex), board.columns.length))
           : board.columns.length
         board.columns.splice(toIndex, 0, col)
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'List order updated' })
       }
@@ -625,7 +642,7 @@ export function apply(ctx) {
         if (findLabel(board, name)) return result({ error: 'Label already exists' })
         board.labels.push({ name, color: normColor(a.color) || '#94a3b8' })
         record(board, { cardId: null, type: 'label_added', source: actor, meta: { label: name } })
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Label added: "' + name + '"' })
       }
@@ -652,7 +669,7 @@ export function apply(ctx) {
             record(board, { cardId: null, type: 'label_color_changed', source: actor, field: 'color', from: beforeColor, to: label.color, meta: { label: label.name } })
           }
         }
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Label updated' })
       }
@@ -668,7 +685,7 @@ export function apply(ctx) {
           }
         }
         record(board, { cardId: null, type: 'label_deleted', source: actor, meta: { label: name } })
-        await save(wsid)
+        await save(workspace, session)
         return result({ message: 'Label deleted' })
       }
@@ -677,27 +694,42 @@ export function apply(ctx) {
     }
   }
-  // ---- 工具执行上下文 -> 工作区 id ----
-  const wsidOfExec = async (exec) => {
+  // ---- 工具执行上下文 / 浏览器 workspaceId -> 工作区 ----
+  const workspaceOfExec = async (exec) => {
     const agent = exec && exec.agent
-    const cwd = agent && agent.session && agent.session.header && agent.session.header.cwd
-    if (typeof cwd === 'string' && cwd) {
-      const registry = getWorkspaceRegistry()
-      if (registry) {
-        try {
-          const ws = await registry.resolveByPath(cwd)
-          if (ws) return ws.id
-        } catch (err) {
-          console.log('dsh-kanban: 解析工作区失败：' + ((err && err.message) || err))
-        }
+    const session = agent && agent.session
+    const cwd = session && session.header && session.header.cwd
+    if (typeof cwd !== 'string' || !cwd) return null
+    const registry = getWorkspaceRegistry()
+    if (registry) {
+      try {
+        const workspace = await registry.resolveByPath(cwd)
+        if (workspace) return workspace
+      } catch (err) {
+        console.log('dsh-kanban: 解析工作区失败：' + ((err && err.message) || err))
       }
     }
-    return 'default'
+    // 未登记到 WorkspaceRegistry 的会话仍以自身 cwd 作为工作区根目录。
+    return { id: 'cwd:' + cwd, path: cwd, title: cwd }
+  }
+  const workspaceOfId = (id) => {
+    const registry = getWorkspaceRegistry()
+    return registry && typeof registry.get === 'function' ? registry.get(id) : undefined
   }
+  const emptyBoardSummary = { columns: [], labels: [], cards: [] }
   const runTool = async (method, args, exec) => {
-    const wsid = await wsidOfExec(exec)
-    const r = await dispatch(wsid, method, args, 'agent')
+    const workspace = await workspaceOfExec(exec)
+    if (!workspace) {
+      return {
+        ok: false,
+        message: 'Cannot determine the current workspace from the tool execution context',
+        board: emptyBoardSummary,
+        warnings: [],
+      }
+    }
+    const session = exec && exec.agent && exec.agent.session
+    const r = await dispatch(workspace, method, args, 'agent', session)
     return {
       ok: !r.error,
       message: r.error || r.message || 'Done',
@@ -715,8 +747,14 @@ export function apply(ctx) {
       const body = raw ? JSON.parse(raw) : {}
       const method = typeof body.method === 'string' ? body.method : 'get'
       const args = body.args || {}
-      const wsid = typeof args.workspaceId === 'string' && args.workspaceId ? args.workspaceId : 'default'
-      const result = await dispatch(wsid, method, args, 'human')
+      const workspaceId = typeof args.workspaceId === 'string' ? args.workspaceId : ''
+      const workspace = workspaceId ? workspaceOfId(workspaceId) : undefined
+      if (!workspace) {
+        res.writeHead(400, { 'content-type': 'application/json' })
+        res.end(JSON.stringify({ error: 'Unknown workspace: ' + (workspaceId || '(missing)') }))
+        return
+      }
+      const result = await dispatch(workspace, method, args, 'human')
       res.writeHead(200, { 'content-type': 'application/json' })
       res.end(JSON.stringify(result))
     } catch (err) {
@@ -753,61 +791,63 @@ export function apply(ctx) {
     }
   }
-  // ---- 启动校验：全量体检看板文件（只读 + 备份损坏文件，不迁移、不加载内存）----
+  // ---- 启动校验：逐个工作区体检 .dsh-kanban.json（只读 + 备份损坏文件）----
   const startupState = { done: false }
   const maybeStartupCheck = () => {
     if (startupState.done) return
-    if (!getFs()) return
+    const registry = getWorkspaceRegistry()
+    if (!getFs() || !registry || typeof registry.list !== 'function') return
     startupState.done = true
     runStartupCheck()
   }
   const runStartupCheck = async () => {
     const fs = getFs()
-    const wsRoot = root()
-    if (!fs || !wsRoot) return
+    const registry = getWorkspaceRegistry()
+    if (!fs || !registry || typeof registry.list !== 'function') return
     try {
-      const dir = await fs.resolve('.', { cwd: wsRoot })
-      const entries = await fs.listDir(dir)
-      const boardFiles = entries.filter(
-        (e) => typeof e.name === 'string' && /^kanban-board-.+\.json$/.test(e.name),
-      )
-      if (boardFiles.length === 0) {
-        console.log('dsh-kanban: 启动校验完成，未发现看板数据文件')
-        return
-      }
+      const workspaces = registry.list()
+      let found = 0
       let corrupt = 0
       let pendingUpgrade = 0
       let unsupported = 0
       let ok = 0
-      for (const entry of boardFiles) {
-        const wsid = entry.name.slice('kanban-board-'.length, -'.json'.length)
+      for (const workspace of workspaces) {
+        const key = workspaceKey(workspace)
         try {
-          const text = await fs.readText(entry.target)
+          const target = await fs.resolve(BOARD_FILE, { cwd: workspace.path })
+          const text = await fs.readText(target)
+          found++
           const parsed = parseBoardText(text)
           if (parsed.ok) {
             if (parsed.migrated) {
               pendingUpgrade++
-              console.log('dsh-kanban: 启动校验 ' + wsid + '：schemaVersion ' + parsed.fromVersion + '，首次打开时将自动升级')
+              console.log('dsh-kanban: 启动校验 ' + key + '：schemaVersion ' + parsed.fromVersion + '，首次打开时将自动升级')
             } else {
               ok++
             }
           } else if (parsed.kind === 'unsupported') {
             unsupported++
-            console.log('dsh-kanban: 启动校验 ' + wsid + '：文件由更新版本插件写入（schemaVersion ' + parsed.version + '）')
+            console.log('dsh-kanban: 启动校验 ' + key + '：文件由更新版本插件写入（schemaVersion ' + parsed.version + '）')
           } else {
             corrupt++
             const suffix = 'corrupt-' + timestamp()
-            const backupTarget = await fs.resolve(entry.name + '.' + suffix, { cwd: wsRoot })
-            await fs.writeText(backupTarget, text)
-            console.log('dsh-kanban: 启动校验 ' + wsid + '：数据文件损坏（' + parsed.kind + '），已备份为 ' + entry.name + '.' + suffix)
+            const backupTarget = await fs.resolve(BOARD_FILE + '.' + suffix, { cwd: workspace.path })
+            await fs.writeText(backupTarget, text, undefined, undefined, writePolicyFor(workspace))
+            console.log('dsh-kanban: 启动校验 ' + key + '：数据文件损坏（' + parsed.kind + '），已备份为 ' + BOARD_FILE + '.' + suffix)
           }
         } catch (err) {
-          console.log('dsh-kanban: 启动校验 ' + wsid + '：检查失败 ' + ((err && err.message) || err))
+          if (!err || (err.code !== 'ENOENT' && err.message !== 'ENOENT')) {
+            console.log('dsh-kanban: 启动校验 ' + key + '：检查失败 ' + ((err && err.message) || err))
+          }
         }
       }
+      if (found === 0) {
+        console.log('dsh-kanban: 启动校验完成，未发现看板数据文件')
+        return
+      }
       console.log(
         'dsh-kanban: 启动校验完成：共 ' +
-          boardFiles.length +
+          found +
           ' 个看板文件，正常 ' +
           ok +
           '，损坏并已备份 ' +
@@ -914,8 +954,10 @@ export function apply(ctx) {
         },
       },
       async execute(args, exec) {
-        const wsid = await wsidOfExec(exec)
-        const r = await dispatch(wsid, 'getCard', args, 'agent')
+        const workspace = await workspaceOfExec(exec)
+        if (!workspace) return { ok: false, message: 'Cannot determine the current workspace from the tool execution context', warnings: [] }
+        const session = exec && exec.agent && exec.agent.session
+        const r = await dispatch(workspace, 'getCard', args, 'agent', session)
         if (r.error) return { ok: false, message: r.error, warnings: Array.isArray(r.warnings) ? r.warnings : [] }
         return { ok: true, message: 'Card ' + String(args.id || '') + ' details', card: r.card, warnings: Array.isArray(r.warnings) ? r.warnings : [] }
       },
@@ -1122,12 +1164,14 @@ export function apply(ctx) {
         },
       },
       async execute(args, exec) {
-        const wsid = await wsidOfExec(exec)
-        const r = await dispatch(wsid, 'get', args, 'agent')
+        const workspace = await workspaceOfExec(exec)
+        if (!workspace) return { ok: false, message: 'Cannot determine the current workspace from the tool execution context', labels: [], warnings: [] }
+        const session = exec && exec.agent && exec.agent.session
+        const r = await dispatch(workspace, 'get', args, 'agent', session)
         const labels = (r.board && r.board.labels) || []
         return {
           ok: true,
-          message: 'Labels (workspace ' + wsid + ')',
+          message: 'Labels (workspace ' + workspaceKey(workspace) + ')',
           labels,
           warnings: Array.isArray(r.warnings) ? r.warnings : [],
         }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@alpacachen/dsh-kanban",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A kanban board plugin for DeepSeek Harness: a 'Board' tab in conversations plus 14 kanban_* AI tools, per-workspace isolation and disk persistence. Built with React, TypeScript, dnd-kit, shadcn/ui and Tailwind CSS.",
   "type": "module",
   "main": "index.js",