@yangdcm/dsh-expert-team 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -3,6 +3,71 @@
 本包遵循[语义化版本](https://semver.org/lang/zh-CN/)。dsh 宿主版本线的对应关系写在
 `package.json` 的 `engines.dsh` 与 `dsh.compatibility` 里，插件市场按它判断"这个插件跟你的宿主兼不兼容"。
 
+## 1.2.1
+
+**卸载回收覆盖历史副本**（1.2.0 的补丁）
+
+- `/team uninstall` 此前只遍历登记清单，而 **1.2.0 之前铺下的 skill/preset 没有登记过**
+  （那时还没有清单）—— 从 1.1.x 升上来的用户跑它只会得到"没有需要回收的副本"，
+  而 `$DSH_HOME/skills/expert-team` 里的旧副本仍在（`gate:sync` 会一直报漂移）。
+  现在除清单外还会看两个众所周知的自举落点，判据仍是"有戳或身份对得上"，
+  用户自己写的同名内容照样不动。
+## 1.2.0
+
+**安全加固（本机来源守卫）+ 自举安装收口 + 设置接进宿主命名空间**
+
+### 设置接进宿主命名空间
+
+- 插件加载时把设置注册为宿主命名空间 `expert-team`（`ctx.inject(['settings'], …)` 作为优雅降级边界）：
+  - 出现在 **设置 → 插件 → 插件配置**，由宿主按我们给的 schema 渲染 —— schema 由
+    `lib/settings.js` 的 `SETTINGS_SPEC` **生成**（字段/范围/默认值都是单一真源，不抄第二份）；
+  - 随插件市场的**备份与恢复**一起走（市场只备份"profile 插件清单 + 设置"，自造 JSON 不在内）；
+  - 改动**即时生效**：`scope.watch()` → 用同一份 `config` 重算容量上限/轮次上限/档位门，不必重启。
+- `base` 用**当前生效设置**填充 ⇒ 面板一打开看到的就是真正在用的值，**不需要任何一次性迁移**；
+  优先级不变：`schema 默认 < 我们传的 base < 官方面板用户层`。
+- **诚实边界**：`roster.defaultRoles`（角色 id 数组或 null）**不上**官方面板 —— 它在 schemastery 里的
+  表达方式跨版本没把握，一旦 schema 建错宿主会拒绝注册、面板里什么都看不到。该字段继续由浮层设置
+  页签与 `$DSH_HOME/expert-team/settings.json` 负责；写入时**每个字段只进一个存储**
+  （可表达的进宿主、表达不了的进文件），不制造"一个字段两个家"。
+- 宿主没有 settings 服务、或 `@deepseek-ai/schemastery` 解析不到（例如在仓库里跑测试）⇒ 完全回退到
+  `settings.json`，行为与 1.1.x 一致；失败原因会被记下并出声，不静默。
+- `POST /settings` 响应新增 `settingsSource: 'host' | 'file'`，便于排查"这次改到底写哪儿了"。
+
+### 自举安装收口
+
+- **skill 改为运行时注册**（`ctx.skills.register`）：默认**一个文件都不再写到 `$DSH_HOME/skills`**，
+  相对资源用 `resourceBase` 指回包内目录。宿主没有 skill 注册表时才回退到复制（行为与 1.1.x 相同）。
+  宿主优先级是 项目条目 > 运行时条目 > 用户根，因此运行时注册还能压过历史遗留的旧副本。
+- **preset 仍走复制**（宿主 `dsh-agent-presets` 没有"运行时加扫描根"的 API，roots 只来自配置），
+  但现在：① 带**版本戳** `.expert-team-version`，升级后**整目录重铺**（旧实现"存在即 return"，
+  于是插件升级后运行时永远停在旧副本，且没有任何报错）；② 登记到
+  `$DSH_HOME/expert-team/installed.json`；③ 只在目标**确属本插件产物**时才覆盖
+  （用户自己写的同名 preset 不认、不动）。
+- 新增 **`/team uninstall`**：回收本插件铺到 `$DSH_HOME` 的副本（skill/preset 与清单本身），
+  **只删带我们戳或身份可判定为本插件产物的目录**，用户内容一律保留并如实列出；幂等。
+  它不碰工作区里的 `team/` 运行目录，也不碰插件包本身（那由插件市场卸载）。
+- `scripts/check-sync.mjs`：skill 那一份副本改为**可选目标** —— 1.2.0 起它默认不存在，
+  再按硬性目标比对就会在正常安装上误报漂移。
+
+### 安全加固
+
+**安全加固：浮层路由的本机来源守卫 + `/file` 走宿主策略**
+
+- 11 条浮层路由（`/state` `/artifact` `/codeidx` `/file` `/decide` `/plan` `/plan/approve`
+  `/plan/discard` `/task` `/metrics/refresh` `/settings`）此前只校验 HTTP 方法，现在在**唯一的注册入口**
+  `registerLocal` 上统一套 `localOnly` 守卫：
+  - `Host` 非回环 ⇒ 403 —— 挡 **DNS rebinding**（攻击页把自己的域名解析到 127.0.0.1 后即为同源）
+  - **写方法**的 `Origin` 非回环 ⇒ 403 —— 挡跨站写入；GET 刻意放行，因为浏览器不会把无 CORS 头的
+    响应体交给跨站页面，而放行它能保住 `/team canvas --watch` 生成的 `file://` 页面（`Origin: null`）
+  - `socket.remoteAddress` 非回环 ⇒ 403 —— 挡局域网（宿主配 `host: 0.0.0.0` 时）
+  - **写方法** `content-type` 非 `application/json` ⇒ 415 —— 挡 form / text-plain 这类不触发预检的简单请求
+  - 三条规则都**只在相应头部存在时生效**：浏览器必然带 Host、POST 必然带 Origin，而本地非浏览器
+    客户端本就能自造头部（插件没有鉴权模型，这一点写在 README 的已知限制里）
+- `/file`：有宿主 `ctx.fs` 时改走宿主策略（`resolve` + `readText`），**策略拒绝时如实报 403，
+  不再退回裸 `readFile`**；响应新增 `source: 'host-fs' | 'node-fs'` 便于排查
+- 新增棘轮：`routes-shared.test.mjs` 断言 `lib/command.js` 里真正调用宿主 `register` 的地方只有
+  `registerLocal` 内部那一处、11 条路由全部声明 `methods` —— 新加路由不可能忘记加固
+
 ## 1.1.1
 
 **兼容性声明 + 可移植性修复**（不含功能变更）

package/README.en.md

@@ -74,8 +74,23 @@ cd ~/.dsh/profiles/web
 pnpm install && dsh web
 ```
 
-> The first `/team` run idempotently bootstraps the `expert-team` skill and the
-> 「专家团模式」 preset into `$DSH_HOME/skills/` and `$DSH_HOME/.agent-presets/`.
+> **The skill is never copied to disk**: when the plugin loads it registers the `expert-team` skill as a
+> **runtime entry** in the host skill registry (relative resources resolve through `resourceBase` back into
+> the package), so nothing appears under `$DSH_HOME/skills/` — uninstalling stays clean. Only when the host
+> has no skill registry does it fall back to copying.
+>
+> **The 「专家团模式」 preset is still copied** into `$DSH_HOME/.agent-presets/` (the host offers no
+> runtime API to add a preset scan root), but it carries a version stamp and is re-materialised in full on
+> upgrade instead of silently going stale. `/team uninstall` reclaims the copies this plugin laid down —
+> it only removes directories carrying our stamp, and never touches content you authored yourself.
+>
+> **Where settings live**: on load the plugin registers its settings as the host namespace `expert-team`,
+> so they appear under **Settings → Plugins → Plugin configuration** and take effect immediately (limits,
+> round caps and the tier gate are recomputed in-process — no restart), and they travel with the plugin
+> market's **backup and restore**. **Honest boundary**: the default roster (an array of role ids) is *not*
+> on the official page — its value type cannot be expressed reliably in the host schema, so it stays with
+> the overlay's settings tab and `$DSH_HOME/expert-team/settings.json`. On a host with no settings service
+> every setting falls back to that file.
 
 ## Quick start
 
@@ -128,12 +143,18 @@ npm run check:name      # verify no placeholder package name is left behind
 
 ## Known limitations
 
-- **The local HTTP routes do not yet validate Origin/Host**: the 11 overlay routes (including
-  `/file`, which can only read workspace files) currently check the HTTP method only. Keep `dsh web`
-  bound to `127.0.0.1`; same-origin hardening is planned.
+- **The local routes are guarded, but that is not authentication**: all 11 overlay routes now check
+  `Host` (blocks DNS rebinding), the `Origin` of write requests (blocks cross-site writes), and the
+  client address (blocks non-loopback clients); write requests must also send `application/json`
+  (blocks form / text-plain "simple requests" that never trigger a preflight). `/file` now goes through
+  the host `ctx.fs` policy and reports 403 instead of falling back to a raw read when the policy denies it.
+  **Residual risk, stated plainly**: a local non-browser process can forge any header, and dsh plugins
+  have no authentication model — so do not expose `dsh web` to an untrusted network (with
+  `host: 0.0.0.0` the guard only stops clients without a loopback address).
 - **Web profile only**: the overlay and routes need `webServer`. The command and artifacts still work without it.
 - **Preset drift**: the bundled 「专家团模式」 is a copy of the official `standard` preset plus the role
-  tools; upstream preset restructuring needs a matching update here.
+  tools; upstream preset restructuring needs a matching update here. Upgrades re-materialise it by version
+  stamp, and `/team uninstall` reclaims it (a same-named preset you authored yourself is left alone).
 - Calls `git status --porcelain` (read-only) to judge artifact freshness.
 
 ## License

package/README.md

@@ -71,8 +71,19 @@ cd ~/.dsh/profiles/web
 pnpm install && dsh web
 ```
 
-> 首次 `/team` 会幂等地把 `expert-team` skill 与「专家团模式」preset 自举到
-> `$DSH_HOME/skills/` 与 `$DSH_HOME/.agent-presets/`。
+> **skill 不落地**：插件加载时就把 `expert-team` skill 作为**运行时条目**注册进宿主的 skill 注册表
+> （相对资源用 `resourceBase` 指回包内目录），所以 `$DSH_HOME/skills/` 下不会出现副本 ——
+> 卸载即干净。宿主没有 skill 注册表时才会回退为复制到 `$DSH_HOME/skills/`。
+>
+> **「专家团模式」preset 仍会复制**到 `$DSH_HOME/.agent-presets/`（宿主没有"运行时加扫描根"的
+> API），但带版本戳：升级后整目录重铺，不会静默停在旧版本。用 `/team uninstall` 可回收本插件
+> 铺下的副本（只删带我们版本戳的目录，用户自己写的同名内容一律保留）。
+>
+> **设置在哪改**：插件加载时把设置注册成宿主命名空间 `expert-team` ⇒ 出现在
+> **设置 → 插件 → 插件配置**，改动**即时生效**（上限/轮次/档位门在进程内重算，不必重启），
+> 并且随插件市场的**备份与恢复**一起走。**诚实边界**：`默认班底`（角色 id 数组）不在官方页面里
+> —— 它的取值类型在宿主 schema 里表达不可靠，继续由浮层设置页签与
+> `$DSH_HOME/expert-team/settings.json` 负责；宿主没有 settings 服务时，全部设置退回该文件。
 
 ## 快速上手
 
@@ -81,6 +92,7 @@ pnpm install && dsh web
 /team --persist 重构订单模块            # 持久化活团队：成员可反复指挥、跨会话恢复
 /team --no-code 评审现有 API 设计       # 只产出计划/评审/测试工件，不改代码
 /team --confirm 大改版需求              # 先建 run、不自动派工，浮层点「执行」才开工
+/team uninstall                         # 回收本插件铺到 $DSH_HOME 的副本（skill 默认走运行时注册，本就不落地）
 /team status                            # 所有 run 的阶段、成员、模型计划、实时违规
 /team resume <run-id>                   # 跨会话恢复
 ```
@@ -123,11 +135,16 @@ dsh 安装里插件自带的 Config schema（dsh 路径自动探测，可用 `DS
 
 ## 已知限制
 
-- **本地 HTTP 路由尚未做同源/Host 校验**：浮层用的 11 条路由（含只能读工作区文件的 `/file`）
-  目前只校验 HTTP 方法。请把 dsh web 保持监听 `127.0.0.1`；同源加固在计划中。
+- **本机来源守卫已就位，但不是鉴权**：11 条浮层路由现在统一校验 Host（挡 DNS rebinding）、
+  写方法的 Origin（挡跨站写入）、客户端地址（挡局域网），写方法还要求 `application/json`
+  （挡 form / text-plain 这类不触发预检的"简单请求"）；`/file` 改走宿主 `ctx.fs` 策略，
+  读被策略拒绝时如实报 403 而**不退回裸读**。
+  **残余风险如实说明**：本地非浏览器进程本来就能自造任意请求头，而 dsh 插件没有鉴权模型 ——
+  所以别把 `dsh web` 暴露到不可信网络（宿主配置 `host: 0.0.0.0` 时，守卫只挡住"没有回环地址"的客户端）。
 - **仅 web profile**：浮层与路由依赖 `webServer`；无浮层时命令与工件仍然可用。
 - **preset 漂移**：随包的「专家团模式」是官方 `standard` preset 的拷贝 + 角色工具，
-  宿主若调整内置 preset 结构，需要同步更新。
+  宿主若调整内置 preset 结构，需要同步更新。升级插件时会按版本戳整目录重铺；
+  `/team uninstall` 可回收它（用户自己写的同名 preset 不会被碰）。
 - 会调用 `git status --porcelain`（只读）用于工件新鲜度判断。
 
 ## License

package/lib/command-parse.js

@@ -57,6 +57,7 @@ export const USAGE = [
   '  /team settle [<run>]               清算冷启动后「没人做」的在飞任务（→ pending + attempt+1 + 留痕）',
   '  /team wait [<run>]                 查看在飞任务进展（不阻塞；无进展超 5 分钟会提示）',
   '  /team clear [<run>]                清理一个或全部 run',
+  '  /team uninstall                    回收本插件铺到 $DSH_HOME 的副本（skill 现默认走运行时注册，本就不落地）',
 ].join('\n');
 
 // ── command parsing ────────────────────────────────────────────────────────
@@ -117,6 +118,8 @@ export function parseTeamCommand(rawInput) {
   }
   if (lower === 'clear') return { kind: 'clear' };
   if (lower.startsWith('clear ')) return { kind: 'clear', run: input.slice(6).trim() };
+  // 卸载收口：把本插件铺到 $DSH_HOME 的副本（历史 skill/preset）收回来
+  if (lower === 'uninstall' || lower === '卸载') return { kind: 'uninstall' };
   // L3-2′ 可清算：显式清算冷启动后的搁浅任务（回 pending + attempt+1 + 留痕）
   if (lower === 'settle') return { kind: 'settle', run: null };
   if (lower.startsWith('settle ')) return { kind: 'settle', run: input.slice(7).trim() };

package/lib/command.js

@@ -27,7 +27,7 @@ import { createWriteTracer, formatConflict } from './write-tracer.js';
 import { createLoopGuard } from './loop-guard.js';
 // C 线第 17 项：派工即回写（派工成功后由**代码**把任务置 in_progress + owner，不靠模型记得改）。
 import { createDispatchLedger } from './dispatch-ledger.js';
-import { readRequestBody, withRoute } from './routes/shared.js';
+import { readRequestBody, withRoute, localOnly } from './routes/shared.js';
 import { renderMetrics } from './metrics/render.js';
 // E 线 E1/E2：首产物耗时（`first-runnable` − `run:started`）与收尾预算（实现期 vs 冻结后收尾）。
 // 时钟算术**只此一份** —— 两处各写一遍等于故意埋一次「一个事实多份拷贝」（本仓头号返工源）。
@@ -71,6 +71,9 @@ import {
 import { USAGE, resolveProfile, parseTeamCommand } from './command-parse.js';
 // F 线：设置控制台的 spec / 校验 / 合并（纯函数模块，UI 表单结构也由它生成）。
 import { SETTINGS_GROUPS, SETTINGS_SPEC, defaultSettings, normalizeSettings, mergeSettings, settingsSchema, compilePolicy, policyBlockFrom } from './settings.js';
+// 宿主设置命名空间接线（1.2.0）：设置进官方面板 + 随市场备份恢复 + 改动即时生效。
+// 模块内部用**动态 import** 取 schemastery，因此本仓在没有 profile 的环境里照样能跑测试。
+import { installHostSettings, hostValues, hostScope, hostSettingsNote, updateHostSettings, pickFileOnly, pickHostExpressible, HOST_SETTINGS_NAMESPACE, buildHostSchema, hostBase, hostSchemaPaths } from './host-settings.js';
 
 /**
  * 工件写入的受控入口（批 2-1）。
@@ -87,6 +90,13 @@ import { SETTINGS_GROUPS, SETTINGS_SPEC, defaultSettings, normalizeSettings, mer
 let WRITER_IDENTITY = null;
 const writerEvents = (e) => { try { pushActivityEvent(e); } catch { /* 观测不该影响写入 */ } };
 let ARTIFACT = createArtifactWriter({ fsPort: nodeFsPort(), onEvent: writerEvents, identity: () => WRITER_IDENTITY });
