@ranger1/dx 0.1.111 → 0.1.113

package/lib/cli/commands/core.js

@@ -5,6 +5,8 @@ import { confirmManager } from '../../confirm.js'
 import { execManager } from '../../exec.js'
 import { showHelp, showCommandHelp } from '../help.js'
 
+const DEFAULT_TEST_WORKERS = 8
+
 export function handleHelp(cli, args = []) {
   if (args[0]) showCommandHelp(args[0], cli)
   else showHelp(cli)
@@ -71,7 +73,8 @@ export async function handleBuild(cli, args) {
 export async function handleTest(cli, args) {
   const type = args[0] || 'e2e'
   const target = args[1] || 'all'
-  const testPath = args[2] // 可选的测试文件路径
+  const testPaths = args.slice(2) // unit 可选多个测试文件路径；e2e 只使用第一个
+  const testPath = testPaths[0]
 
   // 解析 -t 参数用于指定特定测试用例（使用原始参数列表）
   const allArgs = cli.args  // 使用原始参数列表包含所有标志
@@ -137,15 +140,17 @@ export async function handleTest(cli, args) {
     } else {
       logger.step(`运行单个 ${type} 测试: ${testPath}`)
     }
-  } else if (type === 'unit' && testPath) {
+  } else if (type === 'unit' && testPaths.length > 0) {
     let command = String(testConfig.command).trim()
     const useDirectPathArg = shouldUseDirectPathArg(command)
-    const normalizedTestPath = useDirectPathArg
-      ? normalizeUnitTestPathForCommand(cli, command, testPath)
-      : testPath
+    const normalizedTestPaths = testPaths.map(path =>
+      useDirectPathArg
+        ? normalizeUnitTestPathForCommand(cli, command, path)
+        : path
+    )
     const forwardedArgs = useDirectPathArg
-      ? [shellEscape(normalizedTestPath)]
-      : [`--runTestsByPath ${shellEscape(normalizedTestPath)}`]
+      ? normalizedTestPaths.map(shellEscape)
+      : [`--runTestsByPath ${normalizedTestPaths.map(shellEscape).join(' ')}`]
 
     if (testNamePattern) {
       forwardedArgs.push(`-t ${shellEscape(testNamePattern)}`)
@@ -161,19 +166,24 @@ export async function handleTest(cli, args) {
       ...testConfig,
       command,
       description: testNamePattern
-        ? `运行单个单元测试文件的特定用例: ${testPath} -> ${testNamePattern}`
-        : `运行单个单元测试文件: ${testPath}`,
+        ? `运行单元测试文件的特定用例: ${testPaths.join(', ')} -> ${testNamePattern}`
+        : `运行单元测试文件: ${testPaths.join(', ')}`,
     }
 
     if (testNamePattern) {
-      logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPath})`)
+      logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPaths.join(', ')})`)
     } else {
-      logger.step(`运行单个 ${type} 测试: ${testPath}`)
+      logger.step(`运行 ${type} 测试: ${testPaths.join(', ')}`)
     }
   } else {
     logger.step(`运行 ${type} 测试`)
   }
 
+  testConfig = {
+    ...testConfig,
+    command: appendDefaultTestWorkers(testConfig.command, type),
+  }
+
   await cli.executeCommand(testConfig)
 }
 
@@ -205,6 +215,35 @@ function shouldUseDirectPathArg(command) {
   )
 }
 
