@openprd/cli 0.1.1 → 0.1.8

package/src/workspace-workflow.js

@@ -2,16 +2,16 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { analyzePrdSnapshot, buildPrdSnapshot, diffSnapshots, formatVersionId, renderPrdMarkdown, summarizeSnapshot } from './prd-core.js';
+import { formatProductTypeDisplay, formatProductTypeOptions, formatProductTypeQuestion, formatProductTypeSentence, formatTemplatePackDisplay } from './product-type-copy.js';
 import { getDiagramReviewState } from './diagram-workspace.js';
 import { exists, parseYamlText, readJson, readText, writeJson, writeText } from './fs-utils.js';
 import { artifactBundlePaths, canonicalReviewPath, defaultReviewArtifactPath, openArtifactInBrowser, renderPlaygroundArtifact, renderPlaygroundMarkdown, renderPlaygroundPatch, renderReviewArtifact, renderReviewEntryHtml, writeHtmlArtifact } from './html-artifacts.js';
-import { findOpenPrdSpecLanguageViolations } from './language-policy.js';
-import { buildSpec as buildOpenSpecSpec } from './openspec/generate.js';
+import { buildReleaseLedgerSummary } from './release-ledger.js';
 import { assertReviewPresentationReady, getReviewPresentationGate } from './review-presentation.js';
 import { syncSessionBindingFromReview, syncSessionBindingFromSnapshot } from './session-binding.js';
 import { timestamp } from './time.js';
 import { generateWorkUnitId, normalizeWorkUnitId, readWorkUnitBinding, resolveTargetRoot, writeWorkUnitBinding } from './work-unit.js';
