@ranger1/dx 0.1.94 → 0.1.96

package/lib/cli/commands/core.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { join, relative } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import { logger } from '../../logger.js'
 import { confirmManager } from '../../confirm.js'
 import { execManager } from '../../exec.js'
@@ -83,11 +83,7 @@ export async function handleTest(cli, args) {
 
   // 解析 -t 参数用于指定特定测试用例（使用原始参数列表）
   const allArgs = cli.args  // 使用原始参数列表包含所有标志
-  const testNamePatternIndex = allArgs.indexOf('-t')
-  let testNamePattern = null
-  if (testNamePatternIndex !== -1 && testNamePatternIndex + 1 < allArgs.length) {
-    testNamePattern = allArgs[testNamePatternIndex + 1]
-  }
+  const testNamePattern = resolveTestNamePattern(allArgs)
 
   // 根据测试类型自动设置环境标志
   if (type === 'e2e' && !cli.flags.e2e) {
@@ -120,7 +116,8 @@ export async function handleTest(cli, args) {
       process.exit(1)
     }
 
-    let command = fileCommand.replace('{TEST_PATH}', shellEscape(testPath))
+    const normalizedTestPath = normalizeE2eTestPathForCommand(cli, fileCommand, testPath)
+    let command = fileCommand.replace('{TEST_PATH}', shellEscape(normalizedTestPath))
 
     if (testNamePattern) {
       command += ` -t ${shellEscape(testNamePattern)}`
@@ -179,6 +176,15 @@ function shellEscape(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`
 }
 
+function resolveTestNamePattern(args = []) {
+  const aliases = ['-t', '--name', '--test-name-pattern']
+  for (let i = 0; i < args.length; i++) {
+    if (!aliases.includes(args[i])) continue
+    if (i + 1 < args.length) return args[i + 1]
+  }
+  return null
+}
+
 function shouldUseDirectPathArg(command) {
   const text = String(command || '')
   return (
@@ -196,11 +202,11 @@ function normalizeUnitTestPathForCommand(cli, command, testPath) {
     return rawPath
   }
 
-  const vitestProjectCwd = resolveNxVitestProjectCwd(cli, command)
-  if (!vitestProjectCwd) return rawPath
+  const projectCwd = resolveNxTargetProjectCwd(cli, command, ['test'])
+  if (!projectCwd) return rawPath
 
   const projectRoot = cli?.projectRoot || process.cwd()
-  const absoluteProjectCwd = join(projectRoot, vitestProjectCwd)
+  const absoluteProjectCwd = join(projectRoot, projectCwd)
   const absoluteTestPath = join(projectRoot, rawPath)
   const relativePath = relative(absoluteProjectCwd, absoluteTestPath)
 
@@ -211,33 +217,78 @@ function normalizeUnitTestPathForCommand(cli, command, testPath) {
   return relativePath
 }
 
-function resolveNxVitestProjectCwd(cli, command) {
+function normalizeE2eTestPathForCommand(cli, command, testPath) {
+  const rawPath = String(testPath || '')
+  if (!rawPath) return rawPath
+
+  const projectCwd = resolveNxTargetProjectCwd(cli, command, ['test:e2e'])
+  if (!projectCwd) return rawPath
+
   const projectRoot = cli?.projectRoot || process.cwd()
-  const nxTarget = extractNxTestTarget(command)
-  if (!nxTarget) return null
+  const absoluteProjectCwd = join(projectRoot, projectCwd)
+  const absoluteTestPath = join(projectRoot, rawPath)
+  const relativePath = relative(absoluteProjectCwd, absoluteTestPath)
+
+  if (!relativePath || relativePath.startsWith('..')) {
+    return rawPath
+  }
 
-  const projectConfigPath = join(projectRoot, 'apps', nxTarget, 'project.json')
+  return relativePath
+}
+
+function resolveNxTargetProjectCwd(cli, command, targetNames = []) {
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const nxResolution = extractNxTarget(command, targetNames)
+  if (!nxResolution) return null
+
+  const projectDir = join(projectRoot, 'apps', nxResolution.project)
+  const projectConfigPath = join(projectDir, 'project.json')
   if (!existsSync(projectConfigPath)) return null
 
   try {
     const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf8'))
-    const testTarget = projectConfig?.targets?.test
-    const command = String(testTarget?.options?.command || '')
-    const cwd = testTarget?.options?.cwd
-    if (!/\bvitest\s+run\b/.test(command)) return null
-    if (typeof cwd !== 'string' || cwd.trim().length === 0) return null
-    return cwd
+    const resolvedTarget = projectConfig?.targets?.[nxResolution.target]
+    const cwd = resolvedTarget?.options?.cwd
+    if (typeof cwd === 'string' && cwd.trim().length > 0) {
+      return cwd
+    }
+    if (nxResolution.target === 'test:e2e') {
+      const e2eDir = join(projectDir, 'e2e')
+      if (existsSync(e2eDir)) {
+        return relative(projectRoot, e2eDir)
+      }
+    }
+    return relative(projectRoot, dirname(projectConfigPath))
   } catch {
     return null
   }
 }
 
-function extractNxTestTarget(command) {
+function extractNxTarget(command, targetNames = []) {
   const text = String(command || '').trim()
-  const match =
-    text.match(/\bnx(?:\.js)?\s+test\s+([^\s]+)/) ||
-    text.match(/\bnx(?:\.js)?\s+run\s+([^:\s]+):test\b/)
-  return match?.[1] || null
+  const names = Array.isArray(targetNames) && targetNames.length > 0 ? targetNames : ['test']
+
+  for (const targetName of names) {
+    if (targetName === 'test') {
+      const directMatch = text.match(/\bnx(?:\.js)?\s+test\s+([^\s]+)/)
+      if (directMatch?.[1]) {
+        return { project: directMatch[1], target: 'test' }
+      }
+    }
+
+    const escapedTarget = targetName.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+    const runMatch = text.match(new RegExp(`\\bnx(?:\\.js)?\\s+run\\s+([^:\\s]+):${escapedTarget}\\b`))
+    if (runMatch?.[1]) {
+      return { project: runMatch[1], target: targetName }
+    }
+
+    const directColonMatch = text.match(new RegExp(`\\bnx(?:\\.js)?\\s+${escapedTarget}\\s+([^\\s]+)`))
+    if (directColonMatch?.[1]) {
+      return { project: directColonMatch[1], target: targetName }
+    }
+  }
+
+  return null
 }
 
 export async function handleLint(cli, args) {

package/lib/cli/flags.js

@@ -24,7 +24,11 @@ export const FLAG_DEFINITIONS = {
     { flag: '--name', expectsValue: true },
     { flag: '-n', expectsValue: true },
   ],
-  test: [{ flag: '-t', expectsValue: true }],
+  test: [
+    { flag: '-t', expectsValue: true },
+    { flag: '--name', expectsValue: true },
+    { flag: '--test-name-pattern', expectsValue: true },
+  ],
   package: [
     { flag: '--skip-build' },
     { flag: '--keep-workdir' },

package/lib/cli/help.js

@@ -41,11 +41,11 @@ export function showHelp() {
     '      dx db script fix-pending-transfer-status --prod  # 运行数据库脚本（生产环境，需确认）',
     '      dx db script my-script --dev -- --arg1 --arg2  # 向脚本传递额外参数（-- 后面的部分）',
     '',
-    '  test [type] [target] [path] [-t pattern]  运行测试',
+    '  test [type] [target] [path] [-t pattern|--name pattern]  运行测试',
     '    type: e2e, unit (默认: e2e)',
     '    target: 由 commands.json 的 test.<type>.<target> 决定（e2e 默认会拒绝隐式 all）',
     '    path: 测试文件或目录路径 (guarded e2e target 必填，例如 backend/quantify)',
-    '    -t pattern: 指定测试用例名称模式 (可选，需要和 path 一起使用)',
+    '    -t pattern / --name pattern: 指定测试用例名称模式 (可选，需要和 path 一起使用)',
     '    说明: guarded E2E target 禁止无路径或 all 全量执行，dx test e2e all 也不受支持',
     '',
     '  worktree [action] [num...] Git Worktree管理',
@@ -94,6 +94,7 @@ export function showHelp() {
     '  dx test e2e backend apps/backend/e2e/auth     # 按目录运行后端 E2E',
     '  dx test e2e backend apps/backend/e2e/activity/activity.admin.e2e-spec.ts  # 运行单个E2E测试文件',
     '  dx test e2e backend apps/backend/e2e/activity/activity.admin.e2e-spec.ts -t "should list all activity definitions"  # 运行特定测试用例',
+    '  dx test unit backend apps/backend/src/modules/chat/chat.service.spec.ts --name "should create chat"  # 运行单测中的特定用例',
     '  dx test e2e quantify apps/quantify/e2e/health/health.e2e-spec.ts  # 运行 Quantify E2E 文件',
     '  dx test unit backend apps/backend/src/modules/chat/chat.service.spec.ts  # 运行单个后端单测文件',
     '  dx test e2e all          # 不受支持，必须指定 target 和 path',
@@ -254,13 +255,13 @@ start 命令用法:
     case 'test':
       console.log(`
 test 命令用法:
-  dx test [type] [target] [path] [-t pattern]
+  dx test [type] [target] [path] [-t pattern|--name pattern]
 
 参数说明:
   type: e2e, unit (默认: e2e)
   target: 由 commands.json 的 test.<type>.<target> 决定
   path: guarded e2e target 必须提供文件或目录路径
-  -t pattern: 指定测试用例名称模式，需要和 path 一起使用
+  -t pattern / --name pattern: 指定测试用例名称模式，需要和 path 一起使用
 
 限制说明:
   guarded E2E target 禁止无路径全量执行。

package/lib/codex-initial.js

@@ -59,6 +59,8 @@ async function copyDirMerge({ srcDir, dstDir }) {
 
   for (const file of files) {
     const rel = relative(srcDir, file)
+    const topLevelDir = rel.split('/')[0]
+    if (DEPRECATED_SKILL_DIRS.includes(topLevelDir)) continue
     const target = join(dstDir, rel)
     await ensureDir(dirname(target))
     await fs.copyFile(file, target)
@@ -91,6 +93,7 @@ export async function runCodexInitial(options = {}) {
     await ensureDir(target.dir)
     await removeDeprecatedSkillDirs(target.dir)
     const copyStats = await copyDirMerge({ srcDir: srcSkillsDir, dstDir: target.dir })
+    await removeDeprecatedSkillDirs(target.dir)
     stats.push({ ...target, ...copyStats })
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ranger1/dx",
-  "version": "0.1.94",
+  "version": "0.1.96",
   "type": "module",
   "license": "MIT",
   "repository": {

package/skills/error-handling-audit-fixer/SKILL.md

@@ -9,23 +9,76 @@ description: Use when backend、NestJS、领域异常治理或错误处理审查
 
 先判断项目是否已经具备统一错误处理基础设施，再扫描业务代码是否绕过 `DomainException` / `ErrorCode` 体系。默认只输出审计结果和修复建议，不自动改代码；只有用户明确要求时才进入自动修复。
 
+## 扫描范围
+
+脚本不预设任何项目路径，需要通过 `--src-dir` / `--e2e-dir` 显式传入。执行前必须先完成项目探索（见下方步骤 0）。
+
+以下路径/后缀始终排除，不会产生误报：
+
+| 排除类别 | 路径/后缀 |
+|----------|-----------|
+| 单元测试 | `*.spec.ts`、`*.test.ts`、`*.e2e-spec.ts` |
+| 测试辅助 | `*.mock.ts`、`*.stub.ts`、`*.fixture.ts`、`fixtures/`、`test-utils/`、`testing/`、`__tests__/`、`__test__/` |
+| 基础设施 | `*/filters/`、`prisma/`、`scripts/` |
+| 异常定义 | `*.exception.ts` |
+| 入口文件 | `main.ts` |
+
+只有在用户**明确要求**评估测试债务时，才传 `--e2e-dir` + `--scope e2e` 扫描测试代码。
+
 ## 快速开始
 
-1. 先审计生产代码：
+### 步骤 0：项目探索（每个项目首次执行时必须完成）
+
+在调用脚本前，先探索项目结构，识别出后端生产代码和测试代码的实际路径。方法：
+
+1. 查看项目根目录结构（`ls` 或 Glob）
+2. 识别后端应用目录（可能是 `apps/backend/src`、`src`、`server/src` 等）
+3. 识别测试目录（可能是 `apps/backend/e2e`、`test`、`e2e`、`__tests__` 等）
+4. 如果是 monorepo，可能有多个后端服务，每个都需要单独传 `--src-dir`
+
+典型示例：
+
+| 项目类型 | 生产代码 | 测试代码 |
+|----------|----------|----------|
+| NestJS monorepo | `apps/backend/src` | `apps/backend/e2e` |
+| 单体 NestJS | `src` | `test` 或 `e2e` |
+| 多服务 monorepo | `apps/api/src`、`apps/worker/src` | `apps/api/e2e`、`apps/worker/e2e` |
+
+### 步骤 1：审计生产代码
+
+将探索到的路径传给脚本（`--src-dir` 可传多个）：
+
+```bash
+SKILL_HOME="${SKILL_HOME:-$HOME/.claude/skills}"
+python "$SKILL_HOME/error-handling-audit-fixer/scripts/error_handling_audit.py" \
+  --workspace "$PWD" \
+  --src-dir <探索到的生产代码路径>
+```
+
+示例（当前项目）：
 
 ```bash
-CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
-python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_audit.py" \
+python "$SKILL_HOME/error-handling-audit-fixer/scripts/error_handling_audit.py" \
   --workspace "$PWD" \
-  --scope src
+  --src-dir apps/backend/src
 ```
 
-2. 再按需审计 E2E 或全量：
+多服务示例：
 
 ```bash
-python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_audit.py" \
+python "$SKILL_HOME/error-handling-audit-fixer/scripts/error_handling_audit.py" \
   --workspace "$PWD" \
-  --scope all \
+  --src-dir apps/api/src \
+  --src-dir apps/worker/src
+```
+
+### 步骤 2：（仅在用户明确要求时）审计测试代码
+
+```bash
+python "$SKILL_HOME/error-handling-audit-fixer/scripts/error_handling_audit.py" \
+  --workspace "$PWD" \
+  --e2e-dir <探索到的测试代码路径> \
+  --scope e2e \
   --output-json /tmp/error-handling-audit.json
 ```
 
@@ -37,7 +90,7 @@ python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_aud
 
 ## 执行流程
 
-1. 默认先扫描 `apps/backend/src`，只有在用户明确要求或需要评估测试债务时再扫描 `apps/backend/e2e`。
+1. 默认只扫描 `apps/backend/src`（生产代码）。测试代码、E2E、prisma seed、脚本等非生产路径全部排除。只有在用户明确要求评估测试债务时，才传 `--scope e2e` 扫描测试代码。
 2. 先判断基础设施状态：
    - 是否存在 `DomainException`
    - 是否存在 `ErrorCode`
@@ -56,47 +109,31 @@ python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_aud
 6. 只有在用户明确说“自动修复”“直接改”或等价表述时，才进入落代码阶段。
 7. 若脚本结果与实际代码不一致，必须抽样打开命中文件复核，不要把脚本结果当成绝对真相。
 
-## 审计命令
+## 审计命令（rg 快速复核）
 
-项目具备 ripgrep 时，可先用下列命令快速复核：
+以下 rg 命令用于手工复核，将 `<SRC_DIR>` 替换为步骤 0 探索到的实际路径：
 
 ```bash
 rg "new (BadRequestException|UnauthorizedException|ForbiddenException|NotFoundException|HttpException|InternalServerErrorException)\(" \
-  apps/backend/src apps/backend/e2e \
-  --glob '!*spec.ts' \
+  <SRC_DIR> \
+  --glob '!*spec.ts' --glob '!*test.ts' \
   --glob '!*exception.ts' \
-  --glob '!apps/backend/src/common/filters/**' \
-  --glob '!apps/backend/src/main.ts'
+  --glob '!*/filters/**' \
+  --glob '!*main.ts'
 ```
 
 ```bash
-rg "new Error\(" apps/backend/src apps/backend/e2e --glob '!*spec.ts'
+rg "new Error\(" <SRC_DIR> --glob '!*spec.ts' --glob '!*test.ts'
 ```
 
 ```bash
-rg "new DomainException\([^)]*$" -A3 apps/backend/src
+rg "new DomainException\([^)]*$" -A3 <SRC_DIR>
 ```
 
 ```bash
-rg "DomainException\([^)]*[\u4e00-\u9fa5]" apps/backend/src apps/backend/e2e \
+rg "DomainException\([^)]*[\u4e00-\u9fa5]" <SRC_DIR> \
   --glob '!*spec.ts' \
-  --glob '!apps/backend/src/common/exceptions/**'
-```
-
-如果只想快速看生产代码，可优先改成：
-
-```bash
-python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_audit.py" \
-  --workspace "$PWD" \
-  --scope src
-```
-
-如果只想看 E2E 存量问题，可改成：
-
-```bash
-python "$CODEX_HOME/skills/error-handling-audit-fixer/scripts/error_handling_audit.py" \
-  --workspace "$PWD" \
-  --scope e2e
+  --glob '!*/common/exceptions/**'
 ```
 
 ## 修复准则

package/skills/error-handling-audit-fixer/scripts/error_handling_audit.py

@@ -60,16 +60,34 @@ def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="审计后端错误处理是否绕过 DomainException / ErrorCode 体系")
     parser.add_argument("--workspace", required=True, help="仓库根目录")
     parser.add_argument(
-        "--include-glob",
+        "--src-dir",
+        action="append",
+        default=None,
+        help="生产代码目录（相对于 workspace，可重复），如 apps/backend/src",
+    )
+    parser.add_argument(
+        "--e2e-dir",
         action="append",
         default=None,
-        help="附加扫描 glob，可重复传入",
+        help="测试代码目录（相对于 workspace，可重复），如 apps/backend/e2e",
     )
     parser.add_argument(
         "--scope",
         choices=["all", "src", "e2e"],
-        default="all",
-        help="预设扫描范围：all=src+e2e，src=仅生产代码，e2e=仅测试代码",
+        default="src",
+        help="扫描范围：src=仅生产代码（默认），e2e=仅测试代码，all=src+e2e",
+    )
+    parser.add_argument(
+        "--include-glob",
+        action="append",
+        default=None,
+        help="附加扫描 glob（覆盖自动推导），可重复传入",
+    )
+    parser.add_argument(
+        "--exclude-pattern",
+        action="append",
+        default=None,
+        help="额外排除路径片段（可重复），如 prisma/ scripts/",
     )
     parser.add_argument("--output-json", help="输出 JSON 文件路径")
     parser.add_argument(
@@ -95,18 +113,44 @@ def iter_files(workspace: Path, globs: Iterable[str]) -> list[Path]:
     return sorted(files)
 
 
-def should_skip(path: Path) -> bool:
+SKIP_SUFFIXES = (
+    ".spec.ts",
+    ".test.ts",
+    ".e2e-spec.ts",
+    ".exception.ts",
+    ".mock.ts",
+    ".stub.ts",
+    ".fixture.ts",
+)
+
+SKIP_DIR_FRAGMENTS = (
+    "__tests__/",
+    "__test__/",
+    "test-utils/",
+    "testing/",
+    "fixtures/",
+    "/filters/",
+    "prisma/",
+    "scripts/",
+)
+
+SKIP_FILENAMES = ("main.ts",)
+
+
+def should_skip(path: Path, extra_excludes: list[str] | None = None) -> bool:
     path_text = path.as_posix()
-    if path_text.endswith(".spec.ts"):
-        return True
-    if path_text.endswith(".exception.ts"):
-        return True
-    if path_text == "apps/backend/src/main.ts":
-        return True
-    if path_text.startswith("apps/backend/src/common/filters/"):
-        return True
-    if path_text.startswith("apps/backend/src/common/exceptions/"):
+    if path.name in SKIP_FILENAMES:
         return True
+    for suffix in SKIP_SUFFIXES:
+        if path_text.endswith(suffix):
+            return True
+    for fragment in SKIP_DIR_FRAGMENTS:
+        if fragment in path_text:
+            return True
+    if extra_excludes:
+        for pattern in extra_excludes:
+            if pattern in path_text:
+                return True
     return False
 
 
@@ -114,12 +158,14 @@ def line_no(content: str, index: int) -> int:
     return content.count("\n", 0, index) + 1
 
 
-def default_globs_for_scope(scope: str) -> list[str]:
+def build_globs(scope: str, src_dirs: list[str], e2e_dirs: list[str]) -> list[str]:
     if scope == "src":
-        return ["apps/backend/src/**/*.ts"]
-    if scope == "e2e":
-        return ["apps/backend/e2e/**/*.ts"]
-    return ["apps/backend/src/**/*.ts", "apps/backend/e2e/**/*.ts"]
+        dirs = src_dirs
+    elif scope == "e2e":
+        dirs = e2e_dirs
+    else:
+        dirs = src_dirs + e2e_dirs
+    return [f"{d}/**/*.ts" for d in dirs]
 
 
 def safe_read_text(path: Path) -> str:
@@ -284,30 +330,32 @@ def find_constructor_calls(content: str, constructor_name: str) -> list[tuple[in
     return matches
 
 
-def collect_foundation_status(workspace: Path) -> FoundationStatus:
-    backend_root = workspace / "apps/backend/src"
-    all_ts_files = sorted(backend_root.glob("**/*.ts"))
+def collect_foundation_status(workspace: Path, src_dirs: list[str]) -> FoundationStatus:
     has_domain_exception = False
     has_error_code = False
     has_exception_filters = False
     has_module_exceptions_dir = False
     has_structured_request_id_signal = False
 
-    for path in all_ts_files:
-        path_text = path.as_posix()
-        content = safe_read_text(path)
-        if not content:
+    for src_dir in src_dirs:
+        root = workspace / src_dir
+        if not root.is_dir():
             continue
-        if re.search(r"\bclass\s+DomainException\b", content):
-            has_domain_exception = True
-        if re.search(r"\b(enum|const)\s+ErrorCode\b", content) or re.search(r"\bErrorCode\.[A-Z0-9_]+\b", content):
-            has_error_code = True
-        if "/filters/" in path_text and re.search(r"ExceptionFilter|Catch\s*\(", content):
-            has_exception_filters = True
-        if "/exceptions/" in path_text and not path_text.startswith("apps/backend/src/common/exceptions/"):
-            has_module_exceptions_dir = True
-        if "requestId" in content and re.search(r"\b(args|code)\b", content):
-            has_structured_request_id_signal = True
+        for path in sorted(root.glob("**/*.ts")):
+            path_text = path.as_posix()
+            content = safe_read_text(path)
+            if not content:
+                continue
+            if re.search(r"\bclass\s+DomainException\b", content):
+                has_domain_exception = True
+            if re.search(r"\b(enum|const)\s+ErrorCode\b", content) or re.search(r"\bErrorCode\.[A-Z0-9_]+\b", content):
+                has_error_code = True
+            if "/filters/" in path_text and re.search(r"ExceptionFilter|Catch\s*\(", content):
+                has_exception_filters = True
+            if "/exceptions/" in path_text and "common/exceptions" not in path_text:
+                has_module_exceptions_dir = True
+            if "requestId" in content and re.search(r"\b(args|code)\b", content):
+                has_structured_request_id_signal = True
 
     return FoundationStatus(
         has_domain_exception=has_domain_exception,
@@ -506,9 +554,19 @@ def print_report(foundations: FoundationStatus, findings: list[Finding]) -> None
 def main() -> int:
     args = parse_args()
     workspace = Path(args.workspace).resolve()
-    globs = args.include_glob or default_globs_for_scope(args.scope)
-    files = [path for path in iter_files(workspace, globs) if not should_skip(path.relative_to(workspace))]
-    foundations = collect_foundation_status(workspace)
+
+    src_dirs: list[str] = args.src_dir or []
+    e2e_dirs: list[str] = args.e2e_dir or []
+    extra_excludes: list[str] | None = args.exclude_pattern
+
+    if not src_dirs and not e2e_dirs and not args.include_glob:
+        print("错误：必须通过 --src-dir 或 --e2e-dir 指定扫描目录，或通过 --include-glob 指定 glob 模式")
+        print("示例：--src-dir apps/backend/src --e2e-dir apps/backend/e2e")
+        return 1
+
+    globs = args.include_glob or build_globs(args.scope, src_dirs, e2e_dirs)
+    files = [path for path in iter_files(workspace, globs) if not should_skip(path.relative_to(workspace), extra_excludes)]
+    foundations = collect_foundation_status(workspace, src_dirs or e2e_dirs)
 
     findings: list[Finding] = []
     for path in files:

package/skills/git-pr-ship/SKILL.md

@@ -442,7 +442,49 @@ MSG
 
 若继续：`ROUND += 1`，回到 4.1。
 
-若结束且 `CODE_CHANGED_SINCE_LAST_CHECK=true`：执行最终验证——按串行顺序跑 `dx lint` -> `dx build affected --dev` -> 关联测试，有错即停。有失败则修复并 commit/push，无失败则完成。
+若结束且 `CODE_CHANGED_SINCE_LAST_CHECK=true`：执行最终验证——按串行顺序跑 `dx lint` -> `dx build affected --dev` -> 关联测试，有错即停。有失败则修复并 commit/push，无失败则进入 4.7 发布验证总结。
+
+若结束且 `CODE_CHANGED_SINCE_LAST_CHECK=false`（本轮零问题直接通过）：同样进入 4.7，基于最近一次验证结果发布总结。
+
+### 4.7 发布验证总结报告到 PR
+
+最终验证通过后，在 PR 上发布一条验证总结，让审查者一眼看清本次交付的质量门禁结果。
+
+收集并汇总以下信息：
+- **审查轮数**：共经历了几轮审查修复循环
+- **Lint 结果**：通过/失败（最终状态）
+- **构建结果**：通过/失败（最终状态）
+- **测试执行明细**：列出实际执行的每条测试命令及其结果（如 `dx test e2e backend apps/backend/e2e/ai-model/virtual-model.e2e-spec.ts` -> 通过），未执行测试的类别注明"无相关改动，跳过"
+- **代码审查**：共发现多少问题、修复多少、拒绝多少
+
+```bash
+gh pr comment <PR_NUMBER> --body-file - <<'MSG'
+## ✅ 验证总结
+
+### 门禁结果
+
+| 步骤 | 状态 | 备注 |
+|------|------|------|
+| Lint (`dx lint`) | ✅ 通过 | |
+| 构建 (`dx build affected --dev`) | ✅ 通过 | |
+| 后端 E2E | ✅ 通过 | `dx test e2e backend <实际执行的文件/目录>` |
+| 前端单测 | ⏭️ 跳过 | 无相关改动 |
+| 管理端单测 | ⏭️ 跳过 | 无相关改动 |
+
+### 审查统计
+
+- 审查轮数：N
+- 发现问题：X 个（Critical: a / Major: b / Minor: c）
+- 已修复：Y 个
+- 拒绝修复：Z 个（附理由见上方修复报告）
+
+### 结论
+
+所有质量门禁通过，PR 可合并。
+MSG
+```
+
+> **注意**：表格中的"状态"和"备注"列必须基于实际执行结果填写，不能编造。若某步骤失败后经修复再次通过，标注"✅ 通过（修复后重跑）"。测试命令列必须写出实际执行的完整命令，不能用占位符。
 
 ---