dsh-workspace-acl-allow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 张子凌
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# dsh-workspace-acl-allow
+
+DeepSeek Harness 插件。为**你显式声明**的工作区目录预置一条 Windows ACL 授权，使 dsh 的文件沙箱能够正常启动受限执行进程，从而不再需要把会话升权到「完全访问」、也不再弹出升权确认框。
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE) [![npm](https://img.shields.io/npm/v/dsh-workspace-acl-allow.svg?label=npm&labelColor=000000&color=ff4b01)](https://www.npmjs.com/package/dsh-memory-palace) [![DeepSeek Harness:0.1.7-rc.2](https://img.shields.io/badge/DeepSeek%20Harness-0.1.7--rc.2-success.svg?labelColor=4D6BFE)](https://github.com/deepseek-ai/deepseek-harness) [![Desktop: supported](https://img.shields.io/badge/Desktop-supported-success.svg?labelColor=4D6BFE)](#安装)
+
+## 它解决什么问题
+
+**沟槽的deepseek harness**从 0.1.7 起，给 grantWrite 加了 Low 完整性标签，把权限门槛抬高了。
+
+|  | ≤0.1.6 | ≥0.1.7-alpha.1 |
+| --- | --- | --- |
+| grantWrite 写入内容 | 只写 DACL 能力 ACE | ACE + deny + Low 强制标签 |
+| 需要的目录权限 | WRITE_DAC（owner 隐式自带） | 还要 WRITE_OWNER——owner 隐式权限不含它，必须 DACL 显式授予 |
+| 对继承 Modify 的目录 | ✅ 静默成功 | ❌ 必败 Win32 5 |
+
+只被授予「修改」的普通目录不满足这一点，写入会以「拒绝访问」失败，执行进程启动即失败；模型随后按工具说明申请升权，于是每次都要人工确认一次。
+
+本插件在宿主进程内，为你声明过的目录补一条**完全控制**的授权项（其中已包含「修改属主」），使宿主自身那次写入得以通过。
+
+插件**不实现**宿主的授权逻辑：不处理能力标识、不写完整性标签、不改目录属主、不撤销任何权限。
+
+### 如果你也遇到了已下错误则本插件可能/也许/大概能解决你的问题
+| tools error | step error] |
+| --- | --- |
+| ![tools error](assets/tools-error-1.png) | ![step error](assets/tools-error-2.png) |
+
+## 安装
+
+```
+dsh plugin --profile web add dsh-workspace-acl-allow
+```
+
+本仓库为组合包，安装后其配置层会随 profile 一并加载。
+
+## 使用
+
+授权只在你**明确表达意图**时发生，有且只有两个入口：
+
+1. **在 dsh 中添加工作区** —— 工作区记录写入后立即完成授权。插件加载之前就已注册的工作区，会在插件启动时一并补齐。
+2. **在插件页手动新增路径** —— 打开「插件」页 → 本插件 → 详情页底部的「工作区授权白名单」，输入目录路径并新增。适合尚未注册为工作区的目录。
+
+列表中的每条记录都会带回状态：
+
+| 状态 | 含义 |
+|---|---|
+| 已授权 | 授权项已就位 |
+| 授权失败（退出码 …） | 授权未生效；常见原因是目录属主不是当前用户，或当前用户对该目录没有修改 DACL 的权限 |
+| 受保护目录，已拒绝 | 命中内置保护清单，不会被授权（见下） |
+| 目录不存在 | 路径无效 |
+
+每个条目都可以「重新授权」（忽略记录强制重跑一次）或「移除」（只删除本插件的记录，**不会**改动目录上已有的任何权限）。
+
+## 显式原则
+
+插件**不会**接管任何会话的工作目录。会话目录可以直接指向任意位置，插件不会因为在某个目录下开会话就静默放宽它的权限——这类目录需要你自己在插件页声明。这是刻意的取舍：放宽一个目录的权限属于安全敏感动作，必须由人发起。
+
+## 内置保护清单
+
+以下位置**始终拒绝**，无法通过配置或界面解除：
+
+- 盘符根目录
+- 系统目录（Windows 目录、程序文件目录、程序数据目录）
+- 用户配置文件根目录（其下的子目录不受限）
+- 回收站与系统卷信息目录
+
+另外不接受相对路径与网络路径。
+
+## 平台
+
+**仅支持 Windows。** 非 Windows 平台上插件不生效（只记录一条日志）。本项目仅在 Windows 上开发与验证，没有其他平台的实测环境。
+
+## 副作用
+
+- 被处理的目录上，当前用户会从「继承的修改」变为**显式的完全控制**（含修改权限与属主）。以该用户身份运行的任何进程对该目录的权限随之放宽。这与 dsh 工作区模型的既有代价同源——宿主授权成功后同样会留下常驻的授权项与完整性标签。
+- 授权只作用于**工作区根目录一条授权项**，不递归修改子项权限（除非显式开启对应配置）。
+- 移除列表条目不会撤销已生效的授权；撤销由 dsh 自身的授权体系负责。
+
+## 配置
+
+配置写在 profile 的配置层中，安装后即可生效。
+
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `watchWorkspaces` | `true` | 是否订阅工作区新增事件（关闭后只剩手动入口） |
+| `deepGrant` | `false` | 是否递归处理子项。仅在子目录继承被破坏时开启 |
+| `retryCooldownMs` | `3600000` | 授权失败项的冷却时间（毫秒），冷却内不重复尝试 |
+| `excludePaths` | `[]` | 追加的排除模式（支持 `*` 与 `**`），只能追加内置保护项之外的内容 |
+
+### 状态机
+> $DSH_HOME/dsh-workspace-acl-allow/state.json
+
+## 卸载
+
+```
+dsh plugin --profile web remove dsh-workspace-acl-allow
+```
+
+卸载会停止后续授权，但**不会**撤销已经写入目录的授权项。如需清理，请针对具体目录手工移除相应的授权条目。
+
+## 版本历史
+
+- **0.1.0** 
+    - 🔥dsh 新增加工作区自动授权
+    - 🔥UI 插件-dsh-workspace-acl-allow-工作区授权白名单
+    - 🔥UI 显示已授权工作区路径
+    - 🔥UI 支持手动新增 PATH 授权
+
+## License
+
+[MIT](./LICENSE)

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-workspace-acl-allow bundle patch：一个 insert 注册本插件。
+# insert.name 必须是【包名】（dsh plugin add 后由 profile 的 node_modules 解析到 lib/index.js）；
+# insert.id 必须与入口导出的 cordis `name`（'workspace-acl-allow'）一致。
+- insert:
+    - id: workspace-acl-allow
+      name: 'dsh-workspace-acl-allow'

package/lib/client.js

@@ -0,0 +1,300 @@
+window.__ModuleLoader__.load({
+  id: "dsh-workspace-acl-allow",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    let React = require("react");
+
+
+    // ---- 白名单管理块：注册进 plugins.detail.section，仅在本插件自己的详情页渲染 ----
+    // 位置选择说明：plugins.detail.section 是「追加」型座位，渲染在详情页配置区之后，
+    // 因此不与宿主自动生成的配置表单争位；bundle.config / row.config 是「接管」型座位，
+    // 注册它们会让宿主不再自动生成该配置页，故此处不使用。
+    const PACKAGE_NAME = "dsh-workspace-acl-allow";
+    const ROUTE_BASE = "/workspace-acl-allow";
+
+    const CSS = [
+      ".dshacla-root{margin-top:12px;border:.5px solid var(--dsw-alias-border-l4);border-radius:16px;background:var(--dsw-alias-bg-layer-3);padding:16px;font:inherit;color:var(--dsw-alias-label-primary)}",
+      ".dshacla-head{display:flex;align-items:center;gap:12px;flex-wrap:wrap;margin-bottom:4px}",
+      ".dshacla-title{font-size:15px;font-weight:600;line-height:1.4;margin:0}",
+      ".dshacla-desc{font-size:12.5px;line-height:1.6;color:var(--dsw-alias-label-tertiary);margin:0 0 12px}",
+      ".dshacla-meta{margin-left:auto;font-size:12px;color:var(--dsw-alias-label-tertiary);white-space:nowrap}",
+      ".dshacla-knobs{display:flex;flex-wrap:wrap;gap:8px;margin:0 0 12px}",
+      ".dshacla-knob{border:.5px solid var(--dsw-alias-border-l2);border-radius:999px;padding:2px 10px;font-size:11.5px;line-height:18px;color:var(--dsw-alias-label-secondary)}",
+      ".dshacla-add{display:flex;gap:8px;margin-bottom:12px}",
+      ".dshacla-input{flex:1;min-width:0;box-sizing:border-box;border:.5px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px 10px;font:12px/1.6 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-base)}",
+      ".dshacla-input:focus{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}",
+      ".dshacla-btn{appearance:none;border:1px solid transparent;border-radius:8px;padding:5px 14px;font:inherit;font-size:13px;line-height:1.5;cursor:pointer;white-space:nowrap}",
+      ".dshacla-btn:disabled{opacity:.4;cursor:default}",
+      ".dshacla-btn:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}",
+      ".dshacla-btn-primary{background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3)}",
+      ".dshacla-btn-ghost{border-color:var(--dsw-alias-border-l2);background:none;color:var(--dsw-alias-label-secondary)}",
+      ".dshacla-btn-ghost:hover:not(:disabled){color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-label-dimmed)}",
+      ".dshacla-btn-danger{border-color:var(--dsw-alias-border-l2);background:none;color:var(--dsw-alias-label-secondary)}",
+      ".dshacla-btn-danger:hover:not(:disabled){color:#c86464;border-color:#c86464}",
+      ".dshacla-btn-tiny{padding:3px 10px;font-size:12px}",
+      ".dshacla-list{list-style:none;margin:0;padding:0;border-top:.5px solid var(--dsw-alias-border-l2)}",
+      ".dshacla-item{display:flex;align-items:flex-start;gap:10px;padding:10px 0;border-bottom:.5px solid var(--dsw-alias-border-l2)}",
+      ".dshacla-item:last-child{border-bottom:0}",
+      ".dshacla-item-main{flex:1;min-width:0;display:flex;flex-direction:column;gap:4px}",
+      ".dshacla-path{font:12px/1.6 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;word-break:break-all}",
+      ".dshacla-sub{font-size:11.5px;line-height:1.5;color:var(--dsw-alias-label-tertiary);word-break:break-all}",
+      ".dshacla-ops{display:flex;gap:6px;flex:0 0 auto}",
+      ".dshacla-badge{flex:0 0 auto;border-radius:999px;padding:1px 8px;font-size:11px;line-height:17px;font-weight:500;white-space:nowrap;border:.5px solid transparent}",
+      ".dshacla-badge-ok{background:color-mix(in srgb,#5d8a6c 18%,transparent);color:#5d8a6c;border-color:color-mix(in srgb,#5d8a6c 35%,transparent)}",
+      ".dshacla-badge-bad{background:color-mix(in srgb,#c86464 18%,transparent);color:#c86464;border-color:color-mix(in srgb,#c86464 35%,transparent)}",
+      ".dshacla-badge-mute{background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-tertiary);border-color:var(--dsw-alias-border-l2)}",
+      ".dshacla-empty{padding:18px 0;font-size:12.5px;color:var(--dsw-alias-label-tertiary)}",
+      ".dshacla-note{flex:1;min-width:0;font-size:12px;line-height:1.5;color:var(--dsw-alias-label-secondary)}",
+      ".dshacla-note-bad{color:#c86464}",
+    ].join("\n");
+
+    let stylesInjected = false;
+    function injectStyles() {
+      if (stylesInjected) return;
+      stylesInjected = true;
+      const node = document.createElement("style");
+      node.setAttribute("data-dsh-workspace-acl-allow", "");
+      node.textContent = CSS;
+      document.head.appendChild(node);
+    }
+
+    function subjectIsOurs(subject) {
+      if (subject === null || typeof subject !== "object") return false;
+      if (subject.kind !== "bundle" && subject.kind !== "row") return false;
+      const pkg = subject.pkg;
+      return pkg !== null && typeof pkg === "object" && pkg.name === PACKAGE_NAME;
+    }
+
+    // 本地时区时间：按日期落文案须用本地字段，UTC 会跨日错位。
+    function formatTime(value) {
+      if (typeof value !== "number" || !Number.isFinite(value)) return "";
+      const d = new Date(value);
+      const pad = (n) => (n < 10 ? "0" + n : String(n));
+      return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate()) + " "
+        + pad(d.getHours()) + ":" + pad(d.getMinutes()) + ":" + pad(d.getSeconds());
+    }
+
+    function statusLabel(status) {
+      if (typeof status !== "string" || status.length === 0) return "未知";
+      if (status === "granted") return "已授权";
+      if (status === "skipped:missing") return "目录不存在";
+      if (status === "skipped:blacklist") return "受保护目录，已拒绝";
+      if (status === "skipped:not-windows") return "非 Windows";
+      if (status === "skipped:empty") return "空路径";
+      if (status === "skipped:malformed") return "记录异常";
+      if (status === "skipped:workspace-unregistered") return "工作区已移除（不撤权）";
+      if (status === "failed:no-grantee") return "无法解析当前用户";
+      if (status.startsWith("failed:")) return "授权失败（退出码 " + status.slice(7) + "）";
+      if (status.startsWith("skipped:")) return "已跳过（" + status.slice(8) + "）";
+      return status;
+    }
+
+    function statusKind(status) {
+      if (status === "granted") return "ok";
+      if (typeof status === "string" && status.startsWith("failed:")) return "bad";
+      return "mute";
+    }
+
+    async function apiJson(path, init) {
+      const response = await fetch(path, Object.assign({ cache: "no-store", credentials: "same-origin" }, init || {}));
+      const text = await response.text();
+      let data = null;
+      try { data = text.length > 0 ? JSON.parse(text) : null; } catch { /* 非 JSON 响应按空处理 */ }
+      if (!response.ok) {
+        const base = (data && (data.error || data.message)) || (response.status + " " + response.statusText);
+        // 404/405 表示请求落到了宿主的静态兜底，说明插件服务端接口未就位。
+        const hint = response.status === 404 || response.status === 405
+          ? "（宿主的插件接口未就位，请重启 dsh 后重试）"
+          : "";
+        throw new Error(base + hint);
+      }
+      return data;
+    }
+
+    // 变更结果如实回显：未授权/失败/跳过都不入库，只回显，否则界面会以为什么都没发生。
+    function describeOutcome(action, data) {
+      const target = data && typeof data.path === "string" ? data.path : "";
+      if (action === "remove") {
+        return data && data.removed
+          ? { bad: false, text: "已移除条目：" + target + "（未改动目录上已有的权限）" }
+          : { bad: true, text: "该条目不存在：" + target };
+      }
+      const entry = data ? data.entry : null;
+      const status = entry ? entry.status : undefined;
+      if (status === "granted") return { bad: false, text: "已授权：" + target };
+      if (status === "skipped:missing") return { bad: true, text: "未授权（目录不存在）：" + target };
+      if (status === "skipped:blacklist") return { bad: true, text: "未授权（受保护目录，已拒绝）：" + target };
+      if (status === "skipped:not-windows") return { bad: true, text: "未授权（非 Windows 平台）" };
+      if (status === "skipped:empty") return { bad: true, text: "请输入目录路径" };
+      if (typeof status === "string" && status.startsWith("failed:")) {
+        return {
+          bad: true,
+          text: "授权失败（退出码 " + status.slice(7) + "）：" + target
+            + (entry.lastError ? " — " + entry.lastError : ""),
+        };
+      }
+      return { bad: true, text: "未授权：" + target + " → " + statusLabel(status) };
+    }
+
+    function Badge(props) {
+      return React.createElement("span", { className: "dshacla-badge dshacla-badge-" + statusKind(props.status) },
+        statusLabel(props.status));
+    }
+
+    function WhitelistSection(props) {
+      // 详情页对每个主题都会问一次；非本插件主题不渲染任何内容。
+      const ours = subjectIsOurs(props.subject);
+      const [view, setView] = React.useState(null);
+      const [busy, setBusy] = React.useState(false);
+      const [draft, setDraft] = React.useState("");
+      const [note, setNote] = React.useState("");
+      const [noteBad, setNoteBad] = React.useState(false);
+
+      const load = React.useCallback(() => {
+        apiJson(ROUTE_BASE + "/state")
+          .then((data) => { if (data && data.ok) setView(data); })
+          .catch((error) => { setNoteBad(true); setNote("读取失败：" + String(error.message || error)); });
+      }, []);
+
+      React.useEffect(() => {
+        if (!ours) return undefined;
+        load();
+        return undefined;
+      }, [ours, load]);
+
+      if (!ours) return null;
+
+      const run = (action, endpoint, body) => {
+        if (busy) return;
+        setBusy(true);
+        setNote("");
+        setNoteBad(false);
+        apiJson(endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(body || {}),
+        })
+          .then((data) => {
+            const outcome = describeOutcome(action, data);
+            setNoteBad(outcome.bad);
+            setNote(outcome.text);
+            load();
+          })
+          .catch((error) => { setNoteBad(true); setNote("操作失败：" + String(error.message || error)); })
+          .finally(() => setBusy(false));
+      };
+
+      const list = view && Array.isArray(view.whitelist) ? view.whitelist : [];
+      const config = (view && view.config) || {};
+
+      const knobs = React.createElement("div", { className: "dshacla-knobs" },
+        React.createElement("span", { className: "dshacla-knob" },
+          "工作区事件：" + (config.watchWorkspaces === false ? "关" : "开")),
+        React.createElement("span", { className: "dshacla-knob" },
+          "递归子项（/T）：" + (config.deepGrant ? "开" : "关")),
+        React.createElement("span", { className: "dshacla-knob" },
+          "失败冷却：" + Math.round((Number(config.retryCooldownMs) || 0) / 60000) + " 分钟"));
+
+      const rows = list.length === 0
+        ? React.createElement("li", { className: "dshacla-empty" },
+            "还没有条目。在 dsh 中添加工作区，或在此手动新增路径。"
+            + "只有成功授权的目录会进入清单；被拒绝或失败的只看下方结果行。")
+        : list.map((item) => React.createElement("li", { className: "dshacla-item", key: item.path },
+            React.createElement("div", { className: "dshacla-item-main" },
+              React.createElement("span", { className: "dshacla-path" }, item.path),
+              React.createElement("span", { className: "dshacla-sub" },
+                (item.at ? formatTime(item.at) : "—")
+                + (item.attempts ? " · 尝试 " + item.attempts + " 次" : "")
+                + (item.lastError ? " · " + item.lastError : ""))),
+            React.createElement("span", { className: "dshacla-ops" },
+              React.createElement("span", { className: "dshacla-badge dshacla-badge-" + statusKind(item.status) },
+                statusLabel(item.status)),
+              React.createElement("button", {
+                type: "button",
+                className: "dshacla-btn dshacla-btn-ghost dshacla-btn-tiny",
+                disabled: busy,
+                onClick: () => run("regrant", ROUTE_BASE + "/regrant", { path: item.path }),
+              }, "重新授权"),
+              React.createElement("button", {
+                type: "button",
+                className: "dshacla-btn dshacla-btn-danger dshacla-btn-tiny",
+                disabled: busy,
+                onClick: () => run("remove", ROUTE_BASE + "/remove", { path: item.path }),
+              }, "移除"))));
+
+      const supported = view === null || view.supported !== false;
+
+      return React.createElement("section", { className: "dshacla-root", "aria-label": "工作区授权白名单" },
+        React.createElement("div", { className: "dshacla-head" },
+          React.createElement("h3", { className: "dshacla-title" }, "工作区授权白名单"),
+          React.createElement("span", { className: "dshacla-meta" },
+            view === null ? "读取中…" : "共 " + list.length + " 条"),
+          React.createElement("button", {
+            type: "button",
+            className: "dshacla-btn dshacla-btn-ghost dshacla-btn-tiny",
+            disabled: busy,
+            onClick: () => { setNote(""); load(); },
+          }, "刷新")),
+        React.createElement("p", { className: "dshacla-desc" },
+          "只处理此处显式声明的目录：为当前用户补一条完全控制的 ACL 条目，使 dsh 沙箱的授权调用得以通过。"
+          + "本插件不会撤销任何权限，移除条目也不会改动目录上已有的 ACL。"),
+        supported ? null : React.createElement("p", { className: "dshacla-desc" },
+          "当前平台非 Windows，本插件不生效。"),
+        supported ? knobs : null,
+        supported ? React.createElement("div", { className: "dshacla-add" },
+          React.createElement("input", {
+            className: "dshacla-input",
+            type: "text",
+            spellCheck: false,
+            placeholder: "输入目录的绝对路径，回车即授权",
+            value: draft,
+            disabled: busy,
+            onChange: (event) => setDraft(event.target.value),
+            onKeyDown: (event) => {
+              if (event.key !== "Enter") return;
+              const value = draft.trim();
+              if (value.length === 0) return;
+              run("add", ROUTE_BASE + "/add", { path: value });
+              setDraft("");
+            },
+          }),
+          React.createElement("button", {
+            type: "button",
+            className: "dshacla-btn dshacla-btn-primary",
+            disabled: busy || draft.trim().length === 0,
+            onClick: () => {
+              const value = draft.trim();
+              if (value.length === 0) return;
+              run("add", ROUTE_BASE + "/add", { path: value });
+              setDraft("");
+            },
+          }, busy ? "处理中…" : "新增授权")) : null,
+        supported ? React.createElement("ul", { className: "dshacla-list" }, rows) : null,
+        note.length > 0
+          ? React.createElement("p", { className: "dshacla-note" + (noteBad ? " dshacla-note-bad" : "") }, note)
+          : null,
+        view && typeof view.stateFile === "string"
+          ? React.createElement("p", { className: "dshacla-sub" }, "状态文件：" + view.stateFile)
+          : null);
+    }
+
+
+    function apply(ctx) {
+      ctx.effect(() => injectStyles());
+      // 详情页追加区：宿主按主题分发，本块对非本插件主题返回 null。
+      // plugins.detail.section 由 client-ui-plugin-manager 的 main 入口声明，
+      // slots.inject 会等待该座位出现，故无需在 inject 里声明硬依赖。
+      ctx.slots.inject("plugins.detail.section", () => ctx.slots.register({
+        name: "plugins.detail.section",
+        id: "workspace-acl-allow",
+        order: 100,
+      }, WhitelistSection));
+    }
+
+    exports.apply = apply;
+    exports.inject = ["slots"];
+    return module.exports;
+  }
+});

