@tea-agent/loop-agent 0.33.1 → 0.33.3

package/skills/analyze-product-requirements/scripts/validate-product-requirement.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { acceptanceBlocks, assertHeadings, containsUnresolvedBlockingPriority, field, loadMarkdown, metadata, outputSpecBlocks, printResult, section, storyBlocks, validateAcceptance, validateArtifactLocation, validateStorySpecCoverage } from "./validation-helpers.mjs";
+import { dirname, join } from "node:path";
+import { acceptanceBlocks, assertHeadings, field, loadMarkdown, metadata, outputSpecBlocks, printResult, section, storyBlocks, validateAcceptance, validateArtifactLocation, validateFrontmatter, validateNoImplementationLeakage, validateStorySpecCoverage } from "./validation-helpers.mjs";
 
 const args = process.argv.slice(2);
 const allowPending = args.includes("--allow-pending");
@@ -20,10 +20,11 @@ catch (error) { console.error(error.message); process.exit(2); }
 
 const { path, text } = artifact;
 const errors = [];
+validateFrontmatter(text, ["artifact_version", "artifact_type", "requirement_id", "requirement_status", "analysis_scope"], errors, "Product Requirement");
 validateArtifactLocation(artifact, errors, "product-requirement.md");
 const scope = metadata(text, "analysis_scope");
 const status = metadata(text, "requirement_status");
-if (metadata(text, "artifact_version") !== "3.0") errors.push("artifact_version must be 3.0.");
+if (metadata(text, "artifact_version") !== "4.0") errors.push("artifact_version must be 4.0.");
 if (metadata(text, "artifact_type") !== "product-requirement") errors.push("artifact_type must be product-requirement.");
 if (!["frontend", "backend", "both"].includes(scope)) errors.push("analysis_scope must be frontend, backend, or both.");
 if (targetIndex >= 0 && !["frontend", "backend", "both"].includes(expectedTarget)) errors.push("--target must be frontend, backend, or both.");