-import { appendDecision, appendOpenQuestions, appendProgress, appendWorkflowEvent, buildClarificationPlan, buildClarificationState, buildWorkflowTaskGraph, CAPTURE_SOURCES, coerceCapturedValue, deriveGateLabels, detectWorkspaceScenario, extractMarkdownSection, FIELD_PATH_TO_STATE_KEY, isSupportedProductType, loadLatestVersionSnapshot, loadWorkspace, normalizeVersionId, readVersionIndex, readVersionSnapshot, renderFlowDoc, renderHandoffDoc, renderRolesDoc, resolveActiveTemplatePack, resolveCurrentProductType, validateWorkspace, writeVersionIndex, writeVersionSnapshot } from './workspace-core.js';
+import { appendDecision, appendOpenQuestions, appendProgress, appendWorkflowEvent, buildClarificationPlan, buildClarificationState, buildCurrentStateSnapshot, buildWorkflowTaskGraph, CAPTURE_SOURCES, coerceCapturedValue, deriveGateLabels, detectWorkspaceScenario, extractMarkdownSection, FIELD_PATH_TO_STATE_KEY, isSupportedProductType, loadCurrentLaneSnapshot, loadLatestVersionSnapshot, loadWorkspace, normalizeVersionId, persistWorkspaceCurrentState, readActiveRequirementLane, readVersionIndex, readVersionSnapshot, renderFlowDoc, renderHandoffDoc, renderRolesDoc, resolveActiveTemplatePack, resolveCurrentProductType, validateWorkspace, writeVersionIndex, writeVersionSnapshot } from './workspace-core.js';
 
 function requirementGatePath(projectRoot) {
   return path.join(projectRoot, '.openprd', 'harness', 'requirement-gate.json');
@@ -162,8 +162,8 @@ function normalizePrdReviewStatus(status) {
 }
 
 async function readActiveRequirementGate(projectRoot) {
-  const gate = await readJson(requirementGatePath(projectRoot)).catch(() => null);
-  return gate?.active ? gate : null;
+  const lane = await readActiveRequirementLane(projectRoot).catch(() => null);
+  return lane?.gate?.active ? lane.gate : null;
 }
 
 function meaningfulOverrideValue(value) {
@@ -231,7 +231,10 @@ function resolveReviewPaths(ws, snapshot) {
 
 async function writeReviewFiles(ws, snapshot, { writeEntry = true } = {}) {
   assertReviewPresentationReady(snapshot);
-  const reviewHtml = renderReviewArtifact({ snapshot });
+  const reviewHtml = renderReviewArtifact({
+    snapshot,
+    projectRelease: buildReleaseLedgerSummary(ws.data.releaseLedger),
+  });
   const { canonicalReview, activeReviewEntry } = resolveReviewPaths(ws, snapshot);
   await writeHtmlArtifact(canonicalReview, reviewHtml);
   if (writeEntry) {
@@ -357,24 +360,6 @@ function requirementLooksLikeInterfaceWork(gate) {
   return /界面|页面|菜单|入口|按钮|表单|弹窗|导航|布局|看板|列表|配置页|模块|组件|UI|tab/i.test(text);
 }
 
-function assertOpenSpecPreflightReady(snapshot) {
-  const specText = buildOpenSpecSpec({ snapshot });
-  const violations = findOpenPrdSpecLanguageViolations(specText);
-  if (violations.length === 0) {
-    return;
-  }
-  const examples = violations
-    .slice(0, 3)
-    .map((violation) => `第 ${violation.line} 行：${violation.reason}（${violation.text}）`)
-    .join('；');
-  throw new Error([
-    'OpenPrd 已阻止 synthesize：按当前 PRD 生成的 spec.md 仍会触发简体中文预检，review.html 还不能进入确认。',
-    '请先把标题、问题陈述和场景文案整理成可直接产出 spec 的简体中文表达。',
-    '如果只是内部措辞规范化，请先用 openprd capture . --source agent-normalized 写回，再重新 synthesize。',
-    examples ? `示例：${examples}。` : null,
-  ].filter(Boolean).join(' '));
-}
-
 function requirementPrompt(gate) {
   return String(gate?.promptPreview ?? '').trim();
 }
@@ -450,6 +435,315 @@ function shortList(items, fallback = '待补充') {
   return list.length > 0 ? list.slice(0, 3).join('；') : fallback;
 }
 
+function normalizeTextList(items) {
+  if (Array.isArray(items)) {
+    return items.map((item) => String(item || '').trim()).filter(Boolean);
+  }
+  const text = String(items || '').trim();
+  return text ? [text] : [];
+}
+
+function summarizeProductShape(productType, gate) {
+  if (productType === 'consumer' || productType === 'b2b' || productType === 'agent' || productType === 'base') {
+    return formatProductTypeSentence(productType);
+  }
+  const text = requirementPrompt(gate);
+  if (/agent|自动化|workflow|MCP|tool|skill/i.test(text)) {
+    return formatProductTypeSentence('agent', { inferred: true });
+  }
+  if (/企业|团队|后台|审批|权限|客户|运营/i.test(text)) {
+    return formatProductTypeSentence('b2b', { inferred: true });
+  }
+  if (/个人|用户|社区|内容|创作者|消费|c端|to c/i.test(text)) {
+    return formatProductTypeSentence('consumer', { inferred: true });
+  }
+  return `产品场景仍待确认，可在 ${formatProductTypeOptions()} 之间进一步锁定。`;
+}
+
+function summarizeArchitectureSignals(gate, snapshot) {
+  const sections = snapshot.sections ?? {};
+  const text = `${requirementPrompt(gate)} ${JSON.stringify({
+    technical: sections.constraints?.technical ?? [],
+    dependencies: sections.constraints?.dependencies ?? [],
+  })}`;
+  const hits = [];
+  if (/前端|页面|客户端|web|h5|移动端|ios|android|桌面|ui|交互|网站|站点|博客|内容|文章|落地页/i.test(text)) {
+    hits.push('用户入口与页面体验');
+  }
+  if (/后端|服务端|server|api|数据库|存储|队列|定时任务|cron|webhook/i.test(text)) {
+    hits.push('服务流程与数据处理');
+  }
+  if (/agent|workflow|tool|skill|MCP|自动化|编排/i.test(text)) {
+    hits.push('Agent 协作与自动执行');
+  }
+  return hits.length > 0
+    ? hits.join('；')
+    : '影响环节仍待确认，可先按用户入口、服务流程或 Agent 协作补齐。';
+}
+
+function collectProjectRiskProbes(gate, snapshot) {
+  const sections = snapshot.sections ?? {};
+  const text = `${requirementPrompt(gate)} ${JSON.stringify({
+    users: sections.users ?? {},
+    constraints: sections.constraints ?? {},
+    requirements: sections.requirements ?? {},
+  })}`;
+  const probes = [];
+  const probeMap = [
+    { label: '账号身份与可见范围', pattern: /登录|账号|auth|oauth|权限|角色|rbac/i },
+    { label: '用户数据与信息处理', pattern: /数据|数据库|存储|隐私|文件|上传|下载|同步/i },
+    { label: '团队协作与审批流转', pattern: /团队|协作|审批|组织|成员|管理员|buyer|admin/i },
+    { label: '外部系统与合作方对接', pattern: /第三方|外部|api|sdk|集成|webhook|支付|短信/i },
+    { label: 'AI 结果可靠性与人工兜底', pattern: /ai|agent|模型|llm|生成|推理|prompt/i },
+    { label: '收费模式、额度与成本', pattern: /收费|订阅|付费|价格|额度|点数|积分|成本|quota|billing/i },
+  ];
+  for (const probe of probeMap) {
+    if (probe.pattern.test(text)) {
+      probes.push(probe.label);
+    }
+  }
+  return probes;
+}
+
+function buildProjectFraming({ gate, snapshot, scenario, productType }) {
+  const sections = snapshot.sections ?? {};
+  const guardrailHints = [
+    ...normalizeTextList(sections.requirements?.businessRules),
+    ...normalizeTextList(sections.constraints?.dependencies),
+  ];
+  const riskProbes = collectProjectRiskProbes(gate, snapshot);
+  return {
+    audience: shortList(
+      sections.users?.primaryUsers,
+      scenario.id === 'cold-start-existing-project'
+        ? '需要先确认这次改动主要服务谁。'
+        : '需要先确认目标用户或关键角色。'
+    ),
+    productShape: summarizeProductShape(productType, gate),
+    firstSlice: shortList(sections.scope?.inScope, '需要先确认第一版最小可用切片。'),
+    nonGoals: shortList(sections.scope?.outOfScope, '需要先确认本轮先不做什么。'),
+    guardrails: shortList(guardrailHints, '需要先确认哪些现有能力、数据、流程或体验不能被破坏。'),
+    architectureSignals: summarizeArchitectureSignals(gate, snapshot),
+    riskProbes,
+    riskProbeSummary: shortList(riskProbes, '当前没有明显命中额外风险探针。'),
+  };
+}
+
+function escapeMarkdownTableCell(value) {
+  return String(value ?? '').replace(/\|/g, '/');
+}
+
+function containsPendingClarifyMarker(value) {
+  return /(待确认|需要先确认|仍待确认|未分类)/.test(String(value ?? ''));
+}
+
+function describeProductLensFocus(productType) {
+  if (productType === 'consumer') {
+    return '这轮我会重点看首次使用场景、关键感受，以及用户愿不愿意继续回来。';
+  }
+  if (productType === 'b2b') {
+    return '这轮我会重点看谁拍板、谁使用、谁运营，以及上线协作会卡在哪里。';
+  }
+  if (productType === 'agent') {
+    return '这轮我会重点看哪些步骤让 Agent 自主完成、哪些节点必须人工拍板，以及失败时谁兜底。';
+  }
+  return '这轮我会优先把用户、场景、第一版切片、边界和风险讲清楚。';
+}
+
+function requirementTypeDisplay(gate) {
+  const tier = String(gate?.intent?.requirementTier ?? '').toLowerCase();
+  if (tier === 'l0') {
+    return '快速修正（L0）';
+  }
+  if (tier === 'l1') {
+    return '现有功能优化（L1）';
+  }
+  return '新功能/新流程方案（L2）';
+}
+
+function inferredProductTypeDisplay(productType, gate) {
+  if (productType === 'consumer' || productType === 'b2b' || productType === 'agent' || productType === 'base') {
+    return formatProductTypeDisplay(productType);
+  }
+  const text = requirementPrompt(gate);
+  if (/agent|自动化|workflow|MCP|tool|skill/i.test(text)) {
+    return formatProductTypeDisplay('agent');
+  }
+  if (/企业|团队|后台|审批|权限|客户|运营/i.test(text)) {
+    return formatProductTypeDisplay('b2b');
+  }
+  if (/个人|用户|社区|内容|创作者|消费|c端|to c/i.test(text)) {
+    return formatProductTypeDisplay('consumer');
+  }
+  return '待确认';
+}
+
+function fallbackScopeText(text, fallback) {
+  return containsPendingClarifyMarker(text) ? fallback : text;
+}
+
+function buildMarkdownTable(headers, rows) {
+  const normalizedRows = rows
+    .filter((row) => Array.isArray(row) && row.length > 0)
+    .map((row) => headers.map((_, index) => escapeMarkdownTableCell(row[index] ?? '待确认')));
+  return [
+    `| ${headers.map(escapeMarkdownTableCell).join(' | ')} |`,
+    `| ${headers.map(() => '---').join(' | ')} |`,
+    ...normalizedRows.map((row) => `| ${row.join(' | ')} |`),
+  ];
+}
+
+function inferCoreScopeModule(prompt, productType) {
+  const text = String(prompt ?? '');
+  if (/页面|界面|布局|导航|按钮|表单|网站|站点|博客|内容|文章|落地页|UI/i.test(text)) {
+    return '用户入口与界面';
+  }
+  if (/后端|服务端|接口|api|数据库|存储|同步|队列|webhook|数据/i.test(text)) {
+    return '服务流程与数据处理';
+  }
+  if (/agent|自动化|workflow|tool|skill|MCP|编排/i.test(text) || productType === 'agent') {
+    return 'Agent 主流程';
+  }
+  return '核心主流程';
+}
+
+function pushScopeRow(rows, seen, module, inScope, outOfScope) {
+  const key = String(module ?? '').trim();
+  if (!key || seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  rows.push([module, inScope, outOfScope]);
+}
+
+function buildScopeTableRows({ projectFraming, prompt, productType }) {
+  const rows = [];
+  const seen = new Set();
+  const text = `${prompt ?? ''} ${projectFraming.architectureSignals ?? ''}`;
+  const firstSlice = fallbackScopeText(
+    projectFraming.firstSlice,
+    '先把第一版核心主流程收敛到一个最小可交付闭环。'
+  );
+  const nonGoals = fallbackScopeText(
+    projectFraming.nonGoals,
+    '暂不把与核心目标无关的大范围扩展一起塞进第一版。'
+  );
+  if (/用户入口与页面体验|页面|界面|布局|导航|按钮|表单|网站|站点|博客|内容|文章|落地页|UI/i.test(text)) {
+    pushScopeRow(
+      rows,
+      seen,
+      '用户入口与界面',
+      containsPendingClarifyMarker(projectFraming.firstSlice)
+        ? '先把用户看到的入口、页面结构和关键交互讲清楚。'
+        : firstSlice,
+      nonGoals,
+    );
+  }
+  if (/服务流程与数据处理|后端|服务端|接口|api|数据库|存储|同步|队列|webhook|数据/i.test(text)) {
+    pushScopeRow(
+      rows,
+      seen,
+      '服务流程与数据处理',
+      '先只覆盖支撑主流程所需的接口、状态处理或数据留痕。',
+      '暂不扩到与这次主流程无关的重构、清库或系统级迁移。',
+    );
+  }
+  if (/Agent 协作与自动执行|agent|自动化|workflow|tool|skill|MCP|编排/i.test(text) || productType === 'agent') {
+    pushScopeRow(
+      rows,
+      seen,
+      'Agent 主流程',
+      '先讲清 Agent 负责的步骤、人工确认点和失败恢复。',
+      '暂不把所有自动化场景一次性铺开，避免边界失控。',
+    );
+  }
+  if (rows.length === 0) {
+    pushScopeRow(rows, seen, inferCoreScopeModule(prompt, productType), firstSlice, nonGoals);
+  }
+  return rows;
+}
+
+function pushTechRow(rows, seen, area, approach, responsibility) {
+  const key = String(area ?? '').trim();
+  if (!key || seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  rows.push([area, approach, responsibility]);
+}
+
+function buildTechnicalSolutionRows({ projectFraming, prompt, productType }) {
+  const rows = [];
+  const seen = new Set();
+  const text = `${prompt ?? ''} ${projectFraming.architectureSignals ?? ''}`;
+  if (/用户入口与页面体验|页面|界面|布局|导航|按钮|表单|网站|站点|博客|内容|文章|落地页|UI/i.test(text)) {
+    pushTechRow(
+      rows,
+      seen,
+      '前端 / 用户入口',
+      '先围绕当前入口、页面结构和关键交互做第一版，不提前铺开大范围视觉重做。',
+      '负责把用户真正看到的流程、反馈和操作路径讲清楚。',
+    );
+  }
+  if (/服务流程与数据处理|后端|服务端|接口|api|数据库|存储|同步|队列|webhook|数据/i.test(text)) {
+    pushTechRow(
+      rows,
+      seen,
+      '后端 / 服务逻辑',
+      '只补当前需求真正需要的接口、状态流转或数据写入，先保证主链路跑通。',
+      '负责把规则、状态和数据处理接住，并留下可验证证据。',
+    );
+  }
+  if (/Agent 协作与自动执行|agent|自动化|workflow|tool|skill|MCP|编排/i.test(text) || productType === 'agent') {
+    pushTechRow(
+      rows,
+      seen,
+      'Agent / 自动化编排',
+      '先定义 Agent 自主边界、人工拍板点和失败恢复，再决定要不要继续扩编排深度。',
+      '负责把多步流程串起来，并在失败时把用户安全带回人工兜底。',
+    );
+  }
+  if (rows.length === 0) {
+    pushTechRow(
+      rows,
+      seen,
+      '实现主链路',
+      '先按当前确认范围做最小可用闭环，再决定是否扩展到更多技术面。',
+      '负责把第一版能力真正落到可验证的主流程里。',
+    );
+  }
+  return rows;
+}
+
+function buildClarifyDirectionChoices(productType) {
+  if (productType === 'consumer') {
+    return [
+      '先把第一次上手跑通：更快定第一版，但后续可能还要补留存动作。',
+      '先把关键转化做好：更贴近商业结果，但对场景边界要求更高。',
+      '先把愿意回来这件事做顺：更利于长期价值，但首版会慢一点。',
+    ];
+  }
+  if (productType === 'b2b') {
+    return [
+      '先解决单角色提效：更容易落地，但跨团队价值暂时有限。',
+      '先打通跨角色流转：业务收益更明显，但协调成本更高。',
+      '先补管理与配置能力：便于后续扩张，但首版体感未必最强。',
+    ];
+  }
+  if (productType === 'agent') {
+    return [
+      '先跑通单步自动化：最快看到结果，但协作链路还比较浅。',
+      '先做多步编排：更像完整方案，但边界和失败恢复要更早想清楚。',
+      '先把人工兜底做稳：风险更低，但自动化收益会慢一点体现。',
+    ];
+  }
+  return [
+    '先把用户最痛的一步打通：更容易收敛首版，但覆盖面会窄一些。',
+    '先把主流程串起来：更完整，但第一版实现成本更高。',
+    '先把边界和风险控住：更稳，但用户感知收益会慢一点出现。',
+  ];
+}
+
 function normalizeClarifyMode(mode) {
   if (mode === 'artifact') {
     return 'inline-with-checklist';
@@ -458,8 +752,15 @@ function normalizeClarifyMode(mode) {
 }
 
 function estimateInlineClarificationLines(clarification, reflection) {
+  const projectFraming = reflection?.projectContext?.projectFraming ?? null;
   const activeChangeLines = reflection?.projectContext?.activeChange ? 1 : 0;
-  return 4
+  const framingLines = projectFraming
+    ? 5
+      + (projectFraming.architectureSignals ? 1 : 0)
+      + (projectFraming.riskProbes?.length > 0 ? 1 : 0)
+    : 0;
+  return 2
+    + framingLines
     + clarification.mustAskUser.length
     + Math.min(clarification.canInferLater.length, 2)
     + activeChangeLines;
@@ -498,23 +799,79 @@ function buildInlineClarification({ clarification, reflection, presentation }) {
   }
   const prompt = reflection?.promptPreview || '本轮需求';
   const projectContext = reflection?.projectContext ?? {};
+  const projectFraming = projectContext.projectFraming ?? {};
+  const productType = projectContext.productType;
+  const primaryQuestion = clarification.mustAskUser[0] ?? null;
+  const followUpQuestions = clarification.mustAskUser.slice(1, presentation.mode === 'inline' ? 2 : 3);
+  const scopeTable = buildMarkdownTable(
+    ['功能模块', '这次先做什么', '这次先不做什么'],
+    buildScopeTableRows({ projectFraming, prompt, productType }),
+  );
+  const technicalTable = buildMarkdownTable(
+    ['技术部分', '初步方案', '主要负责什么'],
+    buildTechnicalSolutionRows({ projectFraming, prompt, productType }),
+  );
+  const directionChoices = (
+    containsPendingClarifyMarker(projectFraming.firstSlice)
+    || containsPendingClarifyMarker(projectFraming.audience)
+  )
+    ? buildClarifyDirectionChoices(productType)
+    : [];
   const lines = [
-    `我理解的目标：${prompt}`,
-    `落点：${projectContext.productName ?? '当前项目'}；按${projectContext.scenario ?? '当前工作区'}处理。`,
-    '范围边界：只处理本轮需求，不自动合并历史 active change 或未提到的扩展。',
-    '验收方式：确认用户能看到或完成的结果，以及哪些既有行为不能被改变。',
+    `我先用产品和业务语言复述一下这次需求，并先按总分结构收一下：${prompt}`,
+    '',
+    '需求判断：',
+    `- 需求类型：${requirementTypeDisplay(reflection?.gate)}。`,
+    `- 产品类型：${inferredProductTypeDisplay(productType, reflection?.gate)}。`,
+    '',
+    '需求理解：',
+    `- 主要服务对象：${projectFraming.audience ?? '待确认'}。`,
+    `- 使用场景更像：${projectFraming.productShape ?? '待确认'}。`,
+    `- 第一版先让用户做到：${projectFraming.firstSlice ?? '待确认'}。`,
+    `- 这轮先不碰：${projectFraming.nonGoals ?? '待确认'}。`,
+    `- 必须守住：${projectFraming.guardrails ?? '待确认'}。`,
   ];
+  if (projectFraming.architectureSignals) {
+    lines.push(`- 这次更可能会影响：${projectFraming.architectureSignals}。`);
+  }
+  if (projectFraming.riskProbes?.length > 0) {
+    lines.push(`- 我先提醒的业务风险：${projectFraming.riskProbeSummary}。`);
+  }
+  lines.push(`- ${describeProductLensFocus(productType)}`);
+  lines.push('- 判断这轮是否值得做成：看用户是否真的更顺、更快、更稳地完成关键动作。');
+  lines.push('');
+  lines.push('功能范围：');
+  lines.push(...scopeTable);
+  lines.push('');
+  lines.push('技术方案：');
+  lines.push(...technicalTable);
   if (projectContext.activeChange) {
+    lines.push('');
     lines.push(`历史提醒：当前还有 ${projectContext.activeChange.activeChange}，本轮先分开处理。`);
   }
-  const questions = clarification.mustAskUser.slice(0, presentation.mode === 'inline' ? 3 : 5);
-  if (questions.length > 0) {
-    lines.push('建议确认：');
-    for (const item of questions) {
-      lines.push(`- ${item.prompt}`);
+  lines.push('');
+  if (primaryQuestion) {
+    lines.push('我建议这轮先确认这一点：');
+    lines.push(`- ${primaryQuestion.prompt}`);
+    if (followUpQuestions.length > 0) {
+      lines.push('这点定下来后，我再继续补下面这些：');
+      for (const item of followUpQuestions) {
+        lines.push(`- ${item.prompt}`);
+      }
+    }
+  } else {
+    lines.push('我这边暂时没有新的关键追问了。');
+  }
+  if (directionChoices.length > 0) {
+    lines.push('如果你现在还不想展开细节，也可以先在这 3 个方向里选一个：');
+    for (const choice of directionChoices) {
+      lines.push(`- ${choice}`);
     }
+    lines.push('你可以先回一个方向编号，或直接补一句你的倾向。');
+    lines.push('我收到后会先整理需求摘要给你确认；确认后再进入 PRD 和评审流程，不会直接跳到实现。');
   } else {
-    lines.push('建议确认：如果以上理解正确，用户回复“可以”或“确认执行”后再继续。');
+    lines.push('如果以上理解基本对，请先回复“可以”，或直接指出要调整的地方。');
+    lines.push('我收到后会先整理需求摘要给你确认；确认后再进入 PRD 和评审流程，不会直接跳到实现。');
   }
   return {
     mode: presentation.mode,
@@ -547,33 +904,72 @@ function reflectionQuestion(id, label, prompt) {
   };
 }
 
+function buildLensReflectionQuestion(productType) {
+  if (productType === 'consumer') {
+    return reflectionQuestion('product-lens', '用户场景与回访价值', '请确认这次主要服务哪类个人用户、他们第一次会在什么场景下想用它，以及什么结果会让他们愿意继续回来。');
+  }
+  if (productType === 'b2b') {
+    return reflectionQuestion('product-lens', '角色关系与上线阻力', '请确认谁拍板、谁使用、谁负责推进或运营，以及最可能拖慢上线的是哪段协作、审批或对接。');
+  }
+  if (productType === 'agent') {
+    return reflectionQuestion('product-lens', '自主边界与人工兜底', '请确认哪些步骤希望 Agent 自主完成、哪些节点必须人工拍板，以及失败时由谁接住。');
+  }
+  return reflectionQuestion('product-lens', '用户价值与取舍', '请确认这次最重要的用户价值是什么；如果只能先保一个方向，你更想先保效率、体验，还是风险可控。');
+}
+
+function shouldBuildRequirementIntakeReflection({ gate, scenario, analysis }) {
+  if (gate?.active) {
+    return true;
+  }
+  if (['cold-start-greenfield', 'cold-start-existing-project'].includes(scenario?.id)) {
+    return true;
+  }
+  return Number(analysis?.missingRequiredFields ?? 0) > 0;
+}
+
 async function buildRequirementIntakeReflection({ projectRoot, ws, snapshot, analysis, scenario, gate }) {
-  if (!gate?.active) {
+  if (!shouldBuildRequirementIntakeReflection({ gate, scenario, analysis })) {
     return null;
   }
 
+  const sections = snapshot.sections ?? {};
   const text = requirementPrompt(gate);
+  const promptPreview = text || sections.problem?.problemStatement || snapshot.title || '当前需求待确认';
   const complexity = detectRequirementIntakeComplexity(gate);
   const activeChange = await readActiveChangeHint(projectRoot);
-  const sections = snapshot.sections ?? {};
   const productName = snapshot.title || sections.meta?.title || '当前项目';
   const productType = snapshot.productType ?? resolveCurrentProductType(ws) ?? '未分类';
   const currentProblem = sections.problem?.problemStatement || '待补充';
   const currentScope = shortList(sections.scope?.inScope, '当前范围还没有稳定记录');
   const missing = analysis.missingFields.slice(0, 4).map((field) => field.label);
   const needsInterfaceSketch = requirementLooksLikeInterfaceWork(gate);
+  const projectFraming = buildProjectFraming({
+    gate,
+    snapshot,
+    scenario,
+    productType: snapshot.productType ?? resolveCurrentProductType(ws),
+  });
+  const lensQuestion = buildLensReflectionQuestion(snapshot.productType ?? resolveCurrentProductType(ws));
+  const needsDeliveryShapeQuestion = !needsInterfaceSketch
+    && (
+      projectFraming.riskProbes.length > 0
+      || !containsPendingClarifyMarker(projectFraming.architectureSignals)
+    );
   const mustConfirm = complexity.mode === 'deep'
     ? [
-        reflectionQuestion('intent', '意图与目标', '请确认我对需求目标的理解：目标用户是谁、在哪个场景下，需要完成什么结果？'),
-        reflectionQuestion('project-context', '项目影响范围', '结合当前项目，哪些已有模块、入口、流程或历史需求必须复用，哪些可以调整？'),
-        reflectionQuestion('scope-quality', '范围与验收', '这个需求的范围内、范围外、成功标准和失败路径分别是什么？'),
+        reflectionQuestion('intent', '意图与目标', '请确认我理解得对不对：这次主要是谁在什么场景下遇到什么问题，第一版最想先改善什么结果？'),
+        lensQuestion,
+        reflectionQuestion('project-context', '项目影响范围', '结合当前项目，请确认第一版最小可用切片是什么；哪些已有模块、入口、流程或历史需求必须复用，哪些可以调整？'),
+        reflectionQuestion('scope-quality', '范围与验收', '请确认这次先做到哪一步就算有价值；哪些这轮先不动；哪些老用户习惯、现有业务结果或交付节奏不能被影响？'),
         needsInterfaceSketch
           ? reflectionQuestion('interface-sketch', '界面或流程草图', '需求涉及界面或流程，请先确认主要区域、操作入口、预览/确认点和风险提示。')
-          : reflectionQuestion('details-boundary', '细节与边界', '请确认关键字段、状态变化、数据来源、权限边界和可验收细节。'),
+          : needsDeliveryShapeQuestion
+            ? reflectionQuestion('delivery-shape', '影响环节与业务风险', '请确认这次大概会牵动哪些环节，例如用户入口、内部流程、账号与权限、外部对接、AI 自动化或成本控制；其中最大的业务风险是什么。')
+            : reflectionQuestion('details-boundary', '关键状态与验收细节', '请确认用户会看到的关键状态、重要字段、例外场景和最小验收标准。'),
       ]
     : [
-        reflectionQuestion('project-context', '项目映射', '请确认这个调整具体落在哪个页面、模块、入口或流程，以及哪些已有行为不能被改变。'),
-        reflectionQuestion('acceptance', '验收方式', '请确认完成后用户能看到或做到什么，以及最小验收标准是什么。'),
+        reflectionQuestion('project-context', '项目映射', '请确认这个调整具体落在哪个页面、模块、入口或流程，以及第一版先做哪一小块最有价值。'),
+        reflectionQuestion('acceptance', '验收方式', '请确认完成后用户能明显感受到什么变化、哪些既有行为不能改变，以及最小验收标准是什么。'),
       ];
 
   return {
@@ -583,7 +979,7 @@ async function buildRequirementIntakeReflection({ projectRoot, ws, snapshot, ana
     label: complexity.label,
     minimumDepth: complexity.minimumDepth,
     questionLimit: gateQuestionLimit(gate, complexity.questionLimit),
-    promptPreview: text,
+    promptPreview,
     reasons: complexity.reasons,
     needsInterfaceSketch,
     projectContext: {
@@ -595,15 +991,16 @@ async function buildRequirementIntakeReflection({ projectRoot, ws, snapshot, ana
       currentScope,
       activeChange,
       missingFields: missing,
+      projectFraming,
     },
     rounds: [
       {
         id: 'intent-normalization',
         title: '第 1 轮：意图归一化',
         findings: [
-          `用户原始输入：${text || '待补充'}`,
+          `用户原始输入：${promptPreview}`,
           `初步判断：${complexity.label}`,
-          `需要先把表达收敛成用户、场景、目标、动作和期望结果。`,
+          `需要先把表达收敛成用户、产品形态、场景、目标、动作和期望结果。`,
         ],
       },
       {
@@ -611,8 +1008,9 @@ async function buildRequirementIntakeReflection({ projectRoot, ws, snapshot, ana
         title: '第 2 轮：项目上下文映射',
         findings: [
           `工作区场景：${scenario.label}，${scenario.reason}`,
-          `当前产品：${productName}（${productType}），已记录问题：${currentProblem}`,
+          `当前产品：${productName}；当前产品场景：${formatProductTypeDisplay(productType, { fallback: '待确认' })}；已记录问题：${currentProblem}`,
           `当前范围线索：${currentScope}`,
+          `首轮画像：用户群体=${projectFraming.audience}；产品形态=${projectFraming.productShape}；第一版先做=${projectFraming.firstSlice}`,
           activeChange ? `仍有 active change：${activeChange.activeChange}（${activeChange.status}），需要和本轮需求分开评估。` : '当前没有检测到 active change 冲突。',
         ],
       },
@@ -621,7 +1019,9 @@ async function buildRequirementIntakeReflection({ projectRoot, ws, snapshot, ana
         title: '第 3 轮：产品质量自检',
         findings: [
           `仍需确认的信息：${shortList(missing, '暂无明显缺口')}`,
-          needsInterfaceSketch ? '需求看起来涉及界面或流程，需要先给用户确认草图或关键操作路径。' : '需求暂未明显命中界面，但仍要确认状态、边界和验收方式。',
+          `边界与约束：先不做=${projectFraming.nonGoals}；不能破坏=${projectFraming.guardrails}`,
+          needsInterfaceSketch ? '需求看起来涉及界面或流程，需要先给用户确认草图或关键操作路径。' : `影响环节：${projectFraming.architectureSignals}`,
+          `业务提醒：${projectFraming.riskProbeSummary}`,
           '进入实现前必须保留范围、非目标、异常路径和验收证据。',
         ],
       },
@@ -644,11 +1044,23 @@ function renderRequirementIntakeReflection(reflection) {
     '## 项目上下文',
     '',
     `- 工作区场景: ${reflection.projectContext.scenario}`,
-    `- 当前产品: ${reflection.projectContext.productName} (${reflection.projectContext.productType})`,
+    `- 当前产品: ${reflection.projectContext.productName}；产品场景: ${formatProductTypeDisplay(reflection.projectContext.productType, { fallback: '待确认' })}`,
     `- 当前问题: ${reflection.projectContext.currentProblem}`,
     `- 当前范围: ${reflection.projectContext.currentScope}`,
     reflection.projectContext.activeChange ? `- 历史 active change: ${reflection.projectContext.activeChange.activeChange}` : '- 历史 active change: 无',
     '',
+    '## 首轮项目画像',
+    '',
+    '| 模块 | 当前理解 |',
+    '|---|---|',
+    `| 用户群体 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.audience ?? '待补充')} |`,
+    `| 产品形态 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.productShape ?? '待补充')} |`,
+    `| 第一版先做 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.firstSlice ?? '待补充')} |`,
+    `| 暂不处理 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.nonGoals ?? '待补充')} |`,
+    `| 不能破坏 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.guardrails ?? '待补充')} |`,
+    `| 影响环节 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.architectureSignals ?? '待补充')} |`,
+    `| 业务提醒 | ${escapeMarkdownTableCell(reflection.projectContext.projectFraming?.riskProbeSummary ?? '待补充')} |`,
+    '',
   ];
   for (const round of reflection.rounds) {
     lines.push(`## ${round.title}`, '');
@@ -677,15 +1089,15 @@ async function writeRequirementIntakeReflection(ws, reflection) {
 function buildRequirementIntakeDepth(gate, reflection = null) {
   const needsInterfaceSketch = requirementLooksLikeInterfaceWork(gate);
   const fallbackLayers = [
-    reflectionQuestion('product-context', '用户 / 场景 / 问题', '先确认：什么用户，在什么场景下，遇到什么问题？为什么现在值得解决？'),
-    reflectionQuestion('product-outcome', '目标 / 影响 / 成功标准', '解决后用户能完成什么？减少什么成本或风险？用什么成功指标或验收标准判断有效？'),
-    reflectionQuestion('product-flow', '现状流程 / 目标流程 / 异常路径', '请拆出当前流程、目标流程、关键决策点、失败路径，以及哪些动作必须由用户确认。'),
+    reflectionQuestion('product-context', '用户 / 产品形态 / 问题', '先确认：这是给谁用的、它更像个人产品 / 团队流程 / Agent 协作中的哪一种、为什么现在值得解决？'),
+    reflectionQuestion('product-outcome', '第一版切片 / 目标 / 成功标准', '请确认第一版最小可用切片是什么；解决后用户先能完成什么，用什么业务结果或验收标准判断有效？'),
+    reflectionQuestion('product-flow', '范围 / 非目标 / 异常路径', '请拆出本轮先做什么、不做什么、哪些既有行为不能被破坏，以及关键失败路径和恢复方式。'),
     reflectionQuestion(
       'product-detail',
       needsInterfaceSketch ? '界面草图 / 字段 / 状态' : '细节 / 状态 / 边界',
       needsInterfaceSketch
         ? '这个需求涉及界面，请先给用户一版 ASCII 线框草图，标出主要区域、操作入口、预览/确认点和风险提示，让用户确认后再 synthesize。'
-        : '请补齐关键字段、状态变化、数据来源、权限边界和可验收细节；如果后续发现涉及界面，也要先补 ASCII 线框草图。'
+        : '请补齐用户会看到的关键状态、重要字段、业务边界和可验收细节；如果后续发现涉及界面，也要先补 ASCII 线框草图。'
     ),
   ];
   const layers = reflection?.mustConfirm?.length > 0 ? reflection.mustConfirm : fallbackLayers;
@@ -850,7 +1262,6 @@ async function synthesizeWorkspace(projectRoot, overrides = {}) {
 
   snapshot.content = renderPrdMarkdown(snapshot);
   snapshot.digest = crypto.createHash('sha256').update(snapshot.content).digest('hex');
-  assertOpenSpecPreflightReady(snapshot);
 
   await writeVersionSnapshot(ws, snapshot);
 
@@ -890,14 +1301,13 @@ async function synthesizeWorkspace(projectRoot, overrides = {}) {
     reviewPresentationRequired: !presentationGate.ok,
   });
   await appendDecision(ws, [
-    `已生成版本 ${snapshot.versionId}。`,
-    `产品类型: ${snapshot.productType ?? '未分类'}。`,
-    `模板包: ${snapshot.templatePack}。`,
-    `Digest: ${snapshot.digest}.`,
+    `已整理出一版可确认的需求稿。`,
+    `产品场景: ${formatProductTypeDisplay(snapshot.productType, { fallback: '待确认' })}。`,
+    `场景模板: ${formatTemplatePackDisplay(snapshot.templatePack, { fallback: '待确认' })}。`,
   ]);
   await appendProgress(ws, [
-    `已生成 PRD 快照 ${snapshot.versionId}。`,
-    `已更新当前 PRD、流程、角色和交接文档。`,
+    '已生成新的需求确认稿。',
+    '已同步更新当前需求、流程、角色和交接说明。',
     presentationGate.ok
       ? `已生成可确认评审面板: ${reviewFiles.canonicalReview}。`
       : '评审面板暂未生成：需要先通过 openprd review-presentation 写入展示文案。',
@@ -936,9 +1346,10 @@ async function synthesizeWorkspace(projectRoot, overrides = {}) {
     templatePack: snapshot.templatePack,
     synthesizedAt: snapshot.createdAt,
   }, snapshot);
-  await writeJson(ws.paths.currentState, currentState);
-  const nextWs = { ...ws, data: { ...ws.data, currentState } };
+  const storedCurrentState = await persistWorkspaceCurrentState(ws, currentState);
+  const nextWs = { ...ws, data: { ...ws.data, currentState: storedCurrentState } };
   await syncSessionBindingFromSnapshot(projectRoot, snapshot, {
+    sessionId: ws.data.currentSessionId ?? null,
     reviewStatus: 'pending-confirmation',
     reviewPath: reviewFiles.canonicalReview,
     activeReviewPath: reviewFiles.activeReviewEntry,
@@ -948,7 +1359,7 @@ async function synthesizeWorkspace(projectRoot, overrides = {}) {
   return {
     ws: nextWs,
     snapshot,
-    currentState,
+    currentState: storedCurrentState,
     indexEntry,
     versionIndex: [...versionIndex, indexEntry],
     reviewArtifact: reviewFiles.activeReviewEntry,
@@ -1003,8 +1414,16 @@ async function reviewWorkspace(projectRoot, options = {}) {
   if (!(await exists(ws.workspaceRoot))) {
     throw new Error(`Missing workspace: ${ws.workspaceRoot}`);
   }
-  const latest = await loadLatestVersionSnapshot(ws);
-  if (!latest?.snapshot) {
+  const requestedVersion = normalizeVersionId(options.version);
+  const latest = await loadCurrentLaneSnapshot(ws, {
+    fallbackToLatest: !ws.data.currentSessionId || Boolean(requestedVersion),
+  });
+  const fallbackLatest = latest?.snapshot ? latest : (requestedVersion ? await loadLatestVersionSnapshot(ws) : null);
+  const latestSnapshot = fallbackLatest?.snapshot ?? null;
+  const snapshot = requestedVersion
+    ? await readVersionSnapshot(ws, requestedVersion)
+    : latestSnapshot;
+  if (!snapshot) {
     return {
       ok: false,
       action: 'review',
@@ -1012,12 +1431,7 @@ async function reviewWorkspace(projectRoot, options = {}) {
       errors: ['No synthesized PRD version exists yet. Run openprd synthesize first.'],
     };
   }
-
-  const requestedVersion = normalizeVersionId(options.version);
-  const snapshot = requestedVersion
-    ? await readVersionSnapshot(ws, requestedVersion)
-    : latest.snapshot;
-  if (!snapshot) {
+  if (requestedVersion && normalizeVersionId(snapshot.versionId) !== requestedVersion) {
     return {
       ok: false,
       action: 'review',
@@ -1041,10 +1455,10 @@ async function reviewWorkspace(projectRoot, options = {}) {
 
   const validationErrors = [];
   if (options.digest && options.digest !== snapshot.digest) {
-    validationErrors.push(`Digest mismatch for ${snapshot.versionId}: expected ${snapshot.digest}, got ${options.digest}.`);
+    validationErrors.push(`确认指纹不匹配：当前稿件与传入参数不是同一版，请重新从确认页面复制这次确认命令。`);
   }
   if (requestedWorkUnitId && snapshot.workUnitId !== requestedWorkUnitId) {
-    validationErrors.push(`Work unit mismatch for ${snapshot.versionId}: expected ${snapshot.workUnitId ?? 'none'}, got ${requestedWorkUnitId}.`);
+    validationErrors.push('这次确认命令对应的稿件不一致，请重新从当前确认页面复制命令后再执行。');
   }
   if (validationErrors.length > 0) {
     return {
@@ -1058,7 +1472,7 @@ async function reviewWorkspace(projectRoot, options = {}) {
     };
   }
 
-  const isLatest = normalizeVersionId(snapshot.versionId) === normalizeVersionId(latest.snapshot.versionId);
+  const isLatest = normalizeVersionId(snapshot.versionId) === normalizeVersionId((latestSnapshot ?? snapshot).versionId);
   const presentationGate = getReviewPresentationGate(snapshot);
   if (!presentationGate.ok) {
     return {
@@ -1106,7 +1520,7 @@ async function reviewWorkspace(projectRoot, options = {}) {
           notes: options.notes ?? null,
         },
       };
-      await writeJson(ws.paths.currentState, currentState);
+      await persistWorkspaceCurrentState(ws, currentState);
     }
     workUnit = await writeWorkUnitBinding(ws, {
       snapshot,
@@ -1126,6 +1540,7 @@ async function reviewWorkspace(projectRoot, options = {}) {
       snapshot.workUnitId ? `工作单元: ${snapshot.workUnitId}。` : null,
     ]);
     await syncSessionBindingFromReview(projectRoot, snapshot, {
+      sessionId: ws.data.currentSessionId ?? null,
       reviewStatus: status,
       reviewPath: reviewFiles.canonicalReview,
       activeReviewPath: reviewFiles.activeReviewEntry,
@@ -1174,16 +1589,8 @@ async function clarifyWorkspace(projectRoot, options = {}) {
 
   const versionIndex = await readVersionIndex(ws);
   const currentState = ws.data.currentState ?? {};
-  const snapshot = (await loadLatestVersionSnapshot(ws))?.snapshot ?? buildPrdSnapshot(ws, {
-    ...currentState,
-    versionNumber: currentState.prdVersion ?? (versionIndex.at(-1)?.versionNumber ?? 0),
-    versionId: currentState.prdVersion > 0
-      ? formatVersionId(currentState.prdVersion)
-      : (versionIndex.at(-1)?.versionId ?? 'v0000'),
-    productType: resolveCurrentProductType(ws),
-    templatePack: resolveActiveTemplatePack(ws),
-    status: currentState.status ?? 'draft',
-  });
+  const snapshot = (await loadCurrentLaneSnapshot(ws, { fallbackToLatest: !ws.data.currentSessionId }))?.snapshot
+    ?? buildCurrentStateSnapshot(ws, currentState, versionIndex);
 
   const analysis = analyzePrdSnapshot(snapshot);
   const basePlan = buildClarificationPlan(snapshot, analysis);
@@ -1257,16 +1664,8 @@ async function playgroundWorkspace(projectRoot, options = {}) {
 
   const versionIndex = await readVersionIndex(ws);
   const currentState = ws.data.currentState ?? {};
-  const snapshot = (await loadLatestVersionSnapshot(ws))?.snapshot ?? buildPrdSnapshot(ws, {
-    ...currentState,
-    versionNumber: currentState.prdVersion ?? (versionIndex.at(-1)?.versionNumber ?? 0),
-    versionId: currentState.prdVersion > 0
-      ? formatVersionId(currentState.prdVersion)
-      : (versionIndex.at(-1)?.versionId ?? 'v0000'),
-    productType: resolveCurrentProductType(ws),
-    templatePack: resolveActiveTemplatePack(ws),
-    status: currentState.status ?? 'draft',
-  });
+  const snapshot = (await loadCurrentLaneSnapshot(ws, { fallbackToLatest: !ws.data.currentSessionId }))?.snapshot
+    ?? buildCurrentStateSnapshot(ws, currentState, versionIndex);
 
   const state = buildPlaygroundState(snapshot);
   const bundle = artifactBundlePaths(ws, `${snapshot.versionId}-playground`);
@@ -1433,18 +1832,18 @@ async function captureWorkspace(projectRoot, options = {}) {
     };
   }
   const staleReview = markReviewStateStaleAfterCapture(currentState, applied, currentState.lastCapturedAt);
-  await writeJson(ws.paths.currentState, currentState);
-
-  const snapshot = buildPrdSnapshot({ ...ws, data: { ...ws.data, currentState } }, {
-    ...currentState,
-    versionNumber: currentState.prdVersion ?? 0,
-    versionId: currentState.prdVersion > 0 ? formatVersionId(currentState.prdVersion) : 'v0000',
-    productType: currentState.productType ?? resolveCurrentProductType(ws),
-    templatePack: currentState.templatePack ?? resolveActiveTemplatePack(ws),
+  const storedCurrentState = await persistWorkspaceCurrentState(ws, currentState);
+
+  const snapshot = buildPrdSnapshot({ ...ws, data: { ...ws.data, currentState: storedCurrentState } }, {
+    ...storedCurrentState,
+    versionNumber: storedCurrentState.prdVersion ?? 0,
+    versionId: storedCurrentState.prdVersion > 0 ? formatVersionId(storedCurrentState.prdVersion) : 'v0000',
+    productType: storedCurrentState.productType ?? resolveCurrentProductType(ws),
+    templatePack: storedCurrentState.templatePack ?? resolveActiveTemplatePack(ws),
   });
   const analysis = analyzePrdSnapshot(snapshot);
-  const diagramState = await getDiagramReviewState({ ...ws, data: { ...ws.data, currentState } }, snapshot);
-  const updatedWs = { ...ws, data: { ...ws.data, currentState } };
+  const diagramState = await getDiagramReviewState({ ...ws, data: { ...ws.data, currentState: storedCurrentState } }, snapshot);
+  const updatedWs = { ...ws, data: { ...ws.data, currentState: storedCurrentState } };
   const scenario = await detectWorkspaceScenario(projectRoot, updatedWs, await readVersionIndex(ws));
   const requirementGate = await readActiveRequirementGate(projectRoot);
   const intakeReflection = await buildRequirementIntakeReflection({
@@ -1462,7 +1861,7 @@ async function captureWorkspace(projectRoot, options = {}) {
     analysis,
     basePlan: buildClarificationPlan(snapshot, analysis),
     scenario,
-    captureMeta: currentState.captureMeta,
+    captureMeta: storedCurrentState.captureMeta,
     prdReviewState,
     limit: 8,
   }), requirementGate, intakeReflection);
@@ -1480,7 +1879,7 @@ async function captureWorkspace(projectRoot, options = {}) {
   ]);
 
   return {
-    ws: { ...ws, data: { ...ws.data, currentState } },
+    ws: { ...ws, data: { ...ws.data, currentState: storedCurrentState } },
     applied,
     artifactMarkdown: options.artifactMarkdown ?? null,
     field: applied[0]?.field ?? null,
@@ -1496,16 +1895,12 @@ async function computeWorkspaceGuidance(ws, options = {}) {
   const currentState = ws.data.currentState ?? {};
   const currentProductType = resolveCurrentProductType(ws);
   const currentStatus = currentState.status ?? 'unknown';
-  const latestVersion = versionIndex.length > 0 ? await loadLatestVersionSnapshot(ws) : null;
-  const currentDraftSnapshot = buildPrdSnapshot(ws, {
+  const latestVersion = await loadCurrentLaneSnapshot(ws, { fallbackToLatest: !ws.data.currentSessionId });
+  const currentDraftSnapshot = buildCurrentStateSnapshot(ws, {
     ...currentState,
-    versionNumber: currentState.prdVersion ?? (versionIndex.at(-1)?.versionNumber ?? 0),
-    versionId: currentState.prdVersion > 0
-      ? formatVersionId(currentState.prdVersion)
-      : (versionIndex.at(-1)?.versionId ?? 'v0000'),
     productType: currentProductType,
     templatePack: resolveActiveTemplatePack(ws),
-  });
+  }, versionIndex);
   const analysisSnapshot = shouldUseCurrentDraftForGuidance(currentState)
     ? currentDraftSnapshot
     : (latestVersion?.snapshot ?? currentDraftSnapshot);
@@ -1546,9 +1941,9 @@ async function computeWorkspaceGuidance(ws, options = {}) {
     suggestedQuestions = clarification.mustAskUser.map((item) => item.prompt);
   } else if (!hasProductType) {
     nextAction = 'classify';
-    reason = '产品类型尚未锁定。';
+    reason = '产品场景尚未锁定。';
     suggestedCommand = 'openprd classify . <consumer|b2b|agent>';
-    suggestedQuestions = ['这是 consumer、b2b 还是 agent 产品？'];
+    suggestedQuestions = [formatProductTypeQuestion()];
   } else if (analysis.missingRequiredFields > 0) {
     nextAction = 'interview';
     reason = `仍缺少 ${analysis.missingRequiredFields} 个必填字段。`;
@@ -1708,18 +2103,18 @@ async function classifyWorkspace(projectRoot, productType) {
     templatePack: productType,
     classifiedAt: timestamp(),
   };
-  await writeJson(ws.paths.currentState, currentState);
+  const storedCurrentState = await persistWorkspaceCurrentState(ws, currentState);
   await appendWorkflowEvent(ws, 'classified', { productType });
   await appendDecision(ws, [
-    `已锁定产品类型为 ${productType}。`,
-    `模板包已设置为 ${productType}。`,
+    `已锁定产品场景为 ${formatProductTypeDisplay(productType, { fallback: productType })}。`,
+    `场景模板已设置为 ${formatTemplatePackDisplay(productType, { fallback: productType })}。`,
   ]);
   await appendProgress(ws, [
-    `已将工作区分类为 ${productType}。`,
+    `已将工作区产品场景锁定为 ${formatProductTypeDisplay(productType, { fallback: productType })}。`,
   ]);
-  await writeJson(ws.paths.taskGraph, buildWorkflowTaskGraph(currentState));
+  await writeJson(ws.paths.taskGraph, buildWorkflowTaskGraph(storedCurrentState));
 
-  return { ws, currentState };
+  return { ws: { ...ws, data: { ...ws.data, currentState: storedCurrentState } }, currentState: storedCurrentState };
 }
 
 async function interviewWorkspace(projectRoot, requestedType = null) {
@@ -1754,30 +2149,39 @@ ${content}`);
     templatePack: productType ?? resolveActiveTemplatePack(ws),
     interviewStartedAt: timestamp(),
   };
-  await writeJson(ws.paths.currentState, currentState);
+  const storedCurrentState = await persistWorkspaceCurrentState(ws, currentState);
   await appendWorkflowEvent(ws, 'interview_started', {
     productType: currentState.productType,
     sourceFiles: sourceFiles.map((filePath) => path.relative(ws.workspaceRoot, filePath)),
   });
   await appendProgress(ws, [
-    `已加载 ${productType ?? '未分类'} 的访谈问题。`,
+    `已加载 ${formatProductTypeDisplay(productType, { fallback: '待确认' })} 的访谈问题。`,
     `来源文件: ${sourceFiles.map((filePath) => path.relative(ws.workspaceRoot, filePath)).join(', ')}`,
   ]);
-  await appendOpenQuestions(ws, [
-    '我们要解决什么问题？',
-    '主要用户是谁？',
-    '成功是什么样？',
-    '哪些内容明确不在范围内？',
-    '我们希望 freeze 的第一个里程碑是什么？',
-  ]);
-  await writeJson(ws.paths.taskGraph, buildWorkflowTaskGraph(currentState));
+  const openQuestions = [
+    '这次主要是给谁用的，他们在什么场景下最卡？',
+    '第一版最值得先让用户完成什么关键动作？',
+    '这轮先不做什么，哪些既有体验、流程或业务结果不能被影响？',
+  ];
+  if (productType === 'consumer') {
+    openQuestions.push('什么结果会让用户愿意继续回来，甚至愿意推荐或付费？');
+  } else if (productType === 'b2b') {
+    openQuestions.push('谁拍板、谁使用、谁推进或运营，这几方最容易卡在哪里？');
+  } else if (productType === 'agent') {
+    openQuestions.push('哪些步骤让 Agent 自主做，哪些节点必须保留人工确认或兜底？');
+  } else {
+    openQuestions.push('如果现在还不想讲太细，先确认最重要的用户价值、边界和风险也可以。');
+  }
+  openQuestions.push('如果涉及账号、数据、外部对接、AI 或成本，最大的业务风险是什么？');
+  await appendOpenQuestions(ws, openQuestions);
+  await writeJson(ws.paths.taskGraph, buildWorkflowTaskGraph(storedCurrentState));
 
   return {
-    ws,
+    ws: { ...ws, data: { ...ws.data, currentState: storedCurrentState } },
     productType,
     sourceFiles: sourceFiles.map((filePath) => path.relative(ws.workspaceRoot, filePath)),
     transcript: sourceContent.join('\n\n---\n\n'),
-    currentState,
+    currentState: storedCurrentState,
   };
 }