+/**
+ * 已被接管的宿主 `ctx.fs`（若宿主提供）。**只在读路径（`/file`）里用**。
+ *
+ * 为什么单独留一个引用：工件写入从批 2-1 起就走宿主策略了，但浮层的文件预览一直在用裸
+ * `readFile` —— 同一台机器上两套读规则，等于绕开宿主的 fs 策略（观察策略/沙箱）。
+ */
+let ADOPTED_HOST_FS = null;
 
 /** 让宿主 `ctx.fs` 接管写入（若可用）；返回是否接管成功。 */
 function adoptHostFs(ctx) {
@@ -94,6 +104,7 @@ function adoptHostFs(ctx) {
     const hostFs = ctx && typeof ctx.get === 'function' ? ctx.get('fs') : null;
     if (hostFs && typeof hostFs.writeText === 'function' && typeof hostFs.resolve === 'function') {
       ARTIFACT = createArtifactWriter({ fsPort: cordisFsPort(hostFs), onEvent: writerEvents, identity: () => WRITER_IDENTITY });
+      ADOPTED_HOST_FS = hostFs;
       return true;
     }
   } catch { /* 宿主 fs 不可用则保持回退实现 */ }
@@ -441,6 +452,12 @@ const THIS_DIR = dirname(fileURLToPath(import.meta.url));
 // Single source of truth: the skill + its assets ship inside the bundle and are
 // copied verbatim into the user skill root on demand.
 const SKILL_SRC = new URL('../skills/expert-team/', import.meta.url);
+/**
+ * 包内 skill 目录的**规范化绝对路径**（去掉 URL→路径留下的尾部分隔符）。
+ * 尾斜杠看着无害，但它会被原样塞进 `resourceBase.path` 传给宿主，也可能让按字符串比较路径的
+ * 消费方（以及我们自己的测试）判不等 —— 归一化一次，比在每个使用点各修一遍可靠。
+ */
+const SKILL_DIR = fileURLToPath(SKILL_SRC).replace(/[\\/]+$/, '');
 const TEMPLATES_SRC = new URL('../skills/expert-team/assets/templates/', import.meta.url);
 // The `expert-team` agent preset (role subagent tool instances) ships alongside
 // the skill and is copied into the user preset root so the roster can discover it.
@@ -499,10 +516,28 @@ function loadSettingsSync() {
   return SETTINGS_CACHE;
 }
 
-/** 取当前设置（读失败也返回默认，不抛）。 */
+/**
+ * 取当前设置（读失败也返回默认，不抛）。
+ *
+ * **"设置"这一档的唯一读取口**：宿主命名空间可用时，以它的解析值为准
+ * （构成为 `schema 默认 < 我们传入的 base < 官方面板用户层`），再用文件补上宿主表达不了的字段
+ * （如 `roster.defaultRoles` —— 见 host-settings.js 里为什么它不上官方面板）。
+ * 宿主不可用时，与 1.1.x 完全一致：直接读 `settings.json`。
+ */
 function currentSettings() {
-  return (SETTINGS_CACHE || loadSettingsSync()).settings;
+  const file = (SETTINGS_CACHE || loadSettingsSync()).settings;
+  const host = hostValues();
+  if (!host) return file;
+  const merged = mergeSettings(file, host);
+  if (merged.ok) return merged.value;
+  // 宿主给了我们认不出的键（schema 漂移）⇒ 如实出声一次，然后按文件值走，绝不静默改语义
+  if (!HOST_SETTINGS_WARNED) {
+    HOST_SETTINGS_WARNED = true;
+    console.warn('[expert-team] 宿主设置里有本插件认不出的键，已退回 settings.json：' + merged.errors.slice(0, 3).join('；'));
+  }
+  return file;
 }
+let HOST_SETTINGS_WARNED = false;
 
 /** 设置 → 容量上限的**基础值**（优先级最低的一档：config > env > 设置 > 内置默认）。 */
 function limitsBaseFromSettings(s = currentSettings()) {
@@ -514,6 +549,28 @@ function roundLimitsBaseFromSettings(s = currentSettings()) {
   return { maxReviewRounds: s.gates.maxReviewRounds, maxTestRounds: s.gates.maxTestRounds };
 }
 
+/** 插件加载时传给 `apply(ctx, config)` 的 config（重算时要沿用，不能丢覆写）。 */
+let PLUGIN_CONFIG = {};
+
+/**
+ * 用**当前设置**重算三处派生值：容量上限、轮次上限、档位门。
+ *
+ * 为什么需要它：这三处在 1.1.x 里只在 `apply()` 时算一次，于是"设置改了要重启才生效"。
+ * 现在官方面板/浮层改设置都会走到这里 ⇒ 不重启即生效。用 `PLUGIN_CONFIG` 而不是空对象，
+ * 是为了让 `config` 覆写（优先级最高的一档）在重算后依然压得住设置值。
+ */
+function reapplySettingsDerived() {
+  try {
+    const s = currentSettings();
+    resolveLimits(PLUGIN_CONFIG, limitsBaseFromSettings(s));
+    resolveRoundLimits(PLUGIN_CONFIG, roundLimitsBaseFromSettings(s));
+    resolveTierGate(PLUGIN_CONFIG, s.gates);
+    return true;
+  } catch (e) {
+    console.warn('[expert-team] 重算设置派生值失败（保持上一次生效值）：' + String(e && e.message ? e.message : e));
+    return false;
+  }
+}
 
 function teamRoot(cwd) {
   return join(cwd, 'team');
@@ -666,36 +723,213 @@ async function copyDir(src, dest) {
   }
 }
 
+// ── 自举安装的收口（2026-09-14）─────────────────────────────────────────────
+//
+// 背景：skill 与「专家团模式」preset 一直靠"首次 /team 时复制到 $DSH_HOME"就位。两个真问题：
+//   ① **静默过期**：旧实现是"目标存在就直接 return"，于是插件升级后运行时永远停在旧副本
+//      （改了 skill 却在真实会话里不生效，且没有任何报错 —— 本仓最隐蔽的一类假完成）；
+//   ② **卸载残留**：插件市场卸载只删 node_modules，$DSH_HOME 下那份副本会留下：
+//      一个孤儿 skill，以及一个"选中就报错"的 preset。
+// 现在：skill 改为**运行时注册**（一个文件都不写，见 registerRuntimeSkill）；preset 因为宿主
+// 没有"运行时加扫描根"的 API（`dsh-agent-presets` 的 roots 只来自配置），仍走复制，但加
+// **版本戳**（升级即整目录重铺）并**登记到清单**，由 `/team uninstall` 精确回收 ——
+// 且只回收带我们戳（或身份可判定为本插件产物）的目录，绝不删用户自己写的同名内容。
+
+/** 本插件版本，用作副本的版本戳（从包内 package.json 读，避免 ESM import JSON 的兼容问题）。 */
+const PLUGIN_VERSION = (() => {
+  try {
+    return String(JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version || '0.0.0');
+  } catch { return '0.0.0'; }
+})();
+/** 版本戳文件名：目录里出现它，就说明这个目录是**本插件铺的**。 */
+const INSTALL_STAMP = '.expert-team-version';
+/** 已铺副本的登记表（供 `/team uninstall` 精确回收）。 */
+function installedManifestPath() { return join(dshHome(), 'expert-team', 'installed.json'); }
+
+/** 解析 SKILL.md 的 YAML frontmatter（只支持本文件实际使用的单行标量）。 */
+function parseSkillMarkdown(text) {
+  const src = String(text ?? '');
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(src);
+  if (!m) return { meta: {}, body: src };
+  const meta = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let v = kv[2].trim();
+    if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) v = v.slice(1, -1);
+    if (v) meta[kv[1]] = v;
+  }
+  return { meta, body: src.slice(m[0].length) };
+}
+
+/** 组装"运行时 skill"注册对象；读不到就返回 null（调用方回退到复制）。 */
+function buildSkillRegistration() {
+  const { meta, body } = parseSkillMarkdown(readFileSync(new URL('SKILL.md', SKILL_SRC), 'utf8'));
+  if (!meta.name || !body.trim()) return null;
+  const reg = {
+    name: meta.name,
+    description: meta.description || '',
+    content: body,
+    source: 'runtime',
+    resourceBase: { kind: 'directory', path: SKILL_DIR },
+    metadata: { plugin: '@yangdcm/dsh-expert-team', version: PLUGIN_VERSION },
+  };
+  if (meta.whenToUse) reg.whenToUse = meta.whenToUse;
+  return reg;
+}
+
+/** 运行时 skill 是否注册成功（成功 ⇒ 不再往 $DSH_HOME 写任何 skill 文件）。 */
+let RUNTIME_SKILL_REGISTERED = false;
+
+/**
+ * 把 skill 作为**运行时条目**注册进宿主的 skill 注册表。
+ * 宿主优先级为 项目条目 > 运行时条目 > 用户根 ⇒ 运行时注册还能压过 `$DSH_HOME/skills` 里的历史副本。
+ */
+function registerRuntimeSkill(ctx) {
+  try {
+    const skills = ctx && typeof ctx.get === 'function' ? ctx.get('skills') : null;
+    if (!skills || typeof skills.register !== 'function') return false;
+    const reg = buildSkillRegistration();
+    if (!reg) return false;
+    const dispose = skills.register(reg);
+    RUNTIME_SKILL_REGISTERED = true;
+    if (typeof ctx.effect === 'function') ctx.effect(() => dispose);
+    console.log('[expert-team] skill 已作为运行时条目注册（不再写入 $DSH_HOME/skills）');
+    return true;
+  } catch (e) {
+    console.warn('[expert-team] 运行时注册 skill 失败，回退到自举复制：' + String(e && e.message ? e.message : e));
+    return false;
+  }
+}
+
+async function pathExists(p) { try { await stat(p); return true; } catch { return false; } }
+async function readTextSafe(p) { try { return await readFile(p, 'utf8'); } catch { return null; } }
+
+/** 记下"这个目录是本插件铺的"（卸载据此精确回收）。 */
+async function recordInstalled(kind, dir) {
+  const p = installedManifestPath();
+  try {
+    let cur = {};
+    try { cur = JSON.parse(await readFile(p, 'utf8')) || {}; } catch { cur = {}; }
+    cur[kind] = { path: dir, version: PLUGIN_VERSION, at: new Date().toISOString() };
+    await mkdir(dirname(p), { recursive: true });
+    await ARTIFACT.must(p, JSON.stringify(cur, null, 2) + '\n');
+  } catch (e) {
+    // 登记失败不该让安装本身失败，但**绝不能静默** —— 清单缺失会让 `/team uninstall` 回收不到
+    // 这次铺的副本（那正是"卸载残留"这个坑本身）。如实告警并给出路径。
+    console.warn(`[expert-team] 未能登记已铺副本（${kind}: ${dir}）→ /team uninstall 可能回收不到它：${String(e && e.message ? e.message : e)}`);
+  }
+}
+async function readInstalled() {
+  try { return JSON.parse(await readFile(installedManifestPath(), 'utf8')) || {}; } catch { return {}; }
+}
+
+/**
+ * 这个目录是否可以安全地当成"本插件的副本"来覆盖/删除。
+ * 判据两条，任一成立即可：① 带我们的版本戳；② 身份可判定为本插件产物
+ * （1.2.0 之前铺的副本没有戳 —— 不认它们，升级时就永远刷不掉旧 skill）。
+ */
+async function isOwnedCopy(dir, kind) {
+  if ((await readTextSafe(join(dir, INSTALL_STAMP))) !== null) return true;
+  if (kind === 'skill') {
+    const md = await readTextSafe(join(dir, 'SKILL.md'));
+    if (md === null) return false;
+    return parseSkillMarkdown(md).meta.name === 'expert-team';
+  }
+  const yml = await readTextSafe(join(dir, 'agent.cordis.yml'));
+  return yml !== null && /tool-subagent-pm/.test(yml);
+}
+
+/**
+ * `/team uninstall`：回收本插件铺到 `$DSH_HOME` 的副本（skill / preset）。
+ * 安全规则：**只回收"本插件的副本"** —— 用户自己写的同名 preset/skill 不带我们的戳、
+ * 身份也对不上，绝不会被删。工作区里的 `team/` 运行目录与插件包本身都不动。
+ */
+async function uninstallInstalled() {
+  const rec = await readInstalled();
+  const removed = [];
+  const skipped = [];
+  const seen = new Set();
+  /**
+   * 回收一个候选目录（幂等；只删"本插件的副本"）。
+   * 为什么要 `seen`：清单里的路径与下面两个**历史默认路径**可能重合，重复 rm 会把
+   * "已回收"报两遍，也会让第二次那条 `pathExists` 失败被误记成"保留"。
+   */
+  const reclaim = async (kind, dir) => {
+    if (!dir || seen.has(dir)) return;
+    seen.add(dir);
+    if (!(await pathExists(dir))) return;
+    if (await isOwnedCopy(dir, kind)) {
+      try { await rm(dir, { recursive: true, force: true }); removed.push(`${kind}：${dir}`); }
+      catch (e) { skipped.push(`${kind}：${dir}（删除失败：${String(e && e.message ? e.message : e)}）`); }
+    } else {
+      skipped.push(`${kind}：${dir}（不是本插件的副本 ⇒ 保留）`);
+    }
+  };
+
+  for (const [kind, info] of Object.entries(rec)) await reclaim(kind, info && info.path);
+
+  // 1.2.0 之前的副本**没有登记过**（那时还没有清单）—— 而它们恰恰是这个命令最该处理的历史遗留。
+  // 所以除了清单，还要看两个众所周知的自举落点；判据仍是 `isOwnedCopy`（无戳时按身份判定），
+  // 用户自己写的同名 skill/preset 依旧不会被删。
+  await reclaim('skill', join(dshHome(), 'skills', 'expert-team'));
+  await reclaim('preset', join(dshHome(), '.agent-presets', 'expert-team'));
+
+  try { await rm(installedManifestPath(), { force: true }); } catch { /* 清单删不掉就留着 */ }
+  const lines = ['# /team uninstall', ''];
+  lines.push(removed.length ? '已回收：' : '没有需要回收的副本。');
+  for (const r of removed) lines.push('- ' + r);
+  if (skipped.length) { lines.push('', '保留（未删除）：'); for (const s of skipped) lines.push('- ' + s); }
+  lines.push(
+    '',
+    '说明：skill 现在默认走**运行时注册**，本来就不写盘；这里回收的是历史版本留下的副本，',
+    '或宿主没有 skill 注册表时的回退副本。',
+    '本命令不碰工作区里的 `team/` 运行目录，也不碰插件包本身（那由插件市场卸载）。',
+  );
+  return { kind: 'success', text: lines.join('\n') };
+}
+
 async function ensureSkillInstalled() {
+  // 运行时注册成功 ⇒ 一个文件都不写（默认路径；也是"卸载即干净"的前提）
+  if (RUNTIME_SKILL_REGISTERED) return SKILL_DIR;
   const target = join(dshHome(), 'skills', 'expert-team');
-  try {
-    await readFile(join(target, 'SKILL.md'));
-    return target; // already present
-  } catch {
-    /* missing → copy from bundle */
+  if (await pathExists(target)) {
+    if (!(await isOwnedCopy(target, 'skill'))) {
+      console.warn('[expert-team] $DSH_HOME/skills/expert-team 已存在且不像本插件的产物，未覆盖');
+      return target;
+    }
+    const fresh = (await readTextSafe(join(target, INSTALL_STAMP)))?.trim() === PLUGIN_VERSION
+      && ((await readTextSafe(join(target, 'SKILL.md'))) || '').trim().length > 0;
+    if (fresh) return target;
+    // 旧版本副本：整目录重铺（逐个覆盖会留下新版本已删除的文件）
+    try { await rm(target, { recursive: true, force: true }); } catch { /* 删不掉就试着覆盖 */ }
   }
   try {
-    await copyDir(fileURLToPath(SKILL_SRC), target);
+    await copyDir(SKILL_DIR, target);
+    await ARTIFACT.must(join(target, INSTALL_STAMP), PLUGIN_VERSION + '\n');
+    await recordInstalled('skill', target);
     return target;
-  } catch (err) {
-    return null; // best-effort; the agent can still run from the bundle path if present
-  }
+  } catch { return null; }
 }
 
 async function ensurePresetInstalled() {
   const target = join(dshHome(), '.agent-presets', 'expert-team');
-  try {
-    await readFile(join(target, 'agent.cordis.yml'));
-    return target; // already present
-  } catch {
-    /* missing → copy from bundle */
+  if (await pathExists(target)) {
+    if (!(await isOwnedCopy(target, 'preset'))) {
+      console.warn('[expert-team] $DSH_HOME/.agent-presets/expert-team 已存在且不是本插件所铺，未覆盖（用户的定制优先）');
+      return target;
+    }
+    const fresh = (await readTextSafe(join(target, INSTALL_STAMP)))?.trim() === PLUGIN_VERSION
+      && ((await readTextSafe(join(target, 'agent.cordis.yml'))) || '').trim().length > 0;
+    if (fresh) return target;
+    try { await rm(target, { recursive: true, force: true }); } catch { /* 删不掉就试着覆盖 */ }
   }
   try {
     await copyDir(fileURLToPath(PRESET_SRC), target);
+    await ARTIFACT.must(join(target, INSTALL_STAMP), PLUGIN_VERSION + '\n');
+    await recordInstalled('preset', target);
     return target;
-  } catch (err) {
-    return null; // best-effort
-  }
+  } catch { return null; }
 }
 
 // ── scaffold ───────────────────────────────────────────────────────────────