@@ -31,27 +32,20 @@ else if (expectedTarget && scope !== expectedTarget) errors.push(`analysis_scope
 if (!["pending", "complete"].includes(status)) errors.push("requirement_status must be pending or complete.");
 if (!allowPending && status !== "complete") errors.push("Final Product Requirement must be complete.");
 
-function sourcePath(name) {
-  const value = metadata(text, name);
-  if (!value || ["inline", "none"].includes(value)) return value;
-  return resolve(dirname(path), value);
-}
-for (const name of ["source_requirement", "source_product_analysis", "source_clarification"]) {
-  const value = sourcePath(name);
-  if (!value) errors.push(`${name} is required.`);
-  else if (!["inline", "none"].includes(value) && !existsSync(value)) errors.push(`${name} does not exist: ${value}`);
-}
-for (const name of ["source_product_analysis", "source_clarification"]) {
-  const value = sourcePath(name);
-  if (value && !["inline", "none"].includes(value) && dirname(value) !== dirname(path)) errors.push(`${name} must reference an artifact in the same requirement directory.`);
-}
-
+validateNoImplementationLeakage(text, errors);
 assertHeadings(text, 2, ["需求概述", "业务目标", "需求范围", "业务规则", "决策追溯"], errors, "Product Requirement");
 const range = section(text, 2, "需求范围") ?? "";
-assertHeadings(range, 3, ["已确认需求", "非目标", "默认假设", "未决事项"], errors, "需求范围");
-if (status === "complete" && containsUnresolvedBlockingPriority(section(range, 3, "未决事项") ?? "")) errors.push("Complete Product Requirement cannot contain unresolved P0/P1 items.");
-if (/^##\s+(?:\d+[.、]?\s*)?(?:用户角色|验收标准汇总)\s*$/m.test(text)) errors.push("Product Requirement must not contain standalone 用户角色 or 验收标准汇总 sections.");
+assertHeadings(range, 3, ["已确认范围", "非目标"], errors, "需求范围");
+if (/^###\s+(?:\d+(?:\.\d+)*[.、]?\s*)?默认假设\s*$/m.test(range)) errors.push("Product Requirement must not contain 默认假设.");
+const pendingSection = section(range, 3, "未决事项");
+if (status === "complete" && pendingSection) errors.push("Complete Product Requirement must not contain 未决事项.");
+if (status === "pending") assertHeadings(range, 3, ["未决事项"], errors, "Pending Product Requirement");
+if (status === "complete" && /(?:pending-(?:blocking|non-blocking)|未形成|尚未确认|未决)/i.test(text)) errors.push("Complete Product Requirement must not contain unconfirmed product behavior.");
+if (/^##\s+(?:\d+[.、]?\s*)?(?:用户角色|验收标准汇总|前后端契约|Open Questions|测试建议|边界 case|边界Case)\s*$/im.test(text)) {
+  errors.push("Product Requirement must not contain standalone 用户角色, 验收标准汇总, 前后端契约, Open Questions, 测试建议, or 边界 case sections.");
+}
 
+const acceptanceIds = new Set();
 function validateDomain(domain) {
   const frontend = domain === "frontend";
   const title = frontend ? "前端" : "后端";
@@ -65,16 +59,29 @@ function validateDomain(domain) {
   if (!stories.length) errors.push(`${storyHeading} must contain at least one ${prefix}-* story.`);
   validateStorySpecCoverage(stories, specs, errors, `${title} scope`);
   const storyFields = frontend ? ["角色", "目标", "价值", "入口", "验收标准"] : ["系统能力", "使用方", "业务价值", "触发方式", "验收标准"];
-  const specFields = frontend ? ["页面/组件", "展示内容", "交互动作", "UI 状态", "表单校验", "权限可见性", "边界处理"] : ["输入语义", "输出语义", "数据读写", "权限规则", "业务规则", "安全要求", "幂等与并发", "错误与边界"];
+  const specFields = frontend ? ["页面/组件", "页面路由", "展示内容", "交互动作", "UI 状态", "表单校验", "权限可见性", "边界处理"] : ["输入语义", "输出语义", "数据读写", "权限规则", "业务规则", "安全要求", "幂等与并发", "错误与边界"];
   for (const story of stories) {
     for (const name of storyFields) if (!field(story.text, name)) errors.push(`${story.id} is missing story field ${name}.`);
-    if (!frontend && !/^(?:API|定时任务|事件|消息|内部调用|数据迁移)(?:$|[、,，/])/i.test(field(story.text, "触发方式") ?? "")) errors.push(`${story.id} 触发方式 is invalid.`);
+    const trigger = field(story.text, "触发方式") ?? "";
+    const apiTrigger = /^API[（(](?:Web|Remote|Web\s*\+\s*Remote)[）)]$/i.test(trigger);
+    if (!frontend && !apiTrigger && !/^(?:定时任务|事件|消息|内部调用|数据迁移)$/i.test(trigger)) errors.push(`${story.id} 触发方式 is invalid; API must declare Web, Remote, or Web + Remote.`);
     const spec = specs.find((item) => item.id === story.id);
     if (!spec) continue;
     for (const name of specFields) if (!field(spec.text, name)) errors.push(`${spec.id} output specification is missing field ${name}.`);
+    if (frontend) {
+      const route = field(spec.text, "页面路由") ?? "";
+      const directRoute = /^`?\/[^`\s]+`?(?:\s|$|[；;，,])/.test(route);
+      const embeddedRoute = /^不适用；.+`?\/[^`\s]+`?.*页面/.test(route);
+      if (!directRoute && !embeddedRoute) errors.push(`${spec.id} 页面路由 must start with / or use 不适用； and name its containing page.`);
+      if (/(?:route config|middleware|路由注册文件|路由组件)/i.test(route)) errors.push(`${spec.id} 页面路由 must describe product routing, not implementation files or framework components.`);
+    }
     const criteria = acceptanceBlocks(spec, acPrefix);
     if (!criteria.length) errors.push(`${spec.id} output specification must contain at least one ${acPrefix}-* acceptance criterion.`);
-    for (const item of criteria) validateAcceptance(item.text, item.id, errors);
+    for (const item of criteria) {
+      if (acceptanceIds.has(item.id)) errors.push(`Duplicate acceptance criterion ID: ${item.id}.`);
+      acceptanceIds.add(item.id);
+      validateAcceptance(item.text, item.id, errors);
+    }
     const referenced = [...(field(story.text, "验收标准") ?? "").matchAll(new RegExp(`${acPrefix}-\\d{3,}`, "g"))].map((item) => item[0]).sort();
     const actual = criteria.map((item) => item.id).sort();
     if (referenced.join() !== actual.join()) errors.push(`${story.id} acceptance references must match its output specification criteria.`);
@@ -86,12 +93,17 @@ if (scope === "backend" || scope === "both") validateDomain("backend");
 if (scope === "frontend" && /(?:^##\s+.*后端|^###\s+BE-US-)/m.test(text)) errors.push("frontend scope must not contain backend sections or stories.");
 if (scope === "backend" && /(?:^##\s+.*前端|^###\s+FE-US-)/m.test(text)) errors.push("backend scope must not contain frontend sections or stories.");
 
-const clarificationSource = sourcePath("source_clarification");
-if (status === "complete" && clarificationSource && !["inline", "none"].includes(clarificationSource) && existsSync(clarificationSource)) {
+const clarificationSource = join(dirname(path), "requirement-clarification.md");
+if (!existsSync(clarificationSource)) {
+  errors.push("Product Requirement requires requirement-clarification.md in the same requirement directory.");
+} else {
   const clarification = readFileSync(clarificationSource, "utf8");
-  if (metadata(clarification, "clarification_status") !== "complete") errors.push("Complete Product Requirement requires complete source clarification.");
-  const markers = [...clarification.matchAll(/^-\s*决策标记[：:]\s*(DEC-Q-\d{3,})/gm)].map((item) => item[1]);
-  for (const marker of markers) if (!text.includes(marker)) errors.push(`${marker} from source clarification is missing from Product Requirement.`);
+  const clarificationStatus = metadata(clarification, "clarification_status");
+  if (clarificationStatus !== status) errors.push("Product Requirement and source clarification must have the same pending/complete status.");
+  if (status === "complete") {
+    const markers = [...clarification.matchAll(/^-\s*决策标记[：:]\s*(DEC-Q-\d{3,})/gm)].map((item) => item[1]);
+    for (const marker of markers) if (!text.includes(marker)) errors.push(`${marker} from source clarification is missing from Product Requirement.`);
+  }
 }
 
 printResult("Product Requirement", path, errors);

package/skills/analyze-product-requirements/scripts/validate-requirement-clarification.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { assertHeadings, canonical, field, headings, loadMarkdown, metadata, printResult, section, validateArtifactLocation } from "./validation-helpers.mjs";
+import { dirname } from "node:path";
+import { assertHeadings, canonical, field, headings, loadMarkdown, metadata, printResult, section, validateArtifactLocation, validateFrontmatter } from "./validation-helpers.mjs";
 
 const args = process.argv.slice(2);
 const allowPending = args.includes("--allow-pending");
@@ -20,46 +19,55 @@ try {
 } catch (error) { console.error(error.message); process.exit(2); }
 
 const errors = [];
+validateFrontmatter(clarification.text, ["artifact_version", "artifact_type", "requirement_id", "analysis_scope", "clarification_status", "clarification_rounds"], errors, "Requirement Clarification");
 validateArtifactLocation(clarification, errors, "requirement-clarification.md");
 const scope = metadata(clarification.text, "analysis_scope");
 const status = metadata(clarification.text, "clarification_status");
 const clarificationRounds = Number(metadata(clarification.text, "clarification_rounds"));
-if (metadata(clarification.text, "artifact_version") !== "3.0") errors.push("artifact_version must be 3.0.");
+if (metadata(clarification.text, "artifact_version") !== "4.0") errors.push("artifact_version must be 4.0.");
 if (metadata(clarification.text, "artifact_type") !== "requirement-clarification") errors.push("artifact_type must be requirement-clarification.");
 if (!["frontend", "backend", "both"].includes(scope)) errors.push("analysis_scope must be frontend, backend, or both.");
 if (!["pending", "complete"].includes(status)) errors.push("clarification_status must be pending or complete.");
-if (!Number.isInteger(clarificationRounds) || clarificationRounds < 0 || clarificationRounds > 3) errors.push("clarification_rounds must be an integer from 0 to 3.");
+if (!Number.isInteger(clarificationRounds) || clarificationRounds < 0) errors.push("clarification_rounds must be a non-negative integer.");
 if (!allowPending && status !== "complete") errors.push("Final Requirement Clarification must be complete.");
+const requirementStatus = metadata(requirement.text, "requirement_status");
+if (status !== requirementStatus) errors.push("Requirement Clarification and Product Requirement must have the same pending/complete status.");
 if (scope !== metadata(analysis.text, "analysis_scope")) errors.push("analysis_scope must match Product Analysis.");
+if (scope !== metadata(requirement.text, "analysis_scope")) errors.push("analysis_scope must match Product Requirement.");
 
-const resolveRef = (value) => value ? resolve(dirname(clarification.path), value) : "";
-const source = metadata(clarification.text, "source_product_analysis");
-const target = metadata(clarification.text, "target_product_requirement");
-if (resolveRef(source) !== analysis.path) errors.push("source_product_analysis must reference the supplied Product Analysis.");
-if (resolveRef(target) !== requirement.path) errors.push("target_product_requirement must reference the supplied Product Requirement.");
-if (source && dirname(resolveRef(source)) !== dirname(clarification.path)) errors.push("source_product_analysis must be in the same requirement directory.");
-if (target && dirname(resolveRef(target)) !== dirname(clarification.path)) errors.push("target_product_requirement must be in the same requirement directory.");
-if (source && !existsSync(resolveRef(source))) errors.push(`source_product_analysis does not exist: ${resolveRef(source)}`);
-if (target && !existsSync(resolveRef(target))) errors.push(`target_product_requirement does not exist: ${resolveRef(target)}`);
+if (dirname(analysis.path) !== dirname(clarification.path) || dirname(requirement.path) !== dirname(clarification.path)) errors.push("All requirement artifacts must be in the same requirement directory.");
+const requirementId = metadata(clarification.text, "requirement_id");
+if (requirementId !== metadata(analysis.text, "requirement_id") || requirementId !== metadata(requirement.text, "requirement_id")) errors.push("requirement_id must match across all requirement artifacts.");
 
 const analysisStatus = metadata(analysis.text, "analysis_status");
 const questionBlocks = headings(clarification.text, 3).filter((item) => /^Q-\d{3,}\s+/.test(item.title));
+const sourceSection = section(clarification.text, 2, questionBlocks.length ? "澄清来源" : "来源") ?? "";
+const recordedSourceIdentity = field(sourceSection, "原始需求身份") ?? "";
+const analysisSourceIdentity = field(section(analysis.text, 2, "原始需求") ?? "", "原始需求身份") ?? "";
+if (!/^(?:inline|file):sha256:[a-f0-9]{64}$/.test(recordedSourceIdentity)) errors.push("Clarification source must contain a valid 原始需求身份.");
+else if (recordedSourceIdentity !== analysisSourceIdentity) errors.push("原始需求身份 must match Product Analysis.");
+if (/(?:default-confirmed|confirmed-default)/.test(clarification.text)) errors.push("Requirement Clarification must not use default-confirmed or confirmed-default.");
 
 if (!questionBlocks.length) {
+  if (status !== "complete") errors.push("Compact no-clarification-required artifacts must be complete.");
   if (clarificationRounds !== 0) errors.push("Compact clarification must set clarification_rounds to 0.");
   if (analysisStatus !== "no-clarification-required") errors.push("Compact clarification is allowed only when Product Analysis is no-clarification-required.");
   const required = ["澄清结论", "来源", "合并结果"];
   assertHeadings(clarification.text, 2, required, errors, "Compact Requirement Clarification");
   for (const heading of headings(clarification.text, 2)) if (!required.includes(canonical(heading.title))) errors.push(`Compact Requirement Clarification must not contain section ${canonical(heading.title)}.`);
-  if (!/状态[：:]\s*no-clarification-required/.test(section(clarification.text, 2, "澄清结论") ?? "")) errors.push("Compact clarification must declare no-clarification-required.");
+  const conclusion = section(clarification.text, 2, "澄清结论") ?? "";
+  if (!/状态[：:]\s*no-clarification-required/.test(conclusion)) errors.push("Compact clarification must declare no-clarification-required.");
+  if (status === "complete" && !/^[ \t]*-[ \t]*内容补充[：:][ \t]*用户已确认无需补充\s*$/m.test(conclusion)) {
+    errors.push("Complete compact clarification must record 内容补充：用户已确认无需补充.");
+  }
   if (/\b(?:BR|Q|DEC-Q)-\d{3,}\b/.test(clarification.text)) errors.push("Compact clarification must not fabricate BR, Q, or DEC-Q markers.");
 } else {
-  if (clarificationRounds < 1 || clarificationRounds > 3) errors.push("Question-based clarification must set clarification_rounds from 1 to 3.");
+  if (clarificationRounds < 1) errors.push("Question-based clarification must set clarification_rounds to a positive integer.");
   if (analysisStatus !== "ready-for-clarification") errors.push("Question records require Product Analysis status ready-for-clarification.");
   assertHeadings(clarification.text, 2, ["澄清来源", "决策分支", "问题记录", "决策索引"], errors, "Requirement Clarification");
   const branchSection = section(clarification.text, 2, "决策分支") ?? "";
   const branchIds = [...new Set(branchSection.match(/\bBR-\d{3,}\b/g) ?? [])];
-  if (branchIds.length < 3 || branchIds.length > 6) errors.push("Question-based clarification must define 3–6 top-level BR-* branches.");
+  if (branchIds.length < 1) errors.push("Question-based clarification must define at least one top-level BR-* branch.");
   if (status === "complete") {
     const unresolved = branchSection.split(/\r?\n/).filter((line) => /\|\s*BR-\d{3,}\s*\|/.test(line) && !/\|\s*resolved\s*\|\s*$/.test(line));
     if (unresolved.length) errors.push("Complete clarification requires every branch to be resolved.");
@@ -74,25 +82,28 @@ if (!questionBlocks.length) {
     const priority = field(block.text, "优先级");
     const impactScope = field(block.text, "影响范围");
     const answer = field(block.text, "用户回答");
+    const finalDecision = field(block.text, "最终决策");
     const decisionStatus = field(block.text, "状态");
     const decisionSource = field(block.text, "决策来源");
     if (!branchIds.includes(branch)) errors.push(`${id} 分支 must reference a defined BR-* branch.`);
     if (!Number.isInteger(round) || round < 1 || round > clarificationRounds) errors.push(`${id} 澄清轮次 must be between 1 and clarification_rounds.`);
     if (!["P0", "P1", "P2"].includes(priority)) errors.push(`${id} 优先级 must be P0, P1, or P2.`);
     if (!["common", "frontend", "backend", "both"].includes(impactScope)) errors.push(`${id} 影响范围 is invalid.`);
-    if (!["confirmed", "default-confirmed", "pending-blocking", "pending-non-blocking"].includes(decisionStatus)) errors.push(`${id} 状态 is invalid.`);
-    if (!["user", "source-requirement", "code-evidence", "confirmed-default"].includes(decisionSource)) errors.push(`${id} 决策来源 is invalid.`);
+    if (!["confirmed", "pending-blocking", "pending-non-blocking"].includes(decisionStatus)) errors.push(`${id} 状态 is invalid.`);
+    if (decisionSource !== "user") errors.push(`${id} 决策来源 must be user; source requirements and code facts must not be represented as Q-* decisions.`);
     const marker = field(block.text, "决策标记");
     if (marker !== `DEC-${id}`) errors.push(`${id} 决策标记 must be DEC-${id}.`);
     if (markers.has(marker)) errors.push(`Duplicate decision marker: ${marker}.`);
     markers.add(marker);
-    if (decisionSource === "code-evidence" && !field(block.text, "代码证据")) errors.push(`${id} code-evidence decision requires 代码证据.`);
     if (decisionStatus === "pending-non-blocking" && !field(block.text, "未确认影响")) errors.push(`${id} pending-non-blocking decision requires 未确认影响.`);
-    if (status === "complete" && ["P0", "P1"].includes(priority) && (decisionStatus !== "confirmed" || decisionSource !== "user" || /^(?:未回答|待确认|无)$/.test(answer ?? ""))) errors.push(`${id} ${priority} must contain an explicit user confirmation.`);
+    if (status === "complete" && (decisionStatus !== "confirmed" || decisionSource !== "user" || /^(?:未回答|待确认|无)$/.test(answer ?? ""))) errors.push(`${id} must be confirmed by an explicit user answer before clarification can be complete.`);
+    if (status === "complete" && /^(?:未形成|未回答|待确认|尚未确认|无)$/.test(finalDecision ?? "")) errors.push(`${id} must contain a formed final decision before clarification can be complete.`);
     if (status === "complete" && marker && !requirement.text.includes(marker)) errors.push(`${marker} is missing from Product Requirement decision traceability.`);
     if (!(section(clarification.text, 2, "决策索引") ?? "").includes(marker ?? "__missing__")) errors.push(`${marker ?? id} is missing from 决策索引.`);
   }
+  if (status === "complete" && !/^[ \t]*-[ \t]*共同理解[：:][ \t]*已确认\s*$/m.test(section(clarification.text, 2, "决策索引") ?? "")) {
+    errors.push("Complete question-based clarification must record 共同理解：已确认 in 决策索引.");
+  }
 }
 
-if (status === "complete" && metadata(requirement.text, "requirement_status") !== "complete") errors.push("Complete clarification requires a complete Product Requirement.");
 printResult("Requirement Clarification", clarification.path, errors);

package/skills/analyze-product-requirements/scripts/validation-helpers.mjs

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
 
 export function loadMarkdown(fileArg, label = "artifact") {
   const path = resolve(fileArg);
@@ -14,6 +14,29 @@ export function frontmatter(text) {
   return text.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
 }
 
+export function validateFrontmatter(text, allowedKeys, errors, owner) {
+  const block = frontmatter(text);
+  if (!block) {
+    errors.push(`${owner} must contain YAML frontmatter.`);
+    return;
+  }
+  const keys = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):[ \t]*(.*)$/);
+    if (!match) {
+      errors.push(`${owner} frontmatter must contain only top-level scalar fields.`);
+      continue;
+    }
+    keys.push(match[1]);
+  }
+  for (const key of new Set(keys)) {
+    if (keys.filter((value) => value === key).length > 1) errors.push(`${owner} frontmatter contains duplicate field ${key}.`);
+    if (!allowedKeys.includes(key)) errors.push(`${owner} frontmatter contains unsupported field ${key}.`);
+  }
+  for (const key of allowedKeys) if (!keys.includes(key)) errors.push(`${owner} frontmatter is missing field ${key}.`);
+}
+
 export function metadata(text, name) {
   const block = frontmatter(text);
   const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -100,17 +123,21 @@ export function validateAcceptance(block, owner, errors) {
   if (!/(?:不得|不应|禁止|保留|恢复|重试|兜底|回滚|disabled)/.test(block)) {
     errors.push(`${owner} must include an observable protection or recovery result.`);
   }
+  if (/(?:功能正常|应正常展示|展示正确|接口可用|数据正确|符合预期|妥善处理|合理处理|无异常情况|没有需要处理的异常场景|无需处理失败)/.test(block)) {
+    errors.push(`${owner} must not use vague acceptance language.`);
+  }
 }
 
-export function containsUnresolvedBlockingPriority(block) {
-  if (!block) return false;
-  return block.split(/\r?\n/).slice(1).some((line) => {
-    const plain = line.trim().replace(/^[-*+]\s*/, "").replace(/^\[[ xX]\]\s*/, "");
-    if (!/\bP[01]\b/.test(plain)) return false;
-    if (/^(?:不存在|没有|无)(?:任何)?(?:尚未|未)?(?:解决|确认|关闭|完成)?(?:的)?\s*P[01]\b/.test(plain)) return false;
-    if (/^P[01]\b/.test(plain)) return true;
-    return /(?:pending(?:-blocking)?|unresolved|未解决|未确认|待确认|未决|阻塞)/i.test(plain);
-  });
+export function validateNoImplementationLeakage(text, errors, owner = "Product Requirement") {
+  if (/\bKB-FACT-\d+\b/.test(text)) errors.push(`${owner} must not contain KB-FACT-* markers.`);
+  if (/\bCODE-FACT-\d+\b/.test(text)) errors.push(`${owner} must not contain CODE-FACT-* markers.`);
+  if (/(?:^|[\s`'(])(?:\.\/|\.\.\/)?(?:src|app|packages|lib|internal|cmd|pkg)\/[^\s`')]+/m.test(text)) {
+    errors.push(`${owner} must not contain repository file paths.`);
+  }
+  if (/\b[A-Z][A-Za-z0-9]*(?:Controller|Service|Repository|Handler|Middleware)\b/.test(text)) {
+    errors.push(`${owner} must not contain code-level class or component symbols.`);
+  }
+  if (/证据位置/.test(text)) errors.push(`${owner} must not contain 证据位置.`);
 }
 
 export function assertHeadings(text, level, required, errors, owner) {
@@ -132,23 +159,15 @@ export function printResult(label, path, errors) {
 
 export function validateArtifactLocation(artifact, errors, expectedName) {
   const requirementId = metadata(artifact.text, "requirement_id");
-  const projectRootValue = metadata(artifact.text, "project_root");
   if (!requirementId || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(requirementId)) {
     errors.push("requirement_id must use lowercase letters, digits, and single hyphens.");
     return;
   }
-  if (!projectRootValue) {
-    errors.push("project_root is required.");
-    return;
-  }
-  const projectRoot = resolve(dirname(artifact.path), projectRootValue);
-  if (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
-    errors.push(`project_root does not resolve to an existing directory: ${projectRoot}`);
-    return;
-  }
-  const expected = resolve(join(projectRoot, "docs", "product-analysis", requirementId));
-  if (dirname(artifact.path) !== expected) {
-    errors.push(`Artifact must be located under ${expected}.`);
+  const artifactDir = dirname(artifact.path);
+  const productAnalysisDir = dirname(artifactDir);
+  const docsDir = dirname(productAnalysisDir);
+  if (basename(artifactDir) !== requirementId || basename(productAnalysisDir) !== "product-analysis" || basename(docsDir) !== "docs") {
+    errors.push(`Artifact must be located under <project-root>/docs/product-analysis/${requirementId}.`);
   }
   if (expectedName && basename(artifact.path) !== expectedName) {
     errors.push(`Artifact filename must be ${expectedName}.`);

package/skills/playwright-cli/SKILL.md

@@ -80,6 +80,13 @@ controller receipts：successful `open` → successful `find` → successful pos
 - 文件型证据：`screenshot` 与 `pdf` 必须使用 `--filename <file>`，且文件名由 controller 规范化到当前 case evidence 目录。截图一律写为 `playwright-cli screenshot --filename final.png`；有真实元素 ref 时写为 `playwright-cli screenshot e5 --filename final.png`。`pdf` 写为 `playwright-cli pdf --filename final.pdf`。`snapshot` 不带 filename 时只返回响应；需要文件时写为 `playwright-cli snapshot --filename snapshot.txt`。不得使用 `--path`、`--output`、`--file`，也不得把文件路径作为位置参数。
 - 对话框、上传、拖放和视口变化仅在 case 已给出所需前置条件时使用对应 allowlist 命令。
 
+## 持久化执行事实
+
+每个 browser case 必须在自身 evidenceDir 写入权威的 `execution.md` 与 `case-result.json`，最终报告只读取最后一次写入的文件：
+
+- `case-result.json`：包含匹配的 `caseId`、最终 `status`（`passed`/`failed`/`blocked`）、`evidencePaths`；重跑时用整数 `rerunAttempt` 覆写同一文件，最终状态即报告状态。
+- `execution.md`：当存在可记录的执行事实时，使用固定标题 `### 执行摘要` 与 `### 实际执行步骤`，以便有界确定性报告抽取器展示实际执行步骤与摘要。这两段为可选；缺失只形成 advisory，不会降级已通过状态。
+
 ## 阻塞处理
 
 当环境、数据、权限、时序、异常路径或响应内容无法用 RAG、冻结配置和 runtime allowlist 证明时，

package/skills/analyze-product-dependencies/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "产品依赖分析"
-  short_description: "把故事、输出规范和验收标准映射到真实代码与 API 文档"
-  default_prompt: "使用 $analyze-product-dependencies 将 Product Requirement 映射到代码，并按需生成 API 文档。"

package/skills/analyze-product-requirements/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "产品需求分析"
-  short_description: "分析并按需澄清需求，生成故事、输出规范和验收标准"
-  default_prompt: "使用 $analyze-product-requirements 分析并按需澄清需求，生成完整 Product Requirement。"