speccore 6.98.0 → 7.2.0

package/dist/commands/analyze.js

@@ -70,6 +70,8 @@ const requirement_clarifier_1 = require("../core/requirement-clarifier");
 const agents_1 = require("../core/agents");
 // v6.91.0+: 代码知识图谱摘要注入
 const code_graph_1 = require("../core/code-graph");
+// v7.2.0+: 结构化代码数据提取
+const structured_extractor_1 = require("../core/structured-extractor");
 async function analyzeCommand(options) {
     // v6.97.0+ 修复：全局分析时统一设置 iteration 为 'GLOBAL'，避免任何 fallback 到 getDefaultIteration()
     // 这是根治方案：后面所有 "options.iteration || await getDefaultIteration()" 都会命中 options.iteration
@@ -506,13 +508,17 @@ async function analyzeCommand(options) {
         if (options.scope === 'global') {
             // 全局分析：预创建 .speccore/GLOBAL/ 目录结构，不写迭代目录
             // v6.81.0+: 需求文档单独放在 requirements/ 下，技术文档放在 platforms/ 下
+            // v7.2.0+: 全局技术文档统一放在 overview/ 子目录下，与迭代层 020-specs/overview/ 命名一致
             const globalDir = (0, path_1.join)(process.cwd(), '.speccore', 'GLOBAL');
             await (0, fs_extra_1.ensureDir)(globalDir);
+            await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'overview'));
             await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'platforms'));
             await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'requirements'));
             await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'requirements', 'images'));
             await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'requirements', 'prototypes'));
