@openprd/cli 0.1.10 → 0.1.18

package/src/run-harness.js

@@ -19,6 +19,9 @@ const OPENPRD_HARNESS_RUN_STATE = cjoin(OPENPRD_HARNESS_DIR, 'run-state.json');
 const OPENPRD_HARNESS_ITERATIONS = cjoin(OPENPRD_HARNESS_DIR, 'iterations.jsonl');
 const OPENPRD_HARNESS_LEARNINGS = cjoin(OPENPRD_HARNESS_DIR, 'learnings.md');
 const OPENPRD_HARNESS_LOOP_FEATURE_LIST = cjoin(OPENPRD_HARNESS_DIR, 'feature-list.json');
+const OPENPRD_HARNESS_INSTALL_MANIFEST = cjoin(OPENPRD_HARNESS_DIR, 'install-manifest.json');
+const OPENPRD_HARNESS_HOOK_STATE = cjoin(OPENPRD_HARNESS_DIR, 'hook-state.json');
+const OPENPRD_HARNESS_RUNTIME_ENVIRONMENT = cjoin(OPENPRD_HARNESS_DIR, 'runtime-environment.json');
 const OPENPRD_HARNESS_REQUIREMENT_GATE = cjoin(OPENPRD_HARNESS_DIR, 'requirement-gate.json');
 const OPENPRD_HARNESS_REQUIREMENT_GATES_DIR = cjoin(OPENPRD_HARNESS_DIR, 'requirement-gates');
 const OPENPRD_HARNESS_SESSION_BINDINGS_DIR = cjoin(OPENPRD_HARNESS_DIR, 'session-bindings');
@@ -82,6 +85,34 @@ async function ensureRunHarness(projectRoot) {
   }
 }
 
