@dsh-workbench/core 1.0.0-beta.1 → 1.0.1

package/scripts/share-data-root.mjs

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { appendBlocks, parseBlocks, removeBlocks } from './patch-blocks.mjs';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = dirname(SCRIPT_DIR);
+const HOME = process.env.DSH_HOME?.trim() || join(homedir(), '.dsh');
+const PROFILE = process.env.WORKBENCH_PROFILE?.trim() || 'workbench';
+const PROFILE_DIR = join(HOME, 'profiles', PROFILE);
+const RUNTIME_ROOT = process.env.DSH_WORKBENCH_HOME?.trim() || join(HOME, PROFILE);
+const PATCH_PATH = join(PROFILE_DIR, 'cordis.patch.yml');
+const SANDBOX_PATCH = join(PKG_ROOT, 'profile', 'sandbox.patch.yml');
+const MARKER = join(RUNTIME_ROOT, '.data-root-shared');
+
+const DATA_ROOT_IDS = new Set(['session-persistence-jsonl', 'storage-json', 'attachment-local']);
+const OWN_ROOT = /DSH_WORKBENCH_HOME|dshHomePath\(\s*['"]workbench/;
+
+function say(message) {
+  process.stdout.write(`→ ${message}\n`);
+}
+
+function warn(message) {
+  process.stderr.write(`dsh-workbench: ${message}\n`);
+}
+
+function readText(file) {
+  try {
+    return readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function writeAtomic(file, text) {
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, text, 'utf8');
+  renameSync(tmp, file);
+}
+
+function mergeTree(from, to, skip = new Set()) {
+  let stat;
+  try {
+    stat = statSync(from);
+  } catch {
+    return 0;
+  }
+  if (!stat.isDirectory()) return 0;
+  mkdirSync(to, { recursive: true });
+  let count = 0;
+  for (const entry of readdirSync(from, { withFileTypes: true })) {
+    if (entry.name === '.DS_Store' || skip.has(entry.name)) continue;
+    const source = join(from, entry.name);
+    const target = join(to, entry.name);
+    if (entry.isDirectory()) {
+      count += mergeTree(source, target);
+    } else if (entry.isFile() && !existsSync(target)) {
+      copyFileSync(source, target);
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function unionList(left, right) {
+  return [...new Set([...(Array.isArray(left) ? left : []), ...(Array.isArray(right) ? right : [])])];
+}
+
+function sessionIdsOf(entry) {
+  return Array.isArray(entry?.sessionIds) ? entry.sessionIds : [];
+}
+
+function orderedIds(global, table) {
+  const seen = new Set();
+  const ids = [];
+  for (const id of Array.isArray(global?.workspaceIds) ? global.workspaceIds : []) {
+    if (table[id] === undefined || seen.has(id)) continue;
+    ids.push(id);
+    seen.add(id);
+  }
+  for (const id of Object.keys(table)) {
+    if (seen.has(id)) continue;
+    ids.push(id);
+    seen.add(id);
+  }
+  return ids;
+}
+
+function repairWorkspaceOrder(targetFile) {
+  let target;
+  try {
+    target = JSON.parse(readFileSync(targetFile, 'utf8'));
+  } catch {
+    return false;
+  }
+  if (target?.unit?.name !== 'workspace') return false;
+  const table = target.tables?.workspaces ?? {};
+  const global = target.global ?? {};
+  if (global.pendingMutation !== undefined) return false;
+  const before = Array.isArray(global.workspaceIds) ? global.workspaceIds : [];
+  const seen = new Set();
+  const order = [];
+  for (const id of before) {
+    if (table[id] === undefined || seen.has(id)) continue;
+    order.push(id);
+    seen.add(id);
+  }
+  if (global.initialized === true) {
+    for (const id of Object.keys(table)) {
+      if (seen.has(id)) continue;
+      order.push(id);
+      seen.add(id);
+    }
+  }
+  if (order.length === before.length && order.every((id, index) => id === before[index])) return false;
+  target.global = { ...global, workspaceIds: order };
+  writeAtomic(targetFile, `${JSON.stringify(target, null, 2)}\n`);
+  return true;
+}
+
+function mergeWorkspaceList(sourceFile, targetFile) {
+  let source;
+  try {
+    source = JSON.parse(readFileSync(sourceFile, 'utf8'));
+  } catch {
+    return 0;
+  }
+  if (source?.unit?.name !== 'workspace') return 0;
+  if (!existsSync(targetFile)) {
+    mkdirSync(dirname(targetFile), { recursive: true });
+    copyFileSync(sourceFile, targetFile);
+    return 1;
+  }
+  let target;
+  try {
+    target = JSON.parse(readFileSync(targetFile, 'utf8'));
+  } catch {
+    warn(`${targetFile} 读不出来，这次没并项目列表，下次启动再试。`);
+    return null;
+  }
+  if (target?.unit?.name !== 'workspace') return 0;
+  const sourceTable = source.tables?.workspaces ?? {};
+  const targetTable = target.tables?.workspaces ?? {};
+  const sourceGlobal = source.global ?? {};
+  const targetGlobal = target.global ?? {};
+  if (targetGlobal.pendingMutation !== undefined) {
+    warn(`${targetFile} 里有一次没做完的项目操作，这次先不并项目列表，下次启动再试。`);
+    return null;
+  }
+  const idByPath = new Map();
+  const accounted = new Map();
+  for (const [id, entry] of Object.entries(targetTable)) {
+    if (typeof entry?.path === 'string') idByPath.set(entry.path, id);
+    for (const sessionId of sessionIdsOf(entry)) {
+      if (!accounted.has(sessionId)) accounted.set(sessionId, id);
+    }
+  }
+  const order = orderedIds(targetGlobal, targetTable);
+  const idMap = new Map();
+  let added = 0;
+  for (const sourceId of orderedIds(sourceGlobal, sourceTable)) {
+    const entry = sourceTable[sourceId];
+    if (typeof entry?.path !== 'string') continue;
+    const hitId = idByPath.get(entry.path);
+    if (hitId !== undefined) {
+      const hit = targetTable[hitId];
+      const incoming = sessionIdsOf(entry).filter((sessionId) => {
+        const holder = accounted.get(sessionId);
+        return holder === undefined || holder === hitId;
+      });
+      hit.sessionIds = unionList(sessionIdsOf(hit), incoming);
+      for (const sessionId of hit.sessionIds) {
+        if (!accounted.has(sessionId)) accounted.set(sessionId, hitId);
+      }
+      if (typeof entry.updatedAt === 'string' && (typeof hit.updatedAt !== 'string' || entry.updatedAt > hit.updatedAt)) {
+        hit.updatedAt = entry.updatedAt;
+      }
+      idMap.set(sourceId, hitId);
+      continue;
+    }
+    let newId = sourceId;
+    if (targetTable[newId] !== undefined) newId = randomUUID();
+    const sessionIds = [];
+    for (const sessionId of sessionIdsOf(entry)) {
+      if (accounted.has(sessionId)) continue;
+      accounted.set(sessionId, newId);
+      sessionIds.push(sessionId);
+    }
+    targetTable[newId] = { ...entry, sessionIds };
+    idByPath.set(entry.path, newId);
+    order.push(newId);
+    added += 1;
+  }
+  const preferred = targetGlobal.defaultWorkspaceId;
+  const fromSource = idMap.get(sourceGlobal.defaultWorkspaceId) ?? sourceGlobal.defaultWorkspaceId;
+  const defaultWorkspaceId =
+    typeof preferred === 'string' && targetTable[preferred] !== undefined
+      ? preferred
+      : typeof fromSource === 'string' && targetTable[fromSource] !== undefined
+        ? fromSource
+        : undefined;
+  target.tables = { ...(target.tables ?? {}), workspaces: targetTable };
+  target.global = {
+    ...targetGlobal,
+    workspaceIds: order,
+    archivedSessionIds: unionList(targetGlobal.archivedSessionIds, sourceGlobal.archivedSessionIds),
+    pinnedSessionIds: unionList(targetGlobal.pinnedSessionIds, sourceGlobal.pinnedSessionIds),
+  };
+  if (defaultWorkspaceId === undefined) delete target.global.defaultWorkspaceId;
+  else target.global.defaultWorkspaceId = defaultWorkspaceId;
+  writeAtomic(targetFile, `${JSON.stringify(target, null, 2)}\n`);
+  return added;
+}
+
+function repairTarget(targetFile) {
+  if (repairWorkspaceOrder(targetFile)) say(`项目顺序里有对不上的条目，已按实际项目重排（${targetFile}）。`);
+}
+
+function hasEntries(dir) {
+  try {
+    return readdirSync(dir).some((name) => name !== '.DS_Store');
+  } catch {
+    return false;
+  }
+}
+
+function legacyDataExists() {
+  if (resolve(RUNTIME_ROOT) === resolve(HOME)) return false;
+  return (
+    existsSync(join(RUNTIME_ROOT, 'storages', 'workspace.json')) ||
+    hasEntries(join(RUNTIME_ROOT, 'sessions')) ||
+    hasEntries(join(RUNTIME_ROOT, 'attachments'))
+  );
+}
+
+function missingWorkspacePaths() {
+  const sourceFile = join(RUNTIME_ROOT, 'storages', 'workspace.json');
+  const targetFile = join(HOME, 'storages', 'workspace.json');
+  if (!existsSync(sourceFile) || !existsSync(targetFile)) return [];
+  let source;
+  let target;
+  try {
+    source = JSON.parse(readFileSync(sourceFile, 'utf8'));
+    target = JSON.parse(readFileSync(targetFile, 'utf8'));
+  } catch {
+    return [];
+  }
+  if (source?.unit?.name !== 'workspace' || target?.unit?.name !== 'workspace') return [];
+  const have = new Set();
+  for (const entry of Object.values(target.tables?.workspaces ?? {})) {
+    if (typeof entry?.path === 'string') have.add(entry.path);
+  }
+  const missing = [];
+  for (const entry of Object.values(source.tables?.workspaces ?? {})) {
+    if (typeof entry?.path !== 'string' || have.has(entry.path)) continue;
+    missing.push(typeof entry.title === 'string' && entry.title !== '' ? entry.title : entry.path);
+  }
+  return missing;
+}
+
+function mergeDataRoot() {
+  if (resolve(RUNTIME_ROOT) === resolve(HOME)) return { added: 0, files: 0 };
+  const targetWorkspace = join(HOME, 'storages', 'workspace.json');
+  const sourceStorages = join(RUNTIME_ROOT, 'storages');
+  let added;
+  let files = 0;
+  try {
+    added = mergeWorkspaceList(join(sourceStorages, 'workspace.json'), targetWorkspace);
+    if (added === null) return null;
+    files += mergeTree(join(RUNTIME_ROOT, 'sessions'), join(HOME, 'sessions'));
+    files += mergeTree(join(RUNTIME_ROOT, 'attachments'), join(HOME, 'attachments'));
+    files += mergeTree(sourceStorages, join(HOME, 'storages'), new Set(['workspace.json']));
+  } catch (error) {
+    warn(`并回 ${HOME} 时出错：${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+  repairTarget(targetWorkspace);
+  return { added, files };
+}
+
+function writeMarker() {
+  mkdirSync(dirname(MARKER), { recursive: true });
+  writeFileSync(
+    MARKER,
+    `${JSON.stringify({ at: new Date().toISOString(), from: RUNTIME_ROOT, to: HOME }, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+function inspectProfile() {
+  const patch = readText(PATCH_PATH);
+  if (patch === null) return null;
+  const legacy = parseBlocks(patch).filter((block) => DATA_ROOT_IDS.has(block.id));
+  return {
+    patch,
+    ours: legacy.filter((block) => OWN_ROOT.test(block.body)),
+    custom: legacy.filter((block) => !OWN_ROOT.test(block.body)),
+  };
+}
+
+function customRootMessage(state) {
+  return `${PROFILE} 的会话 / 存储根是你自己改过的（${state.custom.map((block) => block.id).join(' / ')}）—— 这次不动它，也不并数据。`;
+}
+
+function applySharedConfig(state) {
+  if (state.custom.length > 0) {
+    warn(customRootMessage(state));
+    return false;
+  }
+  let patch = state.patch;
+  if (state.ours.length > 0) {
+    const first = Math.min(...state.ours.map((block) => block.lineStart));
+    patch = stripIsolationHeader(patch, first);
+    patch = removeBlocks(patch, (block) => DATA_ROOT_IDS.has(block.id) && OWN_ROOT.test(block.body));
+    writeAtomic(PATCH_PATH, patch);
+    say(`数据根改回共用：从 ${PROFILE} 的 profile 里去掉 ${state.ours.map((block) => block.id).join(' / ')}。`);
+  }
+  const hasSandbox = parseBlocks(patch).some((block) => block.id === 'sandbox-policy');
+  if (!hasSandbox) {
+    const sandbox = readText(SANDBOX_PATCH);
+    const row = sandbox === null ? undefined : parseBlocks(sandbox).find((block) => block.id === 'sandbox-policy');
+    if (row !== undefined) {
+      patch = appendBlocks(patch, row.body);
+      writeAtomic(PATCH_PATH, patch);
+    }
+  }
+  repairTarget(join(HOME, 'storages', 'workspace.json'));
+  return true;
+}
+
+function configureDefault() {
+  const state = inspectProfile();
+  if (state === null) return;
+  if (state.custom.length > 0) {
+    warn(customRootMessage(state));
+    return;
+  }
+  if (legacyDataExists() && !existsSync(MARKER)) {
+    warn(`检测到 ${RUNTIME_ROOT} 里还有旧会话 / 项目 / 附件，这次没有自动并。`);
+    warn('要切到共用数据根，先退出所有 dsh，再运行: dsh-workbench migrate');
+    return;
+  }
+  applySharedConfig(state);
+}
+
+function migrate() {
+  const state = inspectProfile();
+  if (state === null) {
+    warn(`找不到 ${PATCH_PATH}，先运行 dsh-workbench setup。`);
+    return 1;
+  }
+  if (state.custom.length > 0) {
+    warn(customRootMessage(state));
+    return 1;
+  }
+  if (!legacyDataExists()) {
+    applySharedConfig(state);
+    say(`没有发现 ${RUNTIME_ROOT} 里的旧数据，数据根已经是共用的。`);
+    return 0;
+  }
+  if (existsSync(MARKER) && !FORCE) {
+    const missing = missingWorkspacePaths();
+    if (missing.length > 0) {
+      say(`已经迁过一次；旧目录里还有 ${missing.length} 个项目不在共用根：${missing.join('、')}。要补并加 --force（这次 profile 保持原样）。`);
+      return 0;
+    }
+    applySharedConfig(state);
+    say('已经迁过一次；要再并一次加 --force。');
+    return 0;
+  }
+  warn('迁移前先退出所有 dsh（:3080 / :3081）；否则正在运行的实例可能覆盖刚并好的数据。');
+  const result = mergeDataRoot();
+  if (result === null) {
+    warn('这次没有迁移；profile 和旧数据都保持原样。');
+    return 1;
+  }
+  writeMarker();
+  applySharedConfig(state);
+  say(`迁移完成：新增 ${result.added} 个项目，补了 ${result.files} 个文件；旧目录保留。`);
+  return 0;
+}
+
+function stripIsolationHeader(text, blockStart) {
+  const lines = text.split('\n');
+  let marker = -1;
+  for (let i = blockStart - 1; i >= 0; i -= 1) {
+    const line = lines[i] ?? '';
+    if (/^#.*会话\s*\/\s*存储隔离层/.test(line)) {
+      marker = i;
+      break;
+    }
+    if (line.trim() !== '' && !line.startsWith('#')) break;
+  }
+  if (marker === -1) return text;
+  lines.splice(marker, blockStart - marker);
+  return lines.join('\n');
+}
+
+const MIGRATE = process.argv.includes('--migrate') || process.argv.includes('migrate');
+const FORCE = process.argv.includes('--force');
+
+const profileManifest = join(PROFILE_DIR, 'package.json');
+if (!existsSync(profileManifest)) process.exit(0);
+
+if (MIGRATE) process.exit(migrate());
+configureDefault();

package/skills/workbench-module-diy/FAMILY.md

@@ -7,7 +7,7 @@
 
 | 要做什么 | 用 |
 |---|---|
-| 认路、装没装、起不起得来 | `_status`（`unit` 可省）；它的「下一步」就是下一件事 |
+| 认路、装没装、起不起得来 | `_status`（`unit` 可省）；它的「下一步」就是下一件事；带 `unit` 时 text 末尾多一条「发布出口：…」 |
 | 卡片空白 / 崩了 / 读不到 | `_panel` |
 | 找 opencli 命令、看命令形状 | `_recon` → `_spec`（`--help -f json` 原样） |
 | kit 有什么 / 令牌叫什么 | `_components`（`bucket` / `name` 取声明；`scope: tokens` 现读 `--dsw-*` / `--wb-*`） |
@@ -45,8 +45,6 @@
 
 ## 4 发布
 
-只在用户明确说「帮我发布」后调。它一次做完预检 → 全门禁 → 按出口发布 → 发后核包，审批一次。
-发布前先 `_changelog` 把这一版写进 `CHANGELOG.md`：没有这一版的记录，`_publish` 会拦下。
-审批屏会把这一版的更新日志按 markdown 展示给用户。
-需要用户接管时返回 `needsUser: { step, text, command? }` 而不抛异常：把 `text` 说给用户、给命令，
-等「好了」再跑；不向用户要 token，不展示 `package.json`。
+只在用户明确说「帮我发布」后调；先 `_changelog` 把这一版写进 `CHANGELOG.md`。
+出口、署名、标题、安装命令由工具与审批屏处理，不用问、不用补。
+需要用户接管时返回 `needsUser: { step, text, command? }`：把 `text` 说给用户，等「好了」再跑；不向用户要 token。

package/skills/workbench-module-diy/SKILL.md

@@ -45,10 +45,9 @@ description: 在工作台里把当前面板调明白，或者给它造一块新
    看 / 动屏前 `workbench_diy_debug_start`（否则整族拒；Desktop 跳过，改用 `read=` / 录制）；`_panel` / `_status` / `read=` 档不用。
    工具全表 [FAMILY.md](FAMILY.md)。走通才 `dsh-wb-module design accept`；走不通如实记"未验"。
    审批项标注「要你真用一次」，不打勾。结论只报：已装、在面板哪一格。
-8. **发布** —— 只在用户说「帮我发布」之后。先确认他已经在真卡片上说过「没问题」（`design accept` 已打勾），
-   并把这一版写进 `CHANGELOG.md`：`workbench_diy_changelog`（`unit=…`，`note=…`；
-   没写这一版 `release` 会拦下），再调 `workbench_diy_publish`（`unit=…`）。只问「给团队用、公开发、还是先给你一个安装包」；
-   不展示 `package.json` / npm / 版本字段，也不要问 token。出口与 `needsUser` 处理见 [WIRING.md](WIRING.md) §5。
+8. **发布** —— 只在用户说「帮我发布」之后：`workbench_diy_changelog`（`note=…`）记这一版 → `workbench_diy_publish`（`unit=…`）。
+   不手改 `package.json`、不补标题/署名、不问出口：工具与审批屏已经处理；他明确点名安装包 / 公开 / git 才传 target。
+   验收没过先 `design accept`；`needsUser` 照 `text` 转述。细节见 [WIRING.md](WIRING.md) §5。
 
 ## 索引
 
@@ -79,5 +78,5 @@ description: 在工作台里把当前面板调明白，或者给它造一块新
 ## 硬约束
 
 - dsh 已有的从 `kit` 拿（`@dsh-workbench/core/client`）；不手搓 DOM + CSS，不直接 import dsh 的包。
-- DIY 模块默认 `private: true`，不发任何源；用户确认后走 `workbench_diy_publish` 发到团队源 / 公网 / 安装包 / git。
+- DIY 模块默认 `private: true`，不发任何源；用户确认后走 `workbench_diy_publish`。
 - 源码零注释（`//`、块注释、`.css` 注释都不许）；说明写模块 `README.md` 或 spec。

package/skills/workbench-module-diy/WIRING.md

@@ -63,16 +63,7 @@ DIY 族仅在选了 DIY 模式的会话出现（按模式，不按工作区）
 默认 `private: true`，不发任何源。用户说「帮我发布」时，**不要手改 `package.json`、不要让他看 npm**，
 走 `workbench_diy_publish`（`unit=…`）：
 
-1. 先确认他已经在真卡片上说过「没问题」，并已跑过 `design accept`（验收 N/N 全勾）。
-   还要把这一版写进 `CHANGELOG.md`：调 `workbench_diy_changelog`（`unit=…`，`note=…`）；
-   没有这一版的记录（或包里没带 `CHANGELOG.md`）时 `release` 会拦下，并给出补的命令。
-2. 工具一次做完预检（登录 / license / git 远端 / 工作区）→ 全门禁 → 按出口发布 → 发后核包。
-   发布审批屏会把这一版的更新日志按 markdown 展示给用户。
-3. 出口只有四种：团队源（配了私源时默认）、公网 npm（必须用户明确说“公开”）、安装包（没私源时默认，
-   零凭据）、git（提交构建产物 + tag + push）。只问「给团队用、公开发、还是先给你一个安装包」；
-   凭据细节由预检接管。
-4. 工具回 `needsUser` 时，照它那句 `text` 对用户说一句，给能照抄的命令，等他说「好了」再跑；
-   **不在对话里要 token / OTP**，不把红字贴给用户。`otp` 交接后用 `workbench_diy_publish` 的 `verify=true`
-   （或 `release --verify`）只核不发。
-5. `dsh-wb-module publish` 仍是**发货前清单**（只 dry run）；`release --dry-run` 只预览；
-   `--verify` 只核已发布的包。公网源必须显式 `--target public` + license，默认只认团队源 / 安装包。
+1. 先把这一版写进 `CHANGELOG.md`（`workbench_diy_changelog`，`note=…`），真卡片验收过（`design accept`）。
+   出口、署名、标题、安装命令都由工具与审批屏处理：不用问、不用补；用户没点名出口就不传 target。
+2. 工具回 `needsUser` 时照 `text` 转述，不在对话里要 token / OTP；`otp` 交接后 `verify=true` 只核不发。
+3. 只改市集元数据（标题 / 作者 / 说明）不升版本：`refresh=true`。

package/dist/types/shared/api/host/git.test.d.ts

@@ -1 +0,0 @@
-export {};

package/profile/isolation.patch.yml

@@ -1,46 +0,0 @@
-# workbench profile 的会话/存储隔离层（片段）。
-#
-# 这个文件是"补丁层片段"，不是独立补丁文件：seed-profile.sh 会把它
-# 追加进 ~/.dsh/profiles/workbench/cordis.patch.yml。
-#
-# 为什么需要它：dsh-base 把会话与存储的根都挂在 $DSH_HOME 上
-# （dshHomePath('sessions') / dshHomePath('storages')），所以默认情况下
-# 两个 profile 共用同一份会话历史。工作台要提供自己的定制工具，等于一个
-# 独立的 agent 环境，共享会话没有意义 —— 这三行把数据分开。
-#
-# 隔离后（默认 profile；新 profile 由 DSH_WORKBENCH_HOME 指到自己的根）：
-#   会话      $DSH_HOME/workbench/sessions/
-#   工作区    $DSH_HOME/workbench/storages/        （workspace 走 storage-domain）
-#   附件      $DSH_HOME/workbench/attachments/v1/
-# 有意不隔离：
-#   凭据      ~/.dsh/.credentials.yaml          （两边共用同一把 API key）
-#
-# 注意：patch 的 config 是整体替换、不深合并。这三行原本各自只声明了
-# root / dshHome，所以只重述这一个字段是安全的；若你给这些行配过别的
-# 字段（例如 session-persistence-jsonl 的 compression），必须一并重述。
-
-- id: session-persistence-jsonl
-  name: '@deepseek-ai/dsh-session-persistence-jsonl'
-  config:
-    root: !!js (process.env.DSH_WORKBENCH_HOME ?? dshHomePath('workbench')) + '/sessions'
-
-- id: storage-json
-  name: '@deepseek-ai/dsh-storage-json'
-  config:
-    root: !!js (process.env.DSH_WORKBENCH_HOME ?? dshHomePath('workbench')) + '/storages'
-
-- id: attachment-local
-  name: '@deepseek-ai/dsh-attachment-local'
-  config:
-    dshHome: !!js process.env.DSH_WORKBENCH_HOME ?? dshHomePath('workbench')
-
-# 可写根：**无会话**的插件命令（市场装模块、自举跑的那几条）回落到它。
-#
-# 跟启动器的 profile/sandbox.patch.yml 同值，两处都在是因为入口不同：启动器每次启动叠
-# 那一层；直接用 `dsh workbench` 起的没有 `--patch`，就靠这一行。两处同值 ⇒ 谁先谁后都不算变更，
-# 不会触发在线重组。**别把它放回 bundle 层**（在线启用会撞 session-controller 的重组竞态，
-# 见 ADR-0037 的 2026-10-22 补记）。
-- id: sandbox-policy
-  config:
-    mode: !!js process.env.DSH_PERMISSION_MODE ?? 'workspace-write'
-    workspaceRoot: !!js process.env.DSH_WORKBENCH_HOME ?? dshHomePath('workbench')