@gordon.gan/specflow 1.8.0-alpha → 1.8.1-beta

package/dist/core/document/render.js

@@ -6,61 +6,103 @@
  * Optional HTML render reuses `marked`.
  */
 import { marked } from 'marked';
+// ============= Escaping helpers（P1-5/6：HTML 与 markdown 注入面） =============
+/** HTML 转义：用于 <title>/<h1> 插值（防存储型 XSS）。 */
+export function escapeHtml(s) {
+    return String(s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/** Markdown 表格单元格转义：转义 | 与换行（防破坏列对齐/拆行）。 */
+export function escapeTableCell(s) {
+    return String(s).replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+/** 代码围栏内容转义：把可能提前终止 ``` 围栏的行替换为安全形式。 */
+export function escapeFenceContent(s) {
+    return String(s).split('\n').map((line) => (line.trimStart().startsWith('```') ? `\\\`\\\`\\\`${line.slice(3)}` : line)).join('\n');
+}
+/** 单行内联文本：转义换行，避免注入新标题/新行。 */
+export function escapeInline(s) {
+    return String(s).replace(/\r?\n/g, ' ');
+}
 // ============= Contract entity → Markdown (T9.1) =============
 export function renderInterface(i) {
     const rows = [
-        `##### ${i.id} · ${i.name}（${i.method} ${i.path}）`,
+        `##### ${i.id} · ${escapeInline(i.name)}（${i.method} ${i.path}）`,
         '',
         '**字段表**',
         '',
         '| 字段 | 类型 | 必填 | 说明 |',
         '|------|------|------|------|',
-        ...[...i.request_fields ?? [], ...i.response_fields ?? []].map((f) => `| ${f.name} | ${f.type} | ${f.required ? '是' : '否'} | ${f.desc ?? ''} |`),
+        ...[...i.request_fields ?? [], ...i.response_fields ?? []].map((f) => `| ${escapeTableCell(f.name)} | ${escapeTableCell(f.type)} | ${f.required ? '是' : '否'} | ${escapeTableCell(f.desc ?? '')} |`),
         '',
         '**成功示例**',
         '',
         '```http',
-        `${i.method} ${i.path}`,
+        `${i.method} ${escapeFenceContent(i.path)}`,
         '```',
         '',
         '**失败示例**',
         '',
-        ...i.failure_examples.map((ex) => `- ${ex}`),
+        ...i.failure_examples.map((ex) => `- ${escapeInline(ex)}`),
         '',
         '**错误**',
         '',
         '| 条件 | 状态 | 说明 |',
         '|------|------|------|',
-        ...i.errors.map((e) => `| ${e.condition} | ${e.status} | ${e.note ?? ''} |`),
+        ...i.errors.map((e) => `| ${escapeTableCell(e.condition)} | ${escapeTableCell(e.status)} | ${escapeTableCell(e.note ?? '')} |`),
     ];
     return rows.join('\n');
 }
 export function renderTable(t) {
     return [
-        `##### ${t.id} · ${t.name}`,
+        `##### ${t.id} · ${escapeInline(t.name)}`,
         '',
         '```sql',
-        t.ddl,
+        escapeFenceContent(t.ddl),
         '```',
         '',
         ...(t.migration ? ['**存量填充策略**', '', t.migration, ''] : []),
         ...(t.rollback ? ['**回滚兼容**', '', t.rollback, ''] : []),
     ].join('\n');
 }
+export function renderDecisions(decisions) {
+    if (decisions.length === 0)
+        return '';
+    return [
+        '**决策记录**',
+        '',
+        '| 决策 | 结论 |',
+        '|------|------|',
+        ...decisions.map((d) => `| ${escapeTableCell(d.id)} | ${escapeTableCell(d.text)} |`),
+    ].join('\n');
+}
 export function renderEntities(entities) {
     const parts = [];
     for (const i of entities.interfaces)
         parts.push(renderInterface(i));
     for (const t of entities.tables)
         parts.push(renderTable(t));
+    const decisionsMd = renderDecisions(entities.decisions);
+    if (decisionsMd)
+        parts.push(decisionsMd);
     return parts.join('\n\n');
 }
+/** Strip engine repair notes (`<!-- review-fix ... -->`) from the FINAL render. The audit trail
+ *  stays in `chapters/<id>.md` and `review-result.json`; the deliverable document must not show
+ *  internal fix notes. */
+export function stripReviewNotes(text) {
+    return text.replace(/<!--\s*review-fix[\s\S]*?-->/g, '').replace(/\n{3,}/g, '\n\n').trim();
+}
 export function renderDocument(input) {
-    const { outline, entities, narratives } = input;
-    const body = [`# 方案文档：${outline.profile}`, ''];
+    const { outline, entities, narratives, profile, appendixAntiAI } = input;
+    const body = [`# 方案文档：${escapeInline(outline.profile)}`, ''];
     for (const ch of outline.chapters) {
-        body.push(`## ${ch.title}`, '');
-        const narrative = narratives.get(ch.id) ?? '';
+        body.push(`## ${escapeInline(ch.title)}`, '');
+        const narrative = stripReviewNotes(narratives.get(ch.id) ?? '');
         if (narrative.trim())
             body.push(narrative.trim(), '');
     }
@@ -75,11 +117,64 @@ export function renderDocument(input) {
     body.push('| 章节 | 数据来源 | 处理方式 |');
     body.push('|------|---------|---------|');
     for (const ch of outline.chapters) {
-        body.push(`| ${ch.title} | 输入素材 / 项目规约 / 大纲要点 | LLM 生成 + 引擎校验 |`);
+        body.push(`| ${escapeTableCell(ch.title)} | 输入素材 / 项目规约 / 大纲要点 | LLM 生成 + 引擎校验 |`);
     }
     body.push('', '');
+    // 附录 B/C: rendered from profile.appendices (decision: deterministic templates, §7.3).
+    const appendices = profile?.appendices ?? [];
+    if (appendices.includes('anti-ai')) {
+        body.push('---', '', renderAppendixAntiAI(appendixAntiAI), '');
+    }
+    if (appendices.includes('handoff')) {
+        body.push('---', '', renderAppendixHandoff(), '');
+    }
     return body.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
 }
+// ============= 附录 B/C（§7.3 确定性渲染） =============
+/** 附录 B · 去AI味自检（frontend-dev-guide §十一 → README §1.6 五维表）。 */
+export function renderAppendixAntiAI(content) {
+    const items = (content ?? '').trim();
+    const table = [
+        '## 附录 B: 去AI味自检',
+        '',
+        '> 每份交付末尾必须附「去AI味自检」，至少 3 条；缺一视为交付不完整（README §1.6）。',
+        '',
+        '| 维度 | 自检问题 | AI 味反例 |',
+        '|------|---------|----------|',
+        '| 不做决策 | 明确说了「不做什么」？ | 只列功能清单 |',
+        '| 数字具体 | 指标/约束具体到数字？ | 「提升体验」 |',
+        '| 竞品立场 | 与竞品差异有一句话立场？ | 「借鉴头部最佳实践」 |',
+        '| 此刻合理性 | 为什么现在做？不做会怎样？ | 不解释时机 |',
+        '| 优先级倾斜 | P0/P1 有倾斜逻辑？ | 全功能同等权重 |',
+        '',
+        items
+            ? items
+            : '> （自检条目由生成流程填充，至少 3 条；缺失将触发引擎 warning）',
+        '',
+    ];
+    return table.join('\n');
+}
+/** 附录 C · 下游交付衔接（frontend-dev-guide §八 → README §1.5 矩阵 + 三步）。 */
+export function renderAppendixHandoff() {
+    const matrix = [
+        '## 附录 C: 下游交付衔接',
+        '',
+        '| 下游角色 | 交付物 | 对方需要的核心信息 | 常见退货原因 |',
+        '|---------|--------|------------------|-------------|',
+        '| 后端 | 接口对接文档/契约 | 请求/响应/错误码约定、时序、分页排序约定 | 字段名与后端对不上、错误处理各写各的 |',
+        '| QA | 自测报告/测试范围 | 已测/未测项、环境地址、Mock 说明、已知问题 | 无自测记录、环境缺数据 |',
+        '| UI 设计师 | 还原实现（可访问预览） | 各断点/状态实现效果、偏差清单及原因 | 偏差无说明，被当 bug 打回 |',
+        '| DevOps | 构建产物/部署配置 | 环境变量清单、构建命令、SPA 路由回退、缓存策略 | 部署后白屏 404 |',
+        '',
+        '**交付动作三步**：',
+        '',
+        '1. **交前核对**：核心链路自测 + 契约确认 + 预览可访问。',
+        '2. **交底说明**：测什么 / 不测什么 / 已知问题。',
+        '3. **交后跟进**：Bug 24h 分级响应、首周每日巡检。',
+        '',
+    ];
+    return matrix.join('\n');
+}
 // ============= HTML (T9.3) =============
 export async function renderHtml(markdown, title = '方案文档') {
     const bodyHtml = await marked.parse(markdown);
@@ -87,11 +182,12 @@ export async function renderHtml(markdown, title = '方案文档') {
     const mermaidScript = hasMermaid
         ? '<script type="module">\nimport mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";\nmermaid.initialize({ startOnLoad: true });\n</script>'
         : '';
+    const safeTitle = escapeHtml(title);
     return `<!DOCTYPE html>
 <html lang="zh-CN">
 <head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>${title}</title>
+<title>${safeTitle}</title>
 <style>body{max-width:920px;margin:0 auto;padding:2rem;font-family:system-ui,sans-serif;line-height:1.65}table{border-collapse:collapse;width:100%}th,td{border:1px solid #ddd;padding:.4rem}pre{background:#f6f8fa;padding:1rem;overflow-x:auto}</style>
 </head>
-<body><h1>${title}</h1><article>${bodyHtml}</article>${mermaidScript}</body></html>`;
+<body><h1>${safeTitle}</h1><article>${bodyHtml}</article>${mermaidScript}</body></html>`;
 }

package/dist/core/document/review.d.ts

@@ -20,10 +20,23 @@ export interface ReviewPacket {
         pointId: string;
         text: string;
     }>;
+    /** Previous round's findings (decision 9 · closed loop): the reviewer must verify each was
+     *  addressed via the `<!-- review-fix -->` note in the chapter and not re-report fixed ones. */
+    prevFindings: ReviewFinding[];
 }
-export declare function buildReviewPacket(workRoot: string, change: string, outline: Outline): Promise<ReviewPacket>;
+export declare function buildReviewPacket(workRoot: string, change: string, outline: Outline, prevFindings?: ReviewFinding[], 
+/** 内存态章节覆盖（P2）：persist=false 时磁盘无章节文件，传 narrativeMap 让评审者
+ *  看到真实内容而非空串；缺省时回退读磁盘。 */
+narratives?: Map<string, string>): Promise<ReviewPacket>;
 export declare function reviewWithAgent(llm: DocumentLLM, packet: ReviewPacket, prompt?: string): Promise<ReviewResult>;
-export declare function applyFindings(workRoot: string, findings: ReviewFinding[], apply: (finding: ReviewFinding) => Promise<void>): Promise<void>;
+/**
+ * 应用待修复的 findings。闭环语义（decision 9）：
+ *  - status==='open'（默认）→ 尚未解决，需要应用修复（追加 fix note / 重填实体）。
+ *  - status==='fixed'  → 评审者已确认上一轮注记生效，仅作闭环核对记账，不再应用。
+ *  - status==='waived' → 豁免，不应用。
+ * 同一 finding 可能跨轮被回显，按 id 去重避免注记/修复重复累积。
+ */
+export declare function applyFindings(workRoot: string, findings: ReviewFinding[], apply: (finding: ReviewFinding) => Promise<void>, appliedIds?: Set<string>): Promise<void>;
 export declare function sha256(content: string): string;
 export declare function computePartHashes(workRoot: string, chapterIds: string[]): Promise<{
     id: string;
@@ -37,6 +50,8 @@ export interface ReviewCheckResult {
         message: string;
     }>;
 }
-export declare function checkReviewResult(workRoot: string, review: ReviewResult, outline: Outline): Promise<ReviewCheckResult>;
+export declare function checkReviewResult(workRoot: string, review: ReviewResult, outline: Outline, currentHashesParam?: Array<{
+    id: string;
+    sha256: string;
+}>): Promise<ReviewCheckResult>;
 export declare function writeReviewResult(workRoot: string, review: ReviewResult): Promise<void>;
-export declare function readReviewResult(workRoot: string): Promise<ReviewResult | null>;

package/dist/core/document/review.js

@@ -28,9 +28,17 @@ export const AI_REVIEW_CHECKLIST = [
     'R14 大纲要点覆盖',
 ];
 // ============= Packet (T8.1) =============
-export async function buildReviewPacket(workRoot, change, outline) {
+export async function buildReviewPacket(workRoot, change, outline, prevFindings = [], 
+/** 内存态章节覆盖（P2）：persist=false 时磁盘无章节文件，传 narrativeMap 让评审者
+ *  看到真实内容而非空串；缺省时回退读磁盘。 */
+narratives) {
     const chapters = new Map();
     for (const ch of outline.chapters) {
+        const fromMemory = narratives?.get(ch.id);
+        if (fromMemory !== undefined) {
+            chapters.set(ch.id, fromMemory);
+            continue;
+        }
         try {
             chapters.set(ch.id, await fs.readFile(chapterPath(workRoot, ch.id), 'utf-8'));
         }
@@ -45,6 +53,7 @@ export async function buildReviewPacket(workRoot, change, outline) {
         chapters,
         checklist: [...AI_REVIEW_CHECKLIST],
         semanticChecklist: semanticCoverageChecklist(outline),
+        prevFindings,
     };
 }
 // ============= Review call (T8.2) =============
@@ -53,18 +62,32 @@ export async function reviewWithAgent(llm, packet, prompt) {
     const semantic = packet.semanticChecklist.length > 0
         ? packet.semanticChecklist.map((s) => `- ${s.chapter} · ${s.pointId}: ${s.text}`).join('\n')
         : '（无 narrative/mixed 要点）';
+    const prev = packet.prevFindings.length > 0
+        ? packet.prevFindings
+            .map((f) => `- ${f.id} [${f.severity}] ${f.target ?? 'narrative'} ${f.chapter ?? ''}: ${f.message}`)
+            .join('\n')
+        : '（无）';
     const content = [
         `# Review packet`,
         `change: ${packet.change}`,
         `checklist:\n${checklist}`,
+        `## 上一轮 findings（闭环核对：对应章节已追加 <!-- review-fix --> 注记；已解决 → status=fixed，勿重复报告）`,
+        prev,
         `## R14 语义覆盖核对清单（逐要点核对：对应小节存在且有实质内容）`,
         semantic,
         `outline: ${JSON.stringify(packet.outline)}`,
         `chapters:\n${[...packet.chapters.entries()].map(([id, c]) => `### ${id}\n${c}`).join('\n\n')}`,
     ].join('\n\n');
+    // 超长保护（P2）：大文档全文内联会超模型上下文导致审查失败；截断章节正文并标注。
+    const MAX_PACKET_CHARS = 60000;
+    const contentFinal = content.length > MAX_PACKET_CHARS
+        ? content.slice(0, MAX_PACKET_CHARS) + `…（已截断，原内容 ${content.length} 字符 > ${MAX_PACKET_CHARS}；请基于可见部分审查）`
+        : content;
     const input = {
-        system: prompt ?? '你是独立长文档审查者。按 checklist 审查，输出 review-result JSON。R14 必须逐要点核对语义覆盖清单。',
-        messages: [{ role: 'user', content }],
+        system: prompt ??
+            '你是独立长文档审查者。按 checklist 审查，输出 review-result JSON。R14 必须逐要点核对语义覆盖清单。' +
+                '对「上一轮 findings」逐条核实：对应章节已含 review-fix 注记且问题已解决 → 标 status=fixed；仅报告仍未解决的问题。',
+        messages: [{ role: 'user', content: contentFinal }],
     };
     let res;
     try {
@@ -74,18 +97,33 @@ export async function reviewWithAgent(llm, packet, prompt) {
         throw new Error(`reviewWithAgent: LLM call failed: ${e instanceof Error ? e.message : String(e)}`);
     }
     try {
-        return parseReviewResult(JSON.parse(res.content));
+        // 剥离 ```json 围栏与前后缀文本（P2）：LLM 常用围栏包裹/附带说明，裸 JSON.parse 会硬失败。
+        const content = res.content.trim();
+        const fence = content.match(/```(?:json)?\s*([\s\S]*?)```/);
+        const jsonText = fence ? fence[1].trim() : content;
+        return parseReviewResult(JSON.parse(jsonText));
     }
     catch (e) {
         throw new Error(`reviewWithAgent: unparsable review result: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
 // ============= Apply findings by target (T8.3) =============
-export async function applyFindings(workRoot, findings, apply) {
+/**
+ * 应用待修复的 findings。闭环语义（decision 9）：
+ *  - status==='open'（默认）→ 尚未解决，需要应用修复（追加 fix note / 重填实体）。
+ *  - status==='fixed'  → 评审者已确认上一轮注记生效，仅作闭环核对记账，不再应用。
+ *  - status==='waived' → 豁免，不应用。
+ * 同一 finding 可能跨轮被回显，按 id 去重避免注记/修复重复累积。
+ */
+export async function applyFindings(workRoot, findings, apply, appliedIds) {
+    const seen = appliedIds ?? new Set();
     for (const f of findings) {
-        if (f.status === 'fixed') {
-            await apply(f);
-        }
+        if (f.status !== 'open')
+            continue;
+        if (seen.has(f.id))
+            continue;
+        seen.add(f.id);
+        await apply(f);
     }
 }
 // ============= Part hashes (T8.4) =============
@@ -105,7 +143,7 @@ export async function computePartHashes(workRoot, chapterIds) {
     }
     return out;
 }
-export async function checkReviewResult(workRoot, review, outline) {
+export async function checkReviewResult(workRoot, review, outline, currentHashesParam) {
     const diags = [];
     if (review.verdict === 'fail') {
         diags.push({ code: 'review_verdict_fail', severity: 'error', message: 'review verdict is fail' });
@@ -122,9 +160,19 @@ export async function checkReviewResult(workRoot, review, outline) {
     // part_hashes tamper detection (decision 9): review-result MUST include a hash for every chapter
     // that exists on disk, so post-review changes are detected. Missing coverage for a persisted
     // chapter = incomplete review (no tamper verification).
-    const currentHashes = await computePartHashes(workRoot, outline.chapters.map((c) => c.id));
+    //
+    // `part_hashes` is the engine-computed snapshot of what the reviewer ACTUALLY saw (the LLM
+    // cannot compute sha256 reliably). Chapters the engine legitimately changed after that snapshot
+    // (entity refill / narrative fix notes) are recorded in `post_review_repairs` and exempted from
+    // the "stale" verdict — everything else must still match the snapshot, so genuine post-review
+    // tampering is still caught. The engine no longer refreshes hashes before checking, which made
+    // the check vacuous.
+    // currentHashes 由调用方提供（P2）：persist=false 时磁盘无章节，引擎传内存哈希；
+    // 缺省时回退读磁盘（兼容旧调用方/validateWork）。
+    const currentHashes = currentHashesParam ?? await computePartHashes(workRoot, outline.chapters.map((c) => c.id));
     const current = new Map(currentHashes.map((h) => [h.id, h.sha256]));
     const reported = new Set((review.part_hashes ?? []).map((ph) => ph.id));
+    const repaired = new Set((review.post_review_repairs ?? []).map((r) => r.chapter));
     for (const [chId] of current) {
         if (!reported.has(chId)) {
             diags.push({
@@ -136,7 +184,13 @@ export async function checkReviewResult(workRoot, review, outline) {
     }
     for (const ph of review.part_hashes ?? []) {
         const now = current.get(ph.id);
-        if (now !== undefined && now !== ph.sha256) {
+        if (now === undefined) {
+            // 审查后章节被删除（P2）：此前 computePartHashes 静默跳过缺失文件，删除型篡改不可见。
+            if (!repaired.has(ph.id)) {
+                diags.push({ code: 'review_part_missing', severity: 'error', message: `Chapter "${ph.id}" existed at review time but is now missing — possible post-review deletion` });
+            }
+        }
+        else if (now !== ph.sha256 && !repaired.has(ph.id)) {
             diags.push({ code: 'review_part_stale', severity: 'error', message: `Chapter "${ph.id}" changed after review; re-run review` });
         }
     }
@@ -146,12 +200,3 @@ export async function checkReviewResult(workRoot, review, outline) {
 export async function writeReviewResult(workRoot, review) {
     await fs.writeFile(join(workRoot, 'review-result.json'), JSON.stringify(review, null, 2), 'utf-8');
 }
-export async function readReviewResult(workRoot) {
-    try {
-        const raw = JSON.parse(await fs.readFile(join(workRoot, 'review-result.json'), 'utf-8'));
-        return parseReviewResult(raw);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/core/document/scene-detect.d.ts

@@ -1,11 +1,15 @@
 /**
- * Document Engine — scene detection (decision: auto-detect 0to1 / bugfix / feature from
- * natural language; confirm with the user when uncertain).
+ * Document Engine — scene detection (decision: auto-detect 0to1 / bugfix / feature /
+ * poc / migration from natural language; confirm with the user when uncertain).
  *
  * Deterministic keyword scoring as a first pass. The Agent (IDE model) may refine and confirm
  * when confidence is low. Returns the best match + confidence + candidates.
+ *
+ * Scene axis (what we are doing) is orthogonal to the tech-stack axis (which layers are
+ * involved — derived by input-features hasBackend/uiInScope). `frontend-0to1` is the one
+ * stack-specific variant: pure-frontend 0→1 (no backend signals → 0to1 is narrowed to it).
  */
-export type SceneProfile = '0to1' | 'bugfix' | 'feature';
+export type SceneProfile = '0to1' | 'frontend-0to1' | 'bugfix' | 'feature' | 'poc' | 'migration';
 export interface SceneDetectResult {
     profile: SceneProfile | null;
     confidence: number;
@@ -17,6 +21,9 @@ export interface SceneDetectResult {
 }
 /**
  * Detect the most likely scene profile from natural language.
+ * - `frontend-0to1` is NOT a competing candidate: it is a narrowing of `0to1` (pure-frontend,
+ *   no backend hints) — so the "strongest scene" race runs on the 5 base scenes only, and 0to1
+ *   is narrowed to frontend-0to1 when backend is absent and pure-frontend signals are present.
  * - Returns a profile when its score clearly leads (≥ 2× runner-up, or score ≥ threshold).
  * - Returns null when signals are weak/conflicting → caller should confirm with the user.
  */

package/dist/core/document/scene-detect.js

@@ -1,9 +1,13 @@
 /**
- * Document Engine — scene detection (decision: auto-detect 0to1 / bugfix / feature from
- * natural language; confirm with the user when uncertain).
+ * Document Engine — scene detection (decision: auto-detect 0to1 / bugfix / feature /
+ * poc / migration from natural language; confirm with the user when uncertain).
  *
  * Deterministic keyword scoring as a first pass. The Agent (IDE model) may refine and confirm
  * when confidence is low. Returns the best match + confidence + candidates.
+ *
+ * Scene axis (what we are doing) is orthogonal to the tech-stack axis (which layers are
+ * involved — derived by input-features hasBackend/uiInScope). `frontend-0to1` is the one
+ * stack-specific variant: pure-frontend 0→1 (no backend signals → 0to1 is narrowed to it).
  */
 const KEYWORDS = {
     // 从零做一个产品/项目
@@ -23,7 +27,24 @@ const KEYWORDS = {
         { text: 'mvp', weight: 1 },
         { text: 'MVP', weight: 1 },
     ],
-    // 修 bug / 排查故障
+    // 纯前端 0→1（无后端信号的 0to1 收敛变体；hasBackend 命中时回落 0to1）
+    'frontend-0to1': [
+        { text: '纯前端', weight: 4 },
+        { text: '前端项目', weight: 3 },
+        { text: '静态站点', weight: 3 },
+        { text: '静态网站', weight: 3 },
+        { text: '官网', weight: 2 },
+        { text: '落地页', weight: 2 },
+        { text: 'landing page', weight: 3 },
+        { text: 'landing', weight: 2 },
+        { text: '前端应用', weight: 3 },
+        { text: 'web 前端', weight: 2 },
+        { text: '无后端', weight: 3 },
+        { text: '不要后端', weight: 3 },
+        { text: '只有页面', weight: 2 },
+        { text: '纯 UI', weight: 2 },
+    ],
+    // 修 bug / 排查故障（含前端/多端维度；不再单列 fullstack-bugfix）
     bugfix: [
         { text: '报错', weight: 3 },
         { text: '500', weight: 3 },
@@ -43,8 +64,19 @@ const KEYWORDS = {
         { text: '排查', weight: 2 },
         { text: '定位问题', weight: 2 },
         { text: 'debug', weight: 2 },
+        { text: '前端报错', weight: 3 },
+        { text: '页面崩溃', weight: 3 },
+        { text: '页面白屏', weight: 3 },
+        { text: '渲染问题', weight: 3 },
+        { text: '样式错乱', weight: 3 },
+        { text: '浏览器兼容', weight: 2 },
+        { text: '兼容性问题', weight: 3 },
+        { text: '多端', weight: 2 },
+        { text: '跨端', weight: 2 },
+        { text: '联调 bug', weight: 3 },
+        { text: '数据对不上', weight: 2 },
     ],
-    // 给已有系统加功能
+    // 给已有系统加功能（含全栈/接口/前端维度，由输入特征伸缩；不再单列 fullstack-feature）
     feature: [
         { text: '新增', weight: 3 },
         { text: '增加', weight: 2 },
@@ -56,50 +88,131 @@ const KEYWORDS = {
         { text: '功能', weight: 1 },
         { text: '开发一个功能', weight: 3 },
         { text: 'feat', weight: 2 },
+        { text: '新增模块', weight: 3 },
+        { text: '新页面', weight: 3 },
+        { text: '新路由', weight: 3 },
+        { text: '多个页面', weight: 3 },
+        { text: '状态管理', weight: 2 },
+        { text: '接口对接', weight: 2 },
+        { text: '前后端联调', weight: 3 },
+        { text: '功能开发', weight: 2 },
+        { text: '组件化', weight: 2 },
+        { text: '页面组件', weight: 2 },
+    ],
+    // 技术预研 / PoC / 方案选型（原 fullstack-poc；预研不限于全栈，是否全栈由特征决定）
+    poc: [
+        { text: '预研', weight: 3 },
+        { text: '技术调研', weight: 3 },
+        { text: '方案对比', weight: 3 },
+        { text: '候选', weight: 2 },
+        { text: 'poc', weight: 3 },
+        { text: 'PoC', weight: 3 },
+        { text: 'benchmark', weight: 2 },
+        { text: '选型评估', weight: 3 },
+        { text: '评估一下', weight: 2 },
+        { text: '对比一下', weight: 2 },
+        { text: '可行性验证', weight: 3 },
+    ],
+    // 技术升级（原 fullstack-migration；是否全栈由特征决定）
+    migration: [
+        { text: '迁移', weight: 3 },
+        { text: '大版本', weight: 3 },
+        { text: '框架升级', weight: 3 },
+        { text: '技术升级', weight: 3 },
+        { text: '构建工具升级', weight: 3 },
+        { text: 'vue2', weight: 2 },
+        { text: 'vue3', weight: 2 },
+        { text: 'webpack', weight: 2 },
+        { text: 'vite', weight: 2 },
+        { text: '代码迁移', weight: 3 },
+        { text: '升级到', weight: 2 },
     ],
 };
-/** Score a text against one profile's keywords. */
+/**
+ * 关键词匹配（P2）：
+ * - CJK 关键词：子串匹配。
+ * - ASCII/数字关键词（api/server/rest/500/vue2 等）：词边界匹配，避免 'api'⊂rapid、'500'⊂1500、'server'⊂serverless 误报。
+ */
+function keywordHit(text, kw) {
+    if (/^[A-Za-z0-9_.-]+$/.test(kw)) {
+        const re = new RegExp(`(^|[^A-Za-z0-9_])${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}($|[^A-Za-z0-9_])`);
+        return re.test(text);
+    }
+    return text.includes(kw);
+}
+/** Score a text against one profile's keywords. 重叠关键词取最长匹配（P2）：
+ *  '想做一个' 命中后不再计 '想做'/'做一个'；'landing page' 命中后不再计 'landing'；
+ *  '开发一个功能' 命中后不再计 '功能'——避免同一短语重复计分导致误判场景。 */
 function score(text, profile) {
+    // 按长度降序处理：先匹配长的（更具体），命中则其包含的短词不再计分。
+    const sorted = [...KEYWORDS[profile]].sort((a, b) => b.text.length - a.text.length);
     let score = 0;
     const hits = [];
-    for (const kw of KEYWORDS[profile]) {
-        if (text.includes(kw.text)) {
-            score += kw.weight;
-            hits.push(kw.text);
-        }
+    for (const kw of sorted) {
+        if (!keywordHit(text, kw.text))
+            continue;
+        // 若存在更长的已命中关键词包含本词（如 '想做一个' 包含 '想做'），跳过本词避免重复计分。
+        const coveredByLonger = sorted.some((other) => other !== kw && other.text.length > kw.text.length && other.text.includes(kw.text) && keywordHit(text, other.text));
+        if (coveredByLonger)
+            continue;
+        score += kw.weight;
+        hits.push(kw.text);
     }
     return { score, hits };
 }
+/** Backend signal: if the text mentions backend/API/database, a 0to1 is NOT pure-frontend.
+ *  Negated forms (无后端/不要后端/没有后端…) are stripped first so they don't false-positive.
+ *  ASCII hints use word-boundary matching（P2）：'api' 不应命中 rapid/capital，'server' 不应命中 serverless。 */
+const BACKEND_HINTS = ['后端', '服务端', '服务器', '接口', '数据库', '微服务', '后台', '网关', 'api', 'rest', 'backend', 'server', 'daemon'];
+const BACKEND_NEGATIONS = ['无后端', '不要后端', '没有后端', '不用后端', '不需要后端', '无需后端', 'no backend', 'without backend', '不接后端'];
+function hasBackendSignal(lower) {
+    let text = lower;
+    for (const neg of BACKEND_NEGATIONS)
+        text = text.split(neg).join(' ');
+    return BACKEND_HINTS.some((h) => keywordHit(text, h));
+}
 /**
  * Detect the most likely scene profile from natural language.
+ * - `frontend-0to1` is NOT a competing candidate: it is a narrowing of `0to1` (pure-frontend,
+ *   no backend hints) — so the "strongest scene" race runs on the 5 base scenes only, and 0to1
+ *   is narrowed to frontend-0to1 when backend is absent and pure-frontend signals are present.
  * - Returns a profile when its score clearly leads (≥ 2× runner-up, or score ≥ threshold).
  * - Returns null when signals are weak/conflicting → caller should confirm with the user.
  */
 export function detectScene(text) {
     const lower = text.toLowerCase();
-    const scores = Object.keys(KEYWORDS).map((p) => ({
+    const all = Object.keys(KEYWORDS).map((p) => ({
         profile: p,
         score: score(lower, p).score,
     }));
-    scores.sort((a, b) => b.score - a.score);
-    const best = scores[0];
-    const runner = scores[1];
-    const total = scores.reduce((s, x) => s + x.score, 0);
+    const candidates = [...all].sort((a, b) => b.score - a.score);
+    // Base-scene race excludes frontend-0to1 (it narrows 0to1, never outranks it).
+    const base = all.filter((s) => s.profile !== 'frontend-0to1').sort((a, b) => b.score - a.score);
+    const best = base[0];
+    const runner = base[1];
+    const total = base.reduce((s, x) => s + x.score, 0);
     const reasons = [];
     // Strong signal: clear winner.
     if (best.score >= 3 && (runner.score === 0 || best.score >= runner.score * 2)) {
+        let winner = best.profile;
+        // 0to1 → frontend-0to1 narrowing: pure-frontend signals with no backend hints.
+        if (best.profile === '0to1' && !hasBackendSignal(lower)) {
+            const feScore = candidates.find((s) => s.profile === 'frontend-0to1')?.score ?? 0;
+            if (feScore > 0)
+                winner = 'frontend-0to1';
+        }
         const confidence = Math.min(1, best.score / (best.score + runner.score + 1));
-        reasons.push(`匹配「${best.profile}」关键词 ${best.score} 分（次优 ${runner.profile} ${runner.score} 分）`);
-        return { profile: best.profile, confidence, candidates: scores, reasons };
+        reasons.push(`匹配「${winner}」关键词 ${best.score} 分（次优 ${runner.profile} ${runner.score} 分）`);
+        return { profile: winner, confidence, candidates, reasons };
     }
     // Conflicting/weak → uncertain.
     if (total === 0) {
         reasons.push('未检测到明显场景信号，需向用户确认');
     }
     else {
-        reasons.push(`场景信号较弱或冲突（${scores.map((s) => `${s.profile}:${s.score}`).join(', ')}），需确认`);
+        reasons.push(`场景信号较弱或冲突（${base.map((s) => `${s.profile}:${s.score}`).join(', ')}），需确认`);
     }
-    return { profile: null, confidence: 0, candidates: scores, reasons };
+    return { profile: null, confidence: 0, candidates, reasons };
 }
 /** The user-facing prompt when detection is uncertain. */
 export function confirmationPrompt(result, text) {
@@ -113,9 +226,12 @@ export function confirmationPrompt(result, text) {
             .map((c) => `- ${c.profile}: ${c.score} 分`),
         '',
         `请选择场景（或直接输入新的需求描述）：`,
-        `- 0to1   → 从零启动一个产品/项目`,
-        `- bugfix → 排查并修复一个问题`,
-        `- feature → 给已有系统新增功能`,
+        `- 0to1   → 从零启动一个产品/项目（全栈；纯前端自动走 frontend-0to1）`,
+        `- frontend-0to1 → 从零启动一个纯前端项目（无后端/仅页面与样式）`,
+        `- bugfix → 排查并修复一个问题（含前端/多端维度，按输入特征伸缩）`,
+        `- feature → 给已有系统新增功能（按输入特征伸缩：纯逻辑/含后端/含前端/全栈）`,
+        `- poc → 技术预研/选型（新技术评估/PoC/方案对比）`,
+        `- migration → 技术升级（框架迁移/大版本/构建工具升级）`,
     ];
     return lines.join('\n');
 }