@whyshu/argent-engine 0.0.0-stage → 0.6.0

package/engine/scripts/plan-role-rename.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * plan-role-rename —— P2b（角色/preset/技能改名为 `<vertical>-*`）的**只读规划器**
+ *
+ * 为什么只读：P2b 要同时改**仓库**（presets/skills 目录名）与**机器配置**（gateway.json /
+ * roles.json / 角色会话引用），并且只有**重启服务**才能验证挂载成功。所以本工具**不写任何东西**：
+ * 它把"窗口来了要改哪些、改成什么、哪些地方会受影响"算清楚打印出来，供人过一眼再执行。
+ * （`--apply` 刻意不实现 —— 改名必须与重启窗口在一起，不能分两次做。）
+ *
+ * 判据来源（唯一真源，不写死第二份）：
+ *   · 业务线自报的迁移期豁免：`verticals/<id>/manifest.json#legacyNaming`
+ *   · 仓库现状：`presets/`、`skills/` 目录名
+ *   · 机器现状：`<DSH_HOME>/gateway.json`、`<DSH_HOME>/roles.json`（角色 → preset/技能引用）
+ *
+ * 用法：node scripts/plan-role-rename.mjs [--vertical <id>] [--json]
+ * 退出码：0 = 已算清（不表示"需要改"或"不需要改"，看输出）；2 = 参数/环境问题。
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { dshHome } from './lib/scope-pointer.mjs'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = resolve(HERE, '..')
+const argOf = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? process.argv[i + 1] ?? d : d }
+const AS_JSON = process.argv.includes('--json')
+// 不写死任何业务线名（引擎文件里出现业务线名会被 vertical-lint 拦下 —— 这条门禁对
+// 我自己的工具同样有效）：缺省从 `verticals/*/manifest.json` 发现；多于一条时必须显式 --vertical。
+const discovered = existsSync(join(REPO, 'verticals'))
+  ? readdirSync(join(REPO, 'verticals'), { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(REPO, 'verticals', d.name, 'manifest.json')))
+    .map((d) => d.name)
+  : []
+const VERTICAL = argOf('--vertical', '') || (discovered.length === 1 ? discovered[0] : '')
+if (!VERTICAL) {
+  console.error(discovered.length
+    ? `✗ 有多条业务线，请显式指定：--vertical <${discovered.join('|')}>`
+    : '✗ verticals/ 下没有业务线')
+  process.exit(2)
+}
+
+const vdir = join(REPO, 'verticals', VERTICAL)
+if (!existsSync(vdir)) {
+  console.error(`✗ 找不到业务线：${vdir}`)
+  process.exit(2)
+}
+
+const manifest = JSON.parse(readFileSync(join(vdir, 'manifest.json'), 'utf8'))
+const legacy = manifest.legacyNaming || []
+const prefix = manifest.namespace || manifest.id || VERTICAL
+
+const rows = []
+const note = (kind, from, to, where, extra = '') => rows.push({ kind, from, to, where, extra })
+
+// ── ① 仓库：presets / skills 目录 ────────────────────────────────
+const listDirs = (rel) => {
+  const p = join(REPO, rel)
+  return existsSync(p) ? readdirSync(p, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : []
+}
+if (legacy.includes('skills')) {
+  for (const d of listDirs('skills')) {
+    // 只规划"业务线专属"的技能：以 ml- 开头（历史命名），或 manifest 显式声明归属于本线
+    if (/^ml-/.test(d)) {
+      const to = d.replace(/^ml-/, `${prefix}-`)
+      note('skill', d, to, `skills/${d}`, '目录改名 + SKILL.md frontmatter 的 name（必须等于目录名）')
+    }
+  }
+}
+if (legacy.includes('roles') || legacy.includes('presets')) {
+  for (const d of listDirs('presets')) {
+    if (/^argent-ml-/.test(d)) {
+      note('preset', d, d.replace(/^argent-ml-/, `argent-${prefix}-`), `presets/${d}`, '目录改名（preset id 随之变化）')
+    }
+  }
+}
+
+// ── ② 机器：gateway.json / roles.json 里对这些名字的引用 ──────────
+const home = dshHome()
+// 真实位置：`<DSH_HOME>/argent/{gateway,roles}.json`（不是 <DSH_HOME>/ 根）——
+// 用候选列表而不是猜一个（两种布局都认，找不到就明说"未找到"，不谎报"无引用"）。
+const machineFiles = [
+  join(home, 'argent', 'gateway.json'), join(home, 'argent', 'roles.json'),
+  join(home, 'gateway.json'), join(home, 'roles.json'),
+].filter((f) => existsSync(f))
+const oldNames = new Set(rows.map((r) => r.from))
+const hitCount = new Map()
+for (const f of machineFiles) {
+  let doc
+  try { doc = JSON.parse(readFileSync(f, 'utf8')) } catch { continue }
+  const text = JSON.stringify(doc)
+  for (const name of oldNames) {
+    const n = text.split(name).length - 1
+    if (n) hitCount.set(`${f.replace(home, '<DSH_HOME>')} :: ${name}`, n)
+  }
+}
+
+// ── ③ 输出 ────────────────────────────────────────────────────
+if (AS_JSON) {
+  console.log(JSON.stringify({
+    vertical: VERTICAL, prefix, legacyNaming: legacy, machineFiles: machineFiles.map((f) => f.replace(home, '<DSH_HOME>')),
+    plan: rows, machineHits: Object.fromEntries(hitCount),
+  }, null, 2))
+  process.exit(0)
+}
+
+console.log(`\n【P2b 改名规划（只读）】业务线 ${VERTICAL}｜前缀 ${prefix}｜迁移期豁免：${legacy.join('、') || '(无)'}\n`)
+if (!rows.length) {
+  console.log('  无待改名项（仓库侧已是目标命名，或该线的 legacyNaming 未声明 roles/skills）')
+} else {
+  const byKind = rows.reduce((m, r) => (m[r.kind] = (m[r.kind] || 0) + 1, m), {})
+  console.log(`  仓库侧待改 ${rows.length} 项（${Object.entries(byKind).map(([k, v]) => `${k} ${v}`).join('，')}）：`)
+  for (const r of rows) console.log(`    · ${r.kind.padEnd(6)} ${r.from} → ${r.to}\n       位置：${r.where}\n       连带：${r.extra}`)
+}
+console.log(`\n  机器侧引用（${machineFiles.length ? machineFiles.map((f) => f.replace(home, '<DSH_HOME>')).join('、') : '未找到 gateway.json / roles.json'}）：`)
+if (!hitCount.size) console.log('    （这些文件里未发现对上述旧名的引用 —— 仍需在改名后核对角色会话与 preset 挂载）')
+else for (const [k, n] of hitCount) console.log(`    · ${k} × ${n}`)
+
+console.log(`
+  执行前提（**必须成对做，不能分两次**）：
+    ① 先改仓库（目录 + frontmatter name），跑门禁：node scripts/vertical-lint.mjs
+       + python3 scripts/fix-skill-frontmatter.py --check + node scripts/validate-preset-schema.mjs --runtime
+    ② **同一窗口内**改机器配置（gateway.json / roles.json）并重启服务验证角色挂载与会话唤醒
+    ③ 业务线 manifest 的 legacyNaming 收敛（改完即删对应条目，保留就是长期债务）
+  工具刻意不提供 --apply：改名与重启窗口必须在一起，分两次做会出现"配置指旧名、仓库已新名"的窗口期。
+`)

package/engine/scripts/plugin-bootcheck.mjs

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * plugin-bootcheck — host 插件「启动冒烟」预检（v0.8 事故复盘 2026-09-05：
+ * 连续多次「改了 host 插件未验证即提交 → 用户重启才崩」。node --check 只查语法，
+ * 静态词法检查覆盖有限——本脚本用隔离 DSH_HOME + 临时端口真实启动一次 dsh web，
+ * 装配级错误（重复 provide / apply 路径未定义引用 / 模块初始化失败 / 语法）都会在
+ * 启动早期炸出；验证后立即杀进程，不影响运行中的 3080 实例。
+ *
+ * ⚠️ 边界（诚实）：只能覆盖「启动路径」执行的代码——事件回调内（如 @ 消息处理）
+ * 的函数体引用错误需另以运行期冒烟覆盖（发布清单含「重启后 @ 消息回归」项）。
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 2026-10-12 P1-0 重做（依据 `docs/dsh-0.2.x-适配审计.md` §B2/§D1 + 契约 §3.1/§3.3）
+ *
+ * ## 原来的假红
+ * 老实现把**真实 profile** 原样软链进隔离 home（`:41`），于是插件仍解析到**真实 profile
+ * 指的那个 scope**。在 0.2 宿主上那是 0.1.7 ⇒ 0.2 的 peer 门禁把**每一行** disable
+ * （实测 `disabling profile plugin row "…"` ×110 + `startup failed: …`）⇒ 与"Argent 坏了"
+ * 在输出上**无法区分**。而且它还顺手把 dsh 的组合产物 `cordis.yml` 写回**真实** profile。
+ *
+ * ## 现在
+ * ① 按**目标 scope**（`DSH_SCOPE`/`--scope-dir`；缺省 = 真源自动探测，见下）**重建**临时 profile 的
+ *    `@deepseek-ai` 连接（浅镜像：node_modules 条目仍是只读软链，⛔ 不 `cp -R`、⛔ 不碰真实 profile）；
+ * ② 重建后**自证**：`require.resolve('@deepseek-ai/dsh-base')` 必须落在目标 scope 内，
+ *    否则直接报「目标 scope 不可用」而不是继续跑出假红；
+ * ③ 判据从"三个哨兵任一命中"升级为**三条**（见 `scripts/lib/bootcheck-wiring.mjs`）：
+ *    零条 `disabling profile plugin row` ＋ **提供行判据表**命中 ＋ `[preset-probe] DONE fail=0 total=N`；
+ * ④ 三态输出 `PASS` / `FAIL`（附原因与原文证据）/ `EVIDENCE-INSUFFICIENT`（拿不到日志 ⇒ ⛔ 不许判 PASS）；
+ * ⑤ **硬前置**：被测 `dsh` 二进制**必须与目标 scope 同源**（版本一致）—— 解析顺序
+ *    `DSH_BIN` → 目标 scope 推导 → `resolveDshBin({ scopeDir })` 兜底；不一致 ⇒ 当场判红（附双方版本 + 出路）。
+ *
+ * ## 目标 scope 怎么定（P1-3b 2026-10-12：**npx 感知** + 来源可打印）
+ * 唯一真源 = `scripts/lib/dsh-scope.mjs#resolveDshScopeDir()`（本文件⛔不自己实现候选序）。顺序：
+ *   ① `--scope-dir` / `DSH_SCOPE`（显式）→ ② `--global-bin` / `DSH_BIN` 反推（显式指向哪个 dsh）→
+ *   ③ 自动探测：`npm root -g` → PATH 上的 dsh → HOME 相对（邻居→标准）→ 当前 node 前缀 →
+ *      **npx 缓存**（`~/.npm/_npx/<hash>/node_modules/@deepseek-ai`，= 官方首选运行方式
+ *      `npx @deepseek-ai/dsh web` 留下的痕迹）→ homebrew / Intel 绝对兜底。
+ * ⛔ ③ 一个都不存在 ⇒ `null` ⇒ **响亮失败**（不是静默猜一个）。**本批修的缺陷**：老实现走遗留
+ *   `resolveDshScope()`，它在"**纯 npx 机器**"上（PATH 无 dsh、无全局安装、只有 npx 缓存）
+ *   **静默返回一个不存在的路径**（2026-10-12 用户 MBP 实测 `/usr/local/lib/node_modules/@deepseek-ai`，
+ *   存在=false）⇒ 连带 `resolveDshBin()` 定到不存在的 `/usr/local/bin/dsh` ⇒ 客户机上"选错 scope"。
+ * **scope 来源（`from`）每次都打印**（例：`npx 缓存（/Users/x/.npm/_npx/1e7f…/node_modules）`）——
+ *   让"选错了"在输出第一屏就可见，而不是等到 110 条禁用行。
+ *
+ * 用法：`node scripts/plugin-bootcheck.mjs [--profile web] [--scope-dir <…/@deepseek-ai>] [--print-scope]`
+ * 环境：`DSH_SCOPE`（目标 scope）/`DSH_BIN`（被测 dsh；缺省=**按目标 scope 推导**，再退 PATH/全局）/
+ *       `BOOTCHECK_VERBOSE=1`（打印完整子进程日志）/`BOOTCHECK_ALLOW_VERSION_MISMATCH=1`（明知故犯地
+ *       跳过"bin 与 scope 必须同源"的硬前置，只告警）
+ * `--print-scope`（或 `BOOTCHECK_PRINT_SCOPE=1`）：只跑**解析阶段**（零 spawn、零临时 home、
+ *   零真实 profile 读写）后 exit 0 —— 夹具与排障用（"它到底选了哪个 scope、凭什么选的"）。
+ * 退出码：0=PASS（或 `--print-scope` 解析成功）  1=FAIL / EVIDENCE-INSUFFICIENT / 硬前置不满足 / scope 解析不到
+ *
+ * ⚠️ **硬前置（2026-10-12 P1-0）**：被测二进制与目标 scope 的 dsh 版本必须一致 ——
+ * 否则隔离 profile 已重接线到目标 scope、宿主却是别的版本 ⇒ 0.2 的 peer 门禁把每行 disable
+ * （实测 110 条 `disabling profile plugin row`），输出与"Argent 坏了"无法区分。此时**当场判红**。
+ */
+import { spawn, spawnSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { createServer } from 'node:net'
+import { resolveDshBin, resolveBootcheckBin, resolveDshScopeDir, scopeBinCandidates } from './lib/dsh-scope.mjs'
+import { MECHANISM, detectPresetMechanism, mechanismNote } from './lib/preset-mechanism.mjs'
+import {
+  locateScopeFarm, planProfileWiring, planStaysInsideTmp, applyProfileWiring,
+  verifyScopeResolution, evaluateBootLog, readPackageVersion, compareBinScopeVersions,
+  SCOPE_PROBE_PKGS,
+} from './lib/bootcheck-wiring.mjs'
+
+/** 测哪个 profile（默认 web；隔离试跑用别的 profile 时传 --profile）。 */
+const argVal = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? process.argv[i + 1] : d }
+const PROFILE = argVal('--profile', 'web')
+const PORT_PREF = Number(argVal('--port', process.env.BOOTCHECK_PORT || '3199'))
+const KEEP_HOME = process.env.BOOTCHECK_KEEP_HOME === '1' || process.argv.includes('--keep-home')
+
+/** 子进程句柄（异常退出时也要杀，否则会把固定端口占住 ⇒ 下一次假红 EADDRINUSE）。 */
+let activeChild = null
+process.on('exit', () => { try { activeChild?.kill('SIGKILL') } catch { /* 已退出 */ } })
+for (const sig of ['SIGINT', 'SIGTERM']) process.on(sig, () => { try { activeChild?.kill('SIGKILL') } catch { /* 已退出 */ } process.exit(1) })
+
+/** 选一个真正空闲的回环端口（固定端口被占时不再假红；2026-10-12 实测被上一次遗留进程占过）。 */
+function pickFreePort(preferred) {
+  return new Promise((resolve) => {
+    const probe = (p, left) => {
+      const s = createServer()
+      s.once('error', () => { s.close(); left > 0 ? probe(p + 1, left - 1) : resolve(0) })
+      s.once('listening', () => s.close(() => resolve(p)))
+      s.listen(p, '127.0.0.1')
+    }
+    probe(preferred, 20)
+  })
+}
+
+// 2026-09-28 客户机教训：写死 /opt/homebrew/bin/dsh ⇒ 客户机（node 官方包布局）上
+// 启动冒烟一律 ENOENT，把升级门禁的最后一道挡住。
+//
+// 2026-10-12 P1-0（**硬前置**）：被测二进制必须与**目标 scope 同源**。解析顺序 =
+//   ① `DSH_BIN` / `--global-bin`（显式）
+//   ② **由目标 scope 推导**（`resolveBootcheckBin`：标准布局 `<prefix>/bin/dsh`／
+//      邻居布局 `<dir>/bin/dsh`／**平铺布局 `<dir>/node_modules/.bin/dsh`**）
+//   ③ `resolveDshBin({ scopeDir })` 兜底（PATH → 目标 scope 候选 → 全局候选）
+// 由来：老实现只走 ③，先 `command -v dsh` 命中本机全局 **0.1.7**，在平铺预检树上就出现
+// 「profile 农场已重接线到 0.2、宿主仍是 0.1.7」⇒ 110 条 `disabling profile plugin row`。
+// 版本不一致时**响亮判红**（判据见 `lib/bootcheck-wiring.mjs#compareBinScopeVersions`）。
+// ⚠️ ② 的**平铺档**（`<dir>/node_modules/.bin/dsh`）在 **P1-3（2026-10-12）已上移到真源**
+// `lib/dsh-scope.mjs#scopeBinCandidates()`（候选序：标准 → 邻居 → 平铺），本文件与
+// `lib/bootcheck-wiring.mjs` 都**只转发**，⛔ 两处不再各自实现。防漂移判据：用例 C1/C7
+// （bootcheck 侧与 `resolveDshBin()` **同解**）+ `scripts/tests/dsh-scope-resolve.test.mjs`（真源档位序）。
+// ⚠️ ② 的**邻居档**对客户机（`~/.local/node/bin/dsh` → `~/.local/node/node_modules/@deepseek-ai`）有效。
+// ⚠️ P1-3b（2026-10-12）：③ 现在**带上 `scopeDir`** —— 不带参数时 `resolveDshBin()` 内部会退回遗留
+// `resolveDshScope()`（会把"纯 npx 机器"带到一个不存在的路径），那是同一缺陷的第二个入口。
+const explicitBin = argVal('--global-bin', null) || process.env.DSH_BIN || null
+// ── 目标 scope 解析（P1-3b 2026-10-12：**npx 感知**；真源 = `lib/dsh-scope.mjs`）────────────
+// 顺序（唯一实现在真源 `resolveDshScopeDir()`，本文件⛔不再自己拼候选）：
+//   ① `--scope-dir` / `DSH_SCOPE`（显式）　② `--global-bin` / `DSH_BIN` 反推（显式指向哪个 dsh）
+//   ③ 自动探测：`npm root -g` → PATH 上的 dsh → HOME 相对（邻居→标准）→ 当前 node 前缀 →
+//      **npx 缓存**（`~/.npm/_npx/<hash>/node_modules/@deepseek-ai`）→ homebrew / Intel 绝对兜底。
+// ⛔ ③ 一个都不存在 ⇒ `null` ⇒ 这里**响亮失败**（⛔ 不是静默猜一个）。**这就是本批修的缺陷**：
+//    老实现走遗留 `resolveDshScope()`，它在"纯 npx 机器"上**静默返回一个不存在的路径**
+//    （用户 MBP 实测 `/usr/local/lib/node_modules/@deepseek-ai`，存在=false）。
+// 被测 dsh 的 scope（**目标 scope**）：它**参与**隔离 profile 的 `@deepseek-ai` 重建。
+const scopeResolved = resolveDshScopeDir()
+if (!scopeResolved) {
+  console.error('[FAIL] 目标 scope 解析失败：这台机器上找不到任何 @deepseek-ai 农场')
+  console.error('  已按序试过：`--scope-dir`/`DSH_SCOPE` → `--global-bin`/`DSH_BIN` 反推 → `npm root -g` → ' +
+    'PATH 上的 dsh → HOME 相对布局（邻居→标准）→ 当前 node 前缀 → **npx 缓存（~/.npm/_npx/<hash>/…）** → homebrew / Intel 绝对路径。')
+  console.error('  ⛔ 旧实现（遗留 `resolveDshScope()`）会在这里**静默回一个不存在的路径**' +
+    '（实测 `/usr/local/lib/node_modules/@deepseek-ai`）—— 那正是本判据要消灭的误导性失败。')
+  console.error('  出路：① `--scope-dir <…/@deepseek-ai>`；② `DSH_SCOPE=<…>`；③ `DSH_BIN=<该 scope 自带的 dsh>`（由它反推）。')
+  console.error('  判据：该目录下应有 `@deepseek-ai/dsh`（npx 形态 = `<hash>/node_modules/@deepseek-ai`）。')
+  process.exit(1)
+}
+const scopeArg = scopeResolved.dir
+const dshBinFrom = (() => {
+  if (explicitBin) return { bin: explicitBin, from: 'DSH_BIN / --global-bin（显式）' }
+  const derived = resolveBootcheckBin(scopeArg)
+  if (derived) return { bin: derived, from: '目标 scope 推导' }
+  // ⚠️ 兜底**必须**把已定下的目标 scope 传进去：不带参数的 `resolveDshBin()` 内部会退回遗留
+  //    `resolveDshScope()`（同一缺陷入口）⇒ 又可能选出一个**不存在**的 bin。
+  return { bin: resolveDshBin({ scopeDir: scopeArg }), from: 'resolveDshBin({ scopeDir }) 兜底（PATH / 目标 scope 候选 / 全局）' }
+})()
+const dshBin = dshBinFrom.bin
+// ⛔ 兜底也可能一个候选都不存在（纯 npx 机器：PATH 无 dsh，而目标 scope 里又没有 `.bin/dsh`）⇒ 响亮失败；
+//    ⛔ 绝不 spawn 一个不存在的路径（老实现会走到那儿，输出是 ENOENT / 看起来像"Argent 坏了"）。
+if (!existsSync(dshBin)) {
+  console.error(`[FAIL] 被测 dsh 可执行文件不存在：${dshBin}（来源：${dshBinFrom.from}）`)
+  console.error(`  目标 scope=${scopeArg}（来源：${scopeResolved.from}）`)
+  console.error(`  由该 scope 推导的 bin 候选：${scopeBinCandidates(scopeArg).join('　|　') || '（无）'}`)
+  console.error('  出路：① `DSH_BIN=<目标 scope 自带的 dsh>`；② 把 `DSH_SCOPE`/`--scope-dir` 指向那个 dsh 所属的 scope。')
+  process.exit(1)
+}
+
+// ── `--print-scope`：只跑**解析阶段**就退出（零 spawn、零临时 home、⛔ 零真实 profile/clone 读写）──
+// 用途：① 回归夹具 `scripts/tests/bootcheck-scope-resolution.test.mjs` 的"解析态"实跑；
+//      ② 排障一眼看清"它到底选了哪个 scope、**凭什么**选的、bin 是哪来的"。
+if (process.argv.includes('--print-scope') || process.env.BOOTCHECK_PRINT_SCOPE === '1') {
+  console.log(`[bootcheck] 目标 scope=${scopeArg}`)
+  console.log(`[bootcheck] scope 来源=${scopeResolved.from}`)
+  console.log(`[bootcheck] 被测 dsh=${dshBin}`)
+  console.log(`[bootcheck] dsh 来源=${dshBinFrom.from}`)
+  console.log(`[bootcheck] bin 候选=${scopeBinCandidates(scopeArg).join('　|　') || '（无）'}`)
+  process.exit(0)
+}
+const realHome = process.env.REAL_DSH_HOME || join(homedir(), '.dsh')
+
+/** 被测 dsh 的**自报版本**（`<bin> --version`，10s 超时）。拿不到 ⇒ `{version:null, why}`，⛔ 不静默。 */
+function probeBinVersion(bin) {
+  try {
+    const r = spawnSync(bin, ['--version'], { encoding: 'utf8', timeout: 10000 })
+    if (r.error) return { version: null, why: `无法执行 ${bin}：${r.error.message}` }
+    const out = `${r.stdout ?? ''}${r.stderr ?? ''}`
+    if (r.status !== 0 && !/\d+\.\d+\.\d+/.test(out)) return { version: null, why: `\`--version\` exit ${r.status}` }
+    const m = /(\d+\.\d+\.\d+[\w.+-]*)/.exec(out)
+    return m ? { version: m[1], why: null } : { version: null, why: `\`--version\` 输出里认不出语义版本：${out.trim().slice(0, 120)}` }
+  } catch (e) {
+    return { version: null, why: `无法执行 ${bin}：${e.message}` }
+  }
+}
+
+/** 目标 scope 不可用时的统一出口（三态里的 EVIDENCE-INSUFFICIENT：连日志都拿不到）。 */
+function bailScopeUnavailable(why) {
+  console.error(`[EVIDENCE-INSUFFICIENT] ${why}`)
+  console.error(`  目标 scope（${scopeArg}；来源：${scopeResolved.from}）：请确认它是 ` +
+    `<dir>/node_modules/@deepseek-ai（平铺 / npx 形态）或含 ` +
+    `${SCOPE_PROBE_PKGS.map((p) => `@deepseek-ai/${p}`).join(' / ')} 的农场目录；` +
+    '也可用 --scope-dir / DSH_SCOPE 显式指定（`--print-scope` 可先看清解析结果与来源）。')
+  process.exit(1)
+}
+
+const farm = locateScopeFarm(scopeArg)
+if (!farm) bailScopeUnavailable(`目标 scope 不可用：${scopeArg} 下找不到 @deepseek-ai 农场`)
+const mechanism = detectPresetMechanism(farm.farm)
+/** 只读小工具（给 L1 纯函数注入 fs 用；本文件是 L2 装配档，允许直接读 fs）。 */
+const roFs = {
+  join,
+  readText: (p) => { try { return readFileSync(p, 'utf8') } catch { return null } },
+  realpath: (p) => { try { return realpathSync(p) } catch { return null } },
+}
+const targetVersion = readPackageVersion(join(farm.farm, 'dsh'), roFs)
+
+// ── 硬前置：被测 dsh 二进制必须与目标 scope **同源**（2026-10-12 P1-0）─────────
+// 判据在 L1（`lib/bootcheck-wiring.mjs#compareBinScopeVersions`，纯函数、有回归）；
+// 这里只负责取数（`--version`）+ 打印 + 按判据出口。**两侧版本不一致 ⇒ 判红**，
+// 而不是继续跑出一个"看起来像 Argent 坏了"的红（老实现就是这个坑，实测 110 条禁用行）。
+const binVersionInfo = probeBinVersion(dshBin)
+const binCheck = compareBinScopeVersions({
+  binVersion: binVersionInfo.version,
+  scopeVersion: targetVersion,
+  binPath: dshBin,
+  scopeDir: farm.farm,
+  allowMismatch: process.env.BOOTCHECK_ALLOW_VERSION_MISMATCH === '1',
+})
+console.log(`[bootcheck] 被测 dsh=${dshBin}（自报 ${binVersionInfo.version ?? `拿不到：${binVersionInfo.why}`}；来源：${dshBinFrom.from}）`)
+console.log(`[bootcheck] bin↔scope 同源：${binCheck.level === 'ok' ? '✅' : binCheck.level === 'warn' ? '⚠️' : '❌'} ${binCheck.why}`)
+if (binCheck.level === 'fail') {
+  console.error('[FAIL] 硬前置不满足：被测 dsh 二进制与目标 scope **不同源**（详见上一行）')
+  console.error('  这不是目标 scope 的问题 —— 换一个与它同源的 dsh 可执行文件即可（实测：`DSH_BIN=<目标 scope 自带的 dsh>` ⇒ 全绿）。')
+  console.error('  （确要明知故犯地跑下去：BOOTCHECK_ALLOW_VERSION_MISMATCH=1 ⇒ 降级为告警。）')
+  process.exit(1)
+}
+
+// ── preset 挂载探针（2026-09-10 新增）─────────────────────────────────────
+// 由来：0.1.5 起 preset 挂载失败会让 **session resume 直接失败**，而原 bootcheck 只验
+// host 插件装配、完全不覆盖 preset 挂载（persona `prefix` 缺键事故即由此漏过）。
+// 做法：把真实 .agent-presets 链接进隔离 home，并用 --patch 覆盖注入一个探针行，
+//      探针对每个 argent-* preset 建一个 agent 作用域并**真实 mount**，逐个报 OK/FAIL。
+// 角色清单**按被测 dsh 的机制**取（2026-09-28：0.1.7 起 preset 不再扫目录）：
+//   rows      → 从 profile 里装的 argent-presets 插件的 presets.json 取（= 真实声明处）
+//   directory → 扫 ~/.dsh/.agent-presets/argent-*（0.1.5 及更早）
+const tmpHome = mkdtempSync(join(tmpdir(), 'dsh-bootcheck-'))
+mkdirSync(join(tmpHome, 'profiles'), { recursive: true })
+let presetIds = []
+let idsFrom = '(无)'
+try {
+  if (mechanism === MECHANISM.ROWS) {
+    // ⚠️ W9（2026-10-12）：profile 里 bundle 的落点是**包名**（`@whyshu/argent-presets`），
+    //    存量机器上仍是旧裸名目录 ⇒ **两个名字都试**（⛔ 只认一个会在另一半机器上判成「没装」）。
+    //    真源 = `scripts/lib/preset-install.mjs#resolveBundleDir()`；bootcheck 刻意**零第三方/零宿主**
+    //    自持（要在半坏的机器上跑）⇒ 这里只做两名字候选，判据与真源一致（scoped 优先）。
+    const inProfileCands = [
+      join(realHome, 'profiles', PROFILE, 'node_modules', '@whyshu', 'argent-presets', 'presets.json'),
+      join(realHome, 'profiles', PROFILE, 'node_modules', 'argent-presets', 'presets.json'),
+    ]
+    const inProfile = inProfileCands.find((f) => existsSync(f)) || ''
+    const inRepo = join(process.cwd(), 'plugins', 'argent-presets', 'presets.json')
+    const use = inProfile || (existsSync(inRepo) ? inRepo : null)
+    if (use) {
+      presetIds = Object.keys(JSON.parse(readFileSync(use, 'utf8')))
+      idsFrom = `行式清单（${use.includes('node_modules') ? 'profile 内' : '仓库内'}，${presetIds.length} 个）`
+    }
+  } else if (existsSync(join(realHome, '.agent-presets'))) {
+    symlinkSync(join(realHome, '.agent-presets'), join(tmpHome, '.agent-presets'), 'dir')
+    presetIds = readdirSync(join(realHome, '.agent-presets')).filter((d) => {
+      try { return d.startsWith('argent-') && statSync(join(realHome, '.agent-presets', d)).isDirectory() } catch { return false }
+    })
+    idsFrom = `目录式 ~/.dsh/.agent-presets（${presetIds.length} 个）`
+  }
+} catch (e) {
+  console.error('[bootcheck] 取角色清单失败:', e.message)
+}
+
+// ── 隔离 profile：浅镜像 + 按目标 scope 重建 @deepseek-ai ────────────────────
+const profileDir = join(realHome, 'profiles', PROFILE)
+if (!existsSync(profileDir)) bailScopeUnavailable(`真实 profile 不存在：${profileDir}`)
+const tmpProfileDir = join(tmpHome, 'profiles', PROFILE)
+const plan = planProfileWiring({ profileDir, tmpProfileDir, targetFarm: farm.farm })
+const guard = planStaysInsideTmp(plan, { profileDir, tmpProfileDir })
+if (!guard.ok) {
+  console.error('[FAIL] 隔离装配计划越界（会写真实 profile）—— 拒绝执行：')
+  for (const v of guard.violations) console.error('  · ' + v)
+  process.exit(1)
+}
+applyProfileWiring(plan)
+
+// 自证：从临时 profile 解析探针包，必须落到**目标 scope**内（解析不到 ⇒ 目标 scope 不可用）。
+const req = createRequire(join(tmpProfileDir, 'package.json'))
+const resolveFrom = (spec) => {
+  for (const s of [spec, `${spec}/package.json`]) {
+    try { return req.resolve(s) } catch { /* 试下一个 */ }
+  }
+  return null
+}
+const scopeCheck = verifyScopeResolution({ tmpProfileDir, targetFarm: farm.farm, resolveFrom }, roFs)
+if (!scopeCheck.ok) bailScopeUnavailable(scopeCheck.why)
+/** 目标 scope 供的版本（= 重建后临时 profile 会解析到的版本）——用于禁用行归因。 */
+const targetVersionOf = (pkg) => {
+  if (!pkg || !pkg.startsWith('@deepseek-ai/')) return null
+  return readPackageVersion(join(farm.farm, pkg.slice('@deepseek-ai/'.length)), roFs)
+}
+
+console.log(`[bootcheck] profile=${PROFILE}｜机制=${mechanismNote(mechanism)}｜清单=${idsFrom}`)
+console.log(`[bootcheck] 目标 scope=${farm.farm}（来源：${scopeResolved.from}｜layout=${farm.layout}，探针=${farm.probe}，dsh=${targetVersion ?? '?'}）`)
+console.log(`[bootcheck] 隔离装配=${plan.mode}/${plan.scopeMode}（${plan.actions.length} 条动作，profile 浅镜像；` +
+  `${plan.sameFarm ? '目标 scope 与现役一致 ⇒ 不重接线' : '已重接线到目标 scope'}）｜自证：${scopeCheck.why}`)
+for (const n of plan.notes) console.log(`[bootcheck] ⚠️ ${n}`)
+
+const probeFile = join(tmpHome, 'preset-mount-probe.mjs')
+const probePatch = join(tmpHome, 'preset-probe.patch.yml')
+writeFileSync(probeFile, `export const name = 'preset-mount-probe'
+export const inject = ['agentPresets', 'agents']
+export async function apply(ctx) {
+  const ids = (process.env.DSH_PRESET_PROBE_IDS || '').split(',').filter(Boolean)
+  // ⚠️ 必须**等注册表就绪**再挂载（2026-09-28 实测）：0.1.5 目录式启动即注册，
+  // 0.1.7 行式要到装配期才注册（本机实测 +0ms 为 0 个、+3s 才 17 个）⇒
+  // 立刻 mount 会一律 "Unknown agent preset"，把"探针太早"误报成"preset 挂了"。
+  let known = new Set()
+  let broken = new Map()
+  const deadline = Date.now() + 25000
+  while (Date.now() < deadline) {
+    try {
+      const list = await ctx.agentPresets.list()
+      known = new Set(list.map((p) => p.id))
+      broken = new Map(list.filter((p) => p.broken).map((p) => [p.id, p.broken]))
+    } catch { /* 注册表还没起来 */ }
+    if (ids.every((id) => known.has(id))) break
+    await new Promise((r) => setTimeout(r, 500))
+  }
+  const unknown = ids.filter((id) => !known.has(id))
+  if (unknown.length) console.log('[preset-probe] 等注册表超时，仍未声明：' + unknown.join(', '))
+  let fail = 0
+  for (const id of ids) {
+    // 注册表已标记损坏时，直接报出**原始诊断**（比 mount 的泛化报错有用得多）
+    if (broken.has(id)) {
+      fail++
+      const b = broken.get(id)
+      console.log('[preset-probe] FAIL ' + id + '（注册表诊断）: ' + (typeof b === 'string' ? b : JSON.stringify(b)))
+      continue
+    }
+    try {
+      await ctx.agents.create({
+        sessionId: 'bootcheck-preset-' + id,
+        meta: { cwd: process.env.HOME || '/tmp' },
+        setup: async (agentCtx) => { await ctx.agentPresets.mount(agentCtx, id) },
+      })
+      console.log('[preset-probe] OK ' + id)
+    } catch (e) {
+      fail++
+      console.log('[preset-probe] FAIL ' + id + ': ' + ((e && e.message) || e))
+    }
+  }
+  console.log('[preset-probe] DONE fail=' + fail + ' total=' + ids.length)
+}
+`)
+writeFileSync(probePatch, `- insert:\n    - id: preset-mount-probe\n      name: '${probeFile}'\n`)
+
+function waitForReady(url, timeoutMs, isDead) {
+  return new Promise((resolve) => {
+    const start = Date.now()
+    const tryOnce = async () => {
+      if (isDead()) return resolve(false) // 子进程已退出/崩溃 → 立即判失败
+      try {
+        const r = await fetch(url, { signal: AbortSignal.timeout(2000), redirect: 'manual' })
+        // 版本中立就绪判据：0.1.1 根路径 200；**0.1.5+ 根路径需 token（401）或 303 跳转**。
+        // 三者都说明 HTTP 服务已就绪；真正的成功判据是「判据表 + preset 探针 + 无装配级错误特征」。
+        if (r.status >= 200 && r.status < 400) return resolve(true)
+        if (r.status === 401 || r.status === 403) return resolve(true)
+      } catch {
+        /* 未就绪 */
+      }
+      if (Date.now() - start > timeoutMs) return resolve(false)
+      setTimeout(tryOnce, 500)
+    }
+    tryOnce()
+  })
+}
+
+/** 三条判据 + 三态的**统一渲染**（PASS/FAIL/EVIDENCE-INSUFFICIENT 都用它，避免判据在输出里漂移）。 */
+function renderCriteria(ev, { expectedPresets }) {
+  const mark = (b) => (b ? '✅' : '❌')
+  console.log(`[criteria] ① 零条 profile 插件禁用行（peer 门禁）：${mark(ev.criteria.zeroDisable)}（${ev.disable.total} 条）` +
+    `　② 提供行（判据表）：${mark(ev.criteria.providerLine)}［命中 ${ev.providers.filter((p) => p.hit).map((p) => p.id).join(', ') || '无'}］` +
+    (expectedPresets > 0 ? `　③ preset 探针：${mark(ev.criteria.presetProbe)}［fail=${ev.probe.fail ?? '?'} total=${ev.probe.total ?? '?'}／期望 ${expectedPresets}］` : '　③ preset 探针：n/a'))
+}
+
+async function main() {
+  const PORT = await pickFreePort(PORT_PREF)
+  if (!PORT) { console.error('[EVIDENCE-INSUFFICIENT] 找不到空闲回环端口（3199 起试 20 个）⇒ 拿不到日志'); process.exit(1) }
+  if (PORT !== PORT_PREF) console.log(`[bootcheck] ⚠️ 端口 ${PORT_PREF} 被占用 ⇒ 改用 ${PORT}`)
+  // 注意：--patch 是**顶层**选项，必须在 web app 自己的参数（--port/--no-open）之前
+  const args = presetIds.length
+    ? ['--profile', PROFILE, '--patch', probePatch, '--port', String(PORT), '--no-open']
+    : ['--profile', PROFILE, '--port', String(PORT), '--no-open']
+  const child = spawn(dshBin, args, {
+    env: { ...process.env, DSH_HOME: tmpHome, DSH_PRESET_PROBE_IDS: presetIds.join(',') },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  activeChild = child
+  let log = ''
+  child.stdout.on('data', (d) => (log += d))
+  child.stderr.on('data', (d) => (log += d))
+  let exitCode = null
+  child.on('exit', (c) => { exitCode = c; log += `\n[child exited code=${c}]` })
+
+  const httpReady = await waitForReady(`http://127.0.0.1:${PORT}/`, 45000, () => exitCode !== null)
+  // ⚠️ 必须**等**判据面出现再判（2026-09-28）：0.1.7 上 HTTP 就绪早于插件 apply 收尾，
+  // 采样一次会误报"缺少提供行/疑似静默 reject"。等待窗口与 probe 一致，不改变判据语义。
+  if (presetIds.length) {
+    const deadline = Date.now() + 30000
+    while (Date.now() < deadline && !/\[preset-probe\] DONE /.test(log)) await new Promise((r) => setTimeout(r, 300))
+  } else {
+    const deadline = Date.now() + 20000
+    while (Date.now() < deadline && !/\[argent-core\]\s*已启动/.test(log) && exitCode === null) await new Promise((r) => setTimeout(r, 300))
+  }
+
+  const ev = evaluateBootLog(log, { expectedPresets: presetIds.length, httpReady, exitCode, resolveVersion: targetVersionOf })
+
+  // 证据（FAIL / EVIDENCE-INSUFFICIENT 时**逐条**给原文；PASS 时只给摘要）
+  if (ev.verdict !== 'PASS') {
+    renderCriteria(ev, { expectedPresets: presetIds.length })
+    console.error(`[${ev.verdict}] 启动冒烟未通过（隔离 home: ${tmpHome}）`)
+    for (const r of ev.reasons) console.error('  · ' + r)
+    if (ev.disable.total) {
+      const all = [...ev.disable.mismatched, ...ev.disable.consistent, ...ev.disable.unresolved]
+      console.error(`[evidence] 原文匹配串 \`disabling profile plugin row\` 共 ${all.length} 条，逐条如下：`)
+      for (const r of all) console.error('  - ' + r.line)
+      console.error(`[evidence] 归因：${ev.disable.summary}`)
+      if (ev.disable.kind === 'scope-not-wired') {
+        console.error('[evidence] ⚠️ 这是**目标 scope 未接好**（不是 Argent 坏了）：禁用行读到的版本与临时 profile 接的 scope 不一致。')
+      }
+    }
+    if (ev.probe.fails.length) {
+      console.error(`[evidence] preset 探针失败 ${ev.probe.fails.length} 条：`)
+      for (const f of ev.probe.fails.slice(0, 10)) console.error('  - ' + f)
+    }
+    console.error('[evidence] 提供行判据表：')
+    for (const p of ev.providers) console.error(`  ${p.hit ? '✅' : '❌'} ${p.id}${p.required ? '（必需）' : ''}　期望样例：${p.sample}`)
+    const all = log.split('\n')
+    const tail = process.env.BOOTCHECK_VERBOSE === '1' ? all.join('\n') : all.slice(-25).join('\n')
+    console.error('--- 子进程日志' + (process.env.BOOTCHECK_VERBOSE === '1' ? '（完整）' : '尾部 25 行，BOOTCHECK_VERBOSE=1 看全部') + ' ---')
+    console.error(tail || '(无输出)')
+  } else {
+    renderCriteria(ev, { expectedPresets: presetIds.length })
+    console.log(`[PASS] 启动冒烟通过（隔离 home；目标 scope dsh=${targetVersion ?? '?'}；` +
+      `${presetIds.length ? `preset 挂载 ${presetIds.length}/${presetIds.length}` : '未发现 argent-* preset'}；` +
+      `零条禁用行、提供行 ${ev.providers.filter((p) => p.hit).map((p) => p.id).join('+')}）`)
+    console.log('--- 插件日志 ---')
+    console.log(log.split('\n').filter((l) => /argent-|preset-probe|fatal/.test(l)).slice(-8).join('\n'))
+    if (process.env.BOOTCHECK_VERBOSE === '1') { console.log('--- 子进程完整日志 ---'); console.log(log) }
+  }
+
+  child.kill('SIGTERM')
+  setTimeout(() => child.kill('SIGKILL'), 3000).unref()
+  if (ev.verdict === 'PASS' && !KEEP_HOME) { try { rmSync(tmpHome, { recursive: true, force: true }) } catch { /* 留着也无害 */ } }
+  process.exit(ev.verdict === 'PASS' ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error('[FAIL] bootcheck 异常:', e.message, '\n', e.stack)
+  process.exit(1)
+})

package/engine/scripts/plugin-composition.json

@@ -0,0 +1,15 @@
+{
+  "_doc": "profile 组合目标（唯一真源）：patch 层行 vs bundle 层插件。JS 升级器与 Python 客户机预检都读这里 —— 2026-09-28 踩过：预检期望 argent-flow 挂载、升级目标组合里却没有它，于是预检红、升级器却以为正常（两边知识分叉）。",
+  "_history": [
+    "2026-09-28：把 argent-flow 补进 business。它提供 flow_schema_check / flow_failures 两个工具，是流程角色（判失败/查字段缺口）的生产依赖，客户机必须有。",
+    "2026-09-28：argent-skin 移到 bundle 层（dsh 0.1.5 起客户端 UI 插件走 dsh.profile.bundles；patch 层再来一行会 duplicate loader entry id ⇒ 启动即失败）。"
+  ],
+  "business": {
+    "patch": ["argent-core", "argent-flow", "argent-gateway"],
+    "bundles": ["argent-skin"]
+  },
+  "chat": {
+    "patch": ["argent-core"],
+    "bundles": ["argent-skin"]
+  }
+}