add-coder 0.3.33 → 0.3.35

package/templates/core/validation/schema-validator.ts

@@ -0,0 +1,277 @@
+/*
+ * schema 驱动校验器（Plan core-validation-lifecycle Task 1.1 / Spec §1 §SchemaSource）
+ *
+ * **唯一真源**：全部形式判定读 `templates/core/templates/*.schema.json`。
+ * 本文件内**不得出现任何硬编码章节名**——章节、子章节、允许占位符、禁词全部来自 schema。
+ *
+ * 校验项：
+ *  - required section 缺失 → MISSING_SECTION
+ *  - section 的 subsections 缺失 → MISSING_SUBSECTION
+ *  - 多轮文档轮次不足 → ROUND_COUNT_SHORT（由调用方给 expectRounds）
+ *  - schema.placeholders 中仍残留的占位符 → PLACEHOLDER_LEFT
+ *  - schema.forbidden_terms 命中（**围栏代码块外**）→ FORBIDDEN_TERM
+ *
+ * 匹配口径：**半角/全角等价**（见 normalizeWidth）。schema 真源只用一种写法，
+ * 判定时对两侧同时归一，避免"冒号全角了就判缺章节"这类假缺陷。
+ */
+
+export interface SchemaSection {
+  id: string
+  heading?: string
+  required?: boolean
+  subsections?: { heading: string }[]
+  /** 语义锚定：在模板对应行中提取 token，要求这些 token 出现在文档（可配合 within 限定范围） */
+  anchor?: string
+  within?: string
+}
+
+export interface SchemaFile {
+  template: string
+  sections: SchemaSection[]
+  placeholders?: string[]
+  forbidden_terms?: string[]
+  /** 结构位列号（1-based，含首列分隔符偏移，与既有守卫语义一致） */
+  groupColumn?: number | string
+}
+
+/** schema 层（形式）检查码 */
+export type SchemaIssueCode =
+  | "MISSING_SECTION"
+  | "MISSING_SUBSECTION"
+  | "ROUND_COUNT_SHORT"
+  | "PLACEHOLDER_LEFT"
+  | "FORBIDDEN_TERM"
+
+/**
+ * 问题码：schema 层用固定枚举；类型特有规则（validators/*）可声明自己的码
+ * （如 `AUDIT_QUERY_MISSING`、`UNVERIFIED_T_LEFT`），故开放为字符串联合。
+ */
+export type IssueCode = SchemaIssueCode | (string & {})
+
+export interface ValidationIssue {
+  code: IssueCode
+  detail: string
+  expected?: string
+}
+
+export interface ValidateOptions {
+  /** 多轮文档的期望轮次数（来自 Plan/执行记录，不由本模块猜） */
+  expectRounds?: number
+  /** 轮次标题的模板串（默认取 schema 中 heading 含 `<第N轮>` 的 section） */
+  roundHeading?: string
+  /** 模板内容（anchor 校验需要：token 从模板对应行提取） */
+  templateContent?: string
+}
+
+/** 统计子串出现次数 */
+function countOccurrences(haystack: string, needle: string): number {
+  if (!needle) return 0
+  const h = normalizeWidth(haystack)
+  const n = normalizeWidth(needle)
+  let count = 0
+  let idx = h.indexOf(n)
+  while (idx !== -1) {
+    count++
+    idx = h.indexOf(n, idx + n.length)
+  }
+  return count
+}
+
+/**
+ * 半角/全角归一（2026-09-14：半角全角都支持）。
+ *
+ * 为什么放在**匹配层**而不是 schema 真源：真源是形式定义，不该为书写习惯准备两份；
+ * 归一化属于"怎么比"，与"比什么"分离（同 policy.ts 的规则/适用性分离）。
+ *
+ * 覆盖：全角 ASCII 区 U+FF01–U+FF5E → U+0021–U+007E（：（）？！，；／＃ + 全角字母数字），
+ * 以及表意空格 U+3000 → 半角空格。两侧同时归一，故任一侧写全角都能匹配。
+ * 逐码点 1:1 映射，归一后字符串长度不变——indexOf 的下标语义不受影响。
+ */
+const FULLWIDTH_START = 0xff01
+const FULLWIDTH_END = 0xff5e
+const FULLWIDTH_TO_HALF = 0xfee0
+const WIDTH_FOLD_EXTRA: Readonly<Record<string, string>> = { "\u3000": " " }
+
+export function normalizeWidth(text: string): string {
+  let out = ""
+  for (const ch of text) {
+    const code = ch.codePointAt(0) as number
+    if (code >= FULLWIDTH_START && code <= FULLWIDTH_END) {
+      out += String.fromCharCode(code - FULLWIDTH_TO_HALF)
+    } else {
+      out += WIDTH_FOLD_EXTRA[ch] ?? ch
+    }
+  }
+  return out
+}
+
+/** 去掉围栏代码块（禁词判定不该命中示例代码与引用块） */
+export function stripFencedBlocks(content: string): string {
+  return content.replace(/```[\s\S]*?```/g, "\n")
+}
+
+/**
+ * 结构位文本：**标题行 + groupColumn 列**（与既有 doc-format-guard 语义一致）。
+ * 禁词只在该范围内判定——正文正常叙述里出现"阶段"不构成违规。
+ */
+export function structText(content: string, groupColumn?: number | string): string {
+  let text = (content.match(/^#{2,}\s.*$/gm) ?? []).join("\n")
+  const col = typeof groupColumn === "number" ? groupColumn : Number(groupColumn)
+  if (Number.isFinite(col) && col > 0) {
+    const cells = content
+      .split("\n")
+      .map((line) => {
+        const cells = line.split("|")
+        return cells.length > col ? (cells[col + 1] ?? "").trim() : ""
+      })
+      .filter(Boolean)
+    text += "\n" + cells.join("\n")
+  }
+  return text
+}
+
+/**
+ * 语义锚定校验（0.3.27 能力，上移至此以免抽层时丢失）：
+ * 从模板中含 anchor 的行提取 token，要求它们出现在文档（`within` 存在时限定该节范围）。
+ * 模板行或 within 无法定位时**跳过该规则**（与既有守卫一致，不误判）。
+ */
+export function validateAnchors(
+  content: string,
+  schema: SchemaFile,
+  templateContent: string,
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const nContent = normalizeWidth(content)
+  for (const section of schema.sections) {
+    if (!section.anchor) continue
+    const refAnchor = normalizeWidth(section.anchor)
+    const refLine = templateContent.split("\n").find((l) => normalizeWidth(l).includes(refAnchor))
+    if (!refLine) continue
+    const tokens = [
+      ...new Set(
+        normalizeWidth(refLine)
+          .replace(/[#*`|(){]/g, " ")
+          .split(/\s+/)
+          .filter((t) => t !== "" && !t.includes("{")),
+      ),
+    ]
+    if (tokens.length === 0) continue
+    let scope = nContent
+    if (section.within) {
+      const startIdx = nContent.indexOf(normalizeWidth(section.within))
+      if (startIdx < 0) continue
+      const endIdx = nContent.indexOf("\n## ", startIdx + 1)
+      scope = nContent.slice(startIdx, endIdx === -1 ? undefined : endIdx)
+    }
+    const missTokens = tokens.filter((tok) => !scope.includes(tok))
+    if (missTokens.length > 0) {
+      issues.push({
+        code: "ANCHOR_MISS",
+        detail: `缺锚点(${section.id}): ${missTokens.join(" ")}`,
+        expected: section.anchor,
+      })
+    }
+  }
+  return issues
+}
+
+/** 从 schema 推断轮次标题模板（`## <第N轮>` 这类） */
+export function inferRoundHeading(schema: SchemaFile): string | null {
+  const round = schema.sections.find((s) => s.heading?.includes("<第N轮>"))
+  return round?.heading ?? null
+}
+
+/** 轮次标题在文档中的实际出现次数（把 `<第N轮>` 视为通配片段） */
+export function countRounds(content: string, roundHeading: string): number {
+  const heading = normalizeWidth(roundHeading)
+  if (!heading.includes("<第N轮>")) return 0
+  /*
+   * `<第N轮>` → `第<数字>轮`（2026-09-14 修正）：
+   * 旧实现把通配片段缩成「本行以轮结尾」，于是模板自己示范的写法
+   * `## <第N轮> {Round简短描述}`（落地即 `## 第 1 轮 抽层`）被计为 **0 轮** →
+   * 多轮 handoff 一律假报 ROUND_COUNT_SHORT。改为按"第+数字+轮"识别（只锚行首、不锚行尾）：
+   * 既能计带描述的轮次标题，也不会把 `## 附录` / `## 轮次依赖` 之类误计为轮次。
+   */
+  const pattern = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("<第N轮>", "第\\s*\\d+\\s*轮")
+  const re = new RegExp(`^${pattern}`, "gm") // 行首锚定即可，`{Round简短描述}` 可有可无
+  return (normalizeWidth(content).match(re) ?? []).length
+}
+
+export function validateAgainstSchema(
+  content: string,
+  schema: SchemaFile,
+  opts: ValidateOptions = {},
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const proseOnly = stripFencedBlocks(content)
+  /** 归一化视图（匹配用，报告仍引原文）；口径与原文一致：占位符查全文（含围栏内），禁词查结构位 */
+  const contentNormalized = normalizeWidth(content)
+
+  // 1) 章节与子章节
+  const roundHeading = opts.roundHeading ?? inferRoundHeading(schema)
+  for (const section of schema.sections) {
+    if (!section.heading) continue
+    const isRoundSection = roundHeading !== null && section.heading === roundHeading
+    if (isRoundSection) {
+      // 轮次章节始终走轮次计数（默认至少 1 轮），不与字面 `<第N轮>` 比对
+      const need = opts.expectRounds ?? 1
+      const found = countRounds(content, roundHeading as string)
+      if (found < need) {
+        issues.push({
+          code: "ROUND_COUNT_SHORT",
+          detail: `轮次章节不足：期望 ${need} 轮，实际 ${found} 轮`,
+          expected: roundHeading,
+        })
+      }
+      // 轮次子章节（每轮一套）必须逐项检查——这是多轮文档的核心规格，不能被 continue 跳过
+      for (const sub of section.subsections ?? []) {
+        if (countOccurrences(content, sub.heading) < need) {
+          issues.push({
+            code: "MISSING_SUBSECTION",
+            detail: `轮次子章节缺失或不足（需要 ${need} 份）：${sub.heading}`,
+            expected: sub.heading,
+          })
+        }
+      }
+      continue
+    }
+    if (section.required && countOccurrences(content, section.heading) === 0) {
+      issues.push({ code: "MISSING_SECTION", detail: `缺少必需章节：${section.heading}`, expected: section.heading })
+    }
+    for (const sub of section.subsections ?? []) {
+      const need = isRoundSection ? (opts.expectRounds ?? 1) : 1
+      if (countOccurrences(content, sub.heading) < need) {
+        issues.push({
+          code: "MISSING_SUBSECTION",
+          detail: `子章节缺失或不足（需要 ${need} 份）：${sub.heading}`,
+          expected: sub.heading,
+        })
+      }
+    }
+  }
+
+  // 2) 占位符残留（只查 schema 声明的那些；半角/全角写法都算残留——放宽写法不等于放过残留）
+  for (const ph of schema.placeholders ?? []) {
+    if (!ph) continue
+    const nPh = normalizeWidth(ph)
+    const idx = contentNormalized.indexOf(nPh)
+    if (idx === -1) continue
+    const hit = nPh === ph ? ph : `${content.slice(idx, idx + nPh.length)}（宽度等价于 ${ph}）`
+    issues.push({ code: "PLACEHOLDER_LEFT", detail: `占位符未替换：${hit}`, expected: ph })
+  }
+
+  // 3) 结构位禁词（**标题行 + groupColumn 列**；正文叙述不判）
+  const struct = normalizeWidth(structText(content, schema.groupColumn))
+  for (const term of schema.forbidden_terms ?? []) {
+    if (term && struct.includes(normalizeWidth(term))) {
+      issues.push({ code: "FORBIDDEN_TERM", detail: `结构位禁词：${term}（仅标题行与指定列判定）`, expected: term })
+    }
+  }
+
+  // 4) 语义锚定（需要模板内容；缺模板则跳过，不误判）
+  if (opts.templateContent) {
+    issues.push(...validateAnchors(content, schema, opts.templateContent))
+  }
+
+  return issues
+}

package/templates/core/validation/validators/add-route.ts

@@ -0,0 +1,32 @@
+/*
+ * add-route 专司（Task 2.3 / Spec §5）
+ *
+ * 语义规则：产出项统计（`- [ ]` / `- [x]`，与 `check_add_route_completeness` 同口径）
+ * 与「Task 映射表」存在性——add-route 是 Plan→代码的唯一映射表。
+ */
+import { countMatches, issue, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export interface AddRouteStats {
+  total: number
+  open: number
+  done: number
+}
+
+export function addRouteStats(content: string): AddRouteStats {
+  const done = countMatches(content, /^- \[[xX]\]/gm)
+  const open = countMatches(content, /^- \[ \]/gm)
+  return { total: done + open, open, done }
+}
+
+export function checkAddRoute(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const stats = addRouteStats(ctx.content)
+  if (stats.total === 0) {
+    issues.push(issue("ADD_ROUTE_CHECKBOX_MISSING", "未发现任何产出项复选框（- [ ] / - [x]）"))
+  }
+  if (!/Task\s*映射表|Task 映射表/.test(ctx.content)) {
+    issues.push(issue("ADD_ROUTE_TASK_MAP_MISSING", "缺少 Task 映射表（Plan→代码的唯一映射）"))
+  }
+  return issues
+}

package/templates/core/validation/validators/checklist.ts

@@ -0,0 +1,48 @@
+/*
+ * checklist 专司（Task 2.2 / Spec §5）
+ *
+ * 语义规则（schema 不表达）：
+ *  - `[T]` 未勾选数（封口"验收证据"因子的输入）；
+ *  - `[R]` 项存在性（运行时验证须留有清单，不得为零）；
+ *  - 「(待填写)」证据占位残留（证据必须真实，不接受占位）。
+ */
+import { countMatches, issue, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export interface ChecklistStats {
+  tTotal: number
+  tDone: number
+  tOpen: number
+  rTotal: number
+  evidencePlaceholders: number
+}
+
+export function checklistStats(content: string): ChecklistStats {
+  const tDone = countMatches(content, /^- \[[xX]\] \[T\]/gm)
+  const tOpen = countMatches(content, /^- \[ \] \[T\]/gm)
+  return {
+    tTotal: tDone + tOpen,
+    tDone,
+    tOpen,
+    rTotal: countMatches(content, /^- \[[ xX]\] \[R\]/gm),
+    evidencePlaceholders: countMatches(content, /\(待填写\)/gm),
+  }
+}
+
+export function checkChecklist(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const s = checklistStats(ctx.content)
+
+  if (s.tTotal === 0) {
+    issues.push(issue("CHECKLIST_T_MISSING", "未发现任何 [T] 编译期验证项（checklist 缺少可判定内容）"))
+  }
+  if (s.rTotal === 0) {
+    issues.push(issue("CHECKLIST_R_MISSING", "未发现任何 [R] 运行时验证项（须留待运行时清单）"))
+  }
+  if (s.evidencePlaceholders > 0) {
+    issues.push(
+      issue("EVIDENCE_PLACEHOLDER_LEFT", `证据占位残留 ${s.evidencePlaceholders} 处（(待填写)）——证据必须为真实命令与结果`),
+    )
+  }
+  return issues
+}

package/templates/core/validation/validators/handoff.ts

@@ -0,0 +1,46 @@
+/*
+ * handoff 专司（Task 2.1 / Spec §2 多轮计数 + §4）
+ *
+ * schema 层已负责：章节/子章节存在性、轮次计数、占位符、禁词。
+ * 本专司只补两条 schema 表达不了的语义规则：
+ *  1. **§8 必须含可执行审计查询**（`query_audit_logs(`）——"给下一个会话的入口"不能只是文字描述；
+ *  2. **§9 后置确认必须是逐项勾选状态**（不能整节留空）。
+ */
+import { countMatches, issue, proseOnly, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export function checkHandoff(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const content = ctx.content
+
+  if (!/query_audit_logs\s*\(/.test(content)) {
+    issues.push(
+      issue("AUDIT_QUERY_MISSING", "缺少可执行审计查询（query_audit_logs(...)）——下一会话无从恢复上下文"),
+    )
+  }
+
+  // 后置确认：取「后置确认」之后的所有复选框
+  const idx = content.indexOf("后置确认")
+  const post = idx >= 0 ? content.slice(idx) : ""
+  const total = countMatches(post, /^- \[[ xX]\]/gm)
+  if (idx < 0) {
+    issues.push(issue("POSTCHECK_MISSING", "缺少「后置确认」章节", "后置确认"))
+  } else if (total === 0) {
+    issues.push(issue("POSTCHECK_EMPTY", "后置确认无逐项勾选状态（须列明确认项）"))
+  }
+
+  // 多轮文档：每轮的验证标准必须可判定（非空、含可执行证据字样）
+  if ((ctx.expectRounds ?? 1) > 1) {
+    const verdicts = countMatches(content, /^- \[[ xX]\]/gm)
+    if (verdicts === 0) {
+      issues.push(issue("ROUND_VERDICT_MISSING", "多轮文档未见任何逐项验证标准（- [ ] / - [x]）"))
+    }
+  }
+
+  // 脱敏：不得出现凭据硬编码（此处只做"可疑赋值"提示，属 advisory 语义）
+  if (/(POSTGRES_PASSWORD|JWT_SECRET|API_KEY)\s*[:=]\s*["'][^"']{8,}["']/.test(proseOnly(content))) {
+    issues.push(issue("SECRET_HARDCODED", "疑似凭据硬编码（应以环境变量引用）"))
+  }
+
+  return issues
+}

package/templates/core/validation/validators/hitl.ts

@@ -0,0 +1,22 @@
+/*
+ * hitl 专司（Task 2.4 / Spec §5）
+ *
+ * 语义规则：提案必须含维度表格且至少 1 行（无维度 = 无法逐项拍板）；
+ * 且状态字段须存在（DRAFT/TONGYI/BOHUI 可判定）。
+ */
+import { countMatches, issue, proseOnly, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export function checkHitl(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const body = proseOnly(ctx.content)
+
+  const dimensionRows = countMatches(body, /^\|\s*\d+\s*\|[^|]+\|[^|]+\|/gm)
+  if (dimensionRows === 0) {
+    issues.push(issue("HITL_DIMENSION_MISSING", "提案无决策维度行（无法逐项拍板）"))
+  }
+  if (!/状态\s*[:：]/.test(body)) {
+    issues.push(issue("HITL_STATUS_MISSING", "提案缺少状态字段（DRAFT/TONGYI/BOHUI）"))
+  }
+  return issues
+}

package/templates/core/validation/validators/index.ts

@@ -0,0 +1,52 @@
+/*
+ * 专司注册（Plan core-validation-lifecycle Task 2.5 / Spec §2 §ValidatorRegistry）
+ *
+ * 类型 → 专司检查函数。**未注册类型的专司缺口会被显式报告**（`uncoveredTypes()`），
+ * 避免"加了新文档类型但忘了写专司"这种事悄悄发生。
+ */
+import type { TypeCheck } from "./types.js"
+import { checkHandoff } from "./handoff.js"
+import { checkChecklist } from "./checklist.js"
+import { checkTasks } from "./tasks.js"
+import { checkSpec } from "./spec.js"
+import { checkPlan } from "./plan.js"
+import { checkAddRoute } from "./add-route.js"
+import { checkReview } from "./review.js"
+import { checkHitl } from "./hitl.js"
+import { checkReport } from "./report.js"
+
+/** 类型 → 专司（可多对一：同类文档共用一份专司逻辑，但入口按 type 显式登记） */
+export const TYPE_CHECKS: Readonly<Record<string, TypeCheck>> = {
+  "plan.standard": checkPlan,
+  "plan.simple": checkPlan,
+  spec: checkSpec,
+  tasks: checkTasks,
+  checklist: checkChecklist,
+  "add-route": checkAddRoute,
+  "handoff.single": checkHandoff,
+  "handoff.multi": checkHandoff,
+  review: checkReview,
+  "review.implementation": checkReview,
+  "review.runtime": checkReview,
+  hitl: checkHitl,
+  report: checkReport,
+  "runtime-report": checkReport,
+  "collab-contract": checkReport,
+  "fix-verification": checkReport,
+  prd: checkReport,
+} as const
+
+/** 取得该类型的专司（未登记返回 null，由调用方决定是否报缺口） */
+export function typeCheckFor(type: string): TypeCheck | null {
+  return TYPE_CHECKS[type] ?? null
+}
+
+/** 覆盖自检：registry 里已注册但缺少专司的类型（供 checklist 断言） */
+export function uncoveredTypes(registeredTypes: readonly string[]): string[] {
+  return registeredTypes.filter((t) => !(t in TYPE_CHECKS))
+}
+
+export { checkHandoff, checkChecklist, checkTasks, checkSpec, checkPlan, checkAddRoute, checkReview, checkHitl, checkReport }
+export { checklistStats } from "./checklist.js"
+export { tasksStats } from "./tasks.js"
+export { addRouteStats } from "./add-route.js"

package/templates/core/validation/validators/plan.ts

@@ -0,0 +1,20 @@
+/*
+ * plan 专司（Task 2.3 / Spec §5）
+ *
+ * 语义规则：元信息必含「Plan 名称 / 启动时间 / 状态」三字段（HITL 与纳管依赖它们），
+ * 且状态不得停留在"待审批"以外的含糊表述（须可判定）。
+ */
+import { issue, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+const REQUIRED_META = ["**Plan 名称**", "**启动时间**", "**状态**"]
+
+export function checkPlan(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  for (const field of REQUIRED_META) {
+    if (!ctx.content.includes(field)) {
+      issues.push(issue("PLAN_META_MISSING", `Plan 元信息缺少字段：${field}`, field))
+    }
+  }
+  return issues
+}

package/templates/core/validation/validators/report.ts

@@ -0,0 +1,16 @@
+/*
+ * report 类专司（Task 2.4 / Spec §5：report / runtime-report / collab-contract / fix-verification / prd）
+ *
+ * 语义规则：收尾类文档必须有明确结论段（"结论/判定/建议"之一），否则只是过程叙述。
+ */
+import { issue, proseOnly, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export function checkReport(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const body = proseOnly(ctx.content)
+  if (!/结论|判定|建议|Triage 结果/.test(body)) {
+    issues.push(issue("REPORT_CONCLUSION_MISSING", "缺少结论/判定/建议段（收尾类文档须可判定）"))
+  }
+  return issues
+}

package/templates/core/validation/validators/review.ts

@@ -0,0 +1,30 @@
+/*
+ * review 专司（Task 2.4 / Spec §5，三型共用：方案 / 实现 / 运行时）
+ *
+ * 语义规则：必须有「问题清单」章节且清单条目带严重度标记（P0/P1/P2 或 🔴🟡🟢），
+ * 否则 Review 只是叙述、不构成可执行缺陷清单。
+ */
+import { countMatches, issue, proseOnly, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export function checkReview(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const body = proseOnly(ctx.content)
+
+  // 发现清单的等价形态：HITL 发现总览（review-template 的现行结构）/ 问题清单 / 发现列表
+  // （2026-09-13 修订：原实现只认后两者，对 review-template 产生假阳性）
+  if (!/HITL 发现总览|问题清单|发现列表/.test(body)) {
+    issues.push(issue("REVIEW_FINDINGS_MISSING", "缺少发现清单（HITL 发现总览 / 问题清单 / 发现列表）"))
+  }
+  const severities = countMatches(body, /(🔴|🟡|🟢)|\bP[012]\b/g)
+  if (severities === 0) {
+    issues.push(issue("REVIEW_SEVERITY_MISSING", "清单条目未见严重度标记（P0/P1/P2 或 🔴🟡🟢）"))
+  }
+  if (ctx.type === "review.runtime") {
+    const unchecked = countMatches(body, /^- \[ \]\s*Triage/gm)
+    if (unchecked > 0) {
+      issues.push(issue("RUNTIME_TRIAGE_OPEN", `运行时发现未 Triage ${unchecked} 条（不得静默累积）`))
+    }
+  }
+  return issues
+}

package/templates/core/validation/validators/spec.ts

@@ -0,0 +1,25 @@
+/*
+ * spec 专司（Task 2.2 / Spec §5）
+ *
+ * 语义规则：`Plan→Spec 映射` 表至少 1 行（DPS 的映射锚定依赖它），
+ * 且每个 Requirement 至少含一条 WHEN-THEN（可判定性）。
+ */
+import { countMatches, issue, proseOnly, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export function checkSpec(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const body = proseOnly(ctx.content)
+
+  const mappingRows = countMatches(body, /^\|\s*\d+\s*\|.*\|/gm)
+  if (mappingRows === 0) {
+    issues.push(issue("PLAN_SPEC_MAP_MISSING", "缺少「Plan→Spec 映射」表（DPS 映射锚定依赖）"))
+  }
+
+  const requirements = countMatches(body, /^#{2,3}\s+\d+\.\s+/gm)
+  const whenThen = countMatches(body, /^\s*-\s*WHEN\s+/gm)
+  if (requirements > 0 && whenThen === 0) {
+    issues.push(issue("WHEN_THEN_MISSING", "存在 Requirements 章节但无任何 WHEN-THEN 条目（不可判定）"))
+  }
+  return issues
+}

package/templates/core/validation/validators/tasks.ts

@@ -0,0 +1,40 @@
+/*
+ * tasks 专司（Task 2.2 / Spec §5）
+ *
+ * 语义规则：Task 勾选统计（与 `plan_track` 的进度口径一致），
+ * 以及「Plan→Task 映射表」存在性（tasks.md 必须能对回 Plan 的 Task）。
+ */
+import { countMatches, issue, type TypeCheckContext } from "./types.js"
+import type { ValidationIssue } from "../schema-validator.js"
+
+export interface TasksStats {
+  total: number
+  done: number
+}
+
+/** Task 级统计：`### Task N.M` 标题数与其中已完成（含子项全勾）的量 */
+export function tasksStats(content: string): TasksStats {
+  const headings = [...content.matchAll(/^###\s+Task\s+\d+(?:\.\d+)?\s*[:：]/gm)]
+  const total = headings.length
+  let done = 0
+  for (let i = 0; i < headings.length; i++) {
+    const start = headings[i].index ?? 0
+    const end = i + 1 < headings.length ? (headings[i + 1].index ?? content.length) : content.length
+    const body = content.slice(start, end)
+    const boxes = body.match(/^- \[[ xX]\]/gm) ?? []
+    if (boxes.length > 0 && boxes.every((b) => /\[[xX]\]/.test(b))) done++
+  }
+  return { total, done }
+}
+
+export function checkTasks(ctx: TypeCheckContext): ValidationIssue[] {
+  const issues: ValidationIssue[] = []
+  const stats = tasksStats(ctx.content)
+  if (stats.total === 0) {
+    issues.push(issue("TASK_HEADING_MISSING", "未发现 `### Task N.M:` 形式的 Task 标题（无法拆解执行）"))
+  }
+  if (!/Plan\s*→\s*Task|Plan→Task/.test(ctx.content)) {
+    issues.push(issue("PLAN_TASK_MAP_MISSING", "缺少「Plan→Task 映射」表（Tasks 必须可对回 Plan）"))
+  }
+  return issues
+}

package/templates/core/validation/validators/types.ts

@@ -0,0 +1,32 @@
+/*
+ * 专司 validator 的共享契约（Plan core-validation-lifecycle Task 2.x / Spec §2 §ValidatorRegistry）
+ *
+ * 分工原则：**schema 层管形式，专司层管本类型特有的语义**。
+ * 专司只补充「schema 表达不了」的规则（如"§8 必须有可执行审计查询"、"checklist 的 [T] 未勾数"），
+ * 不重复章节存在性判定——那由 schema 层负责（Spec §1）。
+ */
+import type { ValidationIssue } from "../schema-validator.js"
+
+export interface TypeCheckContext {
+  type: string
+  content: string
+  path: string
+  /** 多轮文档的期望轮次（由调用方给出） */
+  expectRounds?: number
+}
+
+export type TypeCheck = (ctx: TypeCheckContext) => ValidationIssue[]
+
+export function issue(code: string, detail: string, expected?: string): ValidationIssue {
+  return expected === undefined ? { code, detail } : { code, detail, expected }
+}
+
+/** 统计匹配次数（供各专司复用） */
+export function countMatches(content: string, re: RegExp): number {
+  return (content.match(re) ?? []).length
+}
+
+/** 去掉围栏代码块（语义检查一般不该被示例代码命中） */
+export function proseOnly(content: string): string {
+  return content.replace(/```[\s\S]*?```/g, "\n")
+}