@@ -4163,6 +4397,7 @@ async function executeTeamCommand(ctx, invocation) {
     case 'resume': return resumeRun(ctx, invocation, cwd, c.run);
     case 'rules': return rulesRun(cwd, c.action, c.rule);
     case 'clear': return clearRuns(cwd, c.run);
+    case 'uninstall': return uninstallInstalled();
     case 'settle': return settleRuns(cwd, c.run, ctx);
     case 'wait': return waitRun(cwd, c.run);
     case 'create': return createRun(ctx, invocation, cwd, c);
@@ -4174,9 +4409,12 @@ async function executeTeamCommand(ctx, invocation) {
 /** 并发写追踪器：**进程级单例**（跨工具调用累积；`_live` 暴露以便单测重置与断言）。 */
 const WRITE_TRACER = createWriteTracer();
 
-export const _live = { pushActivity, phaseAccountingViolations, loggedPhases, authorityViolations, WRITE_TRACER, createWriteTracer, formatConflict, summarizeTool, parseLogLine, roleOfSub, mapRoleToSub, membersFromState, buildRoleSubMap, resolveSubRoles, childSessionTiming, SUB_HEADER_CACHE, workflowEventIndex, workflowChildLabels, workflowChildMeta, workflowRuns, WF_EVENT_CACHE, rememberSessionRun, sessionRunFor, runOwnerSession, SESSION_RUNS, parseTeamCommand, deriveMemberEntries, schemaViolations, runHealth, RUN_STALL_MS, scaffoldFingerprint, SCAFFOLD_REQUIRED, strandedTasks, settleStranded, IN_FLIGHT_STATUSES, normalizeCoverage, SCHEMA_WARN_SEEN, pushActivityEvent, DEFAULT_LIMITS, LIMITS, resolveLimits, capacityViolations, DEFAULT_ROUND_LIMITS, ROUND_LIMITS, ROUND_LIMIT_ENV, resolveRoundLimits, ROUND_LIMIT_OF_KIND, roundOf, isQualityTask, normTitle, roundLimitViolations, reworkLoopWriteGuard, mutateTasks, readStandingRules, appendStandingRule, rulesRun, scopeOverlapWarnings, applyTaskStatus, waitRun, eventFamily, verdictFromToken, normalizeRoleName, truncateCodepoints, filterRunScopedSubs, runCreatedAtMs, runLogTail, liveFiles, LIVE_FILES_CACHE, DEFAULT_ROLES, resolveTierGate, TIER_GATE_ENV, snapshotRun, settingsPath, loadSettingsSync, currentSettings, limitsBaseFromSettings, roundLimitsBaseFromSettings, effectiveTierGate: () => TIER_GATE };
+export const _live = { pushActivity, phaseAccountingViolations, loggedPhases, authorityViolations, WRITE_TRACER, createWriteTracer, formatConflict, summarizeTool, parseLogLine, roleOfSub, mapRoleToSub, membersFromState, buildRoleSubMap, resolveSubRoles, childSessionTiming, SUB_HEADER_CACHE, workflowEventIndex, workflowChildLabels, workflowChildMeta, workflowRuns, WF_EVENT_CACHE, rememberSessionRun, sessionRunFor, runOwnerSession, SESSION_RUNS, parseTeamCommand, deriveMemberEntries, schemaViolations, runHealth, RUN_STALL_MS, scaffoldFingerprint, SCAFFOLD_REQUIRED, strandedTasks, settleStranded, IN_FLIGHT_STATUSES, normalizeCoverage, SCHEMA_WARN_SEEN, pushActivityEvent, DEFAULT_LIMITS, LIMITS, resolveLimits, capacityViolations, DEFAULT_ROUND_LIMITS, ROUND_LIMITS, ROUND_LIMIT_ENV, resolveRoundLimits, ROUND_LIMIT_OF_KIND, roundOf, isQualityTask, normTitle, roundLimitViolations, reworkLoopWriteGuard, mutateTasks, readStandingRules, appendStandingRule, rulesRun, scopeOverlapWarnings, applyTaskStatus, waitRun, eventFamily, verdictFromToken, normalizeRoleName, truncateCodepoints, filterRunScopedSubs, runCreatedAtMs, runLogTail, liveFiles, LIVE_FILES_CACHE, DEFAULT_ROLES, resolveTierGate, TIER_GATE_ENV, snapshotRun, settingsPath, loadSettingsSync, currentSettings, limitsBaseFromSettings, roundLimitsBaseFromSettings, effectiveTierGate: () => TIER_GATE, ensureSkillInstalled, ensurePresetInstalled, uninstallInstalled, buildSkillRegistration, parseSkillMarkdown, PLUGIN_VERSION, INSTALL_STAMP, runtimeSkillRegistered: () => RUNTIME_SKILL_REGISTERED, installHostSettings, hostValues, hostScope, hostSettingsNote, updateHostSettings, pickFileOnly, pickHostExpressible, buildHostSchema, hostBase, hostSchemaPaths, reapplySettingsDerived, currentSettings, mergeSettings };
 
 export function apply(ctx, config) {
+  // 留一份 config：设置在运行时改变（官方面板 / 浮层）时要**用同一份 config** 重算上限与档位门，
+  // 否则 config 覆写会在重算时被悄悄丢掉（"改了设置，用户配的 config 上限没了"这种伤最难查）。
+  PLUGIN_CONFIG = config || {};
   // F 线：先读设置（同步、一次性）—— 它是**最低优先级**的来源（config > env > 设置 > 内置默认）。
   const settingsRepairs = loadSettingsSync().repaired;
   if (settingsRepairs.length) {
@@ -4193,6 +4431,15 @@ export function apply(ctx, config) {
   // 机会式探测而非 inject —— 见 ARTIFACT 声明处的说明（inject 缺失服务会让整条命令挂不上）。
   const hostFsAdopted = adoptHostFs(ctx);
   if (hostFsAdopted) console.log('[expert-team] 工件写入已接管宿主 ctx.fs 版本栅栏');
+  // skill 走**运行时注册**（不写盘）：这是默认路径，也是"卸载即干净"的前提。
+  // 宿主没有 skill 注册表时返回 false，`/team` 会退回自举复制（行为与从前一致）。
+  registerRuntimeSkill(ctx);
+  // 设置注册到宿主命名空间：官方面板可改、随市场的备份/恢复走、改动即时生效（watch → 重算）。
+  // `base` 用**当前生效设置**填充 ⇒ 面板一打开看到的就是真正在用的值，不需要任何一次性迁移。
+  installHostSettings(ctx, {
+    base: currentSettings(),
+    onResolved: () => reapplySettingsDerived(),
+  });
   void loadSessionRuns(); // session→run memory for overlay auto-select
   ctx.commands.register({
     name: 'team',
@@ -4378,9 +4625,24 @@ export function apply(ctx, config) {
     try {
       ctx.inject(['webServer'], (wctx) => {
         wctx.effect(() => {
-          const dispose = wctx.webServer.register({
+          /**
+           * 注册一条**只服务本机同源**的路由。
+           *
+           * 为什么要有这层包装：这 11 条路由以前各自决定要不要校验来源，实际结果是**一条都没校验**
+           * （只校验了 HTTP 方法）。把守卫放在唯一的注册入口上，"新加一条路由"就不可能忘记加固 ——
+           * routes-shared.test.mjs 里还有一条棘轮盯着这里不许再出现裸的 register。
+           *
+           * methods 走行内字段：它决定守卫对哪些方法做 Origin / content-type 校验，且**不会**被传给
+           * 宿主（宿主只认 kind/path/handler，多传字段可能被 schema 拒）。
+           */
+          const registerLocal = (row = {}) => {
+            const { methods = ['GET'], ...rest } = row;
+            return wctx.webServer.register({ ...rest, handler: localOnly(rest.handler, { methods }) });
+          };
+          const dispose = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/state',
+            methods: ['GET'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4642,9 +4904,10 @@ export function apply(ctx, config) {
 
           // Artifact content route (client overlay right-side preview). Resolves
           // cwd from sessionId (or cwd param) + run; serves only known artifacts.
-          const disposeArtifact = wctx.webServer.register({
+          const disposeArtifact = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/artifact',
+            methods: ['GET'],
             // 试点路由：改走 `lib/routes/shared.js` 的 `withRoute`（消掉本条自己的
             // json 助手 / 405 判断 / 500 兜底三份样板）。行为逐字保持：参数校验仍由本函数负责。
             handler: withRoute(async ({ res, json, query }) => {
@@ -4662,9 +4925,10 @@ export function apply(ctx, config) {
 
           // Code index search route (Qoder-style): instant keyword hits from
           // team/CODEINDEX.json. Builds lazily if the index is missing.
-          const disposeCodeidx = wctx.webServer.register({
+          const disposeCodeidx = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/codeidx',
+            methods: ['GET'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4684,9 +4948,10 @@ export function apply(ctx, config) {
 
           // Read-only file preview route (A①: click a code-index hit → preview).
           // Path must be a RELATIVE workspace path (no `..`, no absolute).
-          const disposeFileView = wctx.webServer.register({
+          const disposeFileView = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/file',
+            methods: ['GET'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4695,8 +4960,23 @@ export function apply(ctx, config) {
                 const ws = (url.searchParams.get('workspace') ?? '').trim();
                 const rel = (url.searchParams.get('path') ?? '').trim();
                 if (!ws || !rel || rel.startsWith('/') || rel.includes('..') || !/^[\w@./-]+$/.test(rel)) { json(400, { ok: false, error: 'bad params' }); return; }
-                const text = await readFile(join(ws, rel), 'utf8');
-                json(200, { ok: true, path: rel, text: text.slice(0, 120000) });
+                const abs = join(ws, rel);
+                // 有宿主 fs 就走宿主策略；**读被拒时如实报 403，绝不退回裸 readFile** ——
+                // 退回等于"策略拒绝 + 我们绕开它"，比压根不做策略校验更糟。
+                if (ADOPTED_HOST_FS) {
+                  try {
+                    const resolved = await ADOPTED_HOST_FS.resolve(abs);
+                    const text = await ADOPTED_HOST_FS.readText(resolved);
+                    json(200, { ok: true, path: rel, text: String(text).slice(0, 120000), source: 'host-fs' });
+                  } catch (e) {
+                    const msg = String(e && e.message ? e.message : e);
+                    const notFound = (e && e.code === 'ENOENT') || /ENOENT|not found/i.test(msg);
+                    json(notFound ? 404 : 403, { ok: false, error: notFound ? 'not found' : 'read denied by host fs policy: ' + msg });
+                  }
+                  return;
+                }
+                const text = await readFile(abs, 'utf8');
+                json(200, { ok: true, path: rel, text: text.slice(0, 120000), source: 'node-fs' });
               } catch (e) {
                 json(404, { ok: false, error: String(e && e.code === 'ENOENT' ? 'not found' : (e && e.message ? e.message : e)) });
               }
@@ -4707,9 +4987,10 @@ export function apply(ctx, config) {
           // Human-in-loop decision route: the user makes a choice in the overlay
           // (方案确认门 / 模糊选择 / quality-gate 升级). Records it into RUN.log +
           // DECISIONS.md and clears STATE.pendingDecision so the lead can proceed.
-          const disposeDecide = wctx.webServer.register({
+          const disposeDecide = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/decide',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4854,9 +5135,10 @@ export function apply(ctx, config) {
             const state = await readJsonSafe(join(dir, 'STATE.json'));
             return state ? { dir, state, cwd, run } : null;
           };
-          const disposePlan = wctx.webServer.register({
+          const disposePlan = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/plan',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4906,9 +5188,10 @@ export function apply(ctx, config) {
           });
           wctx.effect(() => disposePlan);
 
-          const disposePlanApprove = wctx.webServer.register({
+          const disposePlanApprove = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/plan/approve',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4969,9 +5252,10 @@ export function apply(ctx, config) {
           });
           wctx.effect(() => disposePlanApprove);
 
-          const disposePlanDiscard = wctx.webServer.register({
+          const disposePlanDiscard = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/plan/discard',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -4998,9 +5282,10 @@ export function apply(ctx, config) {
 
           // Overlay task operation: change one task's status (writes TASKS.json
           // + RUN.log). Same trust level as decide.
-          const disposeTaskOp = wctx.webServer.register({
+          const disposeTaskOp = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/task',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -5025,9 +5310,10 @@ export function apply(ctx, config) {
 
           // ── GET /state 不再聚合（2026-09-13）：显式刷新入口。浮层要刷新指标时用 **POST**，
           //    不要用 GET —— 一个 GET 写盘既破坏幂等，又给 run 工件引入并发写面。
-          const disposeMetrics = wctx.webServer.register({
+          const disposeMetrics = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/metrics/refresh',
+            methods: ['POST'],
             handler: async (req, res) => {
               const json = (code, body) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(body)); };
               try {
@@ -5051,9 +5337,10 @@ export function apply(ctx, config) {
           // **诚实边界**：`roster` / `gates` 两类设置是在 `apply()` 时解析进内存的
           // （容量上限、轮次上限、档位门），所以改完**要重启 `dsh web` 才生效**；
           // `display` 类是浮层每次拉设置时读的，即时生效。响应里如实分开说，不假装"立刻全部生效"。
-          const disposeSettings = wctx.webServer.register({
+          const disposeSettings = registerLocal({
             kind: 'exact',
             path: '/plugins/dsh-expert-team/settings',
+            methods: ['GET', 'POST'],
             handler: withRoute(async ({ req, res, json, body }) => {
               const method = String((req && req.method) || 'GET').toUpperCase();
               if (method === 'GET') {
@@ -5068,24 +5355,37 @@ export function apply(ctx, config) {
                 json(400, { ok: false, errors: merged.errors, settings: merged.value });
                 return;
               }
+              // 宿主命名空间可用 ⇒ 可表达的字段写**宿主**（官方面板与浮层共用同一份真源，
+              // 且随市场备份/恢复）；宿主表达不了的字段（如 roster.defaultRoles）继续写 settings.json。
+              // 两边都只写自己拥有的字段 —— 同一个字段在两个存储里各留一份，是这个仓最忌讳的形态。
+              const viaHost = await updateHostSettings(patch);
+              const fileOnly = pickFileOnly(patch);
+              const writeFile = !viaHost.ok || Object.keys(fileOnly).length > 0;
               try {
-                // `$DSH_HOME/expert-team/` 在全新环境里可能还不存在（受控写入口不会替你建目录）。
-                await mkdir(dirname(settingsPath()), { recursive: true });
-                await ARTIFACT.must(settingsPath(), JSON.stringify(merged.value, null, 2) + '\n');
+                if (writeFile) {
+                  // `$DSH_HOME/expert-team/` 在全新环境里可能还不存在（受控写入口不会替你建目录）。
+                  await mkdir(dirname(settingsPath()), { recursive: true });
+                  const forFile = viaHost.ok ? pickFileOnly(merged.value) : merged.value;
+                  await ARTIFACT.must(settingsPath(), JSON.stringify(forFile, null, 2) + '\n');
+                }
               } catch (e) {
                 json(500, { ok: false, errors: [`设置写入失败：${String((e && e.message) || e)}`], settings: currentSettings() });
                 return;
               }
               const touched = new Set(Object.keys(patch && typeof patch === 'object' ? patch : {}).flatMap((k) => (k.includes('.') ? [k.split('.')[0]] : [k])));
               SETTINGS_CACHE = { settings: merged.value, repaired: [], at: new Date().toISOString() };
-              const needsRestart = touched.has('roster') || touched.has('gates');
+              if (!viaHost.ok) reapplySettingsDerived();   // 文件路径：与 1.1.x 一样在进程内重算
+              const needsRestart = !viaHost.ok && (touched.has('roster') || touched.has('gates'));
               json(200, {
                 ok: true,
                 settings: merged.value,
                 needsRestart,
-                note: needsRestart
-                  ? '已保存。`编制` / `门禁` 两类设置在插件加载时解析 ⇒ **重启 dsh web 后生效**；`显示` 类即时生效。'
-                  : '已保存并即时生效。',
+                settingsSource: viaHost.ok ? 'host' : 'file',
+                note: viaHost.ok
+                  ? `已保存到宿主设置（命名空间 ${HOST_SETTINGS_NAMESPACE}）：官方面板与浮层共用同一份，且随插件市场的备份/恢复一起走；上限与档位门已在进程内重算，**无需重启**。`
+                  : needsRestart
+                    ? '已保存。`编制` / `门禁` 两类设置在插件加载时解析 ⇒ **重启 dsh web 后生效**；`显示` 类即时生效。'
+                    : '已保存并即时生效。',
               });
             }, { methods: ['GET', 'POST'] }),
           });

package/lib/host-settings.js

@@ -0,0 +1,216 @@
+// 宿主设置命名空间接线（1.2.0）
+//
+// ── 为什么要有它（三条具体收益，不是"架构更漂亮"）────────────────────────────
+//   ① 设置出现在 **设置 → 插件 → 插件配置**：由宿主按我们给的 schema 渲染，插件不必自己画表单；
+//   ② 随插件市场的**备份与恢复**一起走 —— 市场只备份"profile 插件清单 + 设置"，自造的
+//      `settings.json` 不在它的备份范围里；
+//   ③ 值改变能**立刻生效**：`scope.watch()` 一到，重算上限/轮次/档位门，不必重启。
+//
+// ── 为什么用**动态 import**，而不是像 dshmarket 那样静态 import schemastery ──────────
+//   dshmarket 那样写是对的：它的包只会在 profile 里被加载，`@deepseek-ai/schemastery`
+//   在 profile 的上一级 node_modules 里解析得到。但**本仓的 76 个测试文件都从仓库路径**
+//   import `lib/command.js` —— 仓库不在任何 profile 里，静态 import 会直接
+//   ERR_MODULE_NOT_FOUND，把整套测试带崩（这正是"零依赖、CI 免 install"的代价）。
+//   动态 import 失败 ⇒ 优雅回退到 settings.json，行为与 1.1.x 一致；成功 ⇒ 上一个微任务后注册完成。
+//
+// ── 优先级（未变）：config > env > **设置** > 内置默认 ──────────────────────────
+//   宿主可用时，"设置"这一档 = 宿主命名空间的解析值，其构成为
+//   `schema 默认 < 我们传入的 base < 用户在官方面板的覆盖`；base 用**当前生效设置**填充，
+//   所以面板一打开看到的就是真正在用的值（不需要任何一次性迁移）。
+//   宿主不可用（或 schemastery 解析不到）时，"设置"这一档 = `$DSH_HOME/expert-team/settings.json`。
+
+import { SETTINGS_GROUPS, SETTINGS_SPEC, flatSpec } from './settings.js';
+
+/** 注册到宿主的命名空间（宿主对命名空间有文法要求：小写字母/数字/短横线）。 */
+export const HOST_SETTINGS_NAMESPACE = 'expert-team';
+
+/**
+ * 能上官方面板的类型。
+ *
+ * `roles` 刻意**不上**：它的取值是"角色 id 数组或 null"，在 schemastery 里要表达成
+ * `union([const(null), array(string)])`，跨版本行为没把握；一旦 schema 建错，宿主会拒绝注册
+ * 甚至让整条插件挂不上。这个字段继续由浮层的设置页签 + settings.json 负责，
+ * 官方页面只显示其余三类（bool / int / enum）。少一个开关，好过"注册失败、面板里什么都不出现"。
+ */
+const HOST_SCHEMA_TYPES = new Set(['bool', 'int', 'enum']);
+
+/** 宿主 schema 覆盖的扁平路径（`identity.profile` 这种）。 */
+export function hostSchemaPaths() {
+  return Object.entries(flatSpec())
+    .filter(([, item]) => HOST_SCHEMA_TYPES.has(item.type))
+    .map(([path]) => path);
+}
+
+/**
+ * 由我们的 `SETTINGS_SPEC` 生成嵌套的 schemastery schema。
+ *
+ * 单一真源：字段、取值范围、默认值全部来自 `lib/settings.js` 的 spec —— 不在这里抄第二份。
+ * 代价是必须**容忍 schemastery 的 API 差异**：只有确实存在的方法才调用（`.min/.max/.default`）。
+ *
+ * @param z - schemastery 的默认导出（由调用方动态 import 得到）。
+ */
+export function buildHostSchema(z) {
+  const shape = {};
+  for (const group of SETTINGS_GROUPS) {
+    const inner = {};
+    for (const [key, item] of Object.entries(SETTINGS_SPEC[group].items)) {
+      if (!HOST_SCHEMA_TYPES.has(item.type)) continue;
+      let field;
+      if (item.type === 'bool') field = z.boolean();
+      else if (item.type === 'int') {
+        field = z.number();
+        if (item.min != null && typeof field.min === 'function') field = field.min(item.min);
+        if (item.max != null && typeof field.max === 'function') field = field.max(item.max);
+      } else field = z.union(item.values.map((v) => z.const(v)));
+      if (typeof field.default === 'function') field = field.default(item.default);
+      inner[key] = field;
+    }
+    if (Object.keys(inner).length) shape[group] = z.object(inner);
+  }
+  return z.object(shape);
+}
+
+/** 从"当前生效设置"里挑出宿主能表达的那些（用作 `register(..., { base })`）。 */
+export function hostBase(settings) {
+  const out = {};
+  for (const path of hostSchemaPaths()) {
+    const [group, key] = path.split('.');
+    const value = settings && settings[group] ? settings[group][key] : undefined;
+    if (value === undefined || value === null) continue;
+    out[group] = out[group] || {};
+    out[group][key] = value;
+  }
+  return out;
+}
+
+/**
+ * 把补丁裁成"宿主能表达"的嵌套对象。
+ * 补丁同时支持嵌套（`{roster:{maxTasks:10}}`）与扁平（`{'roster.maxTasks':10}`），与
+ * `mergeSettings` 同口径 —— 否则同一份补丁在两处会有两种解释。
+ */
+export function pickHostExpressible(patch) {
+  const flat = {};
+  const put = (path, value) => {
+    const item = flatSpec()[path];
+    if (!item || !HOST_SCHEMA_TYPES.has(item.type)) return;
+    flat[path] = value;
+  };
+  if (patch && typeof patch === 'object' && !Array.isArray(patch)) {
+    for (const [k, v] of Object.entries(patch)) {
+      if (k.includes('.')) { put(k, v); continue; }
+      if (!SETTINGS_SPEC[k] || !v || typeof v !== 'object' || Array.isArray(v)) continue;
+      for (const [k2, v2] of Object.entries(v)) put(`${k}.${k2}`, v2);
+    }
+  }
+  const out = {};
+  for (const [path, value] of Object.entries(flat)) {
+    const [group, key] = path.split('.');
+    out[group] = out[group] || {};
+    out[group][key] = value;
+  }
+  return out;
+}
+
+/** 补丁里**宿主表达不了**的那部分（继续由 settings.json 负责）。 */
+export function pickFileOnly(patch) {
+  const expressible = pickHostExpressible(patch);
+  const out = {};
+  const put = (path, value) => {
+    const item = flatSpec()[path];
+    if (!item || HOST_SCHEMA_TYPES.has(item.type)) return;
+    const [group, key] = path.split('.');
+    out[group] = out[group] || {};
+    out[group][key] = value;
+  };
+  if (patch && typeof patch === 'object' && !Array.isArray(patch)) {
+    for (const [k, v] of Object.entries(patch)) {
+      if (k.includes('.')) { put(k, v); continue; }
+      if (!SETTINGS_SPEC[k] || !v || typeof v !== 'object' || Array.isArray(v)) continue;
+      for (const [k2, v2] of Object.entries(v)) put(`${k}.${k2}`, v2);
+    }
+  }
+  void expressible;
+  return out;
+}
+
+// ── 运行时状态（进程内单例；插件卸载时清空）──────────────────────────────────
+
+/** 已注册的宿主作用域；null = 宿主没有 settings 服务（或还没注册完）。 */
+let HOST_SCOPE = null;
+/** 最近一次从宿主读到的解析值。 */
+let HOST_VALUES = null;
+/** 注册失败的原因（供 `/team status` 与诊断如实显示）。 */
+let HOST_NOTE = '';
+
+/**
+ * 把设置注册进宿主命名空间。**同步返回**，注册本身在下一次微任务完成（动态 import）。
+ *
+ * @param ctx - 插件上下文（用 `ctx.inject(['settings'], …)` 作为优雅降级边界：宿主没有该服务时回调不执行）
+ * @param options.base - 当前生效设置（决定面板初始值）
+ * @param options.onResolved - 拿到（或更新）宿主解析值时的回调；用于重算上限/档位
+ * @param options.loadSchema - **仅供测试**注入 schema 加载器（默认动态 import schemastery）。
+ *   仓库里解析不到 schemastery，没有这个接缝就只能测到"回退"那一半，成功路径永远没被测过。
+ * @returns 是否成功挂上了 inject（不代表注册已完成）
+ */
+export function installHostSettings(ctx, { base, onResolved, loadSchema } = {}) {
+  if (!ctx || typeof ctx.inject !== 'function') return false;
+  const load = typeof loadSchema === 'function' ? loadSchema : () => import('@deepseek-ai/schemastery');
+  try {
+    ctx.inject(['settings'], (scoped) => {
+      const service = scoped && scoped.settings;
+      if (!service || typeof service.register !== 'function') return;
+      load().then((mod) => {
+        const z = (mod && mod.default) ? mod.default : mod;
+        const scope = service.register(HOST_SETTINGS_NAMESPACE, buildHostSchema(z), { base: hostBase(base) });
+        HOST_SCOPE = scope;
+        const push = () => {
+          try {
+            HOST_VALUES = typeof scope.get === 'function' ? scope.get() : null;
+            if (onResolved) onResolved(HOST_VALUES);
+          } catch (e) {
+            HOST_NOTE = '读取宿主设置失败：' + String(e && e.message ? e.message : e);
+          }
+        };
+        try { if (typeof scope.watch === 'function') scope.watch(() => push()); } catch { /* watch 缺失不该影响注册 */ }
+        push();
+        if (typeof scoped.effect === 'function') {
+          scoped.effect(() => () => { HOST_SCOPE = null; HOST_VALUES = null; });
+        }
+        console.log(`[expert-team] 设置已注册到宿主命名空间「${HOST_SETTINGS_NAMESPACE}」（官方面板可改，且随市场备份/恢复）`);
+      }).catch((e) => {
+        HOST_NOTE = 'schemastery 不可解析，保持 settings.json：' + String(e && e.message ? e.message : e);
+        console.warn('[expert-team] ' + HOST_NOTE);
+      });
+    });
+    return true;
+  } catch (e) {
+    HOST_NOTE = 'inject(settings) 失败：' + String(e && e.message ? e.message : e);
+    console.warn('[expert-team] ' + HOST_NOTE);
+    return false;
+  }
+}
+
+/** 宿主作用域是否已就绪。 */
+export function hostScope() { return HOST_SCOPE; }
+/** 最近一次宿主解析值（null = 未就绪）。 */
+export function hostValues() { return HOST_VALUES; }
+/** 诊断文案（为什么没用上宿主设置）。 */
+export function hostSettingsNote() { return HOST_NOTE; }
+
+/**
+ * 把补丁写进宿主命名空间（只写它表达得了的那部分）。
+ * @returns `{ ok: true, written: 命中字段数 }`，或 `{ ok: false, reason }`
+ */
+export async function updateHostSettings(patch) {
+  if (!HOST_SCOPE || typeof HOST_SCOPE.update !== 'function') return { ok: false, reason: 'no-host-scope' };
+  const expressible = pickHostExpressible(patch);
+  const groups = Object.keys(expressible);
+  const count = groups.reduce((n, g) => n + Object.keys(expressible[g]).length, 0);
+  if (count === 0) return { ok: false, reason: 'nothing-expressible' };
+  try {
+    await HOST_SCOPE.update(expressible);
+    return { ok: true, written: count };
+  } catch (e) {
+    return { ok: false, reason: 'update-failed', error: String(e && e.message ? e.message : e) };
+  }
+}

package/lib/routes/shared.js

@@ -81,3 +81,137 @@ export function withRoute(handler, { methods = ['GET'] } = {}) {
     }
   };
 }
+
+// ── 本机来源守卫（安全加固 · 2026-09-14）────────────────────────────────────
+//
+// 为什么要有它：这 11 条路由由 dsh 的 webServer 暴露在本机 HTTP 端口上，此前**只校验
+// HTTP 方法**。于是有三条真实可达的攻击路径：
+//   ① **DNS rebinding**：恶意页面把自己的域名解析到 127.0.0.1，浏览器就把它当同源 ⇒
+//      可读 `/state`、`/file`（工作区任意文本）、并写入 `/task`、`/plan`、`/settings`。
+//   ② **跨站简单请求（CSRF）**：跨站 `fetch` 带 `text/plain`、或 `<form>` 提交，都不触发
+//      CORS 预检 ⇒ 写操作照常执行（响应读不到，但**副作用已经发生**）。
+//   ③ **非回环暴露**：宿主配置 `host: 0.0.0.0` 时，同网段任何机器都能打这些接口。
+//
+// 判定规则（每条都对应上面一条攻击路径）：
+//   · `Host` 头存在且主机名不是回环 ⇒ 403。**这是挡 DNS rebinding 的那一条**：浏览器一定会带
+//     Host，而攻击页带的 Host 是它自己的域名。
+//   · `Origin` 头存在且不是回环来源 ⇒ **只在变更方法上** 403。GET 放行是有意的：浏览器不会把
+//     没有 CORS 头的响应体交给跨站页面（我们从不发 `Access-Control-Allow-Origin`），所以跨站
+//     GET 读不到任何东西；而放行它才能保住 `/team canvas --watch` 生成的本地 HTML 文件——
+//     那个页面以 `file://` 打开，发请求时带的是 `Origin: null`。
+//   · `req.socket.remoteAddress` 存在且不是回环 ⇒ 403（挡局域网）。
+//   · 变更方法上 `content-type` 存在且不是 JSON ⇒ 415。浏览器的 form 与"简单请求"只能发
+//     urlencoded / multipart / text-plain，JSON 必须走预检，而我们不回应预检。
+//
+// **三条规则都只在"头存在"时生效** —— 这是刻意的，不是宽松：
+//   · 浏览器（也就是这三条攻击路径里唯一的攻击载体）**必然**带上 Host，POST 必然带 Origin；
+//   · 本地非浏览器客户端本来就能自造任意头，任何头校验都拦不住它 —— 这类客户端需要的是
+//     鉴权，而 dsh 插件没有鉴权模型（市场的同源检查也只是回环+同源）。这一点如实写进 README。
+//   · 副作用：单元测试里的假 req 没有 headers/socket，因此不受影响（不必为测试开口子）。
+//
+// 事实来源：`dshmarket` 对 install/restart 这类端点就是这么做的（"只接受同源 POST"、
+// "重启要求客户端直接来自环回地址、拒绝代理转发请求"）。
+
+/** 回环主机名（Host 头 / Origin 里的主机名都按这个判）。 */
+const LOOPBACK_HOSTNAMES = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+
+/** `Host: 127.0.0.1:3080` → `127.0.0.1`；`[::1]:3080` → `[::1]`；解析不出返回 ''。 */
+export function hostnameOf(hostHeader) {
+  const raw = String(hostHeader == null ? '' : hostHeader).trim().toLowerCase();
+  if (!raw) return '';
+  if (raw.startsWith('[')) {                       // IPv6 字面量：[::1]:3080
+    const end = raw.indexOf(']');
+    return end === -1 ? raw : raw.slice(0, end + 1);
+  }
+  const colon = raw.lastIndexOf(':');
+  return colon === -1 ? raw : raw.slice(0, colon);
+}
+
+/** Host 头是否是回环地址。 */
+export function isLoopbackHost(hostHeader) {
+  const h = hostnameOf(hostHeader);
+  return h !== '' && LOOPBACK_HOSTNAMES.has(h);
+}
+
+/**
+ * 来源（Origin）是否可信：`http://127.0.0.1:3080`、`http://localhost:3080`、`https://[::1]` 可信；
+ * `null`（file:// 页面）与一切外站**不可信**。
+ */
+export function isLoopbackOrigin(origin) {
+  const raw = String(origin == null ? '' : origin).trim();
+  if (!raw || raw.toLowerCase() === 'null') return false;
+  try {
+    const u = new URL(raw);
+    return LOOPBACK_HOSTNAMES.has(u.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+/** socket 地址是否是回环（`127.x.x.x`、`::1`、IPv4-mapped `::ffff:127.x.x.x`）。 */
+export function isLoopbackAddress(addr) {
+  const a = String(addr == null ? '' : addr).trim().toLowerCase();
+  if (!a) return false;
+  if (a === '::1') return true;
+  const v4 = a.startsWith('::ffff:') ? a.slice(7) : a;
+  return /^127\./.test(v4);
+}
+
+/**
+ * 本机来源守卫：返回 `null` 表示放行，否则返回 `{ code, error }`（由调用方写响应）。
+ *
+ * @param req - 请求对象（`headers` / `socket.remoteAddress` 缺失时按"非浏览器客户端"处理）
+ * @param options.methods - 该路由允许的方法；**变更方法**才做 Origin 与 content-type 校验
+ */
+export function guardLocalRequest(req, { methods = ['GET'] } = {}) {
+  const headers = (req && req.headers) || null;
+  const method = String((req && req.method) || 'GET').toUpperCase();
+  const mutating = !['GET', 'HEAD', 'OPTIONS'].includes(method);
+
+  if (headers) {
+    const host = headers.host ?? headers[':authority'];
+    if (host != null && String(host).trim() !== '' && !isLoopbackHost(host)) {
+      return { code: 403, error: 'forbidden: non-loopback Host' };
+    }
+    const origin = headers.origin;
+    if (mutating && origin != null && String(origin).trim() !== '' && !isLoopbackOrigin(origin)) {
+      return { code: 403, error: 'forbidden: cross-origin write' };
+    }
+    if (mutating) {
+      const ct = headers['content-type'];
+      if (ct != null && String(ct).trim() !== '' && !/^application\/json\b/i.test(String(ct).trim())) {
+        return { code: 415, error: 'unsupported media type: expected application/json' };
+      }
+    }
+  }
+
+  const addr = req && req.socket ? req.socket.remoteAddress : null;
+  if (addr != null && String(addr).trim() !== '' && !isLoopbackAddress(addr)) {
+    return { code: 403, error: 'forbidden: non-loopback client' };
+  }
+
+  // 方法校验放在守卫里一起做：路由注册处只包一层就不会漏（见 routes-guard 棘轮测试）。
+  const allow = new Set(methods.map((m) => String(m).toUpperCase()));
+  if (!allow.has(method)) return { code: 405, error: '' };
+
+  return null;
+}
+
+/**
+ * 给任意处理器套上"只服务本机同源"的守卫。**注册每一路由时都要用它包一层** ——
+ * `routes-shared.test.mjs` 有一条棘轮断言：`lib/command.js` 里不允许出现裸的 `handler:`。
+ *
+ * @param handler - `(req, res) => Promise<void> | void`
+ * @param options.methods - 允许的方法（默认 `['GET']`）
+ */
+export function localOnly(handler, { methods = ['GET'] } = {}) {
+  return async function guarded(req, res) {
+    const denied = guardLocalRequest(req, { methods });
+    if (denied) {
+      if (denied.code === 405) { res.writeHead(405); res.end(); return; }
+      json(res, denied.code, { ok: false, error: denied.error });
+      return;
+    }
+    return handler(req, res);
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yangdcm/dsh-expert-team",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "dsh「专家团」bundle：一句自然语言自动组建/持久化一支 12 角色多智能体团队，共享工作区协议 + 阶段门控编排 + 结构化交接 + 质量门禁/自动调度，实现者直接改代码并产出持久工件；带 live 团队浮层（质量门禁/覆盖率/工件预览）。 · Role-based multi-agent expert team for DeepSeek Harness: one sentence in, a staged and gated team delivery out.",
   "type": "module",
   "license": "MIT",
@@ -83,7 +83,7 @@
     "check:name": "node scripts/rename-package.mjs --check",
     "test:regression": "node regression.test.mjs",
     "test:e2e": "node e2e.test.mjs",
-    "test:all": "node smoke.test.mjs && node regression.test.mjs && node e2e.test.mjs && node flow.test.mjs && node plan-decide.test.mjs && node plan-discard.test.mjs && node models-honesty.test.mjs && node evidence-gate.test.mjs && node sync-gate.test.mjs && node artifact-writer.test.mjs && node dag.test.mjs && node metrics.test.mjs && node broken-chain.test.mjs && node schema-warn.test.mjs && node template-copy.test.mjs && node task-binding.test.mjs && node role-merge.test.mjs && node wf-recovery.test.mjs && node panorama.test.mjs && node run-ownership.test.mjs && node role-identity.test.mjs && node command-parse.test.mjs && node member-registry.test.mjs && node schema-check.test.mjs && node run-health.test.mjs && node cordis-fs-port.test.mjs && node scaffold-fingerprint.test.mjs && node preset-lint.test.mjs && node stranded-tasks.test.mjs && node agent-scope-guard.test.mjs && node schema-warn-noise.test.mjs && node tool-card-status.test.mjs && node dag-status.test.mjs && node capacity-limits.test.mjs && node task-cas.test.mjs && node write-lock.test.mjs && node card-stall.test.mjs && node multi-session-and-confirm.test.mjs && node standing-rules.test.mjs && node scope-overlap.test.mjs && node task-cancel-protect.test.mjs && node wait-run.test.mjs && node rework-loop.test.mjs && node client-css-integrity.test.mjs && node interception.test.mjs && node mutation-catalog.test.mjs && node write-bypass-ratchet.test.mjs && node asi-hazards.test.mjs && node dispatch-contract.test.mjs && node closure-ledger.test.mjs && node rework-nature.test.mjs && node loop-guard.test.mjs && node vocab-consistency.test.mjs && node state-no-write.test.mjs && node routes-shared.test.mjs && node metrics-render.test.mjs && node metrics-collect.test.mjs && node first-runnable.test.mjs && node closing-budget.test.mjs && node scan-single-source.test.mjs && node tier.test.mjs && node dispatch-ledger.test.mjs && node tier-gate.test.mjs && node tier-badge.test.mjs && node validate-module.test.mjs && node settings.test.mjs && node settings-page.test.mjs && node policy.test.mjs && node phase-accounting.test.mjs && node log-parse-module.test.mjs && node command-parse-module.test.mjs && node authority.test.mjs && node write-tracer.test.mjs && node token-accounting.test.mjs && node lead-toolface.test.mjs",
+    "test:all": "node bootstrap.test.mjs && node host-settings.test.mjs && node smoke.test.mjs && node regression.test.mjs && node e2e.test.mjs && node flow.test.mjs && node plan-decide.test.mjs && node plan-discard.test.mjs && node models-honesty.test.mjs && node evidence-gate.test.mjs && node sync-gate.test.mjs && node artifact-writer.test.mjs && node dag.test.mjs && node metrics.test.mjs && node broken-chain.test.mjs && node schema-warn.test.mjs && node template-copy.test.mjs && node task-binding.test.mjs && node role-merge.test.mjs && node wf-recovery.test.mjs && node panorama.test.mjs && node run-ownership.test.mjs && node role-identity.test.mjs && node command-parse.test.mjs && node member-registry.test.mjs && node schema-check.test.mjs && node run-health.test.mjs && node cordis-fs-port.test.mjs && node scaffold-fingerprint.test.mjs && node preset-lint.test.mjs && node stranded-tasks.test.mjs && node agent-scope-guard.test.mjs && node schema-warn-noise.test.mjs && node tool-card-status.test.mjs && node dag-status.test.mjs && node capacity-limits.test.mjs && node task-cas.test.mjs && node write-lock.test.mjs && node card-stall.test.mjs && node multi-session-and-confirm.test.mjs && node standing-rules.test.mjs && node scope-overlap.test.mjs && node task-cancel-protect.test.mjs && node wait-run.test.mjs && node rework-loop.test.mjs && node client-css-integrity.test.mjs && node interception.test.mjs && node mutation-catalog.test.mjs && node write-bypass-ratchet.test.mjs && node asi-hazards.test.mjs && node dispatch-contract.test.mjs && node closure-ledger.test.mjs && node rework-nature.test.mjs && node loop-guard.test.mjs && node vocab-consistency.test.mjs && node state-no-write.test.mjs && node routes-shared.test.mjs && node metrics-render.test.mjs && node metrics-collect.test.mjs && node first-runnable.test.mjs && node closing-budget.test.mjs && node scan-single-source.test.mjs && node tier.test.mjs && node dispatch-ledger.test.mjs && node tier-gate.test.mjs && node tier-badge.test.mjs && node validate-module.test.mjs && node settings.test.mjs && node settings-page.test.mjs && node policy.test.mjs && node phase-accounting.test.mjs && node log-parse-module.test.mjs && node command-parse-module.test.mjs && node authority.test.mjs && node write-tracer.test.mjs && node token-accounting.test.mjs && node lead-toolface.test.mjs",
     "test:toolcard": "node tool-card-status.test.mjs",
     "test:flow": "node flow.test.mjs",
     "test:decide": "node plan-decide.test.mjs",
@@ -133,6 +133,8 @@
     "test:wait": "node wait-run.test.mjs",
     "test:loop": "node rework-loop.test.mjs",
     "test:tokens": "node token-accounting.test.mjs",
-    "test:toolface": "node lead-toolface.test.mjs"
+    "test:toolface": "node lead-toolface.test.mjs",
+    "test:bootstrap": "node bootstrap.test.mjs",
+    "test:host-settings": "node host-settings.test.mjs"
   }
 }