@minonl/dia 0.0.0-stage → 0.0.2-beta.0

package/packages/wt/tests/check.test.sh

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# dia wt-check.test.sh —— `dia wt check`（R20 机械闸口）回归测试（2026-10-15）
+#
+# 覆盖：
+#   · A 顶层 node_modules 是软链（跨 checkout 共享的典型形态）
+#   · B 顶层链逃出本 checkout   · C 顶层链悬空   · D 深层链逃逸（仅 --deep）
+#   · ✅ **GVS 白名单**：指向 `<storeDir>/links/@/…` 的链**不算违规** —— 这条断言是"启用 pnpm
+#     global virtual store 后不误报"的唯一保险（判据不区分共享 store 与别人的 checkout ⇒ 一开 GVS 全仓红）
+#   · 真装形态不误报 · 主仓 + 各 worktree 全覆盖 · 仓根杂散 node_modules（--all）
+#   · clean 软链守卫（拒绝清理且不动目录）· 退出码契约（0 干净 / 1 违规 / 2 未知子命令）
+# 用法：bash scripts/dia wt-check.test.sh     （退出码 0 = 全绿）
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WT="$HERE/../bin/dia-wt"
+TD="$(mktemp -d)"
+export DIA_WT_DATA_ROOT="$TD/dr" DIA_WT_REPOS_ROOT="$TD/repos"
+mkdir -p "$DIA_WT_DATA_ROOT" "$DIA_WT_REPOS_ROOT"
+STORE="$TD/store"; mkdir -p "$STORE/links/@/lodash/1.0.0/abc123/node_modules/lodash"
+printf 'x\n' > "$STORE/links/@/lodash/1.0.0/abc123/node_modules/lodash/index.js"
+
+PASS=0; FAIL=0
+ok(){ echo "  ✓ $1"; PASS=$((PASS+1)); }
+bad(){ echo "  ✗ $1"; FAIL=$((FAIL+1)); }
+out(){ cat "$TD/out.txt" | sed 's/^/     | /'; }
+run(){ bash "$WT" "$@" >"$TD/out.txt" 2>&1; echo $?; }
+see(){ grep -q "$1" "$TD/out.txt"; }
+
+mkrepo(){ git -C "$1" init -q; printf 'x\n' > "$1/f"; git -C "$1" add -A
+          git -C "$1" -c user.email=t@t -c user.name=t commit -qm init; }
+# 真装形态：node_modules 真目录 + .pnpm 实体 + 顶层链指向 **checkout 内**
+mk_real(){ local d="$1"
+  mkdir -p "$d/node_modules/.pnpm/lodash@1.0.0/node_modules/lodash"
+  printf 'x\n' > "$d/node_modules/.pnpm/lodash@1.0.0/node_modules/lodash/index.js"
+  ln -sfn .pnpm/lodash@1.0.0/node_modules/lodash "$d/node_modules/lodash"
+  printf '{"storeDir": "%s"}\n' "$STORE" > "$d/node_modules/.modules.yaml"; }
+
+echo "== 1. 真装形态（顶层链指向 checkout 内）⇒ 0 违规 =="
+A="$TD/repoA"; mkdir -p "$A"; mkrepo "$A"; mk_real "$A"
+[ "$(run check "$A")" = 0 ] && ok "退出码 0" || { bad "退出码应为 0"; out; }
+see "全部干净" && ok "输出「全部干净」" || { bad "缺「全部干净」"; out; }
+
+echo "== 2. A：顶层 node_modules 本身是软链 ⇒ 违规 =="
+B="$TD/repoB"; mkdir -p "$B"; mkrepo "$B"; mk_real "$B"     # B 是"另一个 checkout"
+rm -rf "$A/node_modules"; ln -sfn "$B/node_modules" "$A/node_modules"
+RC="$(run check "$A")"
+[ "$RC" = 1 ] && ok "退出码 1" || { bad "退出码应为 1（实得 ${RC}）"; out; }
+see "A 顶层 node_modules 是软链" && ok "报 A 类" || { bad "未报 A 类"; out; }
+see "$B/node_modules" && ok "报出目标 checkout" || { bad "未报出目标"; out; }
+
+echo "== 3. B：顶层链逃出 checkout（指向别的 checkout）⇒ 违规 =="
+rm -f "$A/node_modules"                                     # 先摘掉第 2 步的软链（否则后续夹具会顺着链写进 repoB）
+mk_real "$A"                                                # 恢复真目录，只留一条逃逸链
+ln -sfn "$B/node_modules/.pnpm/lodash@1.0.0/node_modules/lodash" "$A/node_modules/lodash-foreign"
+RC="$(run check "$A")"
+[ "$RC" = 1 ] && ok "退出码 1" || { bad "退出码应为 1（实得 ${RC}）"; out; }
+see "B 顶层链指向其他 checkout" && ok "报 B 类" || { bad "未报 B 类"; out; }
+rm -f "$A/node_modules/lodash-foreign"
+
+echo "== 4. C：顶层链悬空 ⇒ 违规 =="
+ln -sfn "$TD/gone/node_modules/lodash" "$A/node_modules/lodash-dangling"
+RC="$(run check "$A")"
+[ "$RC" = 1 ] && ok "退出码 1" || { bad "退出码应为 1（实得 ${RC}）"; out; }
+see "C 顶层链悬空" && ok "报 C 类" || { bad "未报 C 类"; out; }
+rm -f "$A/node_modules/lodash-dangling"
+
+echo "== 5. ✅ GVS 白名单：链指向 <storeDir>/links ⇒ **不算违规**（启用官方共享方案后不误报）=="
+ln -sfn "$STORE/links/@/lodash/1.0.0/abc123/node_modules/lodash" "$A/node_modules/lodash-gvs"
+RC="$(run check "$A")"
+[ "$RC" = 0 ] && ok "退出码 0（白名单生效）" || { bad "退出码应为 0（实得 ${RC}）：GVS 链被误判"; out; }
+rm -f "$A/node_modules/lodash-gvs"
+
+echo "== 6. D：深层链逃逸 ⇒ 默认不报、--deep 才报 =="
+mkdir -p "$A/node_modules/.pnpm/foo@1.0.0/node_modules"
+ln -sfn "$B/node_modules/.pnpm/lodash@1.0.0/node_modules/lodash" "$A/node_modules/.pnpm/foo@1.0.0/node_modules/foo"
+RC="$(run check "$A")"
+[ "$RC" = 0 ] && ok "默认（浅扫）0 违规" || { bad "浅扫不该报深层链（实得 ${RC}）"; out; }
+RC="$(run check "$A" --deep)"
+[ "$RC" = 1 ] && ok "--deep 退出码 1" || { bad "--deep 应报违规（实得 ${RC}）"; out; }
+see "D 深层链逃逸" && ok "--deep 报 D 类" || { bad "--deep 未报 D 类"; out; }
+rm -rf "$A/node_modules/.pnpm/foo@1.0.0"
+
+echo "== 7. 全覆盖：主仓 ✓ + worktree ✗ 同时报出 =="
+W="$TD/repoW"; mkdir -p "$W"; mkrepo "$W"; mk_real "$W"
+git -C "$W" worktree add -q "$TD/repoW-worktree--t1" -b t1
+mkdir -p "$TD/repoW-worktree--t1"; rm -rf "$TD/repoW-worktree--t1/node_modules"
+ln -sfn "$W/node_modules" "$TD/repoW-worktree--t1/node_modules"
+RC="$(run check "$W")"
+[ "$RC" = 1 ] && ok "退出码 1" || { bad "退出码应为 1（实得 ${RC}）"; out; }
+see "repoW · 主仓 0 违规" && ok "主仓判干净" || { bad "主仓未被判为干净（误报）"; out; }
+see "repoW-worktree--t1 违规" && ok "worktree 被判违规" || { bad "worktree 未被判违规"; out; }
+
+echo "== 8. clean 守卫：软链 node_modules 的 worktree ⇒ 拒绝清理且目录保留 =="
+RC="$(run clean "$W" t1)"
+[ "$RC" = 1 ] && ok "退出码 1（拒绝）" || { bad "应拒绝清理（实得 ${RC}）"; out; }
+see "拒绝清理" && ok "提示「拒绝清理」" || { bad "缺拒绝提示"; out; }
+see "check" && ok "指引先跑 check" || { bad "缺 check 指引"; out; }
+[ -d "$TD/repoW-worktree--t1" ] && ok "worktree 目录仍在（未被动）" || bad "worktree 被删了（守卫失效）"
+rm -f "$TD/repoW-worktree--t1/node_modules"                  # 收尾：删链后应可正常清理
+
+echo "== 9. --all：仓根杂散 node_modules 也算违规 =="
+mkdir -p "$DIA_WT_REPOS_ROOT/node_modules"
+RC="$(run check --all)"
+[ "$RC" = 1 ] && ok "退出码 1" || { bad "退出码应为 1（实得 ${RC}）"; out; }
+see "杂散" && ok "报杂散" || { bad "未报杂散"; out; }
+rm -rf "$DIA_WT_REPOS_ROOT/node_modules"
+
+echo "== 10. 退出码契约：未知子命令=2 / 参数错=1 =="
+bash "$WT" bogus-subcmd >/dev/null 2>&1; RC_UNK=$?
+bash "$WT" check --bogus-flag "$A" >/dev/null 2>&1; RC_ARG=$?
+[ "$RC_UNK" = 2 ] && ok "未知子命令=2" || bad "未知子命令应为 2（实得 ${RC_UNK}）"
+[ "$RC_ARG" = 1 ] && ok "未知参数=1" || bad "未知参数应为 1（实得 ${RC_ARG}）"
+
+echo "== 11. 无 node_modules 的目录 ⇒ 跳过、不报错 =="
+N="$TD/plain"; mkdir -p "$N"
+[ "$(run check "$N")" = 0 ] && ok "退出码 0" || { bad "应 0（实得见现场）"; out; }
+
+echo "== 12. --quiet：干净仓不打印 ✓ 行（定时任务降噪）=="
+run check --quiet "$A" >/dev/null
+see "✓" && bad "--quiet 仍打印 ✓ 行" || ok "--quiet 无 ✓ 行"
+see "全部干净" && ok "仍打印结论行" || { bad "缺结论行"; out; }
+
+echo
+echo "── PASS $PASS · FAIL $FAIL ──"
+rm -rf "$TD"
+[ "$FAIL" = 0 ]