-            logger_1.logger.info(`📁 已预创建 .speccore/GLOBAL/ 目录结构（requirements/ + platforms/）`);
+            // v7.0.0+: 图表可视化目录
+            await (0, fs_extra_1.ensureDir)((0, path_1.join)(globalDir, 'diagrams'));
+            logger_1.logger.info(`📁 已预创建 .speccore/GLOBAL/ 目录结构（overview/ + platforms/ + requirements/ + diagrams/）`);
         }
         else {
             const iterForDirs = options.iteration || await (0, context_1.getDefaultIteration)();
@@ -801,11 +807,13 @@ async function analyzeCommand(options) {
                             targetFilename = filename;
                         }
                         else if (globalSet.has(filename)) {
-                            targetDir = globalBaseDir;
+                            // v7.2.0+: 全局技术文档统一放入 overview/ 子目录，与迭代层命名一致
+                            targetDir = (0, path_1.join)(globalBaseDir, 'overview');
                             targetFilename = filename;
                         }
                         else {
-                            targetDir = globalBaseDir;
+                            // v7.2.0+: 未知文件也归入 overview/ 子目录
+                            targetDir = (0, path_1.join)(globalBaseDir, 'overview');
                             targetFilename = filename;
                         }
                         await (0, fs_extra_1.ensureDir)(targetDir);
@@ -823,6 +831,13 @@ async function analyzeCommand(options) {
                         count++;
                     }
                     logger_1.logger.success(`✅ ${count} 个全局文档已写入 .speccore/GLOBAL/`);
+                    // v7.2.0+: 全局文档质量门禁
+                    const { runGlobalQualityGate, printQualityReport } = await Promise.resolve().then(() => __importStar(require('../core/doc-quality-gate')));
+                    const reports = await runGlobalQualityGate();
+                    printQualityReport(reports);
+                    // v7.2.0+: 自动生成文档间交叉引用
+                    const { generateCrossReferences } = await Promise.resolve().then(() => __importStar(require('../core/doc-cross-reference')));
+                    await generateCrossReferences();
                 }
                 else {
                     // 迭代级：写 020-specs/（综合文档写入 global/ 子目录，v6.41.0+）
@@ -1199,8 +1214,29 @@ async function analyzeCommand(options) {
     if (options.prompt) {
         // v6.97.0+ 修复：全局分析时不应 fallback 到当前迭代
         const iter = options.scope === 'global' ? 'GLOBAL' : (options.iteration || await (0, context_1.getDefaultIteration)());
+        // v7.2.0+: 保存分析上下文到临时目录
+        if (iter && iter !== 'GLOBAL') {
+            try {
+                const { saveAnalysisContext } = await Promise.resolve().then(() => __importStar(require('../core/iteration-cache')));
+                await saveAnalysisContext({
+                    iteration: iter,
+                    docName: options.docName,
+                    featureName: options.featureName,
+                    withCode: options.withCode,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch { /* ignore */ }
+        }
         const prompt = await buildMultiDocPrompt('analyze', { iteration: iter, task: options.task, type: options.type, scope: options.scope, withCode: options.withCode, platform: options.platform, phase: options.phase, autoMode: options.auto }, options);
         process.stdout.write(`[SPECCORE_PROMPT]\n${prompt}`);
+        // v7.2.0+: 全局分析完成后输出下一步引导
+        if (options.scope === 'global') {
+            const guide = await buildGlobalAnalysisGuide(options);
+            if (guide) {
+                process.stdout.write(`\n[SPECCORE_GUIDE]\n${guide}`);
+            }
+        }
         process.exitCode = 10;
         return;
     }
@@ -1652,6 +1688,148 @@ async function injectGraphSummary(prompt) {
         return prompt;
     }
 }
+// ── v7.2.0+: 检测全局分析当前进度 ──
+// Layer 4 拆分为子层: 4a=产品文档, 4b=全局技术核心, 4c=全局技术扩展, 4d=各端技术
+async function detectGlobalLayerProgress() {
+    const globalDir = (0, path_1.join)(process.cwd(), '.speccore', 'GLOBAL');
+    let completedLayer = 0;
+    const missing = [];
+    // Layer 1: 检查各端 _INDEX.md
+    try {
+        const platformsDir = (0, path_1.join)(globalDir, 'platforms');
+        const entries = await (0, fs_extra_2.readdir)(platformsDir, { withFileTypes: true });
+        const platformDirs = entries.filter(e => e.isDirectory() && e.name !== '_shared').map(e => e.name);
+        const hasIndex = platformDirs.length > 0 && (await Promise.all(platformDirs.map(async (d) => (0, fs_extra_1.pathExists)((0, path_1.join)(platformsDir, d, '_INDEX.md'))))).some(Boolean);
+        if (hasIndex)
+            completedLayer = 1;
+        else
+            missing.push('Layer 1: platforms/{端}/_INDEX.md');
+    }
+    catch {
+        missing.push('Layer 1: platforms/{端}/_INDEX.md');
+    }
+    // Layer 2: 检查 _ASSOCIATION.md
+    if (completedLayer >= 1) {
+        if (await (0, fs_extra_1.pathExists)((0, path_1.join)(globalDir, 'platforms', '_shared', '_ASSOCIATION.md'))) {
+            completedLayer = 2;
+        }
+        else {
+            missing.push('Layer 2: platforms/_shared/_ASSOCIATION.md + _MODULES.md');
+        }
+    }
+    // Layer 3: 检查 _MODULES.md
+    if (completedLayer >= 2) {
+        if (await (0, fs_extra_1.pathExists)((0, path_1.join)(globalDir, 'platforms', '_shared', '_MODULES.md'))) {
+            completedLayer = 3;
+        }
+        else {
+            missing.push('Layer 3: platforms/_shared/_MODULES.md（功能模块候选清单）');
+        }
+    }
+    // Layer 4 子层检测
+    let subLayer;
+    if (completedLayer >= 3) {
+        const overviewDir = (0, path_1.join)(globalDir, 'overview');
+        const requirementsDir = (0, path_1.join)(globalDir, 'requirements');
+        const completedSubLayers = [];
+        // 4a: 产品文档
+        const hasReq = await (0, fs_extra_1.pathExists)((0, path_1.join)(requirementsDir, 'REQUIREMENT.md'));
+        if (hasReq)
+            completedSubLayers.push('4a');
+        // 4b: 全局技术核心文档
+        const hasCoreTech = await (0, fs_extra_1.pathExists)((0, path_1.join)(overviewDir, 'ARCHITECTURE.md'))
+            && await (0, fs_extra_1.pathExists)((0, path_1.join)(overviewDir, 'FUNCTION_MAP.md'));
+        if (hasCoreTech)
+            completedSubLayers.push('4b');
+        // 4c: 全局技术扩展文档
+        const hasExtTech = await (0, fs_extra_1.pathExists)((0, path_1.join)(overviewDir, 'SECURITY_AUDIT.md'))
+            || await (0, fs_extra_1.pathExists)((0, path_1.join)(overviewDir, 'DATA_FLOW.md'));
+        if (hasExtTech)
+            completedSubLayers.push('4c');
+        // 4d: 各端技术文档
+        try {
+            const platformsDir = (0, path_1.join)(globalDir, 'platforms');
+            const entries = await (0, fs_extra_2.readdir)(platformsDir, { withFileTypes: true });
+            const platformDirs = entries.filter(e => e.isDirectory() && e.name !== '_shared').map(e => e.name);
+            const hasPlatformDoc = platformDirs.length > 0 && (await Promise.all(platformDirs.map(async (d) => (0, fs_extra_1.pathExists)((0, path_1.join)(platformsDir, d, 'API_INVENTORY.md'))
+                || (0, fs_extra_1.pathExists)((0, path_1.join)(platformsDir, d, 'UI_FLOW.md'))))).some(Boolean);
+            if (hasPlatformDoc)
+                completedSubLayers.push('4d');
+        }
+        catch { /* ignore */ }
+        if (completedSubLayers.length === 4) {
+            completedLayer = 4;
+        }
+        else {
+            const subLayerOrder = ['4a', '4b', '4c', '4d'];
+            const nextSub = subLayerOrder.find(s => !completedSubLayers.includes(s)) || '4d';
+            missing.push(`Layer 4${nextSub}: 全局汇总文档子层`);
+            subLayer = { completed: completedSubLayers, next: nextSub };
+        }
+    }
+    return { completedLayer, nextLayer: Math.min(completedLayer + 1, 4), missing, subLayer };
+}
+// ── v7.2.0+: 全局分析下一步引导 ──
+async function buildGlobalAnalysisGuide(options) {
+    const progress = await detectGlobalLayerProgress();
+    const { completedLayer, nextLayer, subLayer } = progress;
+    const deepDoc = options?.deep;
+    let guide = '';
+    // 进度条
+    const layers = ['Layer 1 索引扫描', 'Layer 2 跨端关联', 'Layer 3 模块深入', 'Layer 4 全局汇总'];
+    guide += `\n📊 全局分析进度: ${completedLayer}/4 层完成\n`;
+    guide += layers.map((l, i) => {
+        const status = i < completedLayer ? '✅' : i === completedLayer ? '▶️' : '⬜';
+        return `   ${status} ${l}`;
+    }).join('\n');
+    guide += '\n';
+    if (completedLayer === 4 && (!subLayer || subLayer.completed.length === 4)) {
+        guide += '\n🎉 全局分析全部完成！\n';
+        guide += '   所有文档已生成在 .speccore/GLOBAL/ 目录\n';
+        guide += '   如需补充某份文档: speccore analyze --scope global --layer 4 --deep <文档名>\n';
+        return guide;
+    }
+    // 下一步命令
+    guide += '\n➡️  下一步:\n';
+    if (deepDoc && options?.iterative) {
+        const outlinePath = (0, path_1.join)(process.cwd(), '.speccore', 'cache', `deep-outline-${deepDoc.replace(/\//g, '-')}.md`);
+        const hasOutline = await (0, fs_extra_1.pathExists)(outlinePath);
+        if (!hasOutline) {
+            guide += `   1. 将 AI 输出的大纲保存到: ${outlinePath}\n`;
+            guide += `   2. 审核/修改大纲\n`;
+            guide += `   3. 再次执行: speccore analyze --scope global --layer 4 --deep ${deepDoc} --iterative\n`;
+        }
+        else {
+            guide += `   1. 将 AI 输出的本节内容追加到文档\n`;
+            guide += `   2. 继续下一节: speccore analyze --scope global --layer 4 --deep ${deepDoc} --iterative\n`;
+        }
+    }
+    else if (deepDoc) {
+        guide += `   speccore analyze --scope global --layer 4 --deep ${deepDoc}\n`;
+        guide += `   （如需迭代式补全: 加 --iterative 参数）\n`;
+    }
+    else if (nextLayer === 4 && subLayer) {
+        const subNames = {
+            '4a': '产品视角文档（requirements/）',
+            '4b': '全局技术核心文档（overview/）',
+            '4c': '全局技术扩展文档（overview/）',
+            '4d': '各端技术文档（platforms/）',
+        };
+        guide += `   speccore analyze --scope global --layer 4\n`;
+        guide += `   （即将生成: ${subNames[subLayer.next] || subLayer.next}）\n`;
+    }
+    else {
+        guide += `   speccore analyze --scope global --layer ${nextLayer}\n`;
+    }
+    // 快捷命令提示
+    guide += '\n💡 快捷命令:\n';
+    guide += `   查看进度: speccore status\n`;
+    if (completedLayer >= 3) {
+        guide += `   深度分析单文档: speccore analyze --scope global --layer 4 --deep ARCHITECTURE.md\n`;
+    }
+    guide += `   全量重新分析: speccore analyze --scope global --with-code\n`;
+    return guide;
+}
 // ── buildMultiDocPrompt: 多文档协议 ──
 async function buildMultiDocPrompt(command, ctx, options) {
     const iter = ctx.iteration || '当前迭代';
@@ -1667,21 +1845,78 @@ async function buildMultiDocPrompt(command, ctx, options) {
         if (ctx.withCode && (options?.streaming || options?.streamingPhase)) {
             return buildStreamingGlobalPrompt(command, ctx, options);
         }
+        // v7.2.0+: 全局分析分层执行 — 检测当前进度，自动分配 layer
+        const progress = await detectGlobalLayerProgress();
+        const targetLayer = options?.layer || progress.nextLayer;
+        const isLayered = !!options?.layer || progress.completedLayer < 4;
+        // v7.2.0+: 结构化代码数据提取 — Layer 1 之前自动执行
+        let structuredDataHint = '';
+        if (targetLayer === 1 && ctx.withCode) {
+            try {
+                // 读取 CONSTITUTION.md 获取源码路径
+                const constitutionPath = (0, path_1.join)(process.cwd(), '.speccore', 'CONSTITUTION.md');
+                let sourcePaths = ['src'];
+                if (await (0, fs_extra_1.pathExists)(constitutionPath)) {
+                    const content = await (0, fs_extra_2.readFile)(constitutionPath, 'utf-8');
+                    const match = content.match(/源码路径[\s\S]*?\n\s*-\s*`?([^`\n]+)`?/g);
+                    if (match) {
+                        sourcePaths = match.map(m => m.replace(/.*-\s*`?/, '').replace(/`?$/, '').trim()).filter(Boolean);
+                    }
+                }
+                await (0, structured_extractor_1.extractStructuredData)(process.cwd(), sourcePaths);
+                structuredDataHint = '\n> 📊 **结构化数据**: 已提取到 `.speccore/cache/structured-data.json`，包含 API/Entity/Route/Component 清单\n';
+            }
+            catch (e) {
+                logger_1.logger.warn(`   ⚠️ 结构化数据提取失败: ${e.message}`);
+            }
+        }
+        // Layer 角色定义
+        const LAYER_ROLES = {
+            1: { role: '代码索引专家', focus: '全面扫描各端源码结构，提取目录/接口/实体/配置等索引信息', output: '各端 _INDEX.md + PATTERNS 模式提取 + semantic-tags.json' },
+            2: { role: '系统架构师', focus: '基于 Layer 1 索引进行跨端关联分析、接口匹配、模块聚类', output: '_ASSOCIATION.md + _MODULES.md' },
+            3: { role: '业务分析师', focus: '按功能模块深入分析业务逻辑、数据流、规则、时序', output: '各端功能模块深入文档 + 模块级 PATTERNS' },
+            4: { role: '产品总监 + 技术负责人', focus: '全局汇总，分 4 个子层执行（4a产品→4b技术核心→4c技术扩展→4d各端）', output: 'requirements/ + overview/ + platforms/' },
+        };
+        const layerMeta = LAYER_ROLES[targetLayer];
         let prompt = `\n# 任务: ${command} (全局分析${ctx.withCode ? '+源码' : ''})\n\n`;
+        // v7.2.0+: 分层专注指令 — 强烈约束 AI 只执行当前 layer
+        prompt += `## 🎯 当前执行层级: Layer ${targetLayer}/4 — ${layerMeta.role}\n\n`;
+        prompt += `> ⚠️ **重要约束**: 你当前只需要完成 **Layer ${targetLayer}** 的工作。不要提前做后续层的内容。\n`;
+        prompt += `> 每层完成后通过 \`speccore analyze --scope global --layer ${targetLayer + 1 <= 4 ? targetLayer + 1 : 4}\` 进入下一层。\n\n`;
+        prompt += `| 层级 | 角色 | 核心任务 | 产出物 |\n`;
+        prompt += `| :--- | :--- | :--- | :--- |\n`;
+        prompt += `| 1 | 代码索引专家 | 扫描源码结构，提取索引 | platforms/{端}/_INDEX.md |\n`;
+        prompt += `| 2 | 系统架构师 | 跨端关联、接口匹配、模块聚类 | platforms/_shared/_ASSOCIATION.md + _MODULES.md |\n`;
+        prompt += `| 3 | 业务分析师 | 功能模块深入分析 | 各端功能模块文档 |\n`;
+        prompt += `| 4 | 产品总监+技术负责人 | 全局汇总、需求总纲、一致性校验 | overview/ + requirements/ |\n\n`;
+        if (progress.completedLayer > 0) {
+            prompt += `📊 检测进度: 已完成 Layer ${progress.completedLayer}/4`;
+            if (progress.missing.length > 0) {
+                prompt += `，待补齐: ${progress.missing.join('; ')}`;
+            }
+            prompt += `\n\n`;
+        }
+        prompt += `## 你的专注任务（Layer ${targetLayer}）\n`;
+        prompt += `- **角色**: ${layerMeta.role}\n`;
+        prompt += `- **核心任务**: ${layerMeta.focus}\n`;
+        prompt += `- **预期产出**: ${layerMeta.output}\n\n`;
         prompt += `## 要求\n`;
-        prompt += `1. **先读宪法**: Read .speccore/CONSTITUTION.md，这是项目配置的唯一权威来源。获取:\n`;
-        prompt += `   - 「工程」列 → 所有工程名（如 meeting-system, booking-service）\n`;
-        prompt += `   - 「源码路径」列 → 各工程的代码目录（用于 Read 源码）\n`;
-        prompt += `   - 「## 端列表」章节 → 全局权威端名列表（如 backend/h5/admin）\n`;
-        prompt += `   - 每个工程独立分析，文档输出到: .speccore/GLOBAL/platforms/{端名}/\n`;
-        prompt += `2. Read .speccore/GLOBAL/ 下所有文档了解跨项目需求\n`;
-        prompt += `3. **禁止行为（重要）**: 不要打开浏览器、不要模拟用户操作、不要访问 URL。所有分析必须基于直接 Read 源码文件完成。如果文件不存在，跳过即可，不要尝试其他方式获取。\n`;
+        prompt += `1. **先读宪法**: Read .speccore/CONSTITUTION.md，获取工程名、源码路径、端列表。\n`;
+        prompt += `2. Read .speccore/GLOBAL/ 下已有文档（特别是前一层的产物）作为输入。\n`;
+        prompt += `3. **禁止行为**: 不要打开浏览器、不要模拟用户操作、不要访问 URL。所有分析基于直接 Read 源码。\n`;
         if (ctx.withCode) {
-            // v6.71.2+: 双层扫描 + 功能模块驱动（替代原来的按端顺序分析）
-            prompt += `4. 从 CONSTITUTION.md 的「源码路径」列读取所有工程目录\n`;
-            prompt += `\n## 📊 Layer 1: 快速扫描所有端（并行，只提取索引）\n\n`;
-            prompt += `对每个端，读取关键索引文件和配置，提取全面索引（不深入代码逻辑）：\n\n`;
-            prompt += `**后端端扫描维度（10项）**：\n`;
+            prompt += `4. 从 CONSTITUTION.md 的「源码路径」列读取所有工程目录。\n`;
+        }
+        // 根据 targetLayer 注入对应的专注内容
+        if (targetLayer === 1) {
+            prompt += `\n## 📊 Layer 1: 快速扫描所有端（基于结构化数据生成索引）\n\n`;
+            prompt += `${structuredDataHint}`;
+            prompt += `**重要**: 不要直接扫描源码文件。已使用代码扫描工具提取了结构化数据，你只需要读取这些数据并整理成 _INDEX.md。\n\n`;
+            prompt += `**步骤**: \n`;
+            prompt += `1. Read \`.speccore/cache/structured-data.json\` — 获取所有端的 API/Entity/Route/Component 清单\n`;
+            prompt += `2. 对每个端，基于结构化数据生成 \`_INDEX.md\`（补充扫描工具未覆盖的内容）\n`;
+            prompt += `3. 扫描工具未覆盖的维度（消息队列、定时任务、配置、外部集成、日志监控、错误处理），需要 Read 相关配置文件补充\n\n`;
+            prompt += `**后端端 _INDEX.md 维度（基于 structured-data.json + 补充扫描）**：\n`;
             prompt += `| 扫描项 | 读取位置 | 提取内容 |\n`;
             prompt += `| :--- | :--- | :--- |\n`;
             prompt += `| 接口层 | Controller/Handler/Resource 目录 | 接口类名、接口路径（从注解/装饰器推断）、鉴权注解 |\n`;
@@ -1710,7 +1945,51 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `| 性能 | 搜索性能相关代码（懒加载/虚拟滚动/缓存/预加载） | 优化手段、适用场景 |\n\n`;
             prompt += `**输出**：每个端一个 \`_INDEX.md\`，按上述维度组织，只含名称和路径列表，不含详细逻辑\n`;
             prompt += `**存放**：\`.speccore/GLOBAL/platforms/{端名}/_INDEX.md\`\n\n`;
-            prompt += `## 🔗 Layer 2: 跨端关联分析（基于 Layer 1 的索引）\n\n`;
+            prompt += `### Layer 1 附加任务：提取可复用模式（PATTERNS）\n`;
+            prompt += `在扫描每个端时，同时识别该端的可复用设计模式，写入 \`.speccore/PATTERNS/\`。这是跨迭代复用的核心资产。\n\n`;
+            prompt += `**后端端模式提取维度（6类）**：\n`;
+            prompt += `| 模式类型 | 扫描位置 | 提取内容 | 存放路径 |\n`;
+            prompt += `| :--- | :--- | :--- | :--- |\n`;
+            prompt += `| 架构模式 | 项目结构、模块划分 | 分层架构、目录约定、模块组织方式 | \`PATTERNS/{端名}/architecture/\` |\n`;
+            prompt += `| 数据模型模式 | Entity/Model/Schema | 通用字段设计（软删除、多租户、审计字段）、关联模式 | \`PATTERNS/{端名}/data-model/\` |\n`;
+            prompt += `| API 契约模式 | Controller/Handler | 统一响应格式、分页模式、错误包装、鉴权装饰器 | \`PATTERNS/{端名}/api-contract/\` |\n`;
+            prompt += `| 安全模式 | 鉴权/校验/加密代码 | JWT/RBAC 实现、输入校验策略、敏感数据处理 | \`PATTERNS/{端名}/security/\` |\n`;
+            prompt += `| 性能模式 | 缓存/批量/异步代码 | 缓存策略、批量查询、异步处理、连接池配置 | \`PATTERNS/{端名}/performance/\` |\n`;
+            prompt += `| 工具/中间件 | utils/middleware 目录 | 可复用的工具函数、通用中间件、拦截器 | \`PATTERNS/{端名}/utils/\` |\n`;
+            prompt += `**前端端模式提取维度（6类）**：\n`;
+            prompt += `| 模式类型 | 扫描位置 | 提取内容 | 存放路径 |\n`;
+            prompt += `| :--- | :--- | :--- | :--- |\n`;
+            prompt += `| 组件模式 | components/ui 目录 | 高复用组件、复合组件、设计 token 使用 | \`PATTERNS/{端名}/components/\` |\n`;
+            prompt += `| Hooks 模式 | hooks/composables 目录 | 可复用逻辑抽离、状态封装、生命周期管理 | \`PATTERNS/{端名}/hooks/\` |\n`;
+            prompt += `| 状态管理模式 | store/pinia/vuex/redux | 状态切片设计、actions 组织、持久化策略 | \`PATTERNS/{端名}/state/\` |\n`;
+            prompt += `| 路由/导航模式 | router/routes 配置 | 路由守卫、权限路由、动态路由、面包屑 | \`PATTERNS/{端名}/routing/\` |\n`;
+            prompt += `| 请求/拦截模式 | API 调用封装 | 请求封装、错误处理、重试策略、缓存策略 | \`PATTERNS/{端名}/api-client/\` |\n`;
+            prompt += `| 布局/样式模式 | layouts/themes 目录 | 布局组件、响应式策略、主题切换、CSS 架构 | \`PATTERNS/{端名}/layout/\` |\n`;
+            prompt += `**跨端通用模式**：如果某模式在 2+ 端出现，优先写入通用分类（如 \`PATTERNS/architecture/\`），端差异用段落标注。\n`;
+            prompt += `**写入方式**：使用 \`PATTERNS/{端名}/{分类}/{kebab-case模式名}.md\` 作为文件名。\n\n`;
+            prompt += `### Layer 1 附加任务：提取语义级节点标签（SEMANTIC TAGS）\n`;
+            prompt += `在扫描每个端时，同时提取语义标签，写入 \`.speccore/cache/semantic-tags.json\`。这是知识图谱理解代码意图的关键资产。\n\n`;
+            prompt += `**提取规则（本地解析，零 Token 消耗）**：\n`;
+            prompt += `| 提取源 | 提取内容 | 示例 |\n`;
+            prompt += `| :--- | :--- | :--- |\n`;
+            prompt += `| JSDoc/TSDoc 注释 | 函数/类的 @description、@summary | \`用户认证入口，处理登录/注册/登出\` |\n`;
+            prompt += `| 文件头注释 | 文件顶部的多行注释 | \`会议室预订服务的核心业务逻辑层\` |\n`;
+            prompt += `| 文件名推断 | 文件名关键词映射到业务域 | auth → 认证授权, order → 订单交易 |\n`;
+            prompt += `| 导出名称推断 | 类名后缀推断角色 | XxxController → 接口控制器, XxxService → 业务服务 |\n`;
+            prompt += `| 目录结构推断 | 文件所在目录映射到模块 | src/user/ → 用户管理, src/order/ → 订单交易 |\n\n`;
+            prompt += `**输出格式**：JSON 数组，每个文件一条记录\n`;
+            prompt += `\`\`\`json\n`;
+            prompt += `[\n`;
+            prompt += `  {\n`;
+            prompt += `    "file": "backend/src/auth/AuthController.ts",\n`;
+            prompt += `    "semanticTags": ["认证授权", "用户管理"],\n`;
+            prompt += `    "description": "用户认证控制器，处理登录/注册/Token刷新",\n`;
+            prompt += `    "businessRole": "接口控制器"\n`;
+            prompt += `  }\n`;
+            prompt += `]\n`;
+            prompt += `\`\`\`\n\n`;
+            prompt += `## 🔗 Layer 2: 跨端关联分析（基于 Layer 1 索引 + structured-data.json）\n\n`;
+            prompt += `> 📊 **结构化数据**: Read \`.speccore/cache/structured-data.json\` 获取 API/Entity 清单，与 Layer 1 索引交叉验证\n\n`;
             prompt += `1. **匹配前后端接口**：\n`;
             prompt += `   - 前端 \`_INDEX.md\` 中的 API 调用路径 vs 后端 \`_INDEX.md\` 中的接口路径\n`;
             prompt += `   - **匹配上** → 建立「前端页面 → 前端 API 调用 → 后端接口 → 后端服务」链路\n`;
@@ -1744,7 +2023,10 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `   - 每个功能模块标注：涉及端、核心页面、核心接口、实体名称、消息队列\n\n`;
             prompt += `**输出**：\n`;
             prompt += `- \`_ASSOCIATION.md\`：前后端关联矩阵 + 接口缺口/未使用接口清单 + 消息流链路 + 定时任务影响 + 外部集成分布 + 配置一致性风险\n`;
+            prompt += `  - 此文档中必须包含 **模块关系 Mermaid 图**（graph LR），展示各功能模块间的依赖关系\n`;
+            prompt += `  - 此文档中必须包含 **接口依赖 Mermaid 图**（graph TD），展示前端页面 → 后端接口的调用关系\n`;
             prompt += `- \`_MODULES.md\`：功能模块候选清单（从源码聚类，含消息/定时任务维度，供 Layer 3 验证）\n`;
+            prompt += `  - 此文档中必须包含 **模块全景 Mermaid 图**（graph LR），展示所有功能模块及其所属端\n`;
             prompt += `**存放**：\`.speccore/GLOBAL/platforms/_shared/\`\n\n`;
             prompt += `## 🔍 Layer 3: 按功能模块深入分析（不是按端）\n\n`;
             prompt += `基于 Layer 2 的 \`_MODULES.md\`，逐个功能模块深入分析。\n`;
@@ -1760,7 +2042,29 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `- 后端端：该功能模块相关的 API 详细设计、数据模型、业务规则、安全策略\n`;
             prompt += `- 前端端：该功能模块相关的页面详细设计、交互流程、字段映射、错误处理\n`;
             prompt += `- 跨端：该功能模块的交互时序图（含异步消息链路，供 Layer 4 汇总到 INTERACTION_MAP.md）\n`;
+            prompt += `  - 时序图用 **Mermaid sequenceDiagram** 语法嵌入到分析文档中\n`;
+            prompt += `  - 关键操作流程用 **Mermaid flowchart** 语法嵌入到分析文档中\n`;
+            prompt += `  - 状态流转用 **Mermaid stateDiagram** 语法嵌入到分析文档中\n`;
             prompt += `- 跨端：该功能模块涉及的外部集成清单（第三方 API、消息队列、定时任务）\n\n`;
+            prompt += `### Layer 3 附加任务：功能模块级模式提取（PATTERNS）\n`;
+            prompt += `每个功能模块分析完成后，提取该模块的可复用模式，补充到 \`.speccore/PATTERNS/\`。\n\n`;
+            prompt += `**提取维度**：\n`;
+            prompt += `- **跨端交互模式**：该模块的前后端交互方式是否有代表性（如表单提交+乐观更新、轮询刷新、WebSocket 实时推送）\n`;
+            prompt += `- **业务规则模式**：该模块的业务规则是否有通用性（如审批流程、库存扣减、权限校验）\n`;
+            prompt += `- **数据流模式**：该模块的数据流转是否有代表性（如缓存更新策略、数据同步机制、离线优先）\n`;
+            prompt += `- **UI 交互模式**：该模块的页面交互是否有复用价值（如列表筛选、表单校验、弹窗确认、拖拽排序）\n`;
+            prompt += `- **错误处理模式**：该模块的错误场景处理是否有代表性（如网络失败重试、权限不足提示、数据冲突解决）\n\n`;
+            prompt += `**存放规则**：\n`;
+            prompt += `- 单端模式 → \`PATTERNS/{端名}/{分类}/{模块名}-{模式类型}.md\`\n`;
+            prompt += `- 跨端模式 → \`PATTERNS/{分类}/{模块名}-{模式类型}.md\`（不绑定端）\n`;
+            prompt += `- 示例：\`PATTERNS/h5-mobile/components/booking-form-validation.md\`、\`PATTERNS/architecture/optimistic-update-pattern.md\`\n\n`;
+            prompt += `### Layer 3 附加任务：功能模块语义标注\n`;
+            prompt += `每个功能模块分析完成后，为该模块涉及的核心代码文件生成语义标注，追加到 \`semantic-tags.json\`。\n\n`;
+            prompt += `**标注维度**：\n`;
+            prompt += `- **业务功能标签**：该文件在功能模块中承担什么职责（如「表单提交校验」、「状态机驱动」、「数据持久化」）\n`;
+            prompt += `- **交互角色标签**：该文件在跨端交互中扮演什么角色（如「请求发起者」、「事件生产者」、「状态同步者」）\n`;
+            prompt += `- **数据流标签**：该文件处理的数据类型（如「用户输入数据」、「配置数据」、「缓存数据」、「消息事件」）\n`;
+            prompt += `- **质量标签**：该文件的代码特征（如「高复用」、「核心业务」、「边界处理」、「性能敏感」）\n\n`;
             prompt += `## 🌍 Layer 4: 全局汇总（所有功能模块分析完成后）\n\n`;
             prompt += `1. **一致性校验**：\n`;
             prompt += `   - 前端字段 vs 后端字段是否一致（名称、类型、必填性、校验规则）\n`;
@@ -1770,23 +2074,42 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `   - 消息孤儿清单（无消费者/无生产者的队列）\n`;
             prompt += `   - 配置不一致清单（超时/重试/限流各端差异）\n`;
             prompt += `   → 输出 \`CONSISTENCY_CHECK.md\`\n\n`;
-            prompt += `2. **生成全局文档**（按视角分离存放，v6.81.0+）：\n`;
-            prompt += `   **产品视角 → 存放到 .speccore/GLOBAL/requirements/：**\n`;
-            prompt += `   - \`requirements/REQUIREMENT.md\`：全局功能清单（按业务场景组织，产品视角）\n`;
-            prompt += `   - \`requirements/{前端端}/REQUIREMENT.md\`：各前端端的产品视角需求（页面+交互+用户旅程）\n`;
+            prompt += `2. **生成全局文档**（按视角分离存放，v6.98.0+）：\n`;
+            prompt += `   **产品视角 → 存放到 .speccore/GLOBAL/requirements/（以专业产品角色撰写，v6.99.0+）：**\n`;
+            prompt += `   - \`requirements/REQUIREMENT.md\`：全局需求总纲（产品总监视角，按业务场景/用户旅程组织）\n`;
+            prompt += `     - 必须包含：产品愿景、目标用户画像、核心场景地图、功能全景图\n`;
+            prompt += `     - 按业务场景组织章节，每个场景：用户故事 → 操作流程 → 业务规则 → 边界条件 → 验收标准\n`;
+            prompt += `     - 包含功能优先级矩阵（P0/P1/P2）、发布里程碑、风险预判\n`;
+            prompt += `     - 包含与竞品的差异化分析（如有）、数据埋点需求、运营需求\n`;
+            prompt += `     - 不要写技术实现细节，不要按端分章节\n`;
+            prompt += `   - \`requirements/{前端端}/REQUIREMENT.md\`：各前端端的产品视角需求（前端产品经理视角）\n`;
             prompt += `     - 前端端示例: requirements/admin-web/REQUIREMENT.md, requirements/h5-mobile/REQUIREMENT.md\n`;
-            prompt += `     - 每个前端端需求目录下可放 images/（截图/流程图）和 prototypes/（原型文件）\n`;
-            prompt += `   **技术视角 → 存放到 .speccore/GLOBAL/ 根目录：**\n`;
-            prompt += `   - \`FUNCTION_MAP.md\`：功能单元 × 端映射表\n`;
-            prompt += `   - \`INTERACTION_MAP.md\`：跨端交互时序图（含同步 API + 异步消息，从 Layer 3 汇总）\n`;
-            prompt += `   - \`API_CONTRACT.yaml\`：全局接口契约（汇总所有后端 API_INVENTORY，含 rate limit、幂等性、版本策略）\n`;
-            prompt += `   - \`ARCHITECTURE.md\`：全局架构文档（服务拓扑、数据流、部署关系、容错设计、降级策略、扩容方案）\n`;
-            prompt += `   - \`SECURITY_AUDIT.md\`：全局安全审计（鉴权策略矩阵、敏感数据流、攻击面分析、CVE 清单、合规检查）\n`;
-            prompt += `   - \`PERFORMANCE_BASELINE.md\`：性能基线（慢查询清单、缓存策略矩阵、并发承载评估、关键路径耗时）\n`;
-            prompt += `   - \`DATA_FLOW.md\`：数据流与隐私分析（PII 识别与追踪、数据生命周期、存储/传输/归档策略、GDPR 合规检查）\n`;
-            prompt += `   - \`EXTERNAL_INTEGRATIONS.md\`：外部集成审计（第三方服务清单、SDK 版本与风险、Webhook 接收分布、重复集成识别）\n`;
-            prompt += `   - \`DEPLOYMENT.md\`：部署运维分析（容器化状态、CI/CD 流水线、健康检查端点、环境配置差异、日志聚合方案）\n`;
-            prompt += `   - \`OBSERVABILITY.md\`：可观测性分析（日志链路追踪、错误码体系、监控埋点清单、告警策略、SLA 定义）\n\n`;
+            prompt += `     - **信息架构**：页面层级结构、导航关系、面包屑、路由映射\n`;
+            prompt += `     - **用户旅程**：从入口到完成目标的完整流程，标注关键决策点、情绪曲线\n`;
+            prompt += `     - **页面清单**：每页含页面名称、URL/路由、核心功能、进入条件、离开条件\n`;
+            prompt += `     - **交互设计**：表单填写流程、列表操作、搜索筛选、分页/无限滚动、弹窗/抽屉\n`;
+            prompt += `     - **状态与反馈**：加载状态、空状态、错误状态、成功反馈、操作确认\n`;
+            prompt += `     - **权限与角色**：各角色可见页面/可操作按钮/数据范围\n`;
+            prompt += `     - **响应式/适配策略**：不同设备尺寸下的布局变化、断点设计\n`;
+            prompt += `     - **无障碍要求**：键盘导航、屏幕阅读器、色彩对比度（如有要求）\n`;
+            prompt += `     - 每个前端端需求目录下可放 images/（截图/流程图/原型图）和 prototypes/（可交互原型文件）\n`;
+            prompt += `   **技术视角 → 存放到 .speccore/GLOBAL/overview/（不与 platforms/requirements 平级）：**\n`;
+            prompt += `   - \`overview/FUNCTION_MAP.md\`：功能单元 × 端映射表\n`;
+            prompt += `   - \`overview/INTERACTION_MAP.md\`：跨端交互时序图（含同步 API + 异步消息，从 Layer 3 汇总）\n`;
+            prompt += `     - 必须包含 **Mermaid sequenceDiagram**，展示各端之间的核心交互时序\n`;
+            prompt += `   - \`overview/API_CONTRACT.yaml\`：全局接口契约（汇总所有后端 API_INVENTORY，含 rate limit、幂等性、版本策略）\n`;
+            prompt += `   - \`overview/ARCHITECTURE.md\`：全局架构文档（服务拓扑、数据流、部署关系、容错设计、降级策略、扩容方案）\n`;
+            prompt += `     - 必须包含 **Mermaid architecture diagram**（graph TB），展示服务拓扑和部署关系\n`;
+            prompt += `     - 必须包含 **Mermaid graph LR**，展示模块间的依赖关系\n`;
+            prompt += `   - \`overview/SECURITY_AUDIT.md\`：全局安全审计（鉴权策略矩阵、敏感数据流、攻击面分析、CVE 清单、合规检查）\n`;
+            prompt += `   - \`overview/PERFORMANCE_BASELINE.md\`：性能基线（慢查询清单、缓存策略矩阵、并发承载评估、关键路径耗时）\n`;
+            prompt += `   - \`overview/DATA_FLOW.md\`：数据流与隐私分析（PII 识别与追踪、数据生命周期、存储/传输/归档策略、GDPR 合规检查）\n`;
+            prompt += `     - 必须包含 **Mermaid flowchart**，展示数据从产生到销毁的完整生命周期\n`;
+            prompt += `   - \`overview/EXTERNAL_INTEGRATIONS.md\`：外部集成审计（第三方服务清单、SDK 版本与风险、Webhook 接收分布、重复集成识别）\n`;
+            prompt += `   - \`overview/DEPLOYMENT.md\`：部署运维分析（容器化状态、CI/CD 流水线、健康检查端点、环境配置差异、日志聚合方案）\n`;
+            prompt += `     - 必须包含 **Mermaid flowchart**，展示 CI/CD 流水线流程\n`;
+            prompt += `   - \`overview/OBSERVABILITY.md\`：可观测性分析（日志链路追踪、错误码体系、监控埋点清单、告警策略、SLA 定义）\n`;
+            prompt += `   - \`overview/CONSISTENCY_CHECK.md\`：一致性校验报告（字段/状态/接口/消息/配置）\n\n`;
             prompt += `3. **生成各端详细文档**（技术视角，从 Layer 3 汇总）：\n`;
             prompt += `   > 存放: .speccore/GLOBAL/platforms/{端名}/\n`;
             prompt += `   **后端端（9项）**：\n`;
@@ -1873,6 +2196,43 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `   - 文件已存在 → 读取旧内容 → 在末尾追加新发现的变体（用 \`---\` 分隔）\n`;
             prompt += `   - 文件不存在 → 直接 Write 新文件\n\n`;
             prompt += `5. 以上文档输出到 .speccore/GLOBAL/ 和 .speccore/PATTERNS/，使用 Write 工具写入\n`;
+            prompt += `\n`;
+            prompt += `## 📊 图表生成规范（v7.0.0+）\n`;
+            prompt += `全局分析必须生成丰富的可视化图表，帮助开发者直观理解系统结构和数据流。\n\n`;
+            prompt += `### Mermaid 图表语法要求\n`;
+            prompt += `所有图表使用标准 Mermaid 语法，嵌入到对应 Markdown 文档的代码块中：\n`;
+            prompt += `\`\`\`mermaid\n`;
+            prompt += `graph LR\n`;
+            prompt += `    A[前端页面] -->|调用| B[后端接口]\n`;
+            prompt += `    B --> C[数据库]\n`;
+            prompt += `\`\`\`\n\n`;
+            prompt += `### 各层级必须生成的图表\n`;
+            prompt += `| 层级 | 文档 | 图表类型 | Mermaid 语法 | 内容 |\n`;
+            prompt += `| :--- | :--- | :--- | :--- | :--- |\n`;
+            prompt += `| Layer 2 | _ASSOCIATION.md | 模块关系图 | graph LR / graph TD | 功能模块间的依赖关系、接口调用链路 |\n`;
+            prompt += `| Layer 2 | _MODULES.md | 模块全景图 | graph LR | 所有功能模块及所属端 |\n`;
+            prompt += `| Layer 3 | 功能模块文档 | 时序图 | sequenceDiagram | 跨端交互时序（请求→处理→响应→推送） |\n`;
+            prompt += `| Layer 3 | 功能模块文档 | 流程图 | flowchart TD | 关键业务流程（如下单、审批、支付） |\n`;
+            prompt += `| Layer 3 | 功能模块文档 | 状态图 | stateDiagram-v2 | 实体状态流转（如订单状态机） |\n`;
+            prompt += `| Layer 4 | INTERACTION_MAP.md | 交互时序图 | sequenceDiagram | 全系统核心跨端交互时序 |\n`;
+            prompt += `| Layer 4 | ARCHITECTURE.md | 架构拓扑图 | graph TB | 服务拓扑、部署关系 |\n`;
+            prompt += `| Layer 4 | ARCHITECTURE.md | 依赖关系图 | graph LR | 模块间依赖关系 |\n`;
+            prompt += `| Layer 4 | DATA_FLOW.md | 数据流图 | flowchart LR | 数据生命周期（产生→传输→存储→归档→销毁） |\n`;
+            prompt += `| Layer 4 | DEPLOYMENT.md | CI/CD 流程图 | flowchart LR | 从代码提交到部署的完整流水线 |\n\n`;
+            prompt += `### 图表质量要求\n`;
+            prompt += `- **节点命名**：使用中文或业务术语，不要使用文件名或类名\n`;
+            prompt += `- **边标注**：标注调用关系（如「调用」、「依赖」、「推送」、「订阅」）\n`;
+            prompt += `- **颜色区分**：用不同颜色区分端（前端=blue, 后端=green, 数据库=gray, 第三方=orange）\n`;
+            prompt += `- **层次清晰**：从上到下或从左到右按逻辑层次排列，避免交叉线过多\n`;
+            prompt += `- **聚焦核心**：不要试图把所有细节放进一张图，核心业务路径优先\n\n`;
+            prompt += `### 独立图表文件（可选但推荐）\n`;
+            prompt += `对于特别复杂的图表，除了嵌入文档外，还可以生成独立的 .mmd 文件到 \`diagrams/\` 目录：\n`;
+            prompt += `- \`diagrams/module-relationship.mmd\`：模块关系图（从 _ASSOCIATION.md 提取）\n`;
+            prompt += `- \`diagrams/architecture.mmd\`：架构拓扑图（从 ARCHITECTURE.md 提取）\n`;
+            prompt += `- \`diagrams/data-flow.mmd\`：数据流图（从 DATA_FLOW.md 提取）\n`;
+            prompt += `- \`diagrams/{模块名}-sequence.mmd\`：核心模块时序图\n`;
+            prompt += `- \`diagrams/{模块名}-flow.mmd\`：核心模块流程图\n`;
+            prompt += `独立 .mmd 文件只包含 Mermaid 代码（无 Markdown 包装），便于后续渲染为 HTML/PNG。\n`;
         }
         else {
             prompt += `4. 读取 .speccore/GLOBAL/ 下各项目需求文档，生成跨项目索引和需求目录\n`;
@@ -1886,27 +2246,27 @@ async function buildMultiDocPrompt(command, ctx, options) {
             prompt += `| _INDEX.md | Layer 1 | platforms/{端}/ | 各端全面索引（10维度扫描：接口/数据/业务/中间件/消息/定时/配置/外部/日志/错误） |\n`;
             prompt += `| _ASSOCIATION.md | Layer 2 | platforms/_shared/ | 前后端关联矩阵 + 接口缺口 + 消息流链路 + 定时任务影响 + 外部集成分布 + 配置一致性风险 |\n`;
             prompt += `| _MODULES.md | Layer 2 | platforms/_shared/ | 功能模块候选清单（含页面/接口/消息三维聚类） |\n`;
-            prompt += `\n### 需求文档（产品视角，v6.81.0+）\n`;
+            prompt += `\n### 需求文档（产品视角，v6.99.0+）\n`;
             prompt += `> 存放: .speccore/GLOBAL/requirements/（含 images/ prototypes/ 子目录）\n\n`;
             prompt += `| 文档 | 视角 | 内容 |\n`;
             prompt += `| :--- | :--- | :--- |\n`;
-            prompt += `| requirements/REQUIREMENT.md | 全局产品视角 | 全局功能清单（按业务场景组织，从功能模块汇总） |\n`;
-            prompt += `| requirements/{前端端}/REQUIREMENT.md | 前端产品视角 | 各前端端的需求（页面+交互+用户旅程+原型占位） |\n`;
-            prompt += `\n### 全局技术性文档（Layer 4 汇总生成，v6.82.0+）\n`;
-            prompt += `> 存放: .speccore/GLOBAL/ 根目录\n\n`;
+            prompt += `| requirements/REQUIREMENT.md | 产品总监视角 | 需求总纲：愿景、用户画像、场景地图、功能全景、优先级矩阵、里程碑、风险预判 |\n`;
+            prompt += `| requirements/{前端端}/REQUIREMENT.md | 前端产品经理视角 | 信息架构、用户旅程、页面清单、交互设计、状态反馈、权限角色、响应式策略 |\n`;
+            prompt += `\n### 全局技术性文档（Layer 4 汇总生成，v7.2.0+）\n`;
+            prompt += `> 存放: .speccore/GLOBAL/overview/（不与 platforms/requirements 平级）\n\n`;
             prompt += `| 文档 | 视角 | 内容 |\n`;
             prompt += `| :--- | :--- | :--- |\n`;
-            prompt += `| FUNCTION_MAP.md | 架构视角 | 功能单元 × 端映射表 |\n`;
-            prompt += `| INTERACTION_MAP.md | 架构视角 | 跨端交互时序图（同步 API + 异步消息） |\n`;
-            prompt += `| API_CONTRACT.yaml | 技术视角 | 全局接口契约（含 rate limit、幂等性、版本策略、废弃标记） |\n`;
-            prompt += `| ARCHITECTURE.md | 技术视角 | 全局架构（服务拓扑、数据流、部署关系、容错、降级、扩容） |\n`;
-            prompt += `| SECURITY_AUDIT.md | 安全视角 | 鉴权矩阵、敏感数据流、攻击面、CVE 清单、合规检查 |\n`;
-            prompt += `| PERFORMANCE_BASELINE.md | 性能视角 | 慢查询清单、缓存策略矩阵、并发承载、关键路径耗时 |\n`;
-            prompt += `| DATA_FLOW.md | 数据视角 | PII 识别追踪、数据生命周期、存储/传输/归档、GDPR 合规 |\n`;
-            prompt += `| EXTERNAL_INTEGRATIONS.md | 集成视角 | 第三方服务清单、SDK 风险、Webhook 分布、重复集成识别 |\n`;
-            prompt += `| DEPLOYMENT.md | 运维视角 | 容器化、CI/CD、健康检查、环境差异、日志聚合 |\n`;
-            prompt += `| OBSERVABILITY.md | 可观测视角 | 日志链路、错误码体系、监控埋点、告警策略、SLA |\n`;
-            prompt += `| CONSISTENCY_CHECK.md | 质量视角 | 一致性校验报告（字段/状态/接口/消息/配置） |\n`;
+            prompt += `| overview/FUNCTION_MAP.md | 架构视角 | 功能单元 × 端映射表 |\n`;
+            prompt += `| overview/INTERACTION_MAP.md | 架构视角 | 跨端交互时序图（同步 API + 异步消息） |\n`;
+            prompt += `| overview/API_CONTRACT.yaml | 技术视角 | 全局接口契约（含 rate limit、幂等性、版本策略、废弃标记） |\n`;
+            prompt += `| overview/ARCHITECTURE.md | 技术视角 | 全局架构（服务拓扑、数据流、部署关系、容错、降级、扩容） |\n`;
+            prompt += `| overview/SECURITY_AUDIT.md | 安全视角 | 鉴权矩阵、敏感数据流、攻击面、CVE 清单、合规检查 |\n`;
+            prompt += `| overview/PERFORMANCE_BASELINE.md | 性能视角 | 慢查询清单、缓存策略矩阵、并发承载、关键路径耗时 |\n`;
+            prompt += `| overview/DATA_FLOW.md | 数据视角 | PII 识别追踪、数据生命周期、存储/传输/归档、GDPR 合规 |\n`;
+            prompt += `| overview/EXTERNAL_INTEGRATIONS.md | 集成视角 | 第三方服务清单、SDK 风险、Webhook 分布、重复集成识别 |\n`;
+            prompt += `| overview/DEPLOYMENT.md | 运维视角 | 容器化、CI/CD、健康检查、环境差异、日志聚合 |\n`;
+            prompt += `| overview/OBSERVABILITY.md | 可观测视角 | 日志链路、错误码体系、监控埋点、告警策略、SLA |\n`;
+            prompt += `| overview/CONSISTENCY_CHECK.md | 质量视角 | 一致性校验报告（字段/状态/接口/消息/配置） |\n`;
             prompt += `\n### 后端端技术性文档（9项，Layer 3/4 汇总）\n`;
             prompt += `> 存放: .speccore/GLOBAL/platforms/{后端端名}/\n\n`;
             prompt += `| 文档 | 内容 |\n`;
@@ -1967,6 +2327,175 @@ async function buildMultiDocPrompt(command, ctx, options) {
         prompt += `\n⚠️ 如 CONSTITUTION.md 中「源码路径」为空或路径不存在: 提示用户先配置，给出三个选项：\n`;
         prompt += `   [1] 停止分析 → 配置后重来 | [2] 跳过源码 → 只用文档分析 | [3] 手动指定路径后继续\n`;
         prompt += '\n' + (0, questions_1.buildAutoModeInstruction)('analyze', iter) + '\n';
+        // v7.2.0+: Layer 专注指令 — 在 Prompt 末尾再次强化约束
+        prompt += `\n## 🎯 Layer ${targetLayer} 执行清单（必须逐项完成）\n\n`;
+        prompt += `> ⚠️ **再次强调**: 你只执行 Layer ${targetLayer}，不要提前做其他层。\n\n`;
+        if (targetLayer === 1) {
+            prompt += `- [ ] Read CONSTITUTION.md 获取所有端和源码路径\n`;
+            prompt += `- [ ] 对每个端扫描 10 个维度，生成 _INDEX.md\n`;
+            prompt += `- [ ] 提取可复用模式写入 PATTERNS/\n`;
+            prompt += `- [ ] 提取语义标签写入 semantic-tags.json\n`;
+            prompt += `- [ ] 写入完成后执行: \`speccore analyze --scope global --layer 2\`\n`;
+        }
+        else if (targetLayer === 2) {
+            prompt += `- [ ] Read 所有 Layer 1 生成的 _INDEX.md\n`;
+            prompt += `- [ ] 匹配前后端接口，生成关联矩阵\n`;
+            prompt += `- [ ] 识别公共服务、消息流、定时任务影响\n`;
+            prompt += `- [ ] 归纳功能模块，生成 _MODULES.md\n`;
+            prompt += `- [ ] 写入 _ASSOCIATION.md + _MODULES.md\n`;
+            prompt += `- [ ] 写入完成后执行: \`speccore analyze --scope global --layer 3\`\n`;
+        }
+        else if (targetLayer === 3) {
+            const filter = options?.filter;
+            prompt += `- [ ] Read Layer 2 的 _MODULES.md 获取功能模块清单\n`;
+            if (filter) {
+                prompt += `> 🔍 **按需分析**: 只分析与 "${filter}" 匹配的模块\n`;
+                prompt += `> 从 _MODULES.md 中筛选涉及 ${filter} 的功能模块，其他模块跳过\n`;
+            }
+            prompt += `- [ ] ${filter ? '筛选匹配的模块，逐个' : '逐个功能模块'}深入分析（读详细源码）\n`;
+            prompt += `- [ ] 每个模块生成：API 设计、数据模型、业务规则、交互时序\n`;
+            prompt += `- [ ] 时序图/流程图/状态图用 Mermaid 嵌入\n`;
+            prompt += `- [ ] 提取模块级模式补充到 PATTERNS/\n`;
+            prompt += `- [ ] 写入完成后执行: \`speccore analyze --scope global --layer 4${filter ? ' --filter ' + filter : ''}\`\n`;
+        }
+        else if (targetLayer === 4) {
+            // v7.2.0+: Layer 4 拆分子层或单文档深度分析
+            const deepDoc = options?.deep;
+            const subLayerTarget = progress.subLayer?.next || '4a';
+            if (deepDoc) {
+                // --deep 模式：单文档深度分析
+                const outlinePath = (0, path_1.join)(process.cwd(), '.speccore', 'cache', `deep-outline-${deepDoc.replace(/\//g, '-')}.md`);
+                const hasOutline = await (0, fs_extra_1.pathExists)(outlinePath);
+                if (options?.iterative && !hasOutline) {
+                    // 迭代模式第一步：输出大纲
+                    prompt += `## 🎯 Layer 4 — 单文档深度分析: ${deepDoc}（大纲阶段）\n\n`;
+                    prompt += `> ⚠️ **当前阶段**: 你只需要输出 **${deepDoc} 的文档大纲**。\n`;
+                    prompt += `> 不要写详细内容，只输出章节结构 + 每个章节的一句话说明。\n\n`;
+                    prompt += `**强制输入**: \n`;
+                    prompt += `- Read Layer 1 的所有 _INDEX.md\n`;
+                    prompt += `- Read Layer 2 的 _ASSOCIATION.md + _MODULES.md\n`;
+                    prompt += `- Read Layer 3 的功能模块深入文档\n`;
+                    prompt += `- Read \`.speccore/cache/structured-data.json\`（API/Entity 结构化数据）\n\n`;
+                    prompt += `**输出格式**: \n`;
+                    prompt += `\`\`\`markdown\n`;
+                    prompt += `# ${deepDoc.replace('.md', '')}\n`;
+                    prompt += `\n`;
+                    prompt += `## 1. 章节标题\n`;
+                    prompt += `> 一句话说明该章节内容\n`;
+                    prompt += `\n`;
+                    prompt += `## 2. 章节标题\n`;
+                    prompt += `> 一句话说明该章节内容\n`;
+                    prompt += `\`\`\`\n\n`;
+                    prompt += `**下一步**: 大纲输出后，用户会审核修改，然后执行 \`speccore analyze --scope global --layer 4 --deep ${deepDoc} --iterative\` 进入逐节填充阶段。\n`;
+                }
+                else if (options?.iterative && hasOutline) {
+                    // 迭代模式第二步：根据大纲逐节填充
+                    const outlineContent = await (0, fs_extra_2.readFile)(outlinePath, 'utf-8');
+                    prompt += `## 🎯 Layer 4 — 单文档深度分析: ${deepDoc}（逐节填充阶段）\n\n`;
+                    prompt += `> ⚠️ **当前阶段**: 根据已确认的大纲，逐节填充详细内容。\n`;
+                    prompt += `> 每次只填充 **一节**，确保深度和质量。\n\n`;
+                    prompt += `**已确认大纲**: \n`;
+                    prompt += outlineContent.slice(0, 2000); // 限制长度
+                    prompt += `\n\n`;
+                    prompt += `**强制输入**: \n`;
+                    prompt += `- Read Layer 1-3 的所有产物\n`;
+                    prompt += `- Read \`.speccore/cache/structured-data.json\`\n`;
+                    prompt += `- 如涉及代码细节，Read 相关源码文件\n\n`;
+                    prompt += `**深度要求**: \n`;
+                    prompt += `- 不要写"待导入"、"待补充"等占位内容\n`;
+                    prompt += `- 每个表格必须有真实数据\n`;
+                    prompt += `- 每个结论必须有证据（引用文件名/类名/方法名）\n`;
+                    prompt += `- 必须包含 Mermaid 图表（如适用）\n\n`;
+                    prompt += `**输出**: 只输出当前节的完整内容（不是整份文档）\n`;
+                }
+                else {
+                    // 非迭代模式：一次性输出完整文档
+                    prompt += `## 🎯 Layer 4 — 单文档深度分析: ${deepDoc}\n\n`;
+                    prompt += `> ⚠️ **专注约束**: 你只生成 **${deepDoc}** 这一份文档，不要生成其他文档。\n`;
+                    prompt += `> 你必须深入分析，不要写框架/占位符。每节必须有实质性内容。\n\n`;
+                    prompt += `**强制输入**: \n`;
+                    prompt += `- Read Layer 1 的所有 _INDEX.md（获取源码结构索引）\n`;
+                    prompt += `- Read Layer 2 的 _ASSOCIATION.md + _MODULES.md（获取跨端关联）\n`;
+                    prompt += `- Read Layer 3 的功能模块深入文档（获取详细分析结果）\n`;
+                    prompt += `- Read \`.speccore/cache/structured-data.json\`（API/Entity 结构化数据）\n`;
+                    prompt += `- 如果涉及代码细节，直接 Read 相关源码文件，引用具体代码片段\n\n`;
+                    prompt += `**深度要求**: \n`;
+                    prompt += `- 不要写"待导入"、"待补充"、"示例"等占位内容\n`;
+                    prompt += `- 每个表格必须有真实数据（从 Layer 1-3 提取）\n`;
+                    prompt += `- 每个结论必须有证据（引用具体文件名/类名/方法名）\n`;
+                    prompt += `- 如果信息不足，明确标注"信息不足: 需要读取 xxx 文件"\n`;
+                    prompt += `- 必须包含 Mermaid 图表（如适用）\n\n`;
+                    prompt += `**输出**: 只输出 \`${deepDoc}\` 的完整内容\n`;
+                }
+            }
+            else {
+                // 子层模式：每次只生成一个子层
+                prompt += `## 🌍 Layer 4: 全局汇总 — 子层 ${subLayerTarget}/4\n\n`;
+                prompt += `> ⚠️ **专注约束**: 你当前只执行 **子层 ${subLayerTarget}**，不要生成其他子层的文档。\n`;
+                prompt += `> 子层完成后执行: \`speccore analyze --scope global --layer 4\` 进入下一子层。\n\n`;
+                prompt += `**强制输入**: \n`;
+                prompt += `- Read Layer 1 的所有 _INDEX.md\n`;
+                prompt += `- Read Layer 2 的 _ASSOCIATION.md + _MODULES.md\n`;
+                prompt += `- Read Layer 3 的功能模块深入文档\n\n`;
+                if (subLayerTarget === '4a') {
+                    prompt += `**子层 4a: 产品视角文档（2-3 份）**\n`;
+                    prompt += `1. \`requirements/REQUIREMENT.md\` — 全局需求总纲\n`;
+                    prompt += `   - 产品愿景、目标用户画像、核心场景地图\n`;
+                    prompt += `   - 按业务场景组织：用户故事 → 操作流程 → 业务规则 → 边界条件 → 验收标准\n`;
+                    prompt += `   - 功能优先级矩阵（P0/P1/P2）\n`;
+                    prompt += `   - 必须从 Layer 3 的功能模块分析中提取真实内容，不要臆造\n`;
+                    prompt += `2. 各前端端 \`requirements/{端}/REQUIREMENT.md\` — 只生成已有前端端的需求\n`;
+                    prompt += `   - 信息架构、用户旅程、页面清单、交互设计\n`;
+                    prompt += `   - 从 Layer 1 的前端 _INDEX.md 提取页面/路由信息\n`;
+                    prompt += `   - 从 Layer 3 的模块分析提取交互流程\n`;
+                }
+                else if (subLayerTarget === '4b') {
+                    prompt += `**子层 4b: 全局技术核心文档（3-4 份）**\n`;
+                    prompt += `1. \`overview/FUNCTION_MAP.md\` — 功能单元 × 端映射表\n`;
+                    prompt += `   - 从 Layer 2 的 _MODULES.md 提取功能模块\n`;
+                    prompt += `   - 每个功能单元标注：涉及端、核心页面、核心接口、状态枚举\n`;
+                    prompt += `2. \`overview/ARCHITECTURE.md\` — 全局架构\n`;
+                    prompt += `   - 服务拓扑（从 Layer 1 的后端 _INDEX.md 提取服务名和依赖）\n`;
+                    prompt += `   - 数据流（从 Layer 3 的模块分析提取）\n`;
+                    prompt += `   - 必须包含 Mermaid architecture diagram\n`;
+                    prompt += `3. \`overview/API_CONTRACT.yaml\` — 全局接口契约\n`;
+                    prompt += `   - 汇总所有后端端的 API_INVENTORY（从 Layer 1 提取）\n`;
+                    prompt += `   - 标注 rate limit、幂等性、版本策略\n`;
+                    prompt += `4. \`overview/INTERACTION_MAP.md\` — 跨端交互时序图\n`;
+                    prompt += `   - 从 Layer 3 的模块时序图汇总\n`;
+                    prompt += `   - 必须包含 Mermaid sequenceDiagram\n`;
+                }
+                else if (subLayerTarget === '4c') {
+                    prompt += `**子层 4c: 全局技术扩展文档（4-5 份）**\n`;
+                    prompt += `1. \`overview/SECURITY_AUDIT.md\` — 安全审计\n`;
+                    prompt += `2. \`overview/PERFORMANCE_BASELINE.md\` — 性能基线\n`;
+                    prompt += `3. \`overview/DATA_FLOW.md\` — 数据流与隐私\n`;
+                    prompt += `4. \`overview/DEPLOYMENT.md\` — 部署运维\n`;
+                    prompt += `5. \`overview/CONSISTENCY_CHECK.md\` — 一致性校验\n`;
+                    prompt += `   - 从 Layer 2 的关联分析提取不一致项\n`;
+                }
+                else if (subLayerTarget === '4d') {
+                    prompt += `**子层 4d: 各端技术文档**\n`;
+                    prompt += `后端端（每端 9 项，但本次只生成核心 3 项，其余后续补充）:\n`;
+                    prompt += `1. \`API_INVENTORY.md\` — 从 Layer 1 的 _INDEX.md 提取完整接口清单\n`;
+                    prompt += `2. \`DATA_MODEL.md\` — 从 Layer 1 的 Entity 目录 + Layer 3 的模块分析提取\n`;
+                    prompt += `3. \`BUSINESS_RULES.md\` — 从 Layer 3 的模块分析提取业务规则\n`;
+                    prompt += `前端端（每端 9 项，但本次只生成核心 3 项）:\n`;
+                    prompt += `1. \`UI_FLOW.md\` — 从 Layer 1 的路由 + Layer 3 的模块分析提取\n`;
+                    prompt += `2. \`API_CALL_MAP.md\` — 从 Layer 1 的 API 调用提取\n`;
+                    prompt += `3. \`STATE_MANAGEMENT.md\` — 从 Layer 1 的 store 目录提取\n`;
+                }
+                prompt += `\n**质量要求**: \n`;
+                prompt += `- 禁止写"待导入"、"待补充"等占位符\n`;
+                prompt += `- 每个表格必须有真实数据（从 Layer 1-3 提取）\n`;
+                prompt += `- 如果信息不足，明确标注"信息不足: 需要读取 xxx"\n`;
+            }
+        }
+        prompt += `\n## 📝 写入方式\n`;
+        prompt += `使用 \`speccore analyze --apply '{"文件路径":"内容"}' --scope global\` 写入。\n`;
+        prompt += `- platforms/ 和 requirements/ 下的文件按原路径写（如 \`platforms/backend/_INDEX.md\`）\n`;
+        prompt += `- overview/ 下的文件写纯文件名即可（如 \`ARCHITECTURE.md\` 自动路由到 overview/）\n`;
+        prompt += `- PATTERNS/ 下的文件写 \`PATTERNS/{分类}/{模式名}.md\`\n`;
         return await injectGraphSummary(prompt);
     }
     const docs = [
@@ -2315,6 +2844,18 @@ sequenceDiagram
             }
         }
     }
+    // v7.2.0+: 细粒度分析 — 只生成指定文档的指定功能
+    if (options?.docName && options?.featureName && !isGlobal) {
+        const targetDoc = options.docName.endsWith('.md') ? options.docName : `${options.docName}.md`;
+        const filtered = taskDocs.filter(([n]) => n === targetDoc || n === options.docName);
+        if (filtered.length > 0) {
+            taskDocs = filtered;
+        }
+        else {
+            // 不在默认文档列表中，创建单文档分析任务
+            taskDocs = [[targetDoc, `# ${targetDoc.replace('.md', '')} — ${options.featureName}\n\n> ${iter} | ${now}\n> 分析范围: 仅「${options.featureName}」功能单元\n\n## 写作要求\n针对「${options.featureName}」进行深入分析，基于需求文档和代码上下文补充详细内容。\n`]];
+        }
+    }
     // ── 用户自定义模板集成（v6.45.0+）──
     const templateLevel = isGlobal ? 'global' : (isTask ? 'task' : 'iteration');
     const userTemplates = await loadUserTemplates(templateLevel, isTask ? taskType : undefined, ctx.platform);
@@ -2340,6 +2881,51 @@ sequenceDiagram
         techDoc[1] = `# 技术架构（跨端全局）\n\n> ${iter}\n\n## 写作要求\n撰写整体技术架构，覆盖所有端的交互关系：\n- 系统整体分层设计（各端在架构中的位置）\n- 跨端交互协议（前端↔后端通信方式、数据流向）\n- 中间件选型（缓存、消息队列、网关等）\n- 数据库整体设计（核心表结构、ER 关系）\n- 技术栈选型及理由\n`;
     }
     let prompt = `\n# 任务: ${command}${task} (${taskDocs.length}个文档 · ${isTask ? `类型:${taskType}` : '迭代全量'}${ctx.phase ? ` · Phase ${ctx.phase}` : ''})\n\n`;
+    // v7.2.0+: 迭代分析代码关联 — 注入结构化数据和语义定位上下文
+    if (!isGlobal && ctx.withCode && ctx.iteration && ctx.iteration !== 'GLOBAL') {
+        try {
+            // 1. 提取结构化数据（如果还没有）
+            const structuredDataPath = (0, path_1.join)(process.cwd(), '.speccore', 'cache', 'structured-data.json');
+            if (!(await (0, fs_extra_1.pathExists)(structuredDataPath))) {
+                const constitutionPath = (0, path_1.join)(process.cwd(), '.speccore', 'CONSTITUTION.md');
+                let sourcePaths = ['src'];
+                if (await (0, fs_extra_1.pathExists)(constitutionPath)) {
+                    const content = await (0, fs_extra_2.readFile)(constitutionPath, 'utf-8');
+                    const match = content.match(/源码路径[\s\S]*?\n\s*-\s*`?([^`\n]+)`?/g);
+                    if (match) {
+                        sourcePaths = match.map(m => m.replace(/.*-\s*`?/, '').replace(/`?$/, '').trim()).filter(Boolean);
+                    }
+                }
+                const { extractStructuredData } = await Promise.resolve().then(() => __importStar(require('../core/structured-extractor')));
+                await extractStructuredData(process.cwd(), sourcePaths);
+            }
+            // 2. 注入结构化数据摘要到 Prompt
+            if (await (0, fs_extra_1.pathExists)(structuredDataPath)) {
+                const data = await (0, fs_extra_2.readFile)(structuredDataPath, 'utf-8');
+                const structured = JSON.parse(data);
+                const stats = structured.stats || {};
+                prompt += `## 📊 代码结构化数据（自动提取）\n\n`;
+                prompt += `> 已扫描项目源码，提取以下结构化信息供分析参考：\n\n`;
+                prompt += `- API 接口: ${stats.totalApis || 0} 个\n`;
+                prompt += `- 数据实体: ${stats.totalEntities || 0} 个\n`;
+                prompt += `- 页面路由: ${stats.totalRoutes || 0} 个\n`;
+                prompt += `- 前端组件: ${stats.totalComponents || 0} 个\n`;
+                prompt += `- 扫描文件: ${stats.totalFiles || 0} 个\n\n`;
+                prompt += `> 💡 分析技术方案时，可参考 \`.speccore/cache/structured-data.json\` 中的 API/Entity/Route/Component 清单\n`;
+                prompt += `> 如需了解具体实现，直接 Read 对应源码文件\n\n`;
+            }
+            // 3. 语义定位：如果指定了功能名，自动关联上下文
+            if (options?.featureName) {
+                const { buildFeatureContext, buildFeatureContextPrompt } = await Promise.resolve().then(() => __importStar(require('../core/semantic-locator')));
+                const iterDir = await (0, context_1.getIterationDir)(ctx.iteration);
+                const featureCtx = await buildFeatureContext(process.cwd(), iterDir, options.featureName, options.docName);
+                prompt += buildFeatureContextPrompt(featureCtx);
+            }
+        }
+        catch (e) {
+            logger_1.logger.warn(`   ⚠️ 代码关联注入失败: ${e.message}`);
+        }
+    }
     // v6.80.0+: 注入需求质量上下文（迭代级分析时）
     if (!isGlobal && !isTask && ctx.iteration && ctx.iteration !== 'GLOBAL') {
         try {
@@ -2510,9 +3096,9 @@ sequenceDiagram
             prompt += `2. 读取全局层产物（建立全局视角，重要）\n`;
             prompt += `   在读取迭代需求之前，先 Read 全局层已有产物，了解系统当前状态：\n`;
             prompt += `   a. Read .speccore/GLOBAL/requirements/REQUIREMENT.md → 系统已有功能清单\n`;
-            prompt += `   b. Read .speccore/GLOBAL/FUNCTION_MAP.md → 已有功能单元和涉及端\n`;
-            prompt += `   c. Read .speccore/GLOBAL/API_CONTRACT.yaml → 已有接口契约\n`;
-            prompt += `   d. Read .speccore/GLOBAL/ARCHITECTURE.md → 全局架构（如有）\n`;
+            prompt += `   b. Read .speccore/GLOBAL/overview/FUNCTION_MAP.md → 已有功能单元和涉及端\n`;
+            prompt += `   c. Read .speccore/GLOBAL/overview/API_CONTRACT.yaml → 已有接口契约\n`;
+            prompt += `   d. Read .speccore/GLOBAL/overview/ARCHITECTURE.md → 全局架构（如有）\n`;
             prompt += `   e. Read .speccore/GLOBAL/platforms/{相关端}/_INDEX.md → 各端已有页面和接口索引\n`;
             prompt += `   f. Read .speccore/GLOBAL/platforms/_shared/_ASSOCIATION.md → 前后端关联矩阵（如有）\n`;
             prompt += `   g. Read .speccore/GLOBAL/platforms/_shared/_MODULES.md → 功能模块候选（如有）\n`;
@@ -2540,9 +3126,18 @@ sequenceDiagram
             prompt += `   - 第 4 步：如果以上都无法确定，根据需求文档内容判断\n`;
             prompt += `   - 第 5 步：将发现的端列表写入 020-specs/PLATFORMS.md\n`;
             // v6.70.0+: REQUIREMENT.md 以产品视角撰写（不按端分章节）
+            // v6.99.0+: 丰富需求文档章节要求
             prompt += `8. **REQUIREMENT.md 写作风格（重要）**：全局需求文档必须以产品/用户视角撰写\n`;
             prompt += `   - **按业务场景/用户旅程组织章节**，不按端分章节（如"H5端需求"、"后端需求"）\n`;
-            prompt += `   - 每个场景描述：用户操作 → 系统响应 → 业务规则 → 边界条件\n`;
+            prompt += `   - 文档结构必须包含（如需求文档中有相关信息）：\n`;
+            prompt += `     - **产品愿景**：本迭代要解决的核心问题和目标价值（1-2段）\n`;
+            prompt += `     - **目标用户画像**：主要用户角色、使用场景、痛点（如有）\n`;
+            prompt += `     - **核心场景地图**：按业务流程组织的场景列表，每个场景标注优先级\n`;
+            prompt += `     - **功能全景图**：所有功能模块的可视化列表（表格或脑图描述）\n`;
+            prompt += `     - **功能优先级矩阵**：P0（必须）/ P1（重要）/ P2（可选）标注\n`;
+            prompt += `     - **发布里程碑**：如有分期计划，标注各阶段交付内容\n`;
+            prompt += `     - **风险预判**：技术风险、业务风险、依赖风险（如有）\n`;
+            prompt += `   - 每个场景描述：用户操作 → 系统响应 → 业务规则 → 边界条件 → 验收标准\n`;
             prompt += `   - 系统响应中自然包含前后端交互，但不刻意标注技术实现细节\n`;
             prompt += `   - 示例正确写法：「用户选择时间段后点击预订，系统检查会议室可用性，如可用则锁定会议室并创建待支付订单」\n`;
             prompt += `   - 示例错误写法：「后端 booking-service 需要新增 /api/bookings 接口，接收 roomId 参数」\n`;
@@ -2572,7 +3167,7 @@ sequenceDiagram
             // v6.70.0+: 跨端功能映射表（FUNCTION_MAP.md）
             // v6.71.3+: 增加与全局层关联分析
             prompt += `7a. **迭代需求与全局层关联分析（重要）**：在生成功能模块清单时，必须对比全局层产物\n`;
-            prompt += `   - 对比迭代需求中的功能模块 vs .speccore/GLOBAL/FUNCTION_MAP.md 中的功能单元\n`;
+            prompt += `   - 对比迭代需求中的功能模块 vs .speccore/GLOBAL/overview/FUNCTION_MAP.md 中的功能单元\n`;
             prompt += `   - 标注每个功能模块的「全局对比」类型（新增/扩展/重构/复用）\n`;
             prompt += `   - 识别冲突：如迭代需求修改了全局层已有接口的字段/路径 → 在 RISK.md 中标注\n`;
             prompt += `   - 识别依赖：如迭代的新功能依赖全局层的某个功能 → 在 FUNCTION_MAP.md「依赖任务」中标注\n\n`;