+function appendDefaultTestWorkers(command, type) {
+  const flag = getDefaultWorkerFlag(type)
+  if (!flag) return command
+
+  const text = String(command || '').trim()
+  if (!text || hasWorkerFlag(text, flag)) return command
+
+  if (isNodeEvalCommandWithoutArgSeparator(text)) {
+    return `${text} -- ${flag}=${DEFAULT_TEST_WORKERS}`
+  }
+
+  return `${text} ${flag}=${DEFAULT_TEST_WORKERS}`
+}
+
+function getDefaultWorkerFlag(type) {
+  if (type === 'e2e') return '--workers'
+  if (type === 'unit') return '--maxWorkers'
+  return null
+}
+
+function hasWorkerFlag(command, flag) {
+  const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  return new RegExp(`(^|[\\s'"])${escapedFlag}(=|\\s|['"]|$)`).test(String(command || ''))
+}
+
+function isNodeEvalCommandWithoutArgSeparator(command) {
+  return /(^|\s)node\s+-e\s/.test(String(command || '')) && !/\s--(\s|$)/.test(String(command || ''))
+}
+
 function normalizeUnitTestPathForCommand(cli, command, testPath) {
   const rawPath = String(testPath || '')
   if (!rawPath) return rawPath

package/lib/cli/dx-cli.js

@@ -560,7 +560,9 @@ class DxCli {
       }
       case 'test':
         this.validateTestPositionals(positionalArgs)
-        ensureMax(3)
+        if ((positionalArgs[0] || 'e2e') !== 'unit') {
+          ensureMax(3)
+        }
         break
       case 'worktree': {
         if (positionalArgs.length === 0) return

package/lib/cli/help-schema.js

@@ -293,18 +293,18 @@ export function validateUsageAgainstRuntime(commandName, usageText, cli) {
     }
   }
 
-  const placeholderTokens = tokens
+  const runtimePositionals = tokens
     .slice(2)
-    .filter(token => isPlaceholderToken(token) && !isEnvironmentPlaceholder(token))
-  const runtimeMaxPositionals = getRuntimeMaxPositionals(commandName)
+    .filter(token => !isEnvironmentPlaceholder(token))
+  const runtimeMaxPositionals = getRuntimeMaxPositionals(commandName, tokens)
 
   if (
     Number.isInteger(runtimeMaxPositionals) &&
-    placeholderTokens.length > runtimeMaxPositionals
+    runtimePositionals.length > runtimeMaxPositionals
   ) {
     return {
       ok: false,
-      reason: `usage for ${commandName} advertises ${placeholderTokens.length} positionals but runtime allows ${runtimeMaxPositionals}`,
+      reason: `usage for ${commandName} advertises ${runtimePositionals.length} positionals but runtime allows ${runtimeMaxPositionals}`,
     }
   }
 
@@ -322,7 +322,7 @@ export function validateUsageAgainstRuntime(commandName, usageText, cli) {
   return { ok: true }
 }
 
-function getRuntimeMaxPositionals(commandName) {
+function getRuntimeMaxPositionals(commandName, tokens = []) {
   switch (commandName) {
     case 'help':
       return 1
@@ -333,10 +333,10 @@ function getRuntimeMaxPositionals(commandName) {
       return 1
     case 'db':
       return 2
-    case 'test':
-      return 3
     case 'worktree':
       return 3
+    case 'test':
+      return tokens[2] === 'unit' ? null : 3
     case 'start':
       return 1
     case 'lint':
@@ -442,7 +442,6 @@ function validateArgumentTokens(args, cli) {
     build: 1,
     package: 1,
     db: 2,
-    test: 3,
     worktree: 3,
     start: 1,
     lint: 0,
@@ -451,7 +450,11 @@ function validateArgumentTokens(args, cli) {
     status: 0,
   }
 
-  const max = maxByCommand[commandName]
+  let max = maxByCommand[commandName]
+  if (commandName === 'test') {
+    max = positionalArgs[0] === 'unit' ? null : 3
+  }
+
   if (Number.isInteger(max) && positionalArgs.length > max) {
     return { ok: false, reason: `命令 ${commandName} 存在未识别的额外参数: ${positionalArgs.slice(max).join(', ')}` }
   }

package/package.json

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

package/skills/backend-audit-fixer/SKILL.md

@@ -7,7 +7,7 @@ description: 必须显式调用才触发
 
 ## 概览
 
-6 个后端审计维度的统一入口。规则太多，**一维度一 subagent，每次只跑一个**：用户每次选一个维度，派一个 subagent 只载那份 reference、只跑那个脚本，回来出该维度报告，再询问是否继续下一个。**不并行扇出、不一次跑全部。**
+7 个后端审计维度的统一入口。规则太多，**一维度一 subagent，每次只跑一个**：用户每次选一个维度，派一个 subagent 只载那份 reference、只跑那个脚本，回来出该维度报告，再询问是否继续下一个。**不并行扇出、不一次跑全部。**
 
 默认只审计出报告；用户明确说"修复/直接改"才进落代码阶段。
 
@@ -18,6 +18,7 @@ description: 必须显式调用才触发
 | backend-layering | references/backend-layering.md | 无（纯 rg） | conventions §4/§5/§6 |
 | e2e | references/e2e.md | scripts/e2e_audit.py | ruler/e2e-audit.md |
 | env-accessor | references/env-accessor.md | scripts/env_accessor_audit.py | conventions §2 |
+| enum-single-source | references/enum-single-source.md | scripts/enum_single_source_audit.py | 枚举唯一真源约定 |
 | error-handling | references/error-handling.md | scripts/error_handling_audit.py | conventions §9 |
 | naming | references/naming.md | scripts/naming_audit.py（需先拼 config） | conventions §10 |
 | pagination-dto | references/pagination-dto.md | scripts/pagination_dto_audit.py | conventions §12 |
@@ -29,18 +30,19 @@ description: 必须显式调用才触发
 **每次只跑一个维度。** 进入 skill 后：
 
 - 用户已点名某维度（"检查命名"/"分页规范"）→ 直接跑该维度，跳到 Step 2。
-- 用户说"全量审计/扫一遍/检查合规"或没点名 → **用纯文本列出下面 6 个维度的编号菜单**，让用户回复编号或维度名再继续。别默认全跑、别并行。
+- 用户说"全量审计/扫一遍/检查合规"或没点名 → **用纯文本列出下面 7 个维度的编号菜单**，让用户回复编号或维度名再继续。别默认全跑、别并行。
 
-> ⚠️ 不要用 AskUserQuestion 列维度：它每题最多 4 个选项，6 个维度会被截断。必须用文本菜单。
+> ⚠️ 不要用 AskUserQuestion 列维度：它每题最多 4 个选项，7 个维度会被截断。必须用文本菜单。
 
 ```
 请选择要审计的维度（每次只跑一个，回复编号或名字）：
 1. backend-layering  — 三层架构/事务/Repository 越层（conventions §4/§5/§6）
 2. e2e               — E2E 中文标题/手工 JWT/请求 helper/fixture 复用（ruler/e2e-audit.md）
 3. env-accessor      — 业务代码直读 process.env（conventions §2）
-4. error-handling    — 裸 BadRequestException/无 code HttpException（conventions §9）
-5. naming            — 文件/文件夹命名规范（conventions §10）
-6. pagination-dto    — 分页 DTO 未继承基类/手工拼装分页返回（conventions §12）
+4. enum-single-source — 枚举类型唯一真源/DB enum 生成链路/重复字面量
+5. error-handling    — 裸 BadRequestException/无 code HttpException（conventions §9）
+6. naming            — 文件/文件夹命名规范（conventions §10）
+7. pagination-dto    — 分页 DTO 未继承基类/手工拼装分页返回（conventions §12）
 ```
 
 ### Step 2：派 1 个 subagent 跑选中的维度

package/skills/backend-audit-fixer/references/enum-single-source.md

@@ -0,0 +1,113 @@
+# 维度：枚举唯一真源（enum-single-source）
+
+脚本：`scripts/enum_single_source_audit.py`。规则来源：数据库枚举唯一真源与共享枚举生成约定。
+
+先区分枚举来源：数据库枚举只允许在 Prisma schema 中手写定义，再通过生成脚本产出 shared 枚举；非数据库枚举也必须只有一个 shared 或模块内真源，其他地方 import/derive 复用。
+
+## 运行
+
+```bash
+SKILL_HOME="${SKILL_HOME:-$HOME/.claude/skills}"
+python "$SKILL_HOME/backend-audit-fixer/scripts/enum_single_source_audit.py" \
+  --workspace /Users/a1/work/ai-monorepo \
+  --output-json /tmp/audit-enum-single-source.json
+```
+
+必要时用 `--schema-dir` 指定 Prisma schema 目录，用 `--include-glob` 扩展扫描范围。
+
+## 执行流程
+
+1. 读取 `apps/backend/prisma/schema/*.prisma` 中的 `enum`，建立 DB enum 名称和值集合。
+2. 检查生成产物是否存在且与 schema 同步：
+   - `packages/shared/src/generated/prisma-enums.ts`
+   - `packages/shared/src/generated/prisma-enum-names.json`（若项目使用该文件约束 lint）
+3. 扫描 `apps/backend/src/**/*.ts` 与 `packages/shared/src/**/*.ts`，排除 generated、测试文件与声明文件。
+4. 识别 DB enum 绕过真源的候选问题：
+   - 在业务代码里重新 `export enum X`，且名称或值匹配 Prisma enum。
+   - 在 DTO/常量里用 `['A', 'B'] as const` 或本地 `*_VALUES` 重写 Prisma enum 值。
+   - Swagger 装饰器里手写 `enum: ['A', 'B']`。
+   - 从 `@prisma/client` 直接 import DB enum，而不是经 shared 生成枚举。
+   - 生成产物缺失或与 Prisma schema 不一致。
+5. 打开命中文件复核。脚本结果是候选，不是最终真相；每条必须给 `verdict`。
+
+## 合法模式
+
+- DB enum 真源：只在 `apps/backend/prisma/schema/*.prisma` 手写。
+- DB enum 生成产物：`packages/shared/src/generated/prisma-enums.ts`，文件头应标记 generated，禁止手改。
+- DB enum values：用 `Object.values(PrismaEnum)` 派生，例如：
+  ```typescript
+  import { TaskRunStatus } from '../generated/prisma-enums'
+
+  export const TASK_RUN_STATUS_VALUES = Object.values(TaskRunStatus) as TaskRunStatus[]
+  ```
+- 非 DB 枚举：不存在于 Prisma schema 时，可在 shared 统一定义（如 `packages/shared/src/constants/backend-enums.ts`）或模块私有 enum 文件定义；同一语义不得在 DTO、service、controller 中重复字面量数组。
+- 组合视图枚举：可以由 DB enum 成员加少量业务状态组合而成，但必须显式从 DB enum 引用已有成员，不要复制 DB enum 全量字面量。
+
+## 违规模式
+
+```typescript
+// DB enum 已存在于 Prisma schema，又在业务代码重写
+export enum TaskRunStatus {
+  PENDING = 'PENDING',
+  RUNNING = 'RUNNING',
+}
+```
+
+```typescript
+// 本地重复 Prisma enum values
+export const TASK_RUN_STATUS_VALUES = ['PENDING', 'RUNNING', 'SUCCESS', 'FAILED'] as const
+```
+
+```typescript
+// DTO/Swagger 重复字面量
+@ApiProperty({ enum: ['PENDING', 'RUNNING', 'SUCCESS', 'FAILED'] })
+status!: string
+```
+
+## 修复准则
+
+- **DB enum 新增/变更**：只改 Prisma schema，创建迁移，再运行项目枚举生成命令（常见为 `pnpm run generate:enums` 或仓库约定脚本）。
+- **业务代码使用 DB enum**：从 shared 生成产物或 shared 统一出口导入，禁止重新定义。
+- **需要 values 数组**：在 shared 常量层用 `Object.values(PrismaEnum)` 派生，然后业务代码 import 该数组。
+- **Swagger enum**：引用生成枚举或 shared values，不手写字符串数组。
+- **非 DB enum 被多处复制**：抽到 shared 或模块唯一 enum 文件；DTO/service/controller 只 import。
+- **生成产物过期**：运行生成命令，确认 `packages/shared/src/generated/prisma-enums.ts` 与 Prisma schema 同步。
+
+## 复核原则
+
+- 名称匹配但值不匹配：标 `needs-review`，确认是不是同名不同语义；不要直接改。
+- 值集合是 Prisma enum 子集：多数是视图状态/筛选条件，只有在语义确认为同一 DB enum 时才报 `real`。
+- 非 DB enum：脚本可能不报或只报候选；人工检查是否存在重复定义与是否适合提升到 shared。
+- 生成产物下的重复结构不算违规，除非缺少 generated 标记或内容与 schema 不一致。
+
+## 返回给主 agent 的 findings
+
+`total` 是脚本候选命中数；`real_total` 是复核后真违规数。每条 violation 必须带 `verdict`。
+
+```json
+{
+  "dimension": "enum-single-source",
+  "infra_status": {"prisma_schema_enums": 0, "generated_prisma_enums": false, "generation_script": false},
+  "total": 0,
+  "real_total": 0,
+  "by_rule": {
+    "db-enum-redeclared": 0,
+    "db-enum-values-duplicated": 0,
+    "swagger-db-enum-literal": 0,
+    "db-enum-imported-from-prisma-client": 0,
+    "generated-prisma-enum-missing": 0,
+    "generated-prisma-enum-stale": 0
+  },
+  "violations": [
+    {
+      "file": "",
+      "line": 0,
+      "rule": "",
+      "symbol": "",
+      "prisma_enum": "",
+      "verdict": "real|false-positive|needs-review",
+      "note": ""
+    }
+  ]
+}
+```

package/skills/backend-audit-fixer/scripts/enum_single_source_audit.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+DEFAULT_SCAN_GLOBS = (
+    "apps/backend/src/**/*.ts",
+    "packages/shared/src/**/*.ts",
+)
+
+EXCLUDED_PARTS = (
+    "/generated/",
+    ".spec.ts",
+    ".test.ts",
+    ".e2e-spec.ts",
+    ".d.ts",
+)
+
+ALLOWED_GENERATED_ENUM_FILE = "packages/shared/src/generated/prisma-enums.ts"
+
+
+@dataclass
+class PrismaEnum:
+    name: str
+    values: list[str]
+    source_file: str
+    line: int
+
+
+@dataclass
+class Finding:
+    rule: str
+    file: str
+    line: int
+    symbol: str
+    prisma_enum: str
+    verdict: str
+    note: str
+    snippet: str
+
+
+def line_no(content: str, index: int) -> int:
+    return content.count("\n", 0, index) + 1
+
+
+def parse_prisma_enums(schema_dir: Path) -> dict[str, PrismaEnum]:
+    enums: dict[str, PrismaEnum] = {}
+    enum_pattern = re.compile(r"^enum\s+(\w+)\s*\{(?P<body>[\s\S]*?)^\}", re.MULTILINE)
+    for path in sorted(schema_dir.glob("*.prisma")):
+        content = path.read_text(encoding="utf-8")
+        for match in enum_pattern.finditer(content):
+            name = match.group(1)
+            values: list[str] = []
+            for raw_line in match.group("body").splitlines():
+                line = raw_line.split("//", 1)[0].strip()
+                if not line or line.startswith("@@") or line.startswith("@"):
+                    continue
+                value = re.sub(r"\s+@.*$", "", line).strip()
+                if value:
+                    values.append(value)
+            enums[name] = PrismaEnum(
+                name=name,
+                values=values,
+                source_file=str(path),
+                line=line_no(content, match.start()),
+            )
+    return enums
+
+
+def iter_scan_files(workspace: Path, globs: Iterable[str]) -> list[Path]:
+    seen: set[Path] = set()
+    files: list[Path] = []
+    for pattern in globs:
+        for path in workspace.glob(pattern):
+            if not path.is_file() or path in seen:
+                continue
+            rel = path.relative_to(workspace).as_posix()
+            if any(part in rel for part in EXCLUDED_PARTS):
+                continue
+            seen.add(path)
+            files.append(path)
+    return sorted(files)
+
+
+def parse_ts_enum_values(body: str) -> list[str]:
+    values: list[str] = []
+    for raw_line in body.splitlines():
+        line = raw_line.split("//", 1)[0].strip().rstrip(",")
+        if not line:
+            continue
+        literal_match = re.search(r"=\s*['\"]([^'\"]+)['\"]", line)
+        if literal_match:
+            values.append(literal_match.group(1))
+            continue
+        name_match = re.match(r"([A-Za-z_]\w*)", line)
+        if name_match:
+            values.append(name_match.group(1))
+    return values
+
+
+def normalized_name(text: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", text.lower())
+
+
+def best_matching_prisma_enum(
+    symbol: str,
+    values: list[str],
+    prisma_enums: dict[str, PrismaEnum],
+) -> tuple[str, str] | None:
+    value_set = set(values)
+    symbol_norm = normalized_name(symbol)
+    for enum in prisma_enums.values():
+        enum_values = set(enum.values)
+        if value_set and value_set == enum_values:
+            return enum.name, "exact-values"
+        if value_set and len(value_set) >= 2 and value_set.issubset(enum_values):
+            return enum.name, "subset-values"
+        if symbol_norm == normalized_name(enum.name):
+            return enum.name, "name-match"
+    return None
+
+
+def redeclared_enum_note(enum_name: str, reason: str) -> str:
+    if reason == "name-match":
+        return (
+            f"TypeScript enum has the same name as Prisma enum {enum_name}; open the source and compare values/semantics "
+            "before deciding whether to replace it with the generated @ai/shared enum."
+        )
+    return f"TypeScript enum matches Prisma enum by {reason}; import generated @ai/shared enum instead."
+
+
+def collect_string_literals(text: str) -> list[str]:
+    return re.findall(r"['\"]([A-Za-z0-9_:-]+)['\"]", text)
+
+
+def scan_ts_enum_declarations(
+    rel: str,
+    content: str,
+    prisma_enums: dict[str, PrismaEnum],
+) -> list[Finding]:
+    findings: list[Finding] = []
+    pattern = re.compile(r"(?:export\s+)?enum\s+(\w+)\s*\{(?P<body>[\s\S]*?)\}", re.MULTILINE)
+    for match in pattern.finditer(content):
+        symbol = match.group(1)
+        values = parse_ts_enum_values(match.group("body"))
+        matched = best_matching_prisma_enum(symbol, values, prisma_enums)
+        if not matched:
+            continue
+        enum_name, reason = matched
+        findings.append(
+            Finding(
+                rule="db-enum-redeclared",
+                file=rel,
+                line=line_no(content, match.start()),
+                symbol=symbol,
+                prisma_enum=enum_name,
+                verdict="candidate",
+                note=redeclared_enum_note(enum_name, reason),
+                snippet=content[match.start() : match.end()].splitlines()[0].strip(),
+            )
+        )
+    return findings
+
+
+def scan_literal_enum_arrays(
+    rel: str,
+    content: str,
+    prisma_enums: dict[str, PrismaEnum],
+) -> list[Finding]:
+    findings: list[Finding] = []
+    pattern = re.compile(
+        r"(?:export\s+)?const\s+(\w+)\s*=\s*\[(?P<body>[\s\S]*?)\]\s*(?:as\s+const)?",
+        re.MULTILINE,
+    )
+    for match in pattern.finditer(content):
+        symbol = match.group(1)
+        body = match.group("body")
+        if "Object.values(" in body:
+            continue
+        values = collect_string_literals(body)
+        matched = best_matching_prisma_enum(symbol, values, prisma_enums)
+        if not matched:
+            continue
+        enum_name, reason = matched
+        findings.append(
+            Finding(
+                rule="db-enum-values-duplicated",
+                file=rel,
+                line=line_no(content, match.start()),
+                symbol=symbol,
+                prisma_enum=enum_name,
+                verdict="candidate",
+                note=f"Literal value array matches Prisma enum by {reason}; derive with Object.values({enum_name}) from generated shared enum.",
+                snippet=content[match.start() : match.end()].splitlines()[0].strip(),
+            )
+        )
+    return findings
+
+
+def scan_swagger_literal_enums(
+    rel: str,
+    content: str,
+    prisma_enums: dict[str, PrismaEnum],
+) -> list[Finding]:
+    findings: list[Finding] = []
+    pattern = re.compile(r"enum\s*:\s*\[(?P<body>[^\]]+)\]", re.MULTILINE)
+    for match in pattern.finditer(content):
+        values = collect_string_literals(match.group("body"))
+        matched = best_matching_prisma_enum("swagger-enum", values, prisma_enums)
+        if not matched:
+            continue
+        enum_name, reason = matched
+        findings.append(
+            Finding(
+                rule="swagger-db-enum-literal",
+                file=rel,
+                line=line_no(content, match.start()),
+                symbol="ApiProperty.enum",
+                prisma_enum=enum_name,
+                verdict="candidate",
+                note=f"Swagger literal enum matches Prisma enum by {reason}; reference generated enum or derived values instead.",
+                snippet=content[match.start() : match.end()].replace("\n", " ").strip(),
+            )
+        )
+    return findings
+
+
+def scan_prisma_client_enum_imports(
+    rel: str,
+    content: str,
+    prisma_enums: dict[str, PrismaEnum],
+) -> list[Finding]:
+    findings: list[Finding] = []
+    pattern = re.compile(r"import\s*\{(?P<body>[^}]+)\}\s*from\s*['\"]@prisma/client['\"]")
+    for match in pattern.finditer(content):
+        imported = [part.strip().split(" as ", 1)[0].strip() for part in match.group("body").split(",")]
+        for symbol in imported:
+            if symbol not in prisma_enums:
+                continue
+            findings.append(
+                Finding(
+                    rule="db-enum-imported-from-prisma-client",
+                    file=rel,
+                    line=line_no(content, match.start()),
+                    symbol=symbol,
+                    prisma_enum=symbol,
+                    verdict="candidate",
+                    note="DB enum should flow through generated @ai/shared prisma-enums, not direct @prisma/client imports.",
+                    snippet=content[match.start() : match.end()].strip(),
+                )
+            )
+    return findings
+
+
+def check_generated_file(workspace: Path, prisma_enums: dict[str, PrismaEnum]) -> list[Finding]:
+    generated = workspace / ALLOWED_GENERATED_ENUM_FILE
+    if not generated.exists():
+        return [
+            Finding(
+                rule="generated-prisma-enums-missing",
+                file=ALLOWED_GENERATED_ENUM_FILE,
+                line=0,
+                symbol="generated-prisma-enums",
+                prisma_enum="*",
+                verdict="real",
+                note="Generated Prisma enum file is missing; run the project enum generation command.",
+                snippet="",
+            )
+        ]
+
+    content = generated.read_text(encoding="utf-8")
+    findings: list[Finding] = []
+    for enum in prisma_enums.values():
+        object_match = re.search(
+            rf"export\s+const\s+{re.escape(enum.name)}\s*=\s*\{{(?P<body>[\s\S]*?)\}}\s*as\s+const",
+            content,
+        )
+        if not object_match:
+            findings.append(
+                Finding(
+                    rule="generated-prisma-enum-missing",
+                    file=ALLOWED_GENERATED_ENUM_FILE,
+                    line=0,
+                    symbol=enum.name,
+                    prisma_enum=enum.name,
+                    verdict="real",
+                    note="Prisma enum is not present in generated shared output; regenerate enums.",
+                    snippet="",
+                )
+            )
+            continue
+        generated_values = collect_string_literals(object_match.group("body"))
+        if set(generated_values) != set(enum.values):
+            findings.append(
+                Finding(
+                    rule="generated-prisma-enum-stale",
+                    file=ALLOWED_GENERATED_ENUM_FILE,
+                    line=line_no(content, object_match.start()),
+                    symbol=enum.name,
+                    prisma_enum=enum.name,
+                    verdict="real",
+                    note="Generated shared enum values differ from Prisma schema; regenerate enums.",
+                    snippet=f"generated={generated_values} prisma={enum.values}",
+                )
+            )
+    return findings
+
+
+def scan_file(path: Path, workspace: Path, prisma_enums: dict[str, PrismaEnum]) -> list[Finding]:
+    rel = path.relative_to(workspace).as_posix()
+    if rel == ALLOWED_GENERATED_ENUM_FILE:
+        return []
+    content = path.read_text(encoding="utf-8")
+    findings: list[Finding] = []
+    findings.extend(scan_ts_enum_declarations(rel, content, prisma_enums))
+    findings.extend(scan_literal_enum_arrays(rel, content, prisma_enums))
+    findings.extend(scan_swagger_literal_enums(rel, content, prisma_enums))
+    findings.extend(scan_prisma_client_enum_imports(rel, content, prisma_enums))
+    return findings
+
+
+def summarize(findings: list[Finding]) -> dict[str, int]:
+    by_rule: dict[str, int] = {}
+    for finding in findings:
+        by_rule[finding.rule] = by_rule.get(finding.rule, 0) + 1
+    return by_rule
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="审计 Prisma/业务枚举唯一真源约束")
+    parser.add_argument("--workspace", required=True, help="仓库根目录")
+    parser.add_argument(
+        "--schema-dir",
+        default="apps/backend/prisma/schema",
+        help="Prisma schema 目录，默认 apps/backend/prisma/schema",
+    )
+    parser.add_argument(
+        "--include-glob",
+        action="append",
+        help="附加扫描 glob；默认扫描 apps/backend/src/**/*.ts 与 packages/shared/src/**/*.ts",
+    )
+    parser.add_argument("--output-json", help="输出 JSON 文件路径")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    workspace = Path(args.workspace).resolve()
+    schema_dir = (workspace / args.schema_dir).resolve()
+    scan_globs = tuple(args.include_glob) if args.include_glob else DEFAULT_SCAN_GLOBS
+
+    prisma_enums = parse_prisma_enums(schema_dir)
+    findings = check_generated_file(workspace, prisma_enums)
+    for path in iter_scan_files(workspace, scan_globs):
+        findings.extend(scan_file(path, workspace, prisma_enums))
+
+    report = {
+        "dimension": "enum-single-source",
+        "workspace": str(workspace),
+        "schema_dir": str(schema_dir),
+        "scan_globs": list(scan_globs),
+        "prisma_enum_count": len(prisma_enums),
+        "total": len(findings),
+        "by_rule": summarize(findings),
+        "violations": [asdict(finding) for finding in findings],
+    }
+
+    if findings:
+        print(f"共发现 {len(findings)} 个枚举唯一真源候选问题：")
+        for finding in findings:
+            print(f"- {finding.file}:{finding.line} [{finding.rule}] {finding.symbol} -> {finding.note}")
+    else:
+        print("未发现枚举唯一真源候选问题。")
+
+    if args.output_json:
+        output_path = Path(args.output_json)
+        output_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(f"\nJSON 已输出到 {output_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/doctor/SKILL.md

@@ -21,7 +21,9 @@ description: 仅在用户显式调用 $doctor 或明确要求使用 doctor 技
 - `dx` 可用，并已完成必要初始化。
 - `agent-browser` 可用，且 Chromium/浏览器依赖已安装到可运行状态。
 - `rg`（rip grep）可用。
-- `rtk` 可用。
+- `gh`（GitHub CLI）可用；若当前工作流需要 GitHub 操作，还应完成认证。
+- `rtk` 可用，且明确是 [rtk-ai/rtk](https://github.com/rtk-ai/rtk)；不能把其他同名二进制当作通过。
+- [rtk-ai/rtk](https://github.com/rtk-ai/rtk) 已分别完成 Codex CLI 与 Claude Code 的初始化。
 - 常用 PATH 配置在当前 shell 中可生效；若需要持久化，说明写入了哪个 shell 配置文件。
 
 ## 执行原则
@@ -38,7 +40,9 @@ description: 仅在用户显式调用 $doctor 或明确要求使用 doctor 技
 1. 收集上下文：
    - 操作系统与架构
    - 当前 shell 与 PATH
-   - `python3`、`python`、`node`、`npm`、`pnpm`、`dx`、`agent-browser`、`rg` 的存在性与版本
+   - `python3`、`python`、`node`、`npm`、`pnpm`、`dx`、`agent-browser`、`rg`、`gh`、`rtk` 的存在性与版本
+   - `gh` 的认证状态（例如 `gh auth status`）
+   - `rtk` 是否为 [rtk-ai/rtk](https://github.com/rtk-ai/rtk)，以及它对 Codex CLI 与 Claude Code 的初始化状态
 2. 对照目标状态判断缺口。
 3. 制定最小修复动作并执行。
 4. 每次修复后重新验证相关项。
@@ -52,6 +56,11 @@ description: 仅在用户显式调用 $doctor 或明确要求使用 doctor 技
 - 每个目标命令是否可被当前 shell 找到。
 - 每个目标命令的版本或基本健康输出。
 - `dx` 的初始化结果或当前初始化状态。
+- `gh --version` 能正常运行；若需要 GitHub 操作，`gh auth status` 应显示可用账号，否则报告未认证原因。
+- `rtk` 必须确认来源为 [rtk-ai/rtk](https://github.com/rtk-ai/rtk)。至少用 `rtk --version`、`rtk --help`、安装来源或命令特征交叉验证；若发现同名非 rtk-ai/rtk 工具，判定为未通过。
+- [rtk-ai/rtk](https://github.com/rtk-ai/rtk) 的 `rtk gain` 能正常运行。
+- [rtk-ai/rtk](https://github.com/rtk-ai/rtk) 的 Codex CLI 初始化必须有明确证据。优先使用 `rtk init --show --codex`，确认全局或本地 Codex 配置已包含 `RTK.md` 与 `AGENTS.md` 引用；若当前 `rtk` 版本命令不同，使用等价的只读检查并在报告中说明。
+- [rtk-ai/rtk](https://github.com/rtk-ai/rtk) 的 Claude Code 初始化必须有明确证据。优先使用 `rtk init --show --agent claude`，确认 Claude Code hook、`RTK.md`、`CLAUDE.md` 引用与 `settings.json` hook 配置处于健康状态；若当前 `rtk` 版本命令不同，使用等价的只读检查并在报告中说明。
 - `agent-browser` 是否能找到并使用已安装的浏览器依赖。
 - 对未通过项给出失败原因、已尝试动作和下一步建议。
 
@@ -61,6 +70,7 @@ description: 仅在用户显式调用 $doctor 或明确要求使用 doctor 技
 
 - 环境摘要：系统、shell、关键 PATH 变更。
 - 检查结果表：检查项、状态、版本/证据、说明。
+- RTK 初始化：分别列出 Codex CLI 与 Claude Code 的检查命令、通过/失败状态、关键证据文件或 hook。
 - 已执行修复：实际执行过的安装、链接、初始化或配置变更。
 - 未完成项：若存在，说明阻塞原因和用户需要做什么。
 - 结论：通过 / 部分通过 / 未通过。

package/skills/doctor/agents/openai.yaml

@@ -1,7 +0,0 @@
-interface:
-  display_name: "Doctor"
-  short_description: "按目标状态自主诊断、修复并验证 Codex 开发环境"
-  default_prompt: "使用 $doctor 对当前系统进行 Codex 开发环境体检；根据实际缺口自主选择修复方式，完成后复检并输出报告。"
-
-policy:
-  allow_implicit_invocation: false