package/packages/wt/tests/clean.test.sh

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# dia wt-clean.test.sh —— `dia wt clean`（R25 收尾闸口）回归测试（2026-10-19）
+#
+# 为什么单独测：`clean` 是**唯一**执行 R25「worktree + 分支」的机械闸口，此前**无测试**。
+# 2026-10-19 实测发现 P0 级静默缺陷：
+#   原实现写死 `br="feat/${feature}"`，而 `create` 接受任意分支名（`review/*`、`fix/*` …）
+#   ⇒ 名字对不上时**跳过删分支且不告警**，仍打印「✅ 清理完成」+ 退出码 0 ⇒ **谎报**。
+#
+# 覆盖：
+#   ① 任意前缀（review/ fix/ feat/ 无前缀）都能删分支 ← 本次修复的核心
+#   ② 已合并 → 删分支 + 退出码 0
+#   ③ 未合并 → **保留分支 + 退出码 1**（不能谎报完成）
+#   ④ detached HEAD → worktree 删掉、不报错、说清楚
+#   ⑤ 有未提交改动 → 拒绝（worktree 与分支都不动）
+#   ⑥ 软链 node_modules → 拒绝（R20 守卫仍在）
+#   ⑦ 清理后 worktree 目录确实消失
+#
+# 用法：bash scripts/dia wt-clean.test.sh     （退出码 0 = 全绿）
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WT="$HERE/../bin/dia-wt"
+TD="$(mktemp -d)"
+trap 'rm -rf "$TD"' EXIT
+export DIA_WT_DATA_ROOT="$TD/dr" DIA_WT_REPOS_ROOT="$TD/repos"
+mkdir -p "$DIA_WT_DATA_ROOT" "$DIA_WT_REPOS_ROOT"
+
+PASS=0; FAIL=0
+ok(){ echo "  ✓ $1"; PASS=$((PASS+1)); }
+bad(){ echo "  ✗ $1"; FAIL=$((FAIL+1)); }
+out(){ sed 's/^/     | /' "$TD/out.txt"; }
+run(){ bash "$WT" "$@" >"$TD/out.txt" 2>&1; echo $?; }
+see(){ grep -q "$1" "$TD/out.txt"; }
+
+mkrepo(){ git -C "$1" init -q -b main; printf 'x\n' > "$1/f"
+          git -C "$1" add -A
+          git -C "$1" -c user.email=t@t -c user.name=t commit -qm init; }
+
+# 建一个 worktree（模拟 dia wt create 的产物：平级目录 + 指定分支名）
+mkwt(){ local repo="$1" feature="$2" branch="$3"
+  local parent; parent="$(cd "$(dirname "$repo")" && pwd)"
+  git -C "$repo" worktree add "$parent/$(basename "$repo")-worktree--$feature" -b "$branch" >/dev/null 2>&1
+}
+
+echo '== ① 任意分支前缀都能删（本次修复核心）=='
+for br in 'review/head-gate' 'fix/wt-clean' 'feat/plain' 'no-prefix'; do
+  R="$TD/r-$br"; mkdir -p "$R"; mkrepo "$R"
+  f="t$(echo "$br" | tr '/-' '__')"
+  mkwt "$R" "$f" "$br"
+  rc="$(run clean "$R" "$f")"
+  if [ "$rc" = 0 ] && ! git -C "$R" rev-parse --verify --quiet "refs/heads/$br" >/dev/null; then
+    ok "${br}：已删分支 + 退出码 0"
+  else
+    bad "${br}：应删分支且退出码 0（实际 rc=${rc}）"; out
+  fi
+  [ -d "$TD/$(basename "$R")-worktree--$f" ] && bad "${br}：worktree 目录仍存在" || ok "${br}：worktree 目录已删"
+done
+
+echo '== ② 已合并分支 → 删分支 + rc 0 =='
+R="$TD/r-merged"; mkdir -p "$R"; mkrepo "$R"; mkwt "$R" m1 'review/merged'
+# 把分支内容合进 main，使其可被 -d 删除
+git -C "$R" merge --no-ff -q 'review/merged' -m merge 2>/dev/null
+rc="$(run clean "$R" m1)"
+[ "$rc" = 0 ] && ! git -C "$R" rev-parse --verify --quiet refs/heads/review/merged >/dev/null \
+  && ok '已合并：分支已删、rc 0' || { bad "已合并：应删分支 rc=0（实际 rc=${rc}）"; out; }
+
+echo '== ③ 未合并分支 → 保留分支 + rc 1（不谎报完成）=='
+R="$TD/r-unmerged"; mkdir -p "$R"; mkrepo "$R"; mkwt "$R" u1 'review/unmerged'
+# 在分支上加提交，使其未合并
+( cd "$TD/r-unmerged-worktree--u1" && printf 'y\n' > y.txt && git add -A \
+  && git -c user.email=t@t -c user.name=t commit -qm 'branch only' ) >/dev/null 2>&1
+rc="$(run clean "$R" u1)"
+[ "$rc" = 1 ] && git -C "$R" rev-parse --verify --quiet refs/heads/review/unmerged >/dev/null \
+  && ok '未合并：分支保留 + rc 1' || { bad "未合并：应保留分支且 rc=1（实际 rc=${rc}）"; out; }
+see '未完全合并' && ok '未合并：有明确告警文案' || { bad '未合并：缺告警文案'; out; }
+[ -d "$TD/r-unmerged-worktree--u1" ] && bad '未合并：worktree 应已删' || ok '未合并：worktree 已删'
+
+echo '== ④ detached HEAD → 删 worktree、不报错 =='
+R="$TD/r-detached"; mkdir -p "$R"; mkrepo "$R"
+parent="$(cd "$(dirname "$R")" && pwd)"
+git -C "$R" worktree add --detach "$parent/$(basename "$R")-worktree--d1" >/dev/null 2>&1
+rc="$(run clean "$R" d1)"
+[ "$rc" = 0 ] && [ ! -d "$parent/$(basename "$R")-worktree--d1" ] \
+  && ok 'detached：worktree 已删、rc 0' || { bad "detached：应 rc=0 且目录消失（实际 rc=${rc}）"; out; }
+see 'detached HEAD' && ok 'detached：说明了跳过删分支' || { bad 'detached：未说明'; out; }
+
+echo '== ⑤ 有未提交改动 → 拒绝（不动 worktree / 分支）=='
+R="$TD/r-dirty"; mkdir -p "$R"; mkrepo "$R"; mkwt "$R" d1 'review/dirty'
+printf 'dirty\n' > "$TD/r-dirty-worktree--d1/dirty.txt"
+rc="$(run clean "$R" d1)"
+[ "$rc" = 1 ] && [ -d "$TD/r-dirty-worktree--d1" ] \
+  && git -C "$R" rev-parse --verify --quiet refs/heads/review/dirty >/dev/null \
+  && ok '脏工作区：拒绝且未动' || { bad "脏工作区：应拒绝且不动（rc=${rc}）"; out; }
+see '唯一工作副本' && ok '脏工作区：给了抢救提示' || { bad '脏工作区：缺抢救提示'; out; }
+
+echo '== ⑥ 软链 node_modules → 拒绝（R20 守卫）=='
+R="$TD/r-link"; mkdir -p "$R"; mkrepo "$R"; mkwt "$R" l1 'review/link'
+ln -sfn "$TD/store-node_modules" "$TD/r-link-worktree--l1/node_modules"
+rc="$(run clean "$R" l1)"
+[ "$rc" = 1 ] && [ -d "$TD/r-link-worktree--l1" ] && ok '软链：拒绝且未动' \
+  || { bad "软链：应拒绝（rc=${rc}）"; out; }
+
+echo '== ⑦ worktree 不存在 → 明确报错 =='
+R="$TD/r-missing"; mkdir -p "$R"; mkrepo "$R"
+rc="$(run clean "$R" nope)"
+[ "$rc" = 1 ] && ok '不存在：rc 1' || bad "不存在：应 rc=1（实际 ${rc}）"
+
+echo '== ⑧ 远端分支仍在 → 提示清理命令（不自动删）=='
+R="$TD/r-remote"; mkdir -p "$R"; mkrepo "$R"
+# 造一个假的 origin（裸库），推一个分支上去
+git init -q --bare "$TD/remote.git"
+git -C "$R" remote add origin "$TD/remote.git"
+git -C "$R" push -q -u origin main 2>/dev/null
+mkwt "$R" r1 'review/remote'
+( cd "$TD/r-remote-worktree--r1" && printf 'z\n' > z.txt && git add -A \
+  && git -c user.email=t@t -c user.name=t commit -qm 'r' && git push -q -u origin review/remote ) >/dev/null 2>&1
+# 先合进 main 让本地分支可删
+git -C "$R" merge --no-ff -q 'review/remote' -m merge 2>/dev/null
+git -C "$R" push -q origin main 2>/dev/null
+rc="$(run clean "$R" r1)"
+see '远端分支仍在' && ok '远端存在：明确提示' || { bad '远端存在：未提示'; out; }
+see 'push origin --delete' && ok '远端存在：给了删除命令' || { bad '远端存在：缺命令'; out; }
+
+echo
+printf '结果：%d 通过，%d 失败\n' "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]