+async function readRuntimeEnvironmentContext(projectRoot) {
+  const [runtimeEnvironment, installManifest, hookState] = await Promise.all([
+    readJson(harnessFile(projectRoot, OPENPRD_HARNESS_RUNTIME_ENVIRONMENT)).catch(() => null),
+    readJson(harnessFile(projectRoot, OPENPRD_HARNESS_INSTALL_MANIFEST)).catch(() => null),
+    readJson(harnessFile(projectRoot, OPENPRD_HARNESS_HOOK_STATE)).catch(() => null),
+  ]);
+  const active = runtimeEnvironment?.active
+    ?? hookState?.runtimeEnvironment
+    ?? {
+      activeClient: 'unknown',
+      surface: 'unknown',
+      confidence: 0,
+      sessionId: null,
+      evidence: [],
+      observedCapabilities: [],
+    };
+  return {
+    active,
+    runtimeDetection: installManifest?.runtimeDetection ?? runtimeEnvironment?.runtimeDetection ?? null,
+    platformCapabilityPacks: installManifest?.platformCapabilityPacks ?? runtimeEnvironment?.platformCapabilityPacks ?? [],
+    files: {
+      runtimeEnvironment: OPENPRD_HARNESS_RUNTIME_ENVIRONMENT,
+      installManifest: OPENPRD_HARNESS_INSTALL_MANIFEST,
+      hookState: OPENPRD_HARNESS_HOOK_STATE,
+    },
+  };
+}
+
 async function readRunState(projectRoot) {
   await ensureRunHarness(projectRoot);
   return readJson(harnessFile(projectRoot, OPENPRD_HARNESS_RUN_STATE)).catch(() => ({
@@ -225,7 +256,7 @@ function executionGate() {
     confirmationChecklistRequired: true,
     allowedIntents: ['开发', '实现', '修复', '继续任务', '落地执行', '深度调研', '深度对标', '复刻落地', '提交'],
     readOnlyIntents: ['看看', '规划', '梳理', '分析', '评估', '预计动哪些文件', '怎么改', '代码审查'],
-    rule: '只有当用户当前明确要求实现、继续、深度调研、对标或提交时，才运行 executionCommand。单纯的“请帮我实现/继续实现”只表示有执行意图，不表示可以跳过 requirement 摘要确认、`capture/classify/synthesize` 写入路径或 review；只有用户明确表示“不需要进行任何确认”时，才允许静默走完整 requirement write path，并对当前精确匹配的稳定 review artifact 记录确认。若还需要向用户索取执行授权，先展示 executionConfirmationChecklist，再请求明确确认；规划、分析、文件影响范围和审查类请求保持只读，并基于证据回答。',
+    rule: '只有当用户当前明确要求实现、继续、深度调研、对标或提交时，才运行 executionCommand。单纯的“请帮我实现/继续实现”只表示有执行意图，不表示可以跳过 requirement 摘要确认、`capture/classify/synthesize` 写入路径或 review；只有用户明确表示“不需要进行任何确认”时，才允许静默走完整 requirement write path，并对当前精确匹配的稳定 review artifact 记录确认。即使用户授权实现，也不等于授权云端热修复、生产远端写入、业务兜底、写死逻辑或缓存补行；这些动作必须由当前用户明确批准，并说明如何同步回本地源码、配置或迁移。若还需要向用户索取执行授权，先展示 executionConfirmationChecklist，再请求明确确认；规划、分析、文件影响范围和审查类请求保持只读，并基于证据回答。',
   };
 }
 
@@ -251,6 +282,7 @@ function buildExecutionConfirmationChecklist(recommendation) {
     outOfScope: [
       '不会默认处理这次范围以外的历史问题。',
       '不会默认顺带做提交、发布或额外的全局调整。',
+      '不会默认做云端热修复、生产远端写入、业务兜底、写死逻辑或缓存补行。',
       '如果真的需要扩大范围，我会先单独说明。',
     ].filter(Boolean),
     verification: [
@@ -261,6 +293,7 @@ function buildExecutionConfirmationChecklist(recommendation) {
     risks: [
       '这一步会正式写入当前工作区。',
       '如果牵出和本次无关的历史遗留问题，我会单列说明，不把它混成本次失败。',
+      '如果确实需要临时兜底或线上热修复，我会先单独说明影响、回滚和本地同步计划，等你明确批准。',
       parallelPlan?.eligible ? '如果多人同时推进，我会避免范围互相踩踏。' : null,
     ],
     confirmationPrompt: '如果你希望我现在就按这次范围继续，我就直接往下做。',
@@ -1816,6 +1849,7 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
   await ensureRunHarness(projectRoot);
   const runState = await readRunState(projectRoot);
   const currentTurn = await readJson(harnessFile(projectRoot, OPENPRD_HARNESS_TURN_STATE)).catch(() => null);
+  const runtimeEnvironment = await readRuntimeEnvironmentContext(projectRoot);
   const currentTurnPrompt = String(currentTurn?.prompt ?? '').trim();
   const fallbackPrompt = !options.hookInject
     ? (inferPromptDrivenLightweightRecommendation(currentTurnPrompt) ? currentTurnPrompt : null)
@@ -1942,8 +1976,8 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
     activeChange,
     nextTaskTitle: nextTask?.title,
     relatedFiles: [
-      focusedChangeId ? `openprd/changes/${focusedChangeId}/tasks.md` : null,
-      activeChange ? `openprd/changes/${activeChange}` : null,
+      focusedChangeId ? `.openprd/changes/${focusedChangeId}/tasks.md` : null,
+      activeChange ? `.openprd/changes/${activeChange}` : null,
     ].filter(Boolean),
     limit: options.hookInject ? 4 : 3,
   }).catch(() => ({ matched: [], summary: { matched: 0 } }));
@@ -2035,6 +2069,7 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
       : null,
     lane,
     recommendation: effectiveRecommendation,
+    runtimeEnvironment,
     knowledgeSkills: {
       matched: renderedKnowledgeSkills,
       mandatoryCheck: knowledgeSkillMatches.mandatoryCheck ?? null,
@@ -2050,6 +2085,7 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
       runState: OPENPRD_HARNESS_RUN_STATE,
       iterations: OPENPRD_HARNESS_ITERATIONS,
       learnings: OPENPRD_HARNESS_LEARNINGS,
+      runtimeEnvironment: OPENPRD_HARNESS_RUNTIME_ENVIRONMENT,
     },
   };
 
@@ -2065,6 +2101,7 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
 async function recordRunHook(projectRoot, options = {}) {
   await ensureRunHarness(projectRoot);
   const state = await readRunState(projectRoot);
+  const runtimeEnvironment = await readRuntimeEnvironmentContext(projectRoot);
   const currentIteration = Number(state.currentIteration ?? 0) + 1;
   const event = {
     version: 1,
@@ -2075,6 +2112,7 @@ async function recordRunHook(projectRoot, options = {}) {
     risk: options.risk ?? 'unknown',
     outcome: options.outcome ?? 'unknown',
     preview: options.preview ?? null,
+    runtimeEnvironment: runtimeEnvironment.active,
   };
   await appendJsonl(harnessFile(projectRoot, OPENPRD_HARNESS_ITERATIONS), event);
   await writeRunState(projectRoot, {

package/src/session-evidence.js

@@ -0,0 +1,363 @@
+/*
+ * 核心功能
+ * 从 Codex 原始会话事件中抽取可审查证据，并隔离系统提示、AGENTS 和工具 schema 噪声。
+ *
+ * 输入
+ * 接收 JSONL 事件对象、消息对象或文本片段。
+ *
+ * 输出
+ * 输出带 sourceKind 的 evidence records，以及供 knowledge matching 使用的清理后文本。
+ *
+ * 定位
+ * 位于会话证据层，服务 daily review、knowledge review 和项目经验召回，不直接读写工作区。
+ *
+ * 依赖
+ * 仅依赖标准 JavaScript，不依赖 CLI、文件系统或 OpenPrd workspace 状态。
+ *
+ * 维护规则
+ * 这里负责证据卫生，不负责判断需求类型；新增来源时先补 sourceKind 和污染样例测试。
+ */
+
+const CONTEXT_ONLY_PATTERNS = [
+  /\bAGENTS\.md instructions\b/i,
+  /<INSTRUCTIONS>/i,
+  /<\/INSTRUCTIONS>/i,
+  /<environment_context>/i,
+  /# Tools\b/i,
+  /## Skills\b/i,
+  /### Available skills\b/i,
+  /\bnamespace\s+\w+\s*\{/i,
+  /\btool schema\b/i,
+  /\bYou are Codex\b/i,
+  /\bOpenPrd Harness\b/i,
+  /\bproject-doc\b/i,
+];
+
+const CONTEXT_ROLE_SET = new Set(['system', 'developer']);
+
+const GENERIC_FRAMEWORK_TERMS = new Set([
+  'agent',
+  'agents',
+  'agentruntime',
+  'codex',
+  'context',
+  'developer',
+  'hook',
+  'hooks',
+  'harness',
+  'instruction',
+  'instructions',
+  'openprd',
+  'schema',
+  'skill',
+  'skills',
+  'system',
+  'tool',
+  'tools',
+  'workflow',
+  'workflows',
+  '项目级',
+  '项目经验',
+  '沉淀',
+]);
+
+function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function trimEvidenceText(value, max = 1200) {
+  const text = normalizeWhitespace(value);
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function normalizeEventType(event = {}) {
+  return String(
+    event.type
+      ?? event.event
+      ?? event.kind
+      ?? event.eventType
+      ?? event.name
+      ?? event.item?.type
+      ?? event.event_msg?.type
+      ?? '',
+  ).trim();
+}
+
+function normalizeRole(event = {}) {
+  return String(
+    event.role
+      ?? event.message?.role
+      ?? event.item?.role
+      ?? event.event_msg?.role
+      ?? '',
+  ).trim().toLowerCase();
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+
+function extractTextFromContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => firstString(part?.text, part?.content, part?.input, part?.output))
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (content && typeof content === 'object') {
+    return firstString(content.text, content.content, content.input, content.output) ?? '';
+  }
+  return '';
+}
+
+function extractEventText(event = {}) {
+  if (typeof event === 'string') return event;
+  const eventMsg = event.event_msg ?? {};
+  const item = event.item ?? {};
+  const message = event.message ?? {};
+  return firstString(
+    event.text,
+    event.content,
+    event.output,
+    event.final_answer,
+    event.summary,
+    event.prompt,
+    event.user_message,
+    event.agent_message,
+    eventMsg.user_message,
+    eventMsg.agent_message,
+    eventMsg.final_answer,
+    eventMsg.summary,
+    eventMsg.message,
+    item.final_answer,
+    item.summary,
+    item.text,
+    item.output,
+    message.text,
+    extractTextFromContent(message.content),
+    extractTextFromContent(item.content),
+  ) ?? '';
+}
+
+function looksLikeContextOnly(text, event = {}) {
+  const role = normalizeRole(event);
+  if (CONTEXT_ROLE_SET.has(role)) return true;
+  return CONTEXT_ONLY_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function classifyEvent(event = {}, text = '') {
+  const role = normalizeRole(event);
+  const type = normalizeEventType(event).toLowerCase();
+  const eventMsg = event.event_msg ?? {};
+  const item = event.item ?? {};
+  if (looksLikeContextOnly(text, event)) {
+    return { sourceKind: 'context-only', reason: 'system-context' };
+  }
+  if (role === 'user' || eventMsg.user_message) {
+    return { sourceKind: 'user-direct', reason: 'user-message' };
+  }
+  if (
+    role === 'assistant'
+    || eventMsg.agent_message
+    || eventMsg.final_answer
+    || item.final_answer
+    || type.includes('final')
+  ) {
+    return { sourceKind: 'assistant-final', reason: 'assistant-message' };
+  }
+  if (
+    type.includes('task_complete')
+    || event.task_complete
+    || eventMsg.task_complete
+    || item.type === 'task_complete'
+  ) {
+    return { sourceKind: 'assistant-final', reason: 'task-complete' };
+  }
+  if (
+    type.includes('function_call')
+    || type.includes('tool')
+    || event.tool
+    || event.name
+    || item.name
+  ) {
+    return { sourceKind: 'tool-action', reason: 'tool-event' };
+  }
+  if (/\b(git status|npm test|node --test|openprd .*--verify|doctor)\b/i.test(text)) {
+    return { sourceKind: 'tool-action', reason: 'command-evidence' };
+  }
+  return { sourceKind: 'context-only', reason: 'unclassified' };
+}
+
+function normalizeEvidenceRecord(record = {}, index = 0) {
+  const text = trimEvidenceText(record.text);
+  if (!text) return null;
+  const sourceKind = String(record.sourceKind ?? 'context-only').trim() || 'context-only';
+  return {
+    sourceKind,
+    text,
+    reason: String(record.reason ?? '').trim() || null,
+    role: String(record.role ?? '').trim() || null,
+    eventType: String(record.eventType ?? '').trim() || null,
+    eventIndex: Number.isFinite(Number(record.eventIndex)) ? Number(record.eventIndex) : index,
+    confidence: Number.isFinite(Number(record.confidence)) ? Number(record.confidence) : (sourceKind === 'context-only' ? 0.2 : 0.8),
+  };
+}
+
+function extractSessionEvidenceRecords(events = [], options = {}) {
+  const maxRecords = Math.max(1, Number(options.maxRecords ?? 80));
+  return (Array.isArray(events) ? events : [events])
+    .map((event, index) => {
+      const text = extractEventText(event);
+      if (!normalizeWhitespace(text)) return null;
+      const classification = classifyEvent(event, text);
+      return normalizeEvidenceRecord({
+        ...classification,
+        text,
+        role: normalizeRole(event),
+        eventType: normalizeEventType(event),
+        eventIndex: index,
+      }, index);
+    })
+    .filter(Boolean)
+    .slice(0, maxRecords);
+}
+
+function normalizeSessionEvidenceRecords(records = []) {
+  return (Array.isArray(records) ? records : [records])
+    .map((record, index) => normalizeEvidenceRecord(record, index))
+    .filter(Boolean);
+}
+
+function cleanEvidenceRecords(records = [], options = {}) {
+  const includeContextOnly = options.includeContextOnly === true;
+  return normalizeSessionEvidenceRecords(records)
+    .filter((record) => includeContextOnly || record.sourceKind !== 'context-only');
+}
+
+function buildCleanEvidenceText(records = [], options = {}) {
+  const maxRecords = Math.max(1, Number(options.maxRecords ?? 24));
+  return cleanEvidenceRecords(records, options)
+    .slice(0, maxRecords)
+    .map((record) => `[${record.sourceKind}] ${record.text}`)
+    .join('\n');
+}
+
+function normalizeSearchText(value) {
+  return String(value ?? '')
+    .toLowerCase()
+    .replace(/[`"'()[\]{}:;,!?]/g, ' ')
+    .replace(/[_/\\.-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function sanitizeEvidenceText(value) {
+  const text = String(value ?? '');
+  if (!text.trim()) return '';
+  const lines = text.split(/\r?\n/);
+  const kept = [];
+  let skipBlock = false;
+  for (const line of lines) {
+    const startsContextBlock = /<INSTRUCTIONS>|<environment_context>|# Tools\b|### Available skills\b/i.test(line);
+    if (startsContextBlock) {
+      skipBlock = true;
+      continue;
+    }
+    if (skipBlock && /<\/INSTRUCTIONS>|<\/environment_context>/i.test(line)) {
+      skipBlock = false;
+      continue;
+    }
+    if (skipBlock) continue;
+    if (CONTEXT_ONLY_PATTERNS.some((pattern) => pattern.test(line))) continue;
+    kept.push(line);
+  }
+  return normalizeWhitespace(kept.join('\n'));
+}
+
+function isGenericFrameworkTerm(token) {
+  const normalized = normalizeSearchText(token);
+  return !normalized || GENERIC_FRAMEWORK_TERMS.has(normalized);
+}
+
+function filterGenericFrameworkTokens(tokens = []) {
+  return [...new Set(tokens.filter((token) => !isGenericFrameworkTerm(token)))];
+}
+
+function buildSessionEvidenceReviewSource(options = {}) {
+  const records = cleanEvidenceRecords(options.records ?? []);
+  const title = firstString(options.title, records.find((record) => record.sourceKind === 'user-direct')?.text, '只读复盘证据候选');
+  const sourceId = firstString(options.sourceId, title, 'session-evidence-review');
+  const sourcePath = firstString(options.sourcePath, 'session-evidence');
+  const userRecords = records.filter((record) => record.sourceKind === 'user-direct');
+  const assistantRecords = records.filter((record) => record.sourceKind === 'assistant-final');
+  const toolRecords = records.filter((record) => record.sourceKind === 'tool-action');
+  const symptoms = [...userRecords, ...assistantRecords]
+    .map((record) => record.text)
+    .slice(0, 8);
+  const rootCauseCandidates = records
+    .filter((record) => ['assistant-final', 'tool-action', 'repo-state'].includes(record.sourceKind))
+    .slice(0, 6)
+    .map((record) => ({
+      title: record.text,
+      nextSteps: ['把这条证据和用户目标重新核对，只在确认可复用时推荐项目级沉淀。'],
+      sourceKind: record.sourceKind,
+    }));
+  return {
+    kind: 'session-evidence-review',
+    evidenceOnly: true,
+    sourceId,
+    sourcePath,
+    primaryPath: sourcePath,
+    sourcePaths: [sourcePath],
+    title,
+    status: 'needs-review',
+    symptoms,
+    attentionGates: [],
+    correlationFields: [],
+    extraContextFields: [],
+    missingCorrelationFields: [],
+    eventNames: [...new Set(records.map((record) => record.sourceKind))],
+    rootCauseCandidates,
+    evidenceSources: records.map((record) => ({
+      kind: record.sourceKind,
+      path: `${sourcePath}#${record.eventIndex}`,
+      reason: record.reason,
+    })),
+    queryExamples: [
+      '先只看 user-direct、assistant-final、tool-action 证据，不把 AGENTS 或系统提示当成用户诉求。',
+      '如果复盘证据跨多轮重复出现，再推荐用户把它保留为当前项目经验。',
+    ],
+    abstractPattern: '从只读复盘证据中先隔离系统上下文噪声，再把重复摩擦或可复用判断沉淀为项目级候选。',
+    triggers: records
+      .filter((record) => record.sourceKind !== 'context-only')
+      .map((record) => `${record.sourceKind}: ${record.text}`)
+      .slice(0, 8),
+    prevention: [
+      'raw session 先抽取 clean evidence，再进入候选判断。',
+      'AGENTS、system、developer、tool schema 和 skill list 只能作为 context-only 背景，不触发用户诉求或项目经验候选。',
+      '项目级沉淀先作为候选推荐给用户确认，不自动 promote。',
+    ],
+    verificationSteps: [
+      '确认每条证据都有 sourceKind。',
+      '确认候选推荐没有依赖 context-only 命中。',
+      '确认用户确认前只生成候选，不修改正式项目 skill。',
+    ],
+  };
+}
+
+export {
+  buildCleanEvidenceText,
+  buildSessionEvidenceReviewSource,
+  cleanEvidenceRecords,
+  extractSessionEvidenceRecords,
+  filterGenericFrameworkTokens,
+  isGenericFrameworkTerm,
+  normalizeSessionEvidenceRecords,
+  sanitizeEvidenceText,
+};

package/src/standards.js

@@ -773,6 +773,42 @@ export async function initStandardsWorkspace(projectRoot, options = {}) {
   };
 }
 
+export const DOC_MEGA_LINE_CHARS = 300;
+export const DOC_AVG_LINE_CHARS = 200;
+export const DOC_STALE_VERSION_THRESHOLD = 20;
+
+export function analyzeDocQuality(relativePath, text) {
+  const lines = text.split('\n');
+  const contentLines = lines.filter((line) => line.trim().length > 0);
+  const megaLines = contentLines.filter((line) => line.length > DOC_MEGA_LINE_CHARS);
+  const totalChars = contentLines.reduce((sum, line) => sum + line.length, 0);
+  const avgLineChars = contentLines.length > 0 ? Math.round(totalChars / contentLines.length) : 0;
+  const maxLineChars = contentLines.reduce((max, line) => Math.max(max, line.length), 0);
+  return {
+    path: relativePath,
+    lines: lines.length,
+    contentLines: contentLines.length,
+    megaLines: megaLines.length,
+    avgLineChars,
+    maxLineChars,
+    bytes: Buffer.byteLength(text, 'utf8'),
+  };
+}
+
+export async function analyzeDocStaleness(projectRoot, docMtimeMs) {
+  const versionsDir = cjoin(projectRoot, '.openprd', 'state', 'versions');
+  const entries = await fs.readdir(versionsDir).catch(() => []);
+  const versionFiles = entries.filter((name) => /^v\d+\.json$/.test(name)).sort();
+  let versionsBehind = 0;
+  for (const name of versionFiles) {
+    const stat = await fs.stat(cjoin(versionsDir, name)).catch(() => null);
+    if (stat && stat.mtimeMs > docMtimeMs) {
+      versionsBehind += 1;
+    }
+  }
+  return { totalVersions: versionFiles.length, versionsBehind };
+}
+
 export async function checkStandardsWorkspace(projectRoot, options = {}) {
   const errors = [];
   const warnings = [];
@@ -838,6 +874,7 @@ export async function checkStandardsWorkspace(projectRoot, options = {}) {
     ...externalReferenceIgnorePatterns(projectRoot, config ?? {}),
   ];
   const requiredDocs = [];
+  const docsQuality = [];
   const sourceFiles = await collectSourceFiles(projectRoot, projectRoot, [], ignorePatterns);
   const hasProjectSource = sourceFiles.length > 0;
   const openPrdToolProject = await isOpenPrdToolProject(projectRoot);
@@ -860,6 +897,28 @@ export async function checkStandardsWorkspace(projectRoot, options = {}) {
     if (hasProjectSource && !openPrdToolProject && options.docsContent !== false && DOC_PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(text))) {
       errors.push(`${relativePath} 仍包含模板占位内容，必须更新为当前项目事实。`);
     }
+
+    if (options.docsQuality !== false) {
+      const quality = analyzeDocQuality(relativePath, text);
+      if (quality.megaLines > 0) {
+        warnings.push(`${relativePath} 存在 ${quality.megaLines} 行超过 ${DOC_MEGA_LINE_CHARS} 字符的巨行（最长 ${quality.maxLineChars} 字符），疑似 append-only 污染，建议运行 openprd docs-compact . 查看压缩建议。`);
+      }
+      if (quality.contentLines >= 10 && quality.avgLineChars > DOC_AVG_LINE_CHARS) {
+        warnings.push(`${relativePath} 平均行长 ${quality.avgLineChars} 字符（阈值 ${DOC_AVG_LINE_CHARS}），文档结构疑似退化为长段落堆叠，建议拆分为结构化小节。`);
+      }
+      if (doc.fileName === 'prd.md') {
+        const docStat = await fs.stat(docPath).catch(() => null);
+        if (docStat) {
+          const staleness = await analyzeDocStaleness(projectRoot, docStat.mtimeMs);
+          quality.versionsBehind = staleness.versionsBehind;
+          quality.totalVersions = staleness.totalVersions;
+          if (staleness.versionsBehind > DOC_STALE_VERSION_THRESHOLD) {
+            warnings.push(`${relativePath} 自上次更新后已产生 ${staleness.versionsBehind} 个 requirement 版本（阈值 ${DOC_STALE_VERSION_THRESHOLD}），基线 PRD 已陈旧，需要回填最新已确认需求。`);
+          }
+        }
+      }
+      docsQuality.push(quality);
+    }
   }
 
   const templateFiles = [];
@@ -901,6 +960,10 @@ export async function checkStandardsWorkspace(projectRoot, options = {}) {
 
   checks.push(`Standards docs root: ${STANDARD_DOCS_ROOT.replaceAll(path.sep, '/')}`);
   checks.push(`Required docs: ${requiredDocs.filter((doc) => doc.exists).length}/${STANDARD_DOCS.length}.`);
+  if (docsQuality.length > 0) {
+    const pollutedDocs = docsQuality.filter((doc) => doc.megaLines > 0).length;
+    checks.push(`Docs quality: ${docsQuality.length} docs analyzed, ${pollutedDocs} with mega-lines > ${DOC_MEGA_LINE_CHARS} chars.`);
+  }
   checks.push(`Manual templates: ${templateFiles.filter((file) => file.exists).length}/${STANDARD_TEMPLATE_FILES.length}.`);
   const lineConfig = config?.developmentStandards?.codeFileLines ?? DEFAULT_DEVELOPMENT_STANDARDS.codeFileLines;
   checks.push(`Development standards: code files ok <= ${lineConfig.okMax} lines, attention <= ${lineConfig.attentionMax} lines.`);
@@ -916,6 +979,7 @@ export async function checkStandardsWorkspace(projectRoot, options = {}) {
     warnings,
     checks,
     requiredDocs,
+    docsQuality,
     templateFiles,
     manualReport,
   };

package/src/test-strategy.js

@@ -145,13 +145,16 @@ export function inferTestStrategyForTask(task = {}) {
     };
   }
 
-  if (includesAny(text, [/visual|视觉|截图|界面|页面|组件|样式|browser|playwright|cypress|e2e|端到端|用户主路径|主流程/])) {
+  const singleElementCentering = includesAny(text, [/centering-board|center-board|visual centroid|bbox center|canvas center|inside centered|internal centering|内部居中|视觉重心|主体外接框|外接框中心|画布中心|单元素|单个元素|偏心|不居中|没居中|图标内部|图片内部|素材内部|按钮图形|logo center|icon center/]);
+  if (includesAny(text, [/visual|视觉|截图|界面|页面|组件|样式|间距|留白|边距|宽度|高度|卡片|对齐|内容槽位|内部槽位|标题|副标题|标签|状态|价格|按钮|密度|圆角|颜色|字号|图标|按钮|padding|margin|spacing|gap|browser|playwright|cypress|e2e|端到端|用户主路径|主流程|内部居中|视觉重心|主体外接框|画布中心|偏心|不居中|没居中/])) {
     return {
       layers: ['integration', 'e2e'],
       size: 'large',
-      scope: includesAny(text, [/visual|视觉|截图|样式/]) ? 'visual-flow' : 'user-flow',
-      evidencePlan: '主流程自动化、截图或 visual-compare 证据 + 本任务 verify 命令',
-      upgradeReason: '触达用户可见路径，需要端到端或视觉级证据',
+      scope: includesAny(text, [/visual|视觉|截图|样式|间距|留白|边距|宽度|高度|卡片|对齐|内容槽位|内部槽位|标题|副标题|标签|状态|价格|按钮|密度|圆角|颜色|字号|图标|按钮|padding|margin|spacing|gap|内部居中|视觉重心|主体外接框|画布中心|偏心|不居中|没居中/]) ? 'visual-flow' : 'user-flow',
+      evidencePlan: singleElementCentering
+        ? '主流程自动化、截图或 visual-compare 证据 + 本任务 verify 命令；单元素内部居中要补 centering-board，量测画布中心、主体外接框中心和视觉重心偏移'
+        : '主流程自动化、截图或 visual-compare 证据 + 本任务 verify 命令；轻量 UI 可视优化也需要 before/after、verification-board 或 alignment-board 证据，同构卡片/列表要覆盖内部内容槽位',
+      upgradeReason: '触达用户可见路径，需要端到端或视觉级证据；轻量 UI 可视优化不能只用构建或 dev-check 收口',
       inferred: true,
     };
   }