package/lib/index.js

@@ -0,0 +1,627 @@
+// dsh-workspace-acl-allow — 为工作区目录预置 Windows ACL 完全控制 ACE。
+//
+// 背景：dsh 启动受限 worker 前，须对工作区根目录调用一次 SetNamedSecurityInfoW，
+// 同时写入 DACL 与 Low 强制标签。标签位于 SACL，而 owner 的隐式权限只覆盖
+// READ_CONTROL 与 WRITE_DAC，因此该调用要求调用者对目录拥有 WRITE_OWNER；
+// 只授予 Modify 的目录会以 Win32 5（拒绝访问）失败，worker 启动即死。
+//
+// 本插件在宿主进程内向用户**显式声明**的目录补一条 (OI)(CI)F 的 allow ACE
+// （F 含 WRITE_OWNER），使宿主自身那次组合调用得以通过。插件不实现宿主的授权
+// 逻辑：不碰能力 SID、不写强制标签、不改 owner、不撤销任何 ACE。
+//
+// 触发仅两条，均为用户显式意图：① 工作区域新增记录（用户在 dsh 添加工作区）；
+// ② 插件设置页手动新增路径。不监听会话创建，也不接管任何会话 cwd。
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+import Schema from "@deepseek-ai/schemastery";
+
+// cordis 服务名，必须与 cordis.patch.yml 的 insert.id 一致。
+export const name = "workspace-acl-allow";
+
+// 静态声明依赖：webServer 承载设置页的同源路由，webRuntime 提供可信来源清单。
+// 依赖就绪前 fiber 处于等待态而非失败态；这与宿主既有插件（内存宫）的写法一致。
+export const inject = ["webServer", "webRuntime"];
+
+const execFileAsync = promisify(execFile);
+
+const DOMAIN_NAME = "workspace";
+const TABLE_NAME = "workspaces";
+const PACKAGE_NAME = "dsh-workspace-acl-allow";
+const ROUTE_PREFIX = "/workspace-acl-allow";
+const STATE_DIR_NAME = PACKAGE_NAME;
+const STATE_FILE_NAME = "state.json";
+
+/** 授权模板：完全控制，含 WRITE_OWNER，与宿主成功路径留下的形态一致。 */
+const GRANT_TEMPLATE = "(OI)(CI)F";
+
+const IS_WINDOWS = process.platform === "win32";
+
+// 字段一律不加 volatile：不同 profile 解析到的是不同的 schemastery 副本——
+// web profile 落到 profile 自带的旧副本（无该 API），desktop profile 落到全局安装
+// 内嵌的新副本（有该 API）。加了会让 web 侧在加载时抛错，不加则两边都能加载。
+// 代价是配置项不经设置页写回，作为安装期开关由 profile 配置层维护。
+// 读值一律经 unwrap()：无论宿主是否把字段包装成引用都能正确取值。
+export const Config = Schema.object({
+  watchWorkspaces: Schema.boolean()
+    .default(true)
+    .description("订阅工作区新增事件：在 dsh 中添加工作区时自动完成授权。"),
+  deepGrant: Schema.boolean()
+    .default(false)
+    .description("icacls 是否附加 /T 递归处理子项。仅在子目录继承被破坏时开启。"),
+  retryCooldownMs: Schema.number()
+    .default(3600000)
+    .description("授权失败项的冷却时间（毫秒）；冷却内不重试，避免重复触发。"),
+  excludePaths: Schema.array(Schema.string())
+    .default([])
+    .description("追加的排除模式（支持 * 与 ** 通配）。只能追加，不能解除内置系统目录保护。"),
+});
+
+// ---- 同源与可信来源围栏 ----
+// 这些路由开在本机 HTTP 面上：必须拒绝跨站与不可信 Host 发起的请求，
+// 否则任意本机页面或进程都能借道触发一次目录授权。
+
+function headerValue(headers, name) {
+  const value = headers?.[name];
+  if (Array.isArray(value)) return typeof value[0] === "string" ? value[0] : undefined;
+  return typeof value === "string" ? value : undefined;
+}
+
+function isLoopbackHostname(hostname) {
+  if (hostname === "localhost" || hostname === "[::1]") return true;
+  const parts = hostname.split(".");
+  return parts.length === 4 && parts[0] === "127"
+    && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+
+/** 可信条目未带端口时只比主机名，带端口时比完整 authority。 */
+function authorityMatches(hostUrl, entry) {
+  const raw = String(entry).trim();
+  if (raw.length === 0) return false;
+  let entryUrl;
+  try {
+    entryUrl = new URL(`http://${raw}`);
+  } catch {
+    return false;
+  }
+  return /:\d+$/.test(raw) ? entryUrl.host === hostUrl.host : entryUrl.hostname === hostUrl.hostname;
+}
+
+function isTrustedRequest(request, trustedHosts) {
+  const host = headerValue(request?.headers, "host");
+  if (typeof host !== "string" || host.length === 0) return false;
+  let hostUrl;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    return false;
+  }
+  const trusted = Array.isArray(trustedHosts) ? trustedHosts : [];
+  if (!isLoopbackHostname(hostUrl.hostname) && !trusted.some((entry) => authorityMatches(hostUrl, entry))) {
+    return false;
+  }
+  if (headerValue(request.headers, "sec-fetch-site") === "cross-site") return false;
+  const origin = headerValue(request.headers, "origin");
+  if (origin === undefined) return true;
+  try {
+    return new URL(origin).host === hostUrl.host;
+  } catch {
+    return false;
+  }
+}
+
+/** 解包 volatile 配置引用；直接给值时原样返回，两种形态都能读。 */
+function unwrap(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (typeof value.get === "function" && !Array.isArray(value)) return unwrap(value.get());
+  return value;
+}
+
+// ---- 路径规范化 ----
+
+/**
+ * 规范化到真实路径：符号链接、短名、大小写别名收敛为一种拼写。
+ * 规范化只服务于本插件自己的去重键与黑名单比对基准——ACL 操作由 Windows
+ * 自行解析路径，拼写差异不影响授权本身能否成功。
+ * @param {string} target - 目标路径。
+ * @returns {string|null} 真实路径；路径不存在时返回 null。
+ */
+function canonicalize(target) {
+  try {
+    return realpathSync.native(target);
+  } catch {
+    return null;
+  }
+}
+
+/** 比较用的归一形式：统一小写，去掉末尾多余分隔符（保留盘符根）。 */
+function normalizeForCompare(target) {
+  const lowered = target.replace(/\//g, "\\").toLowerCase();
+  if (/^[a-z]:\\$/.test(lowered)) return lowered;
+  return lowered.replace(/\\+$/, "");
+}
+
+// ---- 内置黑名单（配置与 UI 均不可解除） ----
+
+/**
+ * 内置拒绝清单分两类，语义不同，不能混：
+ * - `tree`：自身及其子目录全拒——系统安装目录、程序目录、程序数据目录。
+ * - `self`：仅拒自身——用户配置文件根。其下目录（如 .dsh / .codebuddy 等）是正常的
+ *   工作区位置，整棵子树一并拒掉会误伤。
+ * 盘符根与回收站/系统卷信息不在此列，由 isBuiltinDenied 直接判定。
+ * @returns 两类规范化后的拒绝集合。
+ */
+function builtinDenyList() {
+  const tree = [];
+  const self = [];
+  const push = (list, value) => {
+    if (typeof value === "string" && value.trim().length > 0) list.push(value.trim());
+  };
+  push(tree, process.env.SystemRoot);
+  push(tree, process.env.windir);
+  push(tree, process.env.ProgramFiles);
+  push(tree, process.env["ProgramFiles(x86)"]);
+  push(tree, process.env.ProgramData);
+  push(self, process.env.USERPROFILE);
+
+  const normalize = (value) => {
+    const resolved = resolve(value);
+    const real = canonicalize(resolved);
+    return normalizeForCompare(real ?? resolved);
+  };
+  return { tree: new Set(tree.map(normalize)), self: new Set(self.map(normalize)) };
+}
+
+/** 内置拒绝：盘符根、系统目录、用户配置文件根、回收站与系统卷信息。 */
+function isBuiltinDenied(canonicalPath) {
+  const target = normalizeForCompare(canonicalPath);
+  if (/^[a-z]:\\?$/.test(target)) return true;
+  const segments = target.split("\\");
+  const leaf = segments[segments.length - 1] ?? "";
+  if (leaf === "$recycle.bin" || leaf === "system volume information") return true;
+  const { tree, self } = builtinDenyList();
+  if (self.has(target)) return true;
+  for (const denied of tree) {
+    if (target === denied || target.startsWith(denied + "\\")) return true;
+  }
+  return false;
+}
+
+/** 把简单通配模式编译为正则：** 跨分隔符，* 不跨分隔符。 */
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const source = escaped
+    .replace(/\*\*/g, "\u0000")
+    .replace(/\*/g, "[^\\\\]*")
+    .replace(/\u0000/g, ".*")
+    .replace(/\?/g, "[^\\\\]");
+  return new RegExp("^" + source + "$", "i");
+}
+
+function isConfiguredDenied(canonicalPath, patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0) return false;
+  const target = normalizeForCompare(canonicalPath);
+  for (const raw of patterns) {
+    if (typeof raw !== "string" || raw.trim().length === 0) continue;
+    let compiled;
+    try {
+      compiled = globToRegExp(normalizeForCompare(resolve(raw)).replace(/\\+$/, ""));
+    } catch {
+      continue;
+    }
+    if (compiled.test(target)) return true;
+  }
+  return false;
+}
+
+// ---- 落盘状态（插件自有 JSON，位置由宿主 home-paths 解析，不硬编码） ----
+
+function stateDir() {
+  const home = resolveDshHome();
+  return join(home, STATE_DIR_NAME);
+}
+
+/** 解析 harness home：显式 > $DSH_HOME > ~/.dsh（与宿主同一套优先级）。 */
+function resolveDshHome() {
+  const fromEnv = process.env.DSH_HOME;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) return resolve(fromEnv.trim());
+  return join(homedir(), ".dsh");
+}
+
+function stateFilePath() {
+  return join(stateDir(), STATE_FILE_NAME);
+}
+
+function loadState(logger) {
+  const file = stateFilePath();
+  try {
+    if (!existsSync(file)) return {};
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const records = parsed.records;
+    if (records === null || typeof records !== "object" || Array.isArray(records)) return {};
+    return records;
+  } catch (error) {
+    // 状态文件损坏不影响授权能力，只丢失跨重启短路；从空状态继续。
+    logger.warn(`state file is unreadable, starting empty: ${String(error)}`);
+    return {};
+  }
+}
+
+/** 原子写：先写临时文件再 rename，避免中断留下半截 JSON。 */
+function saveState(records, logger) {
+  try {
+    mkdirSync(stateDir(), { recursive: true });
+    const file = stateFilePath();
+    const temp = file + ".tmp";
+    const payload = { unit: { name: PACKAGE_NAME, version: 1 }, records };
+    writeFileSync(temp, JSON.stringify(payload, null, 2), "utf8");
+    renameSync(temp, file);
+    return true;
+  } catch (error) {
+    logger.warn(`state file write failed: ${String(error)}`);
+    return false;
+  }
+}
+
+// ---- 当前用户 SID ----
+
+let cachedSid;
+
+/** 取当前进程用户的 SID；SID 文本与系统语言无关，icacls 用 *SID 形式可免除名称歧义。 */
+async function currentUserSid() {
+  if (cachedSid !== undefined) return cachedSid;
+  cachedSid = null;
+  try {
+    const { stdout } = await execFileAsync("whoami", ["/user", "/fo", "csv", "/nh"], { windowsHide: true });
+    const matched = /S-\d-(?:\d+-)+\d+/.exec(String(stdout));
+    if (matched !== null) cachedSid = matched[0];
+  } catch {
+    cachedSid = null;
+  }
+  return cachedSid;
+}
+
+/** icacls 的受托者写法：优先 SID，取不到时退回 域\用户名。 */
+async function granteeSpec() {
+  const sid = await currentUserSid();
+  if (typeof sid === "string" && sid.length > 0) return `*${sid}`;
+  const domain = process.env.USERDOMAIN;
+  const username = process.env.USERNAME;
+  if (typeof username === "string" && username.length > 0) {
+    return typeof domain === "string" && domain.length > 0 ? `${domain}\\${username}` : username;
+  }
+  return null;
+}
+
+// ---- 授权执行 ----
+
+async function runGrant(canonicalPath, deepGrant) {
+  const grantee = await granteeSpec();
+  if (grantee === null) {
+    return { status: "failed:no-grantee", lastError: "cannot resolve current user identity" };
+  }
+  const args = [canonicalPath, "/grant", `${grantee}:${GRANT_TEMPLATE}`];
+  if (deepGrant) args.push("/T");
+  try {
+    await execFileAsync("icacls", args, { windowsHide: true, maxBuffer: 4 * 1024 * 1024 });
+    return { status: "granted" };
+  } catch (error) {
+    // 只看退出码，不解析本地化输出；输出原文仅留作诊断。
+    const code = error?.code === undefined ? "exec" : String(error.code);
+    const detail = String(error?.stderr ?? error?.message ?? "").trim().slice(0, 400);
+    return { status: `failed:${code}`, lastError: detail };
+  }
+}
+
+// ---- 插件主体 ----
+
+/**
+ * 打开一次插件实例。所有状态与副作用都由返回的句柄持有，fiber 卸载即失效。
+ * @param {object} ctx - cordis 上下文。
+ * @param {object} config - 已校验的 Config 实例（字段为 volatile 引用）。
+ */
+export function apply(ctx, config) {
+  const logger = ctx.logger;
+
+  if (!IS_WINDOWS) {
+    logger.warn("non-Windows platform: inactive (workspace ACL bootstrapping is Windows-only)");
+    return;
+  }
+
+  let records = loadState(logger);
+  const hot = new Map();
+  const pending = new Map();
+
+  const readConfig = () => ({
+    watchWorkspaces: unwrap(config.watchWorkspaces) !== false,
+    deepGrant: unwrap(config.deepGrant) === true,
+    retryCooldownMs: Number(unwrap(config.retryCooldownMs)) || 3600000,
+    excludePaths: unwrap(config.excludePaths) ?? [],
+  });
+
+  const persist = () => { saveState(records, logger); };
+
+  const recordFor = (canonicalPath) => records[canonicalPath] ?? null;
+
+  function store(canonicalPath, entry) {
+    records[canonicalPath] = entry;
+    hot.set(canonicalPath, entry);
+    persist();
+  }
+
+  /**
+   * 幂等入口：三级短路（内存 → 落盘 granted → 执行 icacls）。
+   * @param {string} target - 待授权目录。
+   * @param {string} reason - 触发来源，仅用于日志。
+   * @param {boolean} force - 忽略短路强制重跑（设置页「重新授权」用）。
+   * @returns {Promise<object>} 该目录的最新状态记录。
+   */
+  async function ensureAcl(target, reason, force = false) {
+    if (!IS_WINDOWS) return { status: "skipped:not-windows", at: Date.now(), attempts: 0 };
+    if (typeof target !== "string" || target.trim().length === 0) {
+      return { status: "skipped:empty", at: Date.now(), attempts: 0 };
+    }
+
+    const resolved = resolve(target.trim());
+    const canonicalPath = canonicalize(resolved);
+    if (canonicalPath === null) {
+      logger.info(`[${reason}] skipped:missing ${resolved}`);
+      return { status: "skipped:missing", at: Date.now(), attempts: 0 };
+    }
+
+    const inFlight = pending.get(canonicalPath);
+    if (inFlight !== undefined && !force) return inFlight;
+
+    const run = (async () => {
+      const { deepGrant, retryCooldownMs, excludePaths } = readConfig();
+
+      if (!force) {
+        const cached = hot.get(canonicalPath);
+        if (cached !== undefined && cached.status === "granted") return cached;
+        const stored = recordFor(canonicalPath);
+        if (stored !== null && stored.status === "granted") {
+          hot.set(canonicalPath, stored);
+          return stored;
+        }
+      }
+
+      // skipped:* 是确定性的（由路径与配置即可推出），不落盘也不进热缓存：
+      // 落盘清单只承载「已声明并尝试授权过」的目录，即 granted 与 failed。
+      if (isBuiltinDenied(canonicalPath) || isConfiguredDenied(canonicalPath, excludePaths)) {
+        logger.warn(`[${reason}] skipped:blacklist ${canonicalPath}`);
+        return { status: "skipped:blacklist", at: Date.now(), attempts: 0 };
+      }
+
+      const previous = recordFor(canonicalPath);
+      if (!force && previous !== null && typeof previous.status === "string"
+        && previous.status.startsWith("failed:")
+        && typeof previous.at === "number" && Date.now() - previous.at < retryCooldownMs) {
+        return previous;
+      }
+
+      const result = await runGrant(canonicalPath, deepGrant);
+      const entry = {
+        status: result.status,
+        at: Date.now(),
+        attempts: (previous?.attempts ?? 0) + 1,
+        ...result.lastError === undefined ? {} : { lastError: result.lastError },
+      };
+      if (result.status === "granted") {
+        logger.info(`[${reason}] granted ${canonicalPath}`);
+      } else {
+        logger.warn(`[${reason}] ${result.status} ${canonicalPath}${entry.lastError ? " :: " + entry.lastError : ""}`);
+      }
+      store(canonicalPath, entry);
+      return entry;
+    })();
+
+    pending.set(canonicalPath, run);
+    try {
+      return await run;
+    } finally {
+      pending.delete(canonicalPath);
+    }
+  }
+
+  // ---- 通道一：工作区域新增记录 ----
+
+  function onDomainChanged(change) {
+    // 三个字段全中才处理：本插件自己的落盘不经过 storage 域，但该过滤仍是防止
+    // 其他域写入（以及未来变化）引发误触发与递归的唯一依据。
+    if (change === null || typeof change !== "object") return;
+    if (change.domain !== DOMAIN_NAME || change.table !== TABLE_NAME) return;
+    if (change.operation !== "put") {
+      if (change.operation === "deleted") {
+        logger.info(`skipped:workspace-unregistered ${typeof change.key === "string" ? change.key : ""}`);
+      }
+      return;
+    }
+    const value = change.value;
+    if (value === null || typeof value !== "object" || typeof value.path !== "string") {
+      logger.warn("skipped:malformed workspace record on domain/changed");
+      return;
+    }
+    // 事件回调只做判重与入队，阻塞 I/O 交给异步链。
+    void ensureAcl(value.path, "workspace-event").catch((error) => {
+      logger.warn(`workspace-event handler failed: ${String(error)}`);
+    });
+  }
+
+  if (readConfig().watchWorkspaces) {
+    ctx.on("domain/changed", onDomainChanged);
+  }
+
+  // ---- 加载时补漏：覆盖插件加载之前已注册的工作区（同属通道一语义） ----
+
+  async function sweepRegistered() {
+    try {
+      const registry = ctx.get("workspaceRegistry");
+      if (registry === undefined || registry === null || typeof registry.list !== "function") return;
+      const list = registry.list();
+      if (!Array.isArray(list)) return;
+      for (const workspace of list) {
+        if (typeof workspace?.path !== "string") continue;
+        await ensureAcl(workspace.path, "sweep");
+      }
+    } catch (error) {
+      logger.warn(`sweep failed: ${String(error)}`);
+    }
+  }
+
+  // ---- 设置页接口 ----
+
+  function snapshotConfig() {
+    const { watchWorkspaces, deepGrant, retryCooldownMs } = readConfig();
+    return { watchWorkspaces, deepGrant, retryCooldownMs };
+  }
+
+  function snapshotWhitelist() {
+    return Object.keys(records)
+      .map((canonicalPath) => ({ path: canonicalPath, ...records[canonicalPath] }))
+      .sort((left, right) => (right.at ?? 0) - (left.at ?? 0));
+  }
+
+  // 新增走短路：已授权目录只登记不重跑 icacls。要强制重跑由「重新授权」按钮触发。
+  async function addPath(target) {
+    return ensureAcl(target, "settings-add", false);
+  }
+
+  function removePath(target) {
+    if (typeof target !== "string" || target.trim().length === 0) return false;
+    const canonicalPath = canonicalize(resolve(target.trim()));
+    const key = canonicalPath ?? resolve(target.trim());
+    hot.delete(key);
+    // 只移除本插件的记录，绝不动目录上已存在的任何 ACE。
+    if (key in records) {
+      delete records[key];
+      persist();
+      logger.info(`whitelist entry removed (no ACE revoked) ${key}`);
+      return true;
+    }
+    return false;
+  }
+
+  /** 变更类响应回带的目标路径；界面靠它把结果讲清楚。 */
+  function targetOf(body) {
+    const value = body?.path;
+    return typeof value === "string" ? value.trim() : "";
+  }
+
+  function sendJson(response, status, payload) {
+    const body = JSON.stringify(payload);
+    response.writeHead(status, {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store",
+      "content-length": Buffer.byteLength(body),
+    });
+    response.end(body);
+  }
+
+  function readJsonBody(request) {
+    return new Promise((resolveBody, rejectBody) => {
+      const chunks = [];
+      let size = 0;
+      request.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 64 * 1024) {
+          rejectBody(new Error("request body too large"));
+          request.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      request.on("end", () => {
+        const text = Buffer.concat(chunks).toString("utf8").trim();
+        if (text.length === 0) { resolveBody({}); return; }
+        try { resolveBody(JSON.parse(text)); } catch (error) { rejectBody(error); }
+      });
+      request.on("error", rejectBody);
+    });
+  }
+
+  function trusted(request, response) {
+    if (isTrustedRequest(request, ctx.webRuntime?.trustedHosts ?? [])) return true;
+    logger.warn(`rejected untrusted request: ${String(request?.url ?? "")}`);
+    sendJson(response, 403, { ok: false, error: "forbidden" });
+    return false;
+  }
+
+  async function handleState(request, response) {
+    if (!trusted(request, response)) return;
+    try {
+      sendJson(response, 200, {
+        ok: true,
+        platform: process.platform,
+        supported: IS_WINDOWS,
+        stateFile: stateFilePath(),
+        config: snapshotConfig(),
+        whitelist: snapshotWhitelist(),
+      });
+    } catch (error) {
+      sendJson(response, 500, { ok: false, error: String(error) });
+    }
+  }
+
+  function makeMutation(handler) {
+    return async (request, response) => {
+      if (!trusted(request, response)) return;
+      if (request.method !== "POST") {
+        response.writeHead(405, { allow: "POST" });
+        response.end();
+        return;
+      }
+      try {
+        const body = await readJsonBody(request);
+        const result = await handler(body);
+        sendJson(response, 200, { ok: true, ...result });
+      } catch (error) {
+        sendJson(response, 500, { ok: false, error: String(error) });
+      }
+    };
+  }
+
+  // 路由注册：依赖已由静态 inject 保证就绪，直接取 ctx.webServer 并由 ctx.effect
+  // 持有注销器；单条路由注册失败只记日志，不带垮整个插件。
+  // 变更类路由一律回带目标路径：客户端要据它把结果讲清楚（命中跳过态时不会入库，
+  // 单看列表会以为什么都没发生）。
+  const routes = [
+    { kind: "exact", path: `${ROUTE_PREFIX}/state`, handler: handleState },
+    {
+      kind: "exact",
+      path: `${ROUTE_PREFIX}/add`,
+      handler: makeMutation(async (body) => ({ path: targetOf(body), entry: await addPath(body?.path) })),
+    },
+    {
+      kind: "exact",
+      path: `${ROUTE_PREFIX}/regrant`,
+      handler: makeMutation(async (body) => ({
+        path: targetOf(body),
+        entry: await ensureAcl(body?.path, "settings-regrant", true),
+      })),
+    },
+    {
+      kind: "exact",
+      path: `${ROUTE_PREFIX}/remove`,
+      handler: makeMutation(async (body) => ({ path: targetOf(body), removed: removePath(body?.path) })),
+    },
+  ];
+
+  ctx.effect(() => {
+    const disposers = [];
+    for (const route of routes) {
+      try {
+        disposers.push(ctx.webServer.register(route));
+      } catch (error) {
+        logger.warn(`route ${route.path} was not registered: ${String(error)}`);
+      }
+    }
+    logger.info(`${ROUTE_PREFIX} routes registered (${disposers.length}/${routes.length})`);
+    return () => { for (const dispose of disposers) dispose(); };
+  }, "workspace-acl-allow: routes");
+
+  logger.info(`ready (state: ${stateFilePath()})`);
+  void sweepRegistered();
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "dsh-workspace-acl-allow",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness 插件：为用户显式声明的工作区目录预置 Windows ACL 完全控制 ACE，补上沙箱授权所需的 WRITE_OWNER 前提，消除危险模式弹框。",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "win32"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-plugin-manager"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/schemastery": ">=3.18.3 <4.0.0",
+    "@deepseek-ai/dsh-storage-domain": "*"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepublishOnly": "npm run build"
+  }
+}