package/packages/wt/tests/prune-merged.test.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# dia wt-prune-merged.test.sh —— `prune-merged`（R25 定期闸口）回归测试（2026-10-19）
+#
+# 为什么测：这是**破坏性**操作（删分支），判据错会误删他人工作。必须机械验证：
+#   · 只删「已并入 base」的分支（`-d` 语义）
+#   · **不删**当前分支 / 被 worktree 占用的分支 / 保护名单 / 未合并分支
+#   · 默认 dry-run（不删），`--apply` 才真删
+#   · 退出码：0=干净或已清完 / 1=仍有残留
+#   · `--quiet` 只输出分支名（供巡检任务消费）
+#
+# 用法：bash scripts/dia wt-prune-merged.test.sh    （退出码 0 = 全绿）
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WT="$HERE/../bin/dia-wt"
+TD="$(mktemp -d)"
+trap 'rm -rf "$TD"' EXIT
+export DIA_WT_DATA_ROOT="$TD/dr" DIA_WT_REPOS_ROOT="$TD/repos"
+mkdir -p "$DIA_WT_DATA_ROOT" "$DIA_WT_REPOS_ROOT"
+
+PASS=0; FAIL=0
+ok(){ echo "  ✓ $1"; PASS=$((PASS+1)); }
+bad(){ echo "  ✗ $1"; FAIL=$((FAIL+1)); }
+out(){ sed 's/^/     | /' "$TD/out.txt"; }
+run(){ bash "$WT" prune-merged "$@" >"$TD/out.txt" 2>&1; echo $?; }
+see(){ grep -q "$1" "$TD/out.txt"; }
+notsee(){ grep -q "$1" "$TD/out.txt" && return 1 || return 0; }
+
+# 造仓库：main 有 init 提交；另有 origin/main 指向同一提交（模拟真实基线）
+mkrepo(){
+  local r="$1"; mkdir -p "$r"; git -C "$r" init -q -b main
+  printf 'x\n' > "$r/f"; git -C "$r" add -A
+  git -C "$r" -c user.email=t@t -c user.name=t commit -qm init
+  git -C "$r" update-ref refs/remotes/origin/main refs/heads/main
+}
+# 建一个已并入 main 的分支（内容与 main 相同 → git 认为是 ancestor）
+mkmerged(){ git -C "$1" branch "$2" main >/dev/null 2>&1; }
+# 建一个未并入的分支
+mkunmerged(){
+  local r="$1" b="$2"
+  git -C "$r" checkout -q -b "$b" main
+  # ⚠️ 文件名不能用分支名（含 `/` 会变成子目录 → 写入失败 → 提交没发生 → 分支等于 main）
+  printf 'y\n' > "$r/unmerged-marker.txt"; git -C "$r" add -A
+  git -C "$r" -c user.email=t@t -c user.name=t commit -qm "$b only"
+  git -C "$r" checkout -q main
+}
+
+echo '== ① dry-run：只列出、不删除、退出码 1 =='
+R="$TD/r1"; mkrepo "$R"
+mkmerged "$R" feat/done1; mkmerged "$R" review/done2
+rc="$(run "$R")"
+[ "$rc" = 1 ] && ok '有残留 → 退出码 1' || { bad "应 rc=1（实际 ${rc}）"; out; }
+see 'feat/done1' && see 'review/done2' && ok '列出了两个残留分支' || { bad '未列出残留'; out; }
+git -C "$R" rev-parse --verify -q refs/heads/feat/done1 >/dev/null \
+  && ok 'dry-run 未删除' || bad 'dry-run 却删了分支'
+
+echo '== ② --apply：真删已合并分支 =='
+rc="$(run "$R" --apply)"
+[ "$rc" = 0 ] && ok '全部删净 → 退出码 0' || { bad "应 rc=0（实际 ${rc}）"; out; }
+git -C "$R" rev-parse --verify -q refs/heads/feat/done1 >/dev/null \
+  && bad 'feat/done1 仍在' || ok 'feat/done1 已删'
+git -C "$R" rev-parse --verify -q refs/heads/review/done2 >/dev/null \
+  && bad 'review/done2 仍在' || ok 'review/done2 已删'
+
+echo '== ③ 保护名单：main / master / develop / 自定义 =='
+R="$TD/r2"; mkrepo "$R"
+git -C "$R" branch develop main; git -C "$R" branch keepme main
+mkmerged "$R" feat/gone
+rc="$(run "$R" --apply --protect main,master,develop,dev,keepme)"
+git -C "$R" rev-parse --verify -q refs/heads/main >/dev/null && ok 'main 保留' || bad 'main 被删'
+git -C "$R" rev-parse --verify -q refs/heads/develop >/dev/null && ok 'develop 保留' || bad 'develop 被删'
+git -C "$R" rev-parse --verify -q refs/heads/keepme >/dev/null && ok '自定义保护生效' || bad 'keepme 被删'
+git -C "$R" rev-parse --verify -q refs/heads/feat/gone >/dev/null && bad 'feat/gone 应被删' || ok '非保护分支已删'
+
+echo '== ④ 未合并分支：绝不删 =='
+R="$TD/r3"; mkrepo "$R"
+mkunmerged "$R" feat/wip
+rc="$(run "$R" --apply)"
+[ "$rc" = 0 ] && ok '无已合并残留 → rc 0' || { bad "应 rc=0（实际 ${rc}）"; out; }
+git -C "$R" rev-parse --verify -q refs/heads/feat/wip >/dev/null \
+  && ok '未合并分支保留' || bad '未合并分支被误删！'
+notsee 'feat/wip' && ok '未合并分支未出现在候选里' || { bad '未合并分支被列为候选'; out; }
+
+echo '== ⑤ 被 worktree 占用的分支：跳过 =='
+R="$TD/r4"; mkrepo "$R"
+mkmerged "$R" feat/wt-branch
+parent="$(cd "$(dirname "$R")" && pwd)"
+git -C "$R" worktree add "$parent/$(basename "$R")-worktree--wt" feat/wt-branch >/dev/null 2>&1
+rc="$(run "$R" --apply)"
+git -C "$R" rev-parse --verify -q refs/heads/feat/wt-branch >/dev/null \
+  && ok '被 worktree 占用的分支保留' || bad '误删了 worktree 正在用的分支！'
+git -C "$R" worktree remove "$parent/$(basename "$R")-worktree--wt" --force >/dev/null 2>&1
+
+echo '== ⑥ 当前分支：跳过 =='
+R="$TD/r5"; mkrepo "$R"
+git -C "$R" checkout -q -b feat/current main
+rc="$(run "$R" --apply)"
+git -C "$R" rev-parse --verify -q refs/heads/feat/current >/dev/null \
+  && ok '当前分支保留' || bad '误删当前分支！'
+
+echo '== ⑦ --quiet：只输出分支名（供巡检消费）=='
+R="$TD/r6"; mkrepo "$R"
+mkmerged "$R" feat/q1; mkmerged "$R" feat/q2
+bash "$WT" prune-merged "$R" --quiet >"$TD/out.txt" 2>&1
+[ "$(grep -c 'feat/q' "$TD/out.txt")" = 2 ] && ok '输出 2 行分支名' || { bad '输出行数不对'; out; }
+notsee '仓库：' && ok 'quiet 无装饰性输出' || { bad 'quiet 仍有装饰输出'; out; }
+
+echo '== ⑧ 干净仓库：rc 0 + 明确提示 =='
+R="$TD/r7"; mkrepo "$R"
+rc="$(run "$R")"
+[ "$rc" = 0 ] && ok '干净 → rc 0' || bad "应 rc=0（实际 ${rc}）"
+see '无已合并的残留分支' && ok '有明确提示' || { bad '缺提示'; out; }
+
+echo '== ⑨ 基线不存在：明确报错 =='
+R="$TD/r8"; mkrepo "$R"
+rc="$(run "$R" --base origin/nonexistent)"
+[ "$rc" = 1 ] && ok '基线缺失 → rc 1' || bad "应 rc=1（实际 ${rc}）"
+see '基线不存在' && ok '有明确报错' || { bad '缺报错文案'; out; }
+
+echo '== ⑩ --all：批量扫仓（无基线的仓跳过、不中断）=='
+RR="$TD/reposleyan"; mkdir -p "$RR"
+A="$RR/repoA"; mkrepo "$A"; mkmerged "$A" feat/a-gone
+B="$RR/repoB"; mkdir -p "$B"; git -C "$B" init -q -b main
+printf 'x\n' > "$B/f"; git -C "$B" add -A
+git -C "$B" -c user.email=t@t -c user.name=t commit -qm init   # 无 origin/main
+C="$RR/repoC"; mkrepo "$C"; mkmerged "$C" feat/c-gone
+export DIA_WT_REPOS_ROOT="$RR"
+rc="$(run --all)"
+[ "$rc" = 1 ] && ok '--all 有残留 → rc 1' || { bad "应 rc=1（实际 ${rc}）"; out; }
+see 'feat/a-gone' && see 'feat/c-gone' && ok '扫到两个仓的残留' || { bad '漏扫'; out; }
+notsee 'feat/b' && ok '无基线仓不产生候选（不误删）' || { bad 'repoB 不应有候选'; out; }
+# ⚠️ 非 quiet 模式下「跳过 repoB」的告警是**预期行为**（让人知道少扫了一个仓）；
+#    断言重点 = **不中断**（后面 repoC 仍被扫到）——上面 see 'feat/c-gone' 已覆盖。
+see '跳过' && ok '无基线仓给出跳过说明（不静默）' || { bad '无基线仓应说明'; out; }
+# --all + --apply 一次清完
+rc="$(run --all --apply)"
+[ "$rc" = 0 ] && ok '--all --apply → rc 0' || { bad "应 rc=0（实际 ${rc}）"; out; }
+git -C "$A" rev-parse --verify -q refs/heads/feat/a-gone >/dev/null && bad 'a-gone 仍在' || ok 'repoA 已清'
+git -C "$C" rev-parse --verify -q refs/heads/feat/c-gone >/dev/null && bad 'c-gone 仍在' || ok 'repoC 已清'
+unset DIA_WT_REPOS_ROOT
+
+echo '== ⑪ upstream 落后于本地（`-d` 误拒的真实根因）=='
+# 复现：分支 push -u 后又提交（远端落后）→ 合进 main → `-d` 会因「未并入 upstream」拒绝，
+# 即使该分支**已完全并入 main**（example-repo fix/format-superbook-cli 的真实情形）。
+R="$TD/r9"; mkrepo "$R"
+git -C "$R" init -q --bare "$TD/remote9.git"
+git -C "$R" remote add origin "$TD/remote9.git"
+git -C "$R" push -q -u origin main 2>/dev/null
+git -C "$R" checkout -q -b feat/upstream-behind main
+printf 'u\n' > "$R/u.txt"; git -C "$R" add -A
+git -C "$R" -c user.email=t@t -c user.name=t commit -qm 'u1'
+git -C "$R" push -q -u origin feat/upstream-behind 2>/dev/null   # 远端 = u1
+printf 'u2\n' > "$R/u2.txt"; git -C "$R" add -A
+git -C "$R" -c user.email=t@t -c user.name=t commit -qm 'u2'      # 本地再提交 → 远端落后
+git -C "$R" checkout -q main
+git -C "$R" -c user.email=t@t -c user.name=t merge -q --no-ff feat/upstream-behind -m merge
+git -C "$R" update-ref refs/remotes/origin/main refs/heads/main
+# 前置确认：确实「已并入 origin/main」但 upstream 落后
+git -C "$R" merge-base --is-ancestor feat/upstream-behind refs/remotes/origin/main \
+  && ok '前置：分支已并入 origin/main' || bad '前置条件不成立'
+[ "$(git -C "$R" rev-parse feat/upstream-behind)" != "$(git -C "$R" rev-parse origin/feat/upstream-behind)" ] \
+  && ok '前置：远端确实落后' || bad '前置：远端未落后'
+rc="$(run "$R" --apply)"
+git -C "$R" rev-parse --verify -q refs/heads/feat/upstream-behind >/dev/null \
+  && bad 'upstream 落后导致误拒（未修复）' || ok '已正确删除（不再被 upstream 挡住）'
+
+echo
+printf '结果：%d 通过，%d 失败\n' "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]

