@ranger1/dx 0.1.90 → 0.1.92

package/README.md

@@ -148,8 +148,8 @@ target（端）不写死，由 `env-policy.jsonc.targets` 定义；`commands.jso
 
 技能入口与说明见：
 
-- `codex/skills/pr-review-loop/SKILL.md`
-- `codex/skills/pr-review-loop/references/agents/*.md`
+- `skills/pr-review-loop/SKILL.md`
+- `skills/pr-review-loop/references/agents/*.md`
 
 ### 工作流概览
 

package/lib/cli/commands/core.js

@@ -1,3 +1,5 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join, relative } from 'node:path'
 import { logger } from '../../logger.js'
 import { confirmManager } from '../../confirm.js'
 import { execManager } from '../../exec.js'
@@ -132,6 +134,35 @@ export async function handleTest(cli, args) {
         : `运行单个E2E测试文件: ${testPath}`
     }
 
+    if (testNamePattern) {
+      logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPath})`)
+    } else {
+      logger.step(`运行单个 ${type} 测试: ${testPath}`)
+    }
+  } else if (type === 'unit' && testPath) {
+    let command = String(testConfig.command).trim()
+    const useDirectPathArg = shouldUseDirectPathArg(command)
+    const normalizedTestPath = useDirectPathArg
+      ? normalizeUnitTestPathForCommand(cli, command, testPath)
+      : testPath
+    const forwardedArgs = useDirectPathArg
+      ? [shellEscape(normalizedTestPath)]
+      : [`--runTestsByPath ${shellEscape(normalizedTestPath)}`]
+
+    if (testNamePattern) {
+      forwardedArgs.push(`-t ${shellEscape(testNamePattern)}`)
+    }
+
+    command += ` ${forwardedArgs.join(' ')}`
+
+    testConfig = {
+      ...testConfig,
+      command,
+      description: testNamePattern
+        ? `运行单个单元测试文件的特定用例: ${testPath} -> ${testNamePattern}`
+        : `运行单个单元测试文件: ${testPath}`,
+    }
+
     if (testNamePattern) {
       logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPath})`)
     } else {
@@ -148,6 +179,67 @@ function shellEscape(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`
 }
 
+function shouldUseDirectPathArg(command) {
+  const text = String(command || '')
+  return (
+    /\bnx\s+test\b/.test(text) ||
+    /\bnx\.js\s+test\b/.test(text) ||
+    /\bvitest\s+run\b/.test(text)
+  )
+}
+
+function normalizeUnitTestPathForCommand(cli, command, testPath) {
+  const rawPath = String(testPath || '')
+  if (!rawPath) return rawPath
+
+  if (/\bvitest\s+run\b/.test(String(command || ''))) {
+    return rawPath
+  }
+
+  const vitestProjectCwd = resolveNxVitestProjectCwd(cli, command)
+  if (!vitestProjectCwd) return rawPath
+
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const absoluteProjectCwd = join(projectRoot, vitestProjectCwd)
+  const absoluteTestPath = join(projectRoot, rawPath)
+  const relativePath = relative(absoluteProjectCwd, absoluteTestPath)
+
+  if (!relativePath || relativePath.startsWith('..')) {
+    return rawPath
+  }
+
+  return relativePath
+}
+
+function resolveNxVitestProjectCwd(cli, command) {
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const nxTarget = extractNxTestTarget(command)
+  if (!nxTarget) return null
+
+  const projectConfigPath = join(projectRoot, 'apps', nxTarget, '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
+  } catch {
+    return null
+  }
+}
+
+function extractNxTestTarget(command) {
+  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
+}
+
 export async function handleLint(cli, args) {
   void args
   const baseConfig = cli.commands.lint

package/lib/cli/help.js

@@ -69,7 +69,7 @@ export function showHelp() {
     '',
     '  status                 查看系统状态',
     '',
-    '  initial                初始化 codex 模板到 ~/.codex（覆盖同名文件）',
+    '  initial                同步根目录 skills 到 ~/.codex/skills 和 ~/.claude/skills（覆盖同名文件）',
     '',
     '选项:',
     ' --dev, --development   使用开发环境',
@@ -95,6 +95,7 @@ export function showHelp() {
     '  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 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',
     '  dx deploy front --staging # 部署前端到 Vercel（staging）',
     '  dx deploy backend --prod  # 构建 backend 制品并上传/部署到远端主机',

package/lib/codex-initial.js

@@ -4,49 +4,6 @@ import os from 'node:os'
 
 import { logger } from './logger.js'
 
-const REQUIRED_CODEX_CONFIG = [
-  {
-    section: 'features',
-    values: {
-      multi_agent: 'true',
-    },
-  },
-  {
-    section: 'agents',
-    values: {
-      max_threads: '15',
-    },
-  },
-  {
-    section: 'agents.fixer',
-    values: {
-      description: '"bugfix 代理"',
-      config_file: '"agents/fixer.toml"',
-    },
-  },
-  {
-    section: 'agents.orchestrator',
-    values: {
-      description: '"pr 修复流程编排代理"',
-      config_file: '"agents/orchestrator.toml"',
-    },
-  },
-  {
-    section: 'agents.reviewer',
-    values: {
-      description: '"代码评审代理"',
-      config_file: '"agents/reviewer.toml"',
-    },
-  },
-  {
-    section: 'agents.spark',
-    values: {
-      description: '"通用执行代理"',
-      config_file: '"agents/spark.toml"',
-    },
-  },
-]
-
 async function collectAllFiles(dir) {
   const out = []
 
@@ -68,6 +25,7 @@ async function collectAllFiles(dir) {
         continue
       }
       if (!entry.isFile()) continue
+
       const lowerName = entry.name.toLowerCase()
       if (lowerName.endsWith('.pyc') || lowerName.endsWith('.pyo') || lowerName.endsWith('.pyd')) continue
       out.push(full)
@@ -82,110 +40,6 @@ async function ensureDir(path) {
   await fs.mkdir(path, { recursive: true })
 }
 
-function escapeRegExp(input) {
-  return String(input).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-function ensureTrailingNewline(text) {
-  if (!text) return ''
-  return text.endsWith('\n') ? text : `${text}\n`
-}
-
-function upsertTomlSection(content, { section, values }) {
-  const header = `[${section}]`
-  const sectionPattern = new RegExp(`^\\[${escapeRegExp(section)}\\]\\s*$`, 'm')
-  const sectionHeaderMatch = content.match(sectionPattern)
-  let nextContent = content
-  let changedKeys = 0
-  let createdSection = false
-
-  if (!sectionHeaderMatch) {
-    const blockLines = [header, ...Object.entries(values).map(([key, value]) => `${key} = ${value}`), '']
-    nextContent = ensureTrailingNewline(content)
-    if (nextContent.length > 0 && !nextContent.endsWith('\n\n')) {
-      nextContent += '\n'
-    }
-    nextContent += `${blockLines.join('\n')}\n`
-    return {
-      content: nextContent,
-      changedKeys: Object.keys(values).length,
-      createdSection: true,
-    }
-  }
-
-  const sectionStart = sectionHeaderMatch.index
-  const sectionBodyStart = sectionStart + sectionHeaderMatch[0].length
-  const remaining = content.slice(sectionBodyStart)
-  const nextHeaderMatch = remaining.match(/\n(?=\[[^\]]+\]\s*$)/m)
-  const sectionEnd =
-    nextHeaderMatch && typeof nextHeaderMatch.index === 'number'
-      ? sectionBodyStart + nextHeaderMatch.index + 1
-      : content.length
-
-  const beforeSection = content.slice(0, sectionStart)
-  const originalSectionText = content.slice(sectionStart, sectionEnd)
-  const trailing = content.slice(sectionEnd)
-  const sectionLines = originalSectionText.split('\n')
-
-  for (const [key, value] of Object.entries(values)) {
-    const desiredLine = `${key} = ${value}`
-    const keyPattern = new RegExp(`^${escapeRegExp(key)}\\s*=`, 'm')
-    const lineIndex = sectionLines.findIndex(line => keyPattern.test(line.trim()))
-
-    if (lineIndex === -1) {
-      let insertIndex = sectionLines.length
-      while (insertIndex > 1 && sectionLines[insertIndex - 1] === '') {
-        insertIndex--
-      }
-      sectionLines.splice(insertIndex, 0, desiredLine)
-      changedKeys++
-      continue
-    }
-
-    if (sectionLines[lineIndex].trim() !== desiredLine) {
-      sectionLines[lineIndex] = desiredLine
-      changedKeys++
-    }
-  }
-
-  const updatedSectionText = ensureTrailingNewline(sectionLines.join('\n'))
-  nextContent = `${beforeSection}${updatedSectionText}${trailing}`
-
-  return { content: nextContent, changedKeys, createdSection }
-}
-
-async function ensureCodexConfig({ codexDir }) {
-  const configPath = join(codexDir, 'config.toml')
-  let content = ''
-
-  try {
-    content = await fs.readFile(configPath, 'utf8')
-  } catch (error) {
-    if (error?.code !== 'ENOENT') throw error
-  }
-
-  let changedKeys = 0
-  let createdSections = 0
-  let nextContent = content
-
-  for (const sectionConfig of REQUIRED_CODEX_CONFIG) {
-    const result = upsertTomlSection(nextContent, sectionConfig)
-    nextContent = result.content
-    changedKeys += result.changedKeys
-    if (result.createdSection) createdSections++
-  }
-
-  if (nextContent !== content || content === '') {
-    await fs.writeFile(configPath, ensureTrailingNewline(nextContent), 'utf8')
-  }
-
-  return {
-    configPath,
-    changedKeys,
-    createdSections,
-  }
-}
-
 async function assertDirExists(path, label) {
   try {
     const st = await fs.stat(path)
@@ -198,35 +52,6 @@ async function assertDirExists(path, label) {
   }
 }
 
-async function copyTemplateTree({ srcDir, dstDir }) {
-  const files = await collectTemplateFiles(srcDir)
-  let mdCount = 0
-  let pyCount = 0
-  let jsonCount = 0
-  
-  for (const file of files) {
-    const rel = relative(srcDir, file)
-    const target = join(dstDir, rel)
-    await ensureDir(dirname(target))
-    await fs.copyFile(file, target)
-    
-    if (file.endsWith('.md')) {
-      mdCount++
-    } else if (file.endsWith('.py')) {
-      pyCount++
-      try {
-        await fs.chmod(target, 0o755)
-      } catch {
-        // 忽略权限设置失败
-      }
-    } else if (file.endsWith('.json')) {
-      jsonCount++
-    }
-  }
-  
-  return { total: files.length, md: mdCount, py: pyCount, json: jsonCount }
-}
-
 async function copyDirMerge({ srcDir, dstDir }) {
   const files = await collectAllFiles(srcDir)
 
@@ -240,49 +65,28 @@ async function copyDirMerge({ srcDir, dstDir }) {
   return { fileCount: files.length }
 }
 
-async function copySkillsDirectories({ srcSkillsDir, dstSkillsDir }) {
-  const entries = await fs.readdir(srcSkillsDir, { withFileTypes: true })
-  let copiedDirs = 0
-  let copiedFiles = 0
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const srcDir = join(srcSkillsDir, entry.name)
-    const dstDir = join(dstSkillsDir, entry.name)
-    await ensureDir(dstDir)
-    const stats = await copyDirMerge({ srcDir, dstDir })
-    copiedDirs++
-    copiedFiles += stats.fileCount
-  }
-
-  return { copiedDirs, copiedFiles }
-}
-
 export async function runCodexInitial(options = {}) {
   const packageRoot = options.packageRoot
   if (!packageRoot) throw new Error('runCodexInitial: 缺少 packageRoot')
 
   const homeDir = options.homeDir || os.homedir()
-  const codexDir = join(homeDir, '.codex')
-  const srcSkills = join(packageRoot, 'codex', 'skills')
-  const dstSkills = join(codexDir, 'skills')
-  const srcCodexAgents = join(packageRoot, 'codex', 'agents')
-  const dstCodexAgents = join(codexDir, 'agents')
-
-  await assertDirExists(srcSkills, '模板目录 codex/skills')
-  await assertDirExists(srcCodexAgents, '模板目录 codex/agents')
-
-  await ensureDir(dstSkills)
-  await ensureDir(dstCodexAgents)
-
-  const skillsStats = await copySkillsDirectories({ srcSkillsDir: srcSkills, dstSkillsDir: dstSkills })
-  const codexAgentsStats = await copyDirMerge({ srcDir: srcCodexAgents, dstDir: dstCodexAgents })
-  const configStats = await ensureCodexConfig({ codexDir })
+  const srcSkillsDir = join(packageRoot, 'skills')
+  const targets = [
+    { name: 'codex', dir: join(homeDir, '.codex', 'skills') },
+    { name: 'claude', dir: join(homeDir, '.claude', 'skills') },
+  ]
+
+  await assertDirExists(srcSkillsDir, '模板目录 skills')
+
+  const stats = []
+  for (const target of targets) {
+    await ensureDir(target.dir)
+    const copyStats = await copyDirMerge({ srcDir: srcSkillsDir, dstDir: target.dir })
+    stats.push({ ...target, ...copyStats })
+  }
 
-  logger.success(`已初始化 Codex 模板到: ${codexDir}`)
-  logger.info(`skills: ${skillsStats.copiedDirs} 个目录，覆盖复制 ${skillsStats.copiedFiles} 个文件 -> ${dstSkills}`)
-  logger.info(`codex agents: 覆盖复制 ${codexAgentsStats.fileCount} 个文件 -> ${dstCodexAgents}`)
-  logger.info(
-    `config.toml: 修复 ${configStats.changedKeys} 个配置项，新增 ${configStats.createdSections} 个分组 -> ${configStats.configPath}`,
-  )
+  logger.success('已初始化 skills 模板')
+  for (const target of stats) {
+    logger.info(`${target.name} skills: 覆盖复制 ${target.fileCount} 个文件 -> ${target.dir}`)
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ranger1/dx",
-  "version": "0.1.90",
+  "version": "0.1.92",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
   "files": [
     "bin/",
     "lib/",
-    "codex/",
+    "skills/",
     "LICENSE",
     "README.md",
     "package.json"

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

@@ -0,0 +1,180 @@
+---
+name: backend-layering-audit-fixer
+description: Use when backend、NestJS 分层架构或事务规范审查中，需要检查 Service 是否绕过 Repository 直接访问数据库、Controller 是否跨层注入 Repository、Service 是否伪装 Repository、事务装饰器是否匹配 afterCommit 使用、非 HTTP 场景事务模式是否正确、SSE 端点是否误加事务装饰器、以及是否存在直接 prisma.$transaction() 调用。
+---
+
+# 后端三层架构与事务规范合规检查
+
+## 概览
+
+扫描后端代码是否遵守 **Controller → Service → Repository** 三层架构约束及事务规范。默认只输出审计结果和修复建议；用户明确要求时才自动修复。
+
+规则来源：`ruler/conventions.md` 第 4 节 "NestJS/Prisma 约定" + 第 5 节 "事务规范"。
+
+## 检查项
+
+### 分层架构
+
+| 编号 | 违规类型 | 说明 |
+|------|----------|------|
+| L1 | Service 直接访问数据库 | Service 注入 `PrismaService` 并调用 `this.prisma.*` |
+| L2 | Service 伪装为 Repository | Service 文件含 `getClient()` / `txHost.tx` 模式，实质是 Repository |
+| L3 | Service 死依赖 | Service 注入 `PrismaService` 但从未使用 |
+| L4 | Controller 跨层调用 | Controller 直接注入 Repository |
+
+### 事务规范
+
+| 编号 | 违规类型 | 说明 |
+|------|----------|------|
+| T1 | afterCommit 未被排空 | Controller 用 `@Transactional()` 但调用链中存在 `txEvents.afterCommit()` 回调（应改用 `@TransactionalWithAfterCommit()`） |
+| T2 | Service 违规传播类型 | Service 使用 `Propagation.Required` / `RequiresNew` / `Nested`（禁止 Service 自行创建事务） |
+| T3 | 直接 `prisma.$transaction()` | 绕过 `TransactionHost` 抽象，直接调用 `prisma.$transaction()` |
+| T4 | SSE/流式端点加事务装饰器 | `@Sse()` 或流式返回的方法上使用了 `@Transactional()` / `@TransactionalWithAfterCommit()`（会导致 afterCommit 提前排空） |
+| T5 | 非 HTTP 场景事务模式错误 | Subscriber/Scheduler 使用了 `@Transactional()` 装饰器而非 `txHost.withTransaction()` 或 `txEvents.withAfterCommit()` |
+| T6 | 非 HTTP 场景缺少 CLS 作用域 | Scheduler 调用 `txHost.withTransaction()` 前未用 `cls.run()` 创建 CLS 作用域 |
+
+## 审计命令
+
+**分层架构扫描（并行执行）：**
+
+```bash
+# L1 + L2 + L3：Service 注入 PrismaService
+rg "PrismaService" apps/backend/src/modules --glob '*.service.ts' -l
+
+# L2：Service 含 Repository 模式
+rg "getClient|txHost\.tx" apps/backend/src/modules --glob '*.service.ts' -l
+
+# L4：Controller 注入 Repository
+rg "Repository" apps/backend/src/modules --glob '*.controller.ts' -l
+```
+
+**事务规范扫描（并行执行）：**
+
+```bash
+# T1：找出所有只用 @Transactional() 的 Controller 方法（排除 @TransactionalWithAfterCommit）
+rg "@Transactional\(\)" apps/backend/src/modules --glob '*.controller.ts' -l
+
+# T2：Service 违规传播类型
+rg "Propagation\.(Required|RequiresNew|Nested)" apps/backend/src/modules --glob '*.service.ts' -l
+
+# T3：直接 prisma.$transaction()
+rg "prisma\.\$transaction" apps/backend/src/modules -l
+
+# T4：SSE 端点是否带事务装饰器（需人工确认上下文）
+rg "@Sse\(\)" apps/backend/src/modules --glob '*.controller.ts' -l
+
+# T5：Subscriber/Scheduler 误用 @Transactional 装饰器
+rg "@Transactional" apps/backend/src/modules --glob '*.subscriber.ts' --glob '*.task.ts' --glob '*.scheduler*.ts' -l
+
+# T6：Scheduler 使用 txHost.withTransaction 但未包 cls.run
+rg "txHost\.withTransaction" apps/backend/src/modules --glob '*.scheduler*.ts' --glob '*.task.ts' -l
+```
+
+## 执行流程
+
+1. 执行上述审计命令，收集命中文件列表
+2. **分层检查**：对每个命中文件，读取构造函数和使用处，判定违规类型：
+   - 注入了 `PrismaService` 且有 `this.prisma.*` 调用 → **L1**
+   - 注入了 `PrismaService`/`txHost` 且有 `getClient()` → **L2**
+   - 注入了 `PrismaService` 但无任何 `this.prisma.*` 调用 → **L3**
+   - Controller 文件 import/注入 Repository → **L4**
+3. **事务检查**：
+   - T1：对只用 `@Transactional()` 的 Controller，追踪其调用的 Service 方法，检查是否存在 `txEvents.afterCommit()` 调用
+   - T2：直接匹配即违规
+   - T3：直接匹配即违规
+   - T4：对 `@Sse()` 方法，检查同一方法上是否有事务装饰器
+   - T5：直接匹配即违规（Subscriber/Scheduler 不应用装饰器声明事务）
+   - T6：对命中文件，检查 `txHost.withTransaction()` 调用是否在 `cls.run()` 回调内部
+4. 输出审计报告（按模块分组，标注违规类型和行号）
+5. 仅当用户明确要求修复时，才执行修复
+
+## 修复策略
+
+### 分层架构
+
+**L1：Service 直接访问数据库**
+- 将数据库查询逻辑提取到对应 Repository（新建或复用已有）
+- Service 改为注入 Repository 调用
+
+**L2：Service 伪装为 Repository**
+- 重命名文件为 `*.repository.ts`，类名改为 `*Repository`
+- 更新所有引用（import、Module providers、注入处）
+- 确认 Service 层消费者改为注入新 Repository
+
+**L3：Service 死依赖**
+- 移除构造函数中 `PrismaService` 注入
+- 移除对应 import 语句
+- 运行 lint 确认无残留
+
+**L4：Controller 跨层调用**
+- Controller 中的 Repository 调用下沉到 Service
+- Controller 改为调用 Service 方法
+
+### 事务规范
+
+**T1：afterCommit 未被排空**
+- 将 Controller 方法的 `@Transactional()` 改为 `@TransactionalWithAfterCommit()`
+- 或确认调用链中确实不存在 `afterCommit()` 回调（则无需修改）
+
+**T2：Service 违规传播类型**
+- 改为 `Propagation.Mandatory`（必须在事务中调用）或 `Propagation.Supports`（有事务则加入）
+- 事务边界上移到 Controller 层
+
+**T3：直接 `prisma.$transaction()`**
+- 改用 `txHost.withTransaction()` 或由 Controller 层 `@Transactional()` 声明事务边界
+- Repository 内通过 `txHost.tx` 自动参与事务
+
+**T4：SSE/流式端点加事务装饰器**
+- 移除事务装饰器
+- 如需事务操作，在流式逻辑内部用 `cls.run()` + `txHost.withTransaction()` 局部处理
+
+**T5：非 HTTP 场景误用 @Transactional 装饰器**
+- Subscriber：改用 `txEvents.withAfterCommit()` 包裹处理逻辑
+- Scheduler/Task：改用 `cls.run()` + `txHost.withTransaction()`
+
+**T6：非 HTTP 场景缺少 CLS 作用域**
+- 在 `txHost.withTransaction()` 外层包裹 `cls.run()`：
+  ```typescript
+  await this.cls.run(async () => {
+    await this.txHost.withTransaction(async () => { /* ... */ })
+  })
+  ```
+
+## 排除项
+
+以下场景不视为违规：
+- `*.repository.ts` 文件中使用 `PrismaService` / `getClient()` / `txHost`（Repository 正常职责）
+- `prisma/` 目录下的基础设施文件（`prisma.service.ts` 等）
+- `common/` 目录下的事务基础设施（`TransactionEventsService`、`AfterCommitInterceptor` 等）
+- `*.spec.ts` / `e2e/` 测试文件
+- Subscriber / Scheduler 中通过 `txHost.withTransaction()` 管理事务（正确模式，但其中数据库查询仍应走 Repository）
+
+## 审计报告模板
+
+```
+## 后端分层架构与事务规范审计报告
+
+### 违规汇总
+
+**分层架构：**
+- L1（Service 直接访问 DB）：N 处
+- L2（Service 伪装 Repository）：N 处
+- L3（Service 死依赖）：N 处
+- L4（Controller 跨层调用）：N 处
+
+**事务规范：**
+- T1（afterCommit 未被排空）：N 处
+- T2（Service 违规传播类型）：N 处
+- T3（直接 prisma.$transaction）：N 处
+- T4（SSE 端点加事务装饰器）：N 处
+- T5（非 HTTP 场景误用装饰器）：N 处
+- T6（非 HTTP 缺少 CLS 作用域）：N 处
+
+### 详细列表
+
+#### [模块名]
+| 文件 | 违规类型 | 行号 | 说明 |
+|------|----------|------|------|
+| ... | L1 | 39 | `this.prisma.user.findMany()` |
+| ... | T1 | 85 | `@Transactional()` 但调用链含 `afterCommit()` |
+```

package/{codex/skills → skills}/doctor/SKILL.md

@@ -52,18 +52,11 @@ bash "$CODEX_HOME/skills/doctor/scripts/doctor.sh" --max-rounds 3
 
 ## 脚本职责
 
-- 并行检测：`python3`、`python` 别名、`pnpm`、`dx`、`agent-browser`、`rg`、`multi_agent`、`~/.codex/config.toml` 关键配置。
+- 并行检测：`python3`、`python` 别名、`pnpm`、`dx`、`agent-browser`、`rg`、`multi_agent`。
 - 自动修复：按平台选择安装器修复缺失项。
-- 自动修复：确保 `~/.codex/config.toml` 含以下目标值（缺失补齐、值不符覆盖）：
-  - `[features] multi_agent = true`
-  - `[agents] max_threads = 15`
-  - `[agents.fixer] description/config_file`
-  - `[agents.orchestrator] description/config_file`
-  - `[agents.reviewer] description/config_file`
-  - `[agents.spark] description/config_file`
 - 强制执行：每轮都运行 `pnpm add -g @ranger1/dx@latest && dx initial`。
 - agent-browser：安装/升级并执行 Chromium 安装。
-- 结果输出：展示每项状态、版本、关键信息（含 `codex_config` 检测项）；全部通过则退出 0，否则最多三轮后退出 1。
+- 结果输出：展示每项状态、版本、关键信息；全部通过则退出 0，否则最多三轮后退出 1。
 
 ## 注意