@openprd/cli 0.1.1 → 0.1.9

package/src/openspec/execute.js

@@ -115,7 +115,57 @@ function assertTaskReady(task, state) {
   return dependencyState;
 }
 
-async function runVerifyCommand(command, cwd) {
+function isTaskEvidenceRequiredCommand(command) {
+  return /^openprd\s+tasks\s+\./i.test(String(command ?? ''))
+    && /\s--evidence-required\b/i.test(String(command ?? ''));
+}
+
+function isLegacyPerTaskFullVerifyCommand(command) {
+  return /^openprd\s+run\s+\.\s+--verify\s*$/i.test(String(command ?? '').replace(/\s+/g, ' ').trim());
+}
+
+function taskEvidenceState(task, options = {}) {
+  const metadata = task?.metadata ?? {};
+  const evidence = String(options.evidence ?? metadata.evidence ?? '').trim();
+  const waiver = String(metadata.waiver ?? metadata['waiver-reason'] ?? '').trim();
+  return {
+    evidence,
+    waiver,
+    ok: Boolean(evidence || waiver),
+  };
+}
+
+function buildTaskEvidenceVerification(command, task, options = {}) {
+  const evidenceState = taskEvidenceState(task, options);
+  const legacyHint = isLegacyPerTaskFullVerifyCommand(command)
+    ? '旧任务里的 per-task openprd run . --verify 已保留给阶段或最终门禁，不会在任务推进时触发全局 quality。'
+    : null;
+  const hint = `${legacyHint ? `${legacyHint} ` : ''}先运行本任务最小足够测试或审查，再通过 --evidence <路径或摘要> 传入证据，或在 tasks.md 写入 evidence:/waiver-reason:。`;
+  return {
+    ok: evidenceState.ok,
+    command,
+    exitCode: evidenceState.ok ? 0 : 1,
+    stdout: evidenceState.ok
+      ? [
+          'OpenPrd task evidence: passed',
+          evidenceState.evidence ? `evidence: ${evidenceState.evidence}` : null,
+          evidenceState.waiver ? `waiver: ${evidenceState.waiver}` : null,
+          legacyHint,
+          'scope: task-only; workspace quality is reserved for phase/final gates',
+          '',
+        ].filter(Boolean).join('\n')
+      : '',
+    stderr: evidenceState.ok
+      ? ''
+      : `OpenPrd task evidence: missing evidence for ${task?.id ?? 'task'}. ${hint}\n`,
+  };
+}
+
+async function runVerifyCommand(command, cwd, context = {}) {
+  if ((isTaskEvidenceRequiredCommand(command) || isLegacyPerTaskFullVerifyCommand(command)) && context.task) {
+    return buildTaskEvidenceVerification(command, context.task, context);
+  }
+
   return new Promise((resolve) => {
     const child = spawn(command, {
       cwd,
@@ -152,6 +202,22 @@ async function runVerifyCommand(command, cwd) {
   });
 }
 
+export async function checkOpenSpecTaskEvidenceWorkspace(projectRoot, options = {}) {
+  const state = await loadTaskState(projectRoot, options);
+  const task = resolveTaskSelection(state, options);
+  assertTaskReady(task, state);
+  const command = `openprd tasks . --change ${state.changeId} --item ${task.id} --evidence-required`;
+  const verification = buildTaskEvidenceVerification(command, task, options);
+  return {
+    ok: verification.ok,
+    action: 'evidence-check',
+    projectRoot,
+    changeId: state.changeId,
+    task,
+    verification,
+  };
+}
+
 async function markTaskComplete(task) {
   const text = await readText(task.absolutePath);
   const lines = text.split(/\r?\n/);
@@ -208,7 +274,12 @@ export async function verifyOpenSpecTaskWorkspace(projectRoot, options = {}) {
   if (!task.metadata.verify) {
     throw new Error(`${task.id} is missing verify command.`);
   }
-  const verification = await runVerifyCommand(task.metadata.verify, projectRoot);
+  const verification = await runVerifyCommand(task.metadata.verify, projectRoot, {
+    task,
+    state,
+    evidence: options.evidence,
+    notes: options.notes,
+  });
   await appendTaskEvent(state, {
     action: 'verify',
     taskId: task.id,
@@ -239,7 +310,12 @@ export async function advanceOpenSpecTaskWorkspace(projectRoot, options = {}) {
     if (!task.metadata.verify) {
       throw new Error(`${task.id} is missing verify command.`);
     }
-    verification = await runVerifyCommand(task.metadata.verify, projectRoot);
+    verification = await runVerifyCommand(task.metadata.verify, projectRoot, {
+      task,
+      state,
+      evidence: options.evidence,
+      notes: options.notes,
+    });
     if (!verification.ok) {
       await appendTaskEvent(state, {
         action: 'advance_failed',

package/src/openspec/generate.js

@@ -2,6 +2,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { preferSimplifiedChinese } from '../language-policy.js';
 import { needsBusinessGuardrails } from '../prd-core.js';
+import { EXECUTION_STRATEGY_METADATA_KEYS, formatTaskExecutionStrategyMetadata } from '../execution-strategy.js';
+import { TEST_STRATEGY_METADATA_KEYS, formatTaskTestStrategyMetadata } from '../test-strategy.js';
 import { OPENSPEC_TASK_MAX_ITEMS_PER_FILE } from './constants.js';
 import { openPrdChangeRoot, openPrdDiscoveryConfigPath, readDiscoveryConfig } from './paths.js';
 
@@ -143,7 +145,12 @@ function chunkItems(items, maxItemsPerChunk = 2) {
   return chunks;
 }
 
-const DEFAULT_EXECUTION_VERIFY_COMMAND = 'openprd run . --verify';
+function defaultTaskVerifyCommand(changeId, task) {
+  if (task.type === 'documentation') {
+    return 'openprd standards . --verify';
+  }
+  return `openprd tasks . --change ${changeId} --item ${task.id} --evidence-required`;
+}
 
 const ARCHITECTURE_TASK_DEFINITIONS = [
   {
@@ -321,7 +328,6 @@ function inferArchitectureTasks(snapshot) {
       type: 'implementation',
       title: definition.title,
       done: `${definition.done} 涉及: ${summarizeTaskItems(matches, 2, 72)}。`,
-      verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
       phase: 'architecture',
     }));
 }
@@ -345,7 +351,6 @@ function buildRequirementImplementationTasks(snapshot) {
       type: 'implementation',
       title: cleanImplementationTitle(item),
       done: buildDoneText('已完成：', item),
-      verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
       phase: 'implementation',
     });
   }
@@ -364,7 +369,6 @@ function buildFlowIntegrationTasks(snapshot) {
     type: 'implementation',
     title: `打通主流程闭环：${summarizeTaskItems(flows, 2, 56)}`,
     done: `主流程关键节点已经打通，用户可以按预期从入口走到结果收尾。涉及: ${summarizeTaskItems(flows, 2, 72)}。`,
-    verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
     phase: 'integration',
   }];
 }
@@ -376,7 +380,6 @@ function buildAcceptanceVerificationTasks(snapshot) {
     type: 'verification',
     title: buildVerificationTitle(item),
     done: buildDoneText('已验证：', item),
-    verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
     phase: 'verification',
   }));
 }
@@ -388,7 +391,6 @@ function buildNonFunctionalVerificationTasks(snapshot) {
     type: 'verification',
     title: `回归非功能约束：${summarizeTaskItems(items, 2, 56)}`,
     done: `非功能约束已经回归确认。涉及: ${summarizeTaskItems(items, 2, 72)}。`,
-    verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
     phase: 'verification',
   }));
   const edgeAndFailure = [
@@ -401,7 +403,6 @@ function buildNonFunctionalVerificationTasks(snapshot) {
         type: 'verification',
         title: `回归边界条件与失败处理：${summarizeTaskItems(edgeAndFailure, 2, 56)}`,
         done: `边界条件与失败处理已经回归确认。涉及: ${summarizeTaskItems(edgeAndFailure, 2, 72)}。`,
-        verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
         phase: 'verification',
       }]
     : [];
@@ -430,7 +431,6 @@ function buildTaskItems({ changeId, snapshot, capability }) {
             type: 'verification',
             title: '验证成本与额度护栏',
             done: '已验证免费、试用或低权限用户不能绕过额度、并发、频率或总量限制',
-            verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
             phase: 'verification',
           },
           {
@@ -438,7 +438,6 @@ function buildTaskItems({ changeId, snapshot, capability }) {
             type: 'verification',
             title: '验证滥用与越权路径',
             done: '已覆盖重复请求、并发请求、越权身份和异常恢复等负向场景',
-            verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
             phase: 'verification',
           },
           {
@@ -446,7 +445,6 @@ function buildTaskItems({ changeId, snapshot, capability }) {
             type: 'verification',
             title: '验证成本监控、报警和止损',
             done: '已确认用量或成本信号、报警阈值和人工/自动止损动作可执行',
-            verify: DEFAULT_EXECUTION_VERIFY_COMMAND,
             phase: 'verification',
           },
         ]
@@ -492,15 +490,18 @@ function buildTaskItems({ changeId, snapshot, capability }) {
     deduped.push(item);
   }
 
-  const tasks = deduped.map((item, index) => ({
-    id: `T001.${String(index + 1).padStart(2, '0')}`,
-    title: item.title,
-    type: item.type,
-    phase: item.phase,
-    done: item.done,
-    verify: item.verify ?? (item.type === 'documentation' ? 'openprd standards . --verify' : DEFAULT_EXECUTION_VERIFY_COMMAND),
-    deps: [],
-  }));
+  const tasks = deduped.map((item, index) => {
+    const task = {
+      id: `T001.${String(index + 1).padStart(2, '0')}`,
+      title: item.title,
+      type: item.type,
+      phase: item.phase,
+      done: item.done,
+      deps: [],
+    };
+    task.verify = item.verify ?? defaultTaskVerifyCommand(changeId, task);
+    return task;
+  });
 
   const phaseTasks = {
     governanceStart: tasks.filter((task) => task.phase === 'governance-start'),
@@ -582,6 +583,12 @@ function renderTaskFiles(tasks, maxItemsPerFile) {
       }
       lines.push(`  - done: ${task.done}`);
       lines.push(`  - verify: ${task.verify}`);
+      for (const metadata of formatTaskTestStrategyMetadata(task)) {
+        lines.push(`  - ${metadata}`);
+      }
+      for (const metadata of formatTaskExecutionStrategyMetadata(task)) {
+        lines.push(`  - ${metadata}`);
+      }
       lines.push('');
     }
 
@@ -606,6 +613,12 @@ async function readTaskMax(projectRoot) {
 async function writeDiscoveryConfig(projectRoot, changeId) {
   const configPath = openPrdDiscoveryConfigPath(projectRoot);
   const current = await readJson(configPath).catch(() => ({}));
+  const optionalMetadata = [
+    'deps',
+    'type',
+    ...TEST_STRATEGY_METADATA_KEYS,
+    ...EXECUTION_STRATEGY_METADATA_KEYS,
+  ];
   await writeJson(configPath, {
     ...current,
     activeChange: changeId,
@@ -618,7 +631,7 @@ async function writeDiscoveryConfig(projectRoot, changeId) {
     taskMetadata: {
       stableIdPattern: current?.taskMetadata?.stableIdPattern ?? 'T###.##',
       required: current?.taskMetadata?.required ?? ['done', 'verify'],
-      optional: current?.taskMetadata?.optional ?? ['deps', 'type'],
+      optional: [...new Set([...(current?.taskMetadata?.optional ?? []), ...optionalMetadata])],
       dependencyOrder: current?.taskMetadata?.dependencyOrder ?? 'dependencies must appear before dependents',
     },
   });

package/src/openspec/tasks.js

@@ -6,6 +6,29 @@ import {
   OPENSPEC_TASK_MAX_ITEMS_PER_FILE,
 } from './constants.js';
 import { cjoin, exists, listChangeDirs, readDiscoveryConfig, resolveChangeDir } from './paths.js';
+import {
+  TEST_STRATEGY_METADATA_KEYS,
+  summarizeTaskTestStrategies,
+  validateTaskTestStrategy,
+} from '../test-strategy.js';
+import {
+  EXECUTION_STRATEGY_METADATA_KEYS,
+  summarizeTaskExecutionStrategies,
+  validateTaskExecutionStrategy,
+} from '../execution-strategy.js';
+
+const OPENSPEC_TASK_METADATA_KEYS = [
+  'deps',
+  'done',
+  'verify',
+  'type',
+  'category',
+  'kind',
+  'oracle',
+  ...TEST_STRATEGY_METADATA_KEYS,
+  ...EXECUTION_STRATEGY_METADATA_KEYS,
+];
+const OPENSPEC_TASK_METADATA_PATTERN = new RegExp(`^\\s{2,}-\\s+(${OPENSPEC_TASK_METADATA_KEYS.join('|')}):\\s*(.*)$`, 'i');
 
 async function readText(filePath) {
   return fs.readFile(filePath, 'utf8');
@@ -58,7 +81,7 @@ export function parseOpenSpecTaskFile(text) {
       return;
     }
 
-    const metadataMatch = line.match(/^\s{2,}-\s+(deps|done|verify|type|category|kind|oracle):\s*(.*)$/i);
+    const metadataMatch = line.match(OPENSPEC_TASK_METADATA_PATTERN);
     if (currentTask && metadataMatch) {
       currentTask.metadata[metadataMatch[1].toLowerCase()] = metadataMatch[2].trim();
     }
@@ -272,6 +295,12 @@ export function validateOpenSpecStructuredTasks(sortedFiles, errors, checks) {
     if (normalizedType !== 'governance' && isSpecOnlyValidateCommand(task.metadata.verify)) {
       errors.push(`${formatOpenSpecTaskLocation(task)} 的 verify 只做了 change 结构校验；${normalizedType} 任务必须提供能证明实际落地的验证命令或审查步骤。`);
     }
+    for (const strategyError of validateTaskTestStrategy(task)) {
+      errors.push(`${formatOpenSpecTaskLocation(task)} ${strategyError}`);
+    }
+    for (const strategyError of validateTaskExecutionStrategy(task)) {
+      errors.push(`${formatOpenSpecTaskLocation(task)} ${strategyError}`);
+    }
 
     for (const depId of parseOpenSpecTaskDeps(task.metadata.deps)) {
       if (!OPENSPEC_TASK_ID_PATTERN.test(depId)) {
@@ -290,7 +319,9 @@ export function validateOpenSpecStructuredTasks(sortedFiles, errors, checks) {
     }
   }
 
-  checks.push(`结构化 OpenPrd 任务: ${tasks.length} 个任务，${dependencyCount} 条依赖。`);
+  const strategySummary = summarizeTaskTestStrategies(tasks);
+  const executionSummary = summarizeTaskExecutionStrategies(tasks);
+  checks.push(`结构化 OpenPrd 任务: ${tasks.length} 个任务，${dependencyCount} 条依赖；测试策略显式 ${strategySummary.explicit} 个、推导 ${strategySummary.inferred} 个；执行策略显式 ${executionSummary.explicit} 个、推导 ${executionSummary.inferred} 个。`);
 }
 
 export async function analyzeOpenSpecTaskVolumes(projectRoot, options = {}) {

package/src/prd-core.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { buildArchitectureDiagramModel, buildProductFlowDiagramModel, renderDiagramMermaidFromModel } from './diagram-core.js';
 import { TBD_ZH, languagePolicyLines } from './language-policy.js';
+import { formatProductTypeDisplay, formatProductTypeQuestion, formatTemplatePackDisplay, getProductTypeSectionTitle } from './product-type-copy.js';
 import { timestamp } from './time.js';
 
 function isPlainObject(value) {
@@ -151,7 +152,7 @@ function buildTypeSpecificSection(productType, state, overrides) {
   if (productType === 'consumer') {
     return {
       kind: 'consumer',
-      title: '消费端专项',
+      title: getProductTypeSectionTitle('consumer'),
       fields: {
         persona: pickValue(overrides.persona, state.persona),
         segment: pickValue(overrides.segment, state.segment),
@@ -165,7 +166,7 @@ function buildTypeSpecificSection(productType, state, overrides) {
   if (productType === 'b2b') {
     return {
       kind: 'b2b',
-      title: 'B2B 专项',
+      title: getProductTypeSectionTitle('b2b'),
       fields: {
         buyer: pickValue(overrides.buyer, state.buyer),
         user: pickValue(overrides.user, state.user),
@@ -183,7 +184,7 @@ function buildTypeSpecificSection(productType, state, overrides) {
   if (productType === 'agent') {
     return {
       kind: 'agent',
-      title: 'Agent 专项',
+      title: getProductTypeSectionTitle('agent'),
       fields: {
         humanAgentContract: pickValue(overrides.humanAgentContract, state.humanAgentContract),
         autonomyBoundary: pickValue(overrides.autonomyBoundary, state.autonomyBoundary),
@@ -196,9 +197,9 @@ function buildTypeSpecificSection(productType, state, overrides) {
 
   return {
     kind: 'base',
-    title: '类型专项',
+    title: getProductTypeSectionTitle('base'),
     fields: {
-      note: '请选择产品类型，以启用对应的专项 PRD 模块。',
+      note: '请选择产品场景，以启用对应的专项 PRD 模块。',
     },
   };
 }
@@ -338,8 +339,8 @@ export function renderPrdMarkdown(snapshot) {
     ...languagePolicyLines(),
     `- 版本: ${snapshot.versionId}`,
     `- 负责人: ${snapshot.owner}`,
-    `- 产品类型: ${snapshot.productType ?? '未分类'}`,
-    `- 模板包: ${snapshot.templatePack}`,
+    `- 产品场景: ${formatProductTypeDisplay(snapshot.productType, { fallback: '待确认' })}`,
+    `- 场景模板: ${formatTemplatePackDisplay(snapshot.templatePack, { fallback: '待确认' })}`,
     `- 状态: ${snapshot.status}`,
     `- 生成时间: ${snapshot.createdAt}`,
     '',
@@ -348,7 +349,7 @@ export function renderPrdMarkdown(snapshot) {
       ['负责人', sections.meta.owner],
       ['状态', sections.meta.status],
       ['版本', sections.meta.version],
-      ['产品类型', sections.meta.productType],
+      ['产品场景', formatProductTypeDisplay(snapshot.productType, { fallback: '待确认' })],
       ['日期', sections.meta.date],
     ]),
     renderSection('问题', [
@@ -421,7 +422,7 @@ const BASE_REQUIRED_FIELD_DESCRIPTORS = [
   { section: 'meta', path: 'meta.owner', label: '负责人', prompt: '谁负责这份 PRD？' },
   { section: 'meta', path: 'meta.version', label: '版本', prompt: '这份 PRD 从哪个版本开始？' },
   { section: 'meta', path: 'meta.status', label: '状态', prompt: '当前 PRD 状态是什么？' },
-  { section: 'meta', path: 'meta.productType', label: '产品类型', prompt: '这是 consumer、b2b 还是 agent 产品？' },
+  { section: 'meta', path: 'meta.productType', label: '产品场景', prompt: formatProductTypeQuestion() },
   { section: 'problem', path: 'problem.problemStatement', label: '问题陈述', prompt: '我们要解决什么问题？' },
   { section: 'problem', path: 'problem.whyNow', label: '为什么是现在', prompt: '为什么现在是解决这个问题的合适时机？' },
   { section: 'problem', path: 'problem.evidence', label: '证据', prompt: '有哪些证据支持这个问题？' },

package/src/product-type-copy.js

@@ -0,0 +1,69 @@
+const PRODUCT_TYPE_LABELS = {
+  base: '通用产品或工程场景',
+  consumer: '面向个人消费者场景',
+  b2b: '面向企业服务场景',
+  agent: '以 Agent 为主要使用场景',
+};
+
+function withCode(label, code, includeCode) {
+  return includeCode ? `${label}（${code}）` : label;
+}
+
+export function formatProductTypeDisplay(productType, options = {}) {
+  const { includeCode = false, fallback = '待确认' } = options;
+  const label = PRODUCT_TYPE_LABELS[productType];
+  return label ? withCode(label, productType, includeCode) : fallback;
+}
+
+export function formatTemplatePackDisplay(templatePack, options = {}) {
+  const { includeCode = false, fallback = '待确认' } = options;
+  const label = PRODUCT_TYPE_LABELS[templatePack];
+  if (label) return withCode(label, templatePack, includeCode);
+  if (templatePack === null || templatePack === undefined || `${templatePack}`.trim() === "") return fallback;
+  return includeCode ? `${templatePack}（custom）` : `${templatePack}`;
+}
+
+export function formatProductTypeSentence(productType, options = {}) {
+  const { inferred = false } = options;
+  switch (productType) {
+    case 'consumer':
+      return inferred ? '从当前描述看，更像面向个人消费者场景的产品。' : '当前更像面向个人消费者场景的产品。';
+    case 'b2b':
+      return inferred ? '从当前描述看，更像面向企业服务场景的产品。' : '当前更像面向企业服务场景的产品。';
+    case 'agent':
+      return inferred ? '从当前描述看，更像以 Agent 为主要使用场景的产品。' : '当前更像以 Agent 为主要使用场景的产品。';
+    case 'base':
+      return inferred ? '从当前描述看，更像通用产品或工程场景。' : '当前更像通用产品或工程场景。';
+    default:
+      return inferred ? '从当前描述看，产品场景仍待确认。' : '产品场景仍待确认。';
+  }
+}
+
+export function formatProductTypeOptions(options = {}) {
+  const { includeBase = false, includeCode = false } = options;
+  const values = [];
+  if (includeBase) values.push(withCode(PRODUCT_TYPE_LABELS.base, 'base', includeCode));
+  values.push(withCode(PRODUCT_TYPE_LABELS.consumer, 'consumer', includeCode));
+  values.push(withCode(PRODUCT_TYPE_LABELS.b2b, 'b2b', includeCode));
+  values.push(withCode(PRODUCT_TYPE_LABELS.agent, 'agent', includeCode));
+  return values.join(' / ');
+}
+
+export function formatProductTypeQuestion() {
+  return '这是更偏向面向个人消费者场景的产品、面向企业服务场景的产品，还是以 Agent 为主要使用场景的产品？';
+}
+
+export function getProductTypeSectionTitle(productType) {
+  switch (productType) {
+    case 'consumer':
+      return '个人消费者场景专项';
+    case 'b2b':
+      return '企业服务场景专项';
+    case 'agent':
+      return 'Agent 使用场景专项';
+    case 'base':
+      return '通用场景专项';
+    default:
+      return '产品场景专项';
+  }
+}