package/packages/wt/tests/route.test.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+# dia wt-route.test.sh —— `dia wt route` 回归测试（R1.7 配置驱动判定，2026-10-16）
+#
+# 覆盖（**为什么是这些**）：
+#   · 无配置时**绝不放行**：即便命名空间看着像我的，也只能走 MR（不瞎猜"我是谁"）
+#   · 命名空间推导：配置了 my_namespaces 后，我的仓自动直推
+#   · 显式名单：direct 放行 / mr **否决优先**
+#   · 个人仓基线 + 数据根本地**并集合并**；数据根配置**可以是软链**
+#   · 空列表**不误命中**（`grep -qx ""` 匹配空行是这类脚本的经典假阳性）
+#   · 坏 JSON 不崩、无 remote / 非 git 仓 → 信息不足（rc=2，安全侧）
+#   · worktree 路径输入 → 归主仓判定（沿用既有行为）
+# 用法：bash scripts/dia wt-route.test.sh   （退出码 0 = 全绿）
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WT="$HERE/../bin/dia-wt"
+TD="$(mktemp -d)"
+export DIA_WT_DATA_ROOT="$TD/dr" PERSONAL_AGENT_DIR="$TD/pa"
+mkdir -p "$DIA_WT_DATA_ROOT" "$PERSONAL_AGENT_DIR/config"
+PASS=0; FAIL=0
+ok(){ echo "  ✓ $1"; PASS=$((PASS+1)); }
+bad(){ echo "  ✗ $1"; FAIL=$((FAIL+1)); }
+out(){ sed 's/^/     | /' "$TD/out.txt"; }
+run(){ env -u DIA_WT_ROUTE_CONFIG bash "$WT" route "$@" >"$TD/out.txt" 2>&1; echo $?; }
+see(){ grep -q "$1" "$TD/out.txt"; }
+setcfg(){ printf '%s\n' "$2" > "$1"; }
+CFG="$DIA_WT_DATA_ROOT/route.json"
+BASE="$PERSONAL_AGENT_DIR/config/yan-route.json"
+
+mkrepo(){  # <name> <remote-url>（空 URL ⇒ 不配 remote）
+  local d="$TD/$1"; mkdir -p "$d"; git -C "$d" init -q
+  [ -n "${2:-}" ] && git -C "$d" remote add origin "$2"
+  printf 'x\n' > "$d/f"; git -C "$d" add -A
+  git -C "$d" -c user.email=t@t -c user.name=t commit -qm init; printf '%s' "$d"
+}
+MINE="$(mkrepo myrepo git@git.example.com:example-user/myrepo.git)"
+TEAM="$(mkrepo teamrepo https://git.example.com/fed/teamrepo.git)"
+NOREMOTE="$(mkrepo noremote)"
+
+echo "== 1. 无配置 + 非我命名空间 ⇒ MR（安全侧）=="
+[ "$(run "$TEAM")" = 1 ] && ok "退出码 1" || { bad "应 1"; out; }
+see "安全侧默认 MR" && ok "给出默认理由" || { bad "缺理由"; out; }
+
+echo "== 2. 无配置 + 命名空间看着像我的 ⇒ **仍 MR**（不瞎猜）=="
+[ "$(run "$MINE")" = 1 ] && ok "退出码 1（未因命名空间相似而放行）" || { bad "应 1：不能瞎猜"; out; }
+see "不在 my_namespaces" && ok "说明未配置" || { bad "缺说明"; out; }
+
+echo "== 3. 配置 my_namespaces ⇒ 我的仓自动直推 =="
+setcfg "$CFG" '{ "my_namespaces": ["example-user"] }'
+[ "$(run "$MINE")" = 0 ] && ok "退出码 0" || { bad "应 0"; out; }
+see "∈ my_namespaces" && ok "判定来源 = 命名空间" || { bad "来源不对"; out; }
+[ "$(run "$TEAM")" = 1 ] && ok "非我命名空间仍 MR" || { bad "应 1"; out; }
+
+echo "== 4. direct 名单 ⇒ 直推（覆盖默认）=="
+setcfg "$CFG" '{ "my_namespaces": ["example-user"], "direct": ["teamrepo"] }'
+[ "$(run "$TEAM")" = 0 ] && ok "退出码 0" || { bad "应 0"; out; }
+see "配置 direct 名单命中" && ok "判定来源 = 配置" || { bad "来源不对"; out; }
+
+echo "== 5. mr 名单 ⇒ **否决优先**（即便同时命中 direct）=="
+setcfg "$CFG" '{ "my_namespaces": ["example-user"], "direct": ["teamrepo"], "mr": ["teamrepo"] }'
+[ "$(run "$TEAM")" = 1 ] && ok "退出码 1（否决压过放行）" || { bad "应 1"; out; }
+see "显式否决" && ok "给出否决理由" || { bad "缺理由"; out; }
+
+echo "== 6. 个人仓基线 + 数据根 ⇒ 并集合并（判定来源列出两个文件）=="
+setcfg "$CFG" '{ "direct": ["teamrepo"] }'
+setcfg "$BASE" '{ "my_namespaces": ["example-user"], "direct": ["myrepo"] }'
+[ "$(run "$TEAM")" = 0 ] && ok "本地新增生效（teamrepo 直推）" || { bad "本地配置未生效"; out; }
+see "route.json" && ok "来源含数据根文件" || { bad "缺来源"; out; }
+[ "$(run "$MINE")" = 0 ] && ok "基线条目保留（myrepo 直推）" || { bad "基线未生效"; out; }
+see "yan-route.json" && ok "来源含基线文件" || { bad "缺基线来源"; out; }
+[ "$(run "$NOREMOTE")" = 2 ] && ok "无 remote 的仓：信息不足（rc=2）" || { bad "应 2"; out; }
+
+echo "== 7. 数据根配置**是软链** ⇒ 生效（指向个人仓版本化文件）=="
+mv "$CFG" "$TD/route-real.json"; ln -s "$TD/route-real.json" "$CFG"
+[ "$(run "$TEAM")" = 0 ] && ok "软链配置被读到" || { bad "软链未生效"; out; }
+rm -f "$CFG"; setcfg "$CFG" '{}'
+
+echo "== 8. 空列表**不误命中**（经典假阳性：空串匹配空行）=="
+setcfg "$CFG" '{ "my_namespaces": [], "direct": [], "mr": [] }'
+[ "$(run "$TEAM")" = 1 ] && ok "空名单 ⇒ MR" || { bad "空名单误放行"; out; }
+
+echo "== 9. 坏 JSON ⇒ 不崩、按无配置处理并提示 =="
+setcfg "$CFG" '{ this is not json'
+RC="$(run "$TEAM")"
+[ "$RC" = 1 ] && ok "退出码 1（安全侧）" || { bad "应 1（实得 ${RC}）"; out; }
+see "JSON 解析失败" && ok "提示解析失败" || { bad "缺解析失败提示"; out; }
+
+echo "== 10. \$DIA_WT_ROUTE_CONFIG 显式指定 ⇒ 最高优先（忽略其余）=="
+setcfg "$CFG" '{ "direct": ["myrepo"] }'
+EX="$TD/explicit.json"; setcfg "$EX" '{ "direct": ["teamrepo"] }'
+env DIA_WT_ROUTE_CONFIG="$EX" bash "$WT" route "$TEAM" >"$TD/out.txt" 2>&1; RC=$?
+[ "$RC" = 0 ] && ok "显式配置生效（teamrepo 直推）" || { bad "显式配置未生效（rc=${RC}）"; out; }
+env DIA_WT_ROUTE_CONFIG="$EX" bash "$WT" route "$MINE" >"$TD/out.txt" 2>&1; RC=$?
+[ "$RC" = 1 ] && ok "其余配置被忽略（myrepo 未直推）" || { bad "应忽略数据根配置（rc=${RC}）"; out; }
+rm -f "$EX"
+
+echo "== 11. worktree 路径输入 ⇒ 归主仓判定 =="
+setcfg "$CFG" '{ "direct": ["teamrepo"] }'
+git -C "$TEAM" worktree add -q "$TD/teamrepo-worktree--t1" -b t1 >/dev/null 2>&1
+RC="$(run "$TD/teamrepo-worktree--t1")"
+[ "$RC" = 0 ] && ok "worktree 归主仓 → 直推" || { bad "worktree 判定错（rc=${RC}）"; out; }
+see "teamrepo" && ok "报出主仓名" || { bad "未报主仓名"; out; }
+
+echo "== 12. 非 git 目录 ⇒ 信息不足（rc=2）=="
+mkdir -p "$TD/plain"
+[ "$(run "$TD/plain")" = 2 ] && ok "退出码 2" || { bad "应 2"; out; }
+see "不是 git 仓" && ok "给出理由" || { bad "缺理由"; out; }
+
+echo
+echo "── PASS $PASS · FAIL $FAIL ──"
+rm -rf "$TD"
+[ "$FAIL" = 0 ]

package/packages/wt/tests/scope.test.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# dia wt-scope.test.sh —— `dia wt scope` 的回归测试（G2，2026-10-15）
+#
+# 覆盖：git 仓 ⇒ 派生 worktree 同级；**非 git 目录 ⇒ 不派生**（用户 2026-10-15 关键要求）；
+#       worktree 路径 ⇒ 归主仓且 mainCheckout=false；scope.json 合法且原子；--show；
+#   ⚠️ 与 yan 权限层（core/perm/scope.mjs）的串联判定已移出本包——那是 yan 域，不是 dia wt 的契约。
+# 用法：bash scripts/dia wt-scope.test.sh     （退出码 0 = 全绿）
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WT="$HERE/../bin/dia-wt"
+
+TD="$(mktemp -d)"; export DIA_WT_DATA_ROOT="$TD/dr"
+PASS=0; FAIL=0
+ok(){ echo "  ✓ $1"; PASS=$((PASS+1)); }
+bad(){ echo "  ✗ $1"; FAIL=$((FAIL+1)); }
+check(){ [ "$2" = "$3" ] && ok "$1（=$2）" || bad "$1：期望 $3，实得 $2"; }
+jq_get(){ python3 -c "import json,sys;print(json.load(open(sys.argv[1])).get(sys.argv[2]))" "$1" "$2"; }
+
+echo "== 1. git 仓库 ⇒ 派生 worktree 同级目录 =="
+mkdir -p "$TD/repoA" && git -C "$TD/repoA" init -q
+bash "$WT" scope "$TD/repoA" --feature demo >/dev/null
+S_DIR="$DIA_WT_DATA_ROOT/tasks/scopes"
+scope_of() { echo "$S_DIR/$(basename "$1").json"; }
+S="$(scope_of "$TD/repoA")"
+check "gitRepo" "$(jq_get "$S" gitRepo)" "True"
+check "mainCheckout" "$(jq_get "$S" mainCheckout)" "True"
+check "sibling 派生" "$(jq_get "$S" siblingWorktreeGlob)" "$TD/repoA-worktree--*"
+check "writable 条目数" "$(python3 -c "import json;print(len(json.load(open('$S'))['writable']))")" "2"
+
+echo "== 2. 非 git 目录 ⇒ **不派生**（关键回归：不会串到兄弟目录）=="
+mkdir -p "$TD/plain/sub"
+bash "$WT" scope "$TD/plain" >/dev/null
+S="$(scope_of "$TD/plain")"
+check "gitRepo=false" "$(jq_get "$S" gitRepo)" "False"
+check "sibling 为空" "$(jq_get "$S" siblingWorktreeGlob)" "None"
+check "writable 仅自身" "$(python3 -c "import json;print(len(json.load(open('$S'))['writable']))")" "1"
+
+echo "== 3. worktree 路径 ⇒ 归主仓 + mainCheckout=false =="
+git -C "$TD/repoA" worktree add -q "$TD/repoA-worktree--t1" -b t1 2>/dev/null
+bash "$WT" scope "$TD/repoA-worktree--t1" --feature t1 >/dev/null
+S="$(scope_of "$TD/repoA-worktree--t1")"
+check "repo 归到主仓" "$(jq_get "$S" repo)" "$TD/repoA"
+check "active 是 worktree" "$(jq_get "$S" active)" "$TD/repoA-worktree--t1"
+check "mainCheckout=false" "$(jq_get "$S" mainCheckout)" "False"
+
+echo "== 4. --show 按 cwd 打印适用声明 =="
+# ⚠️ 2026-10-16 起 --show 按 **cwd** 选适用作用域 ⇒ 必须在被覆盖的目录里跑
+out4="$(cd "$TD/plain" && bash "$WT" scope --show 2>/dev/null)"
+echo "$out4" | grep -q '"repo"' && ok "--show 输出 JSON" || bad "--show 无输出（cwd=$TD/plain）"
+echo "$out4" | python3 -c "import json,sys;json.load(sys.stdin)" && ok "--show 输出是合法 JSON" || bad "--show 不是合法 JSON"
+
+echo "== 5. （跳过：yan 权限层串联判定归属 yan 域，不在 dia wt 契约内）=="
+
+
+echo "== 6. 并发不覆盖：两个 worktree 各一份 scope（2026-10-16 修）=="
+bash "$WT" scope "$TD/repoA" --feature A >/dev/null
+bash "$WT" scope "$TD/plain" --feature B >/dev/null
+n="$(ls -1 "$DIA_WT_DATA_ROOT/tasks/scopes"/*.json 2>/dev/null | wc -l | tr -d ' ')"
+[ "$n" -ge 2 ] && ok "两份 scope 共存（$n 份）" || bad "应至少 2 份，实得 $n"
+check "A 的 scope 未被 B 覆盖（repo）" "$(jq_get "$(scope_of "$TD/repoA")" repo)" "$TD/repoA"
+check "B 的 scope 也独立存在" "$(jq_get "$(scope_of "$TD/plain")" repo)" "$TD/plain"
+(cd "$TD/repoA" && bash "$WT" scope --show | python3 -c "import json,sys;d=json.load(sys.stdin);print(d['repo'])") > /tmp/showcwd.txt
+check "按 cwd 选用正确" "$(cat /tmp/showcwd.txt)" "$TD/repoA"
+
+echo
+echo "──────── 结果：$PASS 通过 / $FAIL 失败 ────────"
+rm -rf "$TD"
+[ "$FAIL" -eq 0 ]