lumencode 1.3.1 → 1.3.2

package/lib/report.js

@@ -460,6 +460,195 @@ function buildGitInsight(git) {
   return insights.length > 0 ? insights.join('；') + '。' : null;
 }
 
+/**
+ * 效率指标板块——量化投入产出比
+ */
+function buildEfficiencyMetrics(usageData, gitData) {
+  const lines = [];
+  const metrics = [];
+  const reqCount = usageData.requestCount || 0;
+
+  // 样本量不足时不生成效率指标
+  if (reqCount < 5) return null;
+
+  // 1. 交互效率：每次交互的产出
+  if (gitData && reqCount > 0) {
+    const commits = gitData.commits || 0;
+    const linesAdded = gitData.linesAdded || 0;
+    const filesChanged = gitData.filesChanged || 0;
+
+    if (commits > 0) {
+      const reqsPerCommit = Math.round(reqCount / commits);
+      metrics.push(`- **交互/提交比**：${reqsPerCommit}:1（每 ${reqsPerCommit} 次交互产出 1 次提交）`);
+    }
+    if (linesAdded > 0) {
+      const linesPerReq = (linesAdded / reqCount).toFixed(1);
+      metrics.push(`- **每次交互新增**：${linesPerReq} 行`);
+    }
+    if (filesChanged > 0 && commits > 0) {
+      const filesPerCommit = (filesChanged / commits).toFixed(1);
+      metrics.push(`- **每次提交变更**：${filesPerCommit} 个文件`);
+    }
+  }
+
+  // 2. 成本效率
+  if (usageData.estimatedCost && usageData.estimatedCost > 0) {
+    if (reqCount > 0) {
+      const costPerReq = (usageData.estimatedCost / reqCount).toFixed(3);
+      metrics.push(`- **每次交互成本**：$${costPerReq}`);
+    }
+    if (gitData && gitData.linesAdded > 0) {
+      const costPerKLines = (usageData.estimatedCost / (gitData.linesAdded / 1000)).toFixed(2);
+      metrics.push(`- **每千行代码成本**：$${costPerKLines}`);
+    }
+  }
+
+  // 3. 日均产出
+  if (usageData.activeDays > 0) {
+    const dailyMetrics = [];
+    if (reqCount > 0) {
+      dailyMetrics.push(`日均 ${Math.round(reqCount / usageData.activeDays)} 次交互`);
+    }
+    if (gitData) {
+      if (gitData.commits > 0) {
+        dailyMetrics.push(`${(gitData.commits / usageData.activeDays).toFixed(1)} 次提交`);
+      }
+      if (gitData.linesAdded > 0) {
+        dailyMetrics.push(`+${Math.round(gitData.linesAdded / usageData.activeDays)} 行`);
+      }
+    }
+    if (dailyMetrics.length > 0) {
+      metrics.push(`- **日均产出**：${dailyMetrics.join('，')}`);
+    }
+  }
+
+  // 4. Token 效率
+  if (usageData.outputTokens > 0 && reqCount > 0) {
+    const outputPerReq = (usageData.outputTokens / reqCount).toFixed(0);
+    metrics.push(`- **每次交互输出**：${Number(outputPerReq).toLocaleString('zh-CN')} Token`);
+  }
+
+  if (metrics.length === 0) return null;
+
+  for (const m of metrics) lines.push(m);
+
+  // 效率洞察
+  const insights = [];
+  if (gitData && gitData.commits > 0 && reqCount > 0) {
+    const ratio = reqCount / gitData.commits;
+    if (ratio < 5) {
+      insights.push('交互-提交转化率极高，说明需求明确、AI 理解准确，**沟通效率优秀**。');
+    } else if (ratio > 20) {
+      insights.push('交互-提交比较高，说明有较多的**探索和调试**过程——这在复杂任务中是正常的，但可以评估是否通过更精确的提示词降低无效交互。');
+    }
+  }
+  if (usageData.estimatedCost && gitData?.linesAdded > 0) {
+    const costPerLine = usageData.estimatedCost / gitData.linesAdded;
+    if (costPerLine > 0.1) {
+      insights.push(`每行代码成本 $${costPerLine.toFixed(3)}，属于较高水平——通常意味着在做架构设计或复杂逻辑，而非批量生成。`);
+    } else if (costPerLine < 0.01 && gitData.linesAdded > 100) {
+      insights.push(`每行代码成本仅 $${costPerLine.toFixed(4)}，AI 辅助的**批量生成效率很高**。`);
+    }
+  }
+
+  if (insights.length > 0) {
+    lines.push('');
+    for (const ins of insights) {
+      lines.push(`> ${ins}`);
+    }
+  }
+
+  lines.push('');
+  return lines;
+}
+
+/**
+ * 简报一句话结论——提炼本期最核心的结论
+ */
+function buildBriefConclusion(usageData, gitData) {
+  const parts = [];
+
+  // 产出维度
+  if (gitData && gitData.commits > 0) {
+    const featCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('feat') || s.startsWith('feature');
+    }).length;
+    const fixCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('fix') || s.startsWith('bug');
+    }).length;
+
+    if (featCount > 0 && fixCount > 0) {
+      parts.push(`交付 ${featCount} 个新功能、修复 ${fixCount} 个缺陷`);
+    } else if (featCount > 0) {
+      parts.push(`交付 ${featCount} 个新功能`);
+    } else if (fixCount > 0) {
+      parts.push(`修复 ${fixCount} 个缺陷`);
+    }
+  }
+
+  // AI 参与维度
+  if (gitData?.aiContribution) {
+    const aiPct = Math.round(((gitData.aiContribution.aiLineRatio ?? gitData.aiContribution.aiRatio) || 0) * 100);
+    if (aiPct >= 80) {
+      parts.push('AI 深度参与开发（占比 ' + aiPct + '%）');
+    } else if (aiPct >= 50) {
+      parts.push('AI 辅助占比 ' + aiPct + '%');
+    }
+  }
+
+  // 成本维度
+  if (usageData.estimatedCost && usageData.estimatedCost > 0) {
+    if (usageData.activeDays > 0) {
+      const dailyCost = usageData.estimatedCost / usageData.activeDays;
+      if (dailyCost >= 50) {
+        parts.push('日均费用 $' + dailyCost.toFixed(0) + '，投入强度高');
+      } else if (dailyCost >= 10) {
+        parts.push('日均费用 $' + dailyCost.toFixed(0));
+      }
+    }
+  }
+
+  if (parts.length === 0) return null;
+  return '> ' + parts.join('，') + '。';
+}
+
+/**
+ * 简报环比方向性结论——从数据变化中提炼方向判断
+ */
+function buildBriefDirection(usageData, prevData, gitData) {
+  if (!prevData) return null;
+
+  const conclusions = [];
+
+  // 交互效率：交互量变化 vs 产出变化
+  const reqPct = pctChange(usageData.requestCount, prevData.requestCount);
+  const costPct = pctChange(usageData.estimatedCost, prevData.estimatedCost);
+
+  // 如果交互量下降但成本上升 → 单次交互变贵了
+  if (reqPct !== null && costPct !== null) {
+    const reqDown = reqPct < -10;
+    const costUp = costPct > 10;
+    if (reqDown && costUp) {
+      conclusions.push('交互量下降但费用上升，单次交互成本增加——可能使用了更贵的大模型');
+    }
+  }
+
+  // 产出效率
+  if (gitData && gitData.commits > 0 && usageData.requestCount > 0) {
+    const commitsPerReq = gitData.commits / usageData.requestCount;
+    if (commitsPerReq >= 0.1) {
+      const reqsPerCommit = Math.round(1 / commitsPerReq);
+      const efficiency = reqsPerCommit <= 10 ? '良好' : reqsPerCommit <= 30 ? '中等' : '偏低';
+      conclusions.push(`每 ${reqsPerCommit} 次交互产出 1 次提交，交互-产出转化率${efficiency}`);
+    }
+  }
+
+  if (conclusions.length === 0) return null;
+  return conclusions.length > 0 ? conclusions.join('；') : null;
+}
+
 function buildCostInsight(stats) {
   if (!stats.estimatedCost || stats.estimatedCost <= 0) return null;
   if (stats.activeDays > 0) {
@@ -470,6 +659,88 @@ function buildCostInsight(stats) {
   return null;
 }
 
+/**
+ * 成本结构分析——按模型/按项目/按天的成本拆解
+ */
+function buildCostStructureAnalysis(usageData) {
+  if (!usageData.estimatedCost || usageData.estimatedCost <= 0) return null;
+
+  const lines = [];
+
+  // ── 按模型拆解 ──
+  if (usageData.models && Object.keys(usageData.models).length > 0) {
+    const modelCosts = Object.entries(usageData.models)
+      .filter(([, m]) => (m.cost || 0) > 0)
+      .sort((a, b) => (b[1].cost || 0) - (a[1].cost || 0));
+
+    if (modelCosts.length > 0) {
+      lines.push('**费用构成（按模型）**：');
+      const totalCost = usageData.estimatedCost;
+      for (const [model, data] of modelCosts.slice(0, 5)) {
+        const cost = data.cost || 0;
+        const pct = Math.round((cost / totalCost) * 100);
+        const outputTokens = data.outputTokens || 0;
+        const outputK = outputTokens >= 1000 ? (outputTokens / 1000).toFixed(1) + 'K' : String(outputTokens);
+        lines.push(`- **${model}**：$${cost.toFixed(2)}（${pct}%，输出 ${outputK} Token）`);
+      }
+      // 集中度判断
+      if (modelCosts.length >= 2) {
+        const topPct = Math.round(((modelCosts[0][1].cost || 0) / totalCost) * 100);
+        if (topPct >= 80) {
+          lines.push(`> 费用高度集中在 ${modelCosts[0][0]}（${topPct}%），可评估是否有更经济的模型替代部分场景。`);
+        } else if (topPct >= 60) {
+          lines.push(`> ${modelCosts[0][0]} 占 ${topPct}% 费用，其余 ${modelCosts.length - 1} 个模型分担 ${100 - topPct}%。`);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  // ── 按项目拆解 ──
+  const projects = Object.entries(usageData.projects || {})
+    .filter(([, d]) => (d.estimatedCost || 0) > 0)
+    .sort((a, b) => (b[1].estimatedCost || 0) - (a[1].estimatedCost || 0));
+  if (projects.length > 1) {
+    lines.push('**费用分配（按项目）**：');
+    const totalCost = usageData.estimatedCost;
+    for (const [proj, data] of projects) {
+      const cost = data.estimatedCost || 0;
+      const pct = Math.round((cost / totalCost) * 100);
+      lines.push(`- **${simplifyPath(proj)}**：$${cost.toFixed(2)}（${pct}%）`);
+    }
+    lines.push('');
+  }
+
+  // ── 按天波动 ──
+  if (usageData.dailyStats && Object.keys(usageData.dailyStats).length >= 3) {
+    const dailyEntries = Object.entries(usageData.dailyStats)
+      .map(([date, ds]) => ({ date, cost: ds.estimatedCost || 0, requests: ds.requests || 0 }))
+      .filter(d => d.cost > 0)
+      .sort((a, b) => a.date.localeCompare(b.date));
+
+    if (dailyEntries.length >= 3) {
+      const avgCost = dailyEntries.reduce((s, d) => s + d.cost, 0) / dailyEntries.length;
+      const maxDay = dailyEntries.reduce((a, b) => a.cost > b.cost ? a : b);
+      const minDay = dailyEntries.reduce((a, b) => a.cost < b.cost ? a : b);
+      const volatility = avgCost > 0 ? ((maxDay.cost - minDay.cost) / avgCost * 100).toFixed(0) : 0;
+
+      lines.push('**费用波动**：');
+      lines.push(`- 日均 $${avgCost.toFixed(2)}，最高 ${maxDay.date}（$${maxDay.cost.toFixed(2)}），最低 ${minDay.date}（$${minDay.cost.toFixed(2)}），波动幅度 ${volatility}%`);
+
+      if (parseFloat(volatility) > 200) {
+        lines.push('> 日费用波动极大，可能存在偶发性大批量任务。建议排查高峰日的具体工作内容，评估是否可以分散执行。');
+      } else if (parseFloat(volatility) > 100) {
+        lines.push('> 日费用波动较大，说明工作节奏不均匀。如果与工作日/周末模式相关，属于正常现象。');
+      } else {
+        lines.push('> 日费用波动适中，消费节奏较为平稳。');
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.length > 0 ? lines : null;
+}
+
 function buildDailyTrendInsight(dailyStats, period) {
   const dates = Object.keys(dailyStats).sort();
   if (dates.length < 2) return null;
@@ -791,21 +1062,25 @@ export function generateReport(usageData, gitData, period, startDate, endDate) {
     lines.push('└─────────────────────────────────────┘');
     lines.push('');
 
-    const totalToolCalls = Object.values(usageData.tools).reduce((s, v) => s + v, 0);
+    const toolValues = Object.values(usageData.tools);
+    const totalToolCalls = toolValues.reduce((s, v) => s + toolCalls(v), 0);
     const toolTable = new Table({
       columns: [
         { title: '工具', width: 28 },
         { title: '调用次数', width: 10 },
+        { title: '使用次数', width: 10 },
         { title: '占比', width: 8 },
       ],
     });
 
     const sortedTools = Object.entries(usageData.tools)
-      .sort((a, b) => b[1] - a[1])
+      .sort((a, b) => toolCalls(b[1]) - toolCalls(a[1]))
       .slice(0, 10);
 
-    for (const [name, count] of sortedTools) {
-      toolTable.addRow([name, formatInt(count), formatPercent(count, totalToolCalls)]);
+    for (const [name, val] of sortedTools) {
+      const calls = toolCalls(val);
+      const uses = toolUses(val);
+      toolTable.addRow([name, formatInt(calls), formatInt(uses), formatPercent(calls, totalToolCalls)]);
     }
     lines.push(toolTable.render());
     lines.push('');
@@ -817,6 +1092,10 @@ export function generateReport(usageData, gitData, period, startDate, endDate) {
   return lines.join('\n');
 }
 
+// ── 工具值类型兼容辅助 ──
+function toolCalls(v) { return typeof v === 'number' ? v : (v.calls || 0); }
+function toolUses(v) { return typeof v === 'number' ? v : (v.uses || 0); }
+
 function formatPeriodTitle(period, start, end) {
   switch (period) {
     case 'daily': return `日报 ${start}`;
@@ -965,6 +1244,13 @@ export function generateBriefReport(usageData, gitData, period, startDate, endDa
 
   const lines = [];
 
+  // ── 一句话结论（简报开头） ──
+  const conclusionLine = buildBriefConclusion(usageData, gitData);
+  if (conclusionLine) {
+    lines.push(conclusionLine);
+    lines.push('');
+  }
+
   // 标题
   if (isDingtalk) {
     lines.push(`${titlePrefix} 工作${periodLabel} - ${dateLabel}`);
@@ -1088,7 +1374,7 @@ export function generateBriefReport(usageData, gitData, period, startDate, endDa
     lines.push('');
   }
 
-  // 5. 环比变化
+  // 5. 环比变化（含方向性结论）
   if (prevData) {
     const changes = [];
     const reqPct = pctChange(usageData.requestCount, prevData.requestCount);
@@ -1103,6 +1389,12 @@ export function generateBriefReport(usageData, gitData, period, startDate, endDa
       lines.push(h2('环比变化'));
       lines.push('');
       lines.push(bullet(`相比${prevName}，${changes.join('、')}`));
+
+      // 方向性结论
+      const direction = buildBriefDirection(usageData, prevData, gitData);
+      if (direction) {
+        lines.push(bullet(direction));
+      }
       lines.push('');
     }
   }
@@ -1170,6 +1462,371 @@ function toolTitle(tool) {
   return TOOL_LABELS[tool] || 'AI 编码助手';
 }
 
+/**
+ * Boss 报告——给领导看的工作汇报
+ *
+ * 设计哲学：
+ * 1. 凸显工作成果——交付了多少、做了什么
+ * 2. 说管理者语言——不说技术黑话
+ * 3. 不给自己挖坑——不暴露"AI干了97%"这种数据
+ * 4. 费用包装为"技术工具投入"——工作日计算
+ */
+export function generateBossReport(usageData, gitData, period, startDate, endDate, prevData, platform = 'default') {
+  const periodName = period === 'daily' ? '今日' : period === 'weekly' ? '本周' : '本月';
+  const dateLabel = period === 'monthly' ? startDate.slice(0, 7) : period === 'weekly' ? `${startDate} ~ ${endDate}` : startDate;
+  const lines = [];
+
+  lines.push(`# 工作${periodName === '今日' ? '日报' : periodName === '本周' ? '周报' : '月报'} - ${dateLabel}`);
+  lines.push('');
+
+  // ── 一、工作成果概述（领导第一眼看到的内容） ──
+  const summary = buildBossSummary(usageData, gitData, periodName);
+  lines.push(summary);
+  lines.push('');
+
+  // ── 二、核心产出（具体做了什么） ──
+  const output = buildBossOutput(usageData, gitData, periodName);
+  if (output) {
+    lines.push('## 本期工作内容');
+    lines.push('');
+    for (const l of output) lines.push(l);
+    lines.push('');
+  }
+
+  // ── 三、工作强度（凸工作态度） ──
+  const intensity = buildBossIntensity(usageData, periodName);
+  if (intensity) {
+    lines.push('## 工作投入');
+    lines.push('');
+    for (const l of intensity) lines.push(l);
+    lines.push('');
+  }
+
+  // ── 四、环比亮点（挑好的说） ──
+  if (prevData) {
+    const comparison = buildBossComparison(usageData, prevData, gitData, periodName);
+    if (comparison) {
+      lines.push('## 工作对比');
+      lines.push('');
+      for (const l of comparison) lines.push(l);
+      lines.push('');
+    }
+  }
+
+  // ── 五、技术工具投入（费用用工作日算，包装为投入） ──
+  const cost = buildBossCost(usageData, periodName);
+  if (cost) {
+    lines.push('## 技术工具投入');
+    lines.push('');
+    for (const l of cost) lines.push(l);
+    lines.push('');
+  }
+
+  const result = lines.join('\n').trim();
+
+  // 平台适配
+  if (platform === 'dingtalk') return adaptDingtalkBoss(result);
+  if (platform === 'feishu') return adaptFeishuBoss(result);
+  return result;
+}
+
+/**
+ * 钉钉 Boss 报告适配——纯文本 + emoji 分隔，适合群消息
+ */
+function adaptDingtalkBoss(text) {
+  return text
+    .replace(/^# (.+)$/gm, '$1')
+    .replace(/^## (.+)$/gm, '\n─── $1 ───')
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/`([^`]+)`/g, '"$1"')
+    .replace(/^> (.+)$/gm, '$1')
+    .trim();
+}
+
+/**
+ * 飞书 Boss 报告适配——保留 Markdown（飞书支持良好）
+ */
+function adaptFeishuBoss(text) {
+  // 飞书支持标准 Markdown，只需确保格式兼容
+  return text.trim();
+}
+
+function buildBossSummary(usageData, gitData, periodName) {
+  const parts = [];
+
+  // 产出维度
+  if (gitData && gitData.commits > 0) {
+    const featCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('feat') || s.startsWith('feature');
+    }).length;
+    const fixCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('fix') || s.startsWith('bug');
+    }).length;
+    const refactorCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('refactor');
+    }).length;
+    const perfCount = (gitData.commitList || []).filter(c => {
+      const s = (c.subject || c.message || '').toLowerCase();
+      return s.startsWith('perf');
+    }).length;
+
+    const items = [];
+    if (featCount > 0) items.push(`完成 ${featCount} 项功能开发`);
+    if (fixCount > 0) items.push(`解决 ${fixCount} 个问题`);
+    if (refactorCount > 0) items.push(`优化 ${refactorCount} 处代码结构`);
+    if (perfCount > 0) items.push(`提升 ${perfCount} 处性能`);
+    if (items.length > 0) parts.push(items.join('，'));
+
+    // AI 协同效率——包装为"善用 AI 工具"
+    if (gitData.aiContribution) {
+      const aiRatio = gitData.aiContribution.aiLineRatio ?? gitData.aiContribution.aiRatio;
+      if (aiRatio > 0) {
+        const aiPct = Math.round(aiRatio * 100);
+        if (aiPct >= 80) {
+          parts.push('AI 辅助编码深度协同，开发效率显著提升');
+        } else if (aiPct >= 50) {
+          parts.push('充分运用 AI 辅助工具，人机协作高效');
+        } else {
+          parts.push('善用 AI 工具辅助编码');
+        }
+      }
+    }
+  } else {
+    // 无 Git 数据时用交互量代替
+    const reqCount = usageData.requestCount || 0;
+    if (reqCount > 0) {
+      parts.push(`累计进行 ${fmtN(reqCount)} 次 AI 辅助操作`);
+    }
+  }
+
+  // 项目维度
+  const projects = Object.entries(usageData.projects || {}).filter(([, d]) => d.requests > 0);
+  if (projects.length > 1) {
+    parts.push(`覆盖 ${projects.length} 个项目`);
+  }
+
+  // 态度维度
+  if (usageData.activeDays > 0) {
+    const totalDays = periodName === '今日' ? 1 : periodName === '本周' ? 7 : 30;
+    const coverage = Math.round((usageData.activeDays / totalDays) * 100);
+    if (coverage >= 70) {
+      parts.push('保持高效持续产出');
+    } else if (usageData.activeDays >= 5) {
+      parts.push('工作节奏紧凑');
+    }
+  }
+
+  if (parts.length === 0) return `${periodName}使用 AI 辅助工具进行日常工作。`;
+  return `${periodName}${parts.join('，')}。`;
+}
+
+/**
+ * Boss 报告的工作内容——只展示摘要数字和分类，不暴露 commit message
+ */
+function buildBossOutput(usageData, gitData, periodName) {
+  if (!gitData || gitData.commits === 0) return null;
+  const lines = [];
+
+  // 数字概要——说管理者听得懂的
+  const linesAdded = gitData.linesAdded || 0;
+  const linesDeleted = gitData.linesDeleted || 0;
+  const filesChanged = gitData.filesChanged || 0;
+  const commits = gitData.commits || 0;
+
+  lines.push(`本期共提交 ${commits} 次代码变更，涉及 ${filesChanged} 个文件，新增 ${fmtN(linesAdded)} 行代码。`);
+  lines.push('');
+
+  // 分类摘要——只说做了几类事，不说具体 commit
+  const commitList = gitData.commitList || [];
+  const categories = {
+    '功能开发': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('feat') || s.startsWith('feature'); },
+    '问题修复': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('fix') || s.startsWith('bug'); },
+    '代码优化': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('refactor') || s.startsWith('perf'); },
+    '文档更新': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('doc'); },
+    '测试完善': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('test'); },
+    '工程维护': c => { const s = (c.subject || c.message || '').toLowerCase(); return s.startsWith('chore') || s.startsWith('ci') || s.startsWith('build') || s.startsWith('release'); },
+  };
+
+  const catResults = {};
+  for (const [cat, fn] of Object.entries(categories)) {
+    const items = commitList.filter(fn);
+    if (items.length > 0) catResults[cat] = items.length;
+  }
+  // 未分类的
+  const classified = Object.values(categories).flatMap(fn => commitList.filter(fn));
+  const unclassified = commitList.length - new Set(classified).size;
+  if (unclassified > 0) catResults['其他改进'] = unclassified;
+
+  if (Object.keys(catResults).length > 0) {
+    lines.push('**工作内容分类**：');
+    for (const [cat, count] of Object.entries(catResults)) {
+      lines.push(`- ${cat}：${count} 项`);
+    }
+    lines.push('');
+  }
+
+  // 净代码增长——突出正面的
+  const netLines = linesAdded - linesDeleted;
+  if (netLines > 0) {
+    lines.push(`> 净增代码 ${fmtN(netLines)} 行，项目功能持续扩展。`);
+  } else if (linesAdded > 0) {
+    lines.push(`> 代码变更以优化重构为主，代码库更加精简。`);
+  }
+
+  // AI 协同效率——在产出板块结尾展示
+  if (gitData.aiContribution) {
+    const ai = gitData.aiContribution;
+    const aiLineRatio = ai.aiLineRatio ?? ai.aiRatio;
+    if (aiLineRatio > 0) {
+      const aiPct = Math.round(aiLineRatio * 100);
+      const aiCommits = ai.aiCommits || 0;
+      const totalCommits = gitData.commits || 1;
+      const commitPct = Math.round((aiCommits / totalCommits) * 100);
+      lines.push('');
+      lines.push(`**AI 辅助编码效率**：${aiPct}% 的代码由 AI 辅助生成（涉及 ${aiCommits}/${totalCommits} 次提交），显著提升开发迭代速度。`);
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * Boss 报告的工作投入——凸工作态度，不凸技术细节
+ */
+function buildBossIntensity(usageData, periodName) {
+  const lines = [];
+  const totalDays = periodName === '今日' ? 1 : periodName === '本周' ? 7 : 30;
+  const activeDays = usageData.activeDays || 0;
+
+  if (activeDays > 0) {
+    const coverage = Math.round((activeDays / totalDays) * 100);
+
+    // 用项目维度说事
+    const projects = Object.entries(usageData.projects || {}).filter(([, d]) => d.requests > 0);
+    const projNames = projects.map(([p]) => simplifyPath(p));
+
+    if (periodName === '今日') {
+      // 日报用简洁措辞
+      if (projNames.length === 1) {
+        lines.push(`全天专注于 **${projNames[0]}** 项目开发。`);
+      } else if (projNames.length > 1) {
+        lines.push(`全天推进 ${projNames.join('、')} 等项目。`);
+      }
+    } else if (projNames.length === 1) {
+      lines.push(`持续 ${activeDays} 天在 **${projNames[0]}** 项目上集中投入。`);
+    } else if (projNames.length > 1) {
+      lines.push(`持续 ${activeDays} 天保持活跃，同时推进 ${projNames.join('、')} 等项目。`);
+    } else {
+      lines.push(`${periodName}共 ${activeDays} 天有工作产出。`);
+    }
+
+    // 工作节奏描述（仅周报/月报）
+    if (periodName !== '今日' && usageData.dailyStats) {
+      const dailyEntries = Object.entries(usageData.dailyStats).filter(([, ds]) => (ds.requests || 0) > 0);
+      if (dailyEntries.length >= 3) {
+        // 连续活跃天数
+        const dates = dailyEntries.map(([d]) => d).sort();
+        let maxStreak = 1, streak = 1;
+        for (let i = 1; i < dates.length; i++) {
+          const prev = new Date(dates[i - 1]);
+          const curr = new Date(dates[i]);
+          const diff = (curr - prev) / (1000 * 60 * 60 * 24);
+          if (diff <= 1.5) { streak++; maxStreak = Math.max(maxStreak, streak); }
+          else { streak = 1; }
+        }
+        if (maxStreak >= 5) {
+          lines.push(`最长连续工作 ${maxStreak} 天，工作节奏稳定。`);
+        }
+      }
+    }
+
+    // 覆盖率用工作态度的语言说（仅周报/月报）
+    if (periodName !== '今日') {
+      if (coverage >= 80) {
+        lines.push(`> 工作覆盖率 ${coverage}%，全程高投入。`);
+      } else if (coverage >= 50) {
+        lines.push(`> 工作覆盖率 ${coverage}%，保持稳定产出节奏。`);
+      }
+    }
+
+    lines.push('');
+  }
+
+  return lines.length > 0 ? lines : null;
+}
+
+/**
+ * Boss 报告的环比对比——挑好的说，不好的用正面语言
+ */
+function buildBossComparison(usageData, prevData, gitData, periodName) {
+  if (!prevData) return null;
+  const lines = [];
+  const prevName = periodName === '今日' ? '昨日' : periodName === '本周' ? '上周' : '上月';
+
+  const reqPct = pctChange(usageData.requestCount, prevData.requestCount);
+  const costPct = pctChange(usageData.estimatedCost, prevData.estimatedCost);
+
+  const parts = [];
+
+  // 交互量——下降不一定是坏事，可以用"效率"包装
+  if (reqPct !== null) {
+    if (reqPct > 0) {
+      parts.push(`工作强度提升 ${reqPct}%`);
+    } else if (reqPct > -15) {
+      parts.push('工作节奏保持稳定');
+    }
+    // 下降超过15%就不提交互量了，跳过
+  }
+
+  // 费用——如果上升了但交互量也上升，说明是工作量增加
+  if (costPct !== null && costPct > 0 && reqPct !== null && reqPct > 0) {
+    // 费用上升但交互量也上升——说明工作量增加带动
+    parts.push('投入随工作量同步增长');
+  }
+  // 费用下降或持平——不提
+
+  if (parts.length > 0) {
+    lines.push(`相比${prevName}，${parts.join('，')}。`);
+  } else {
+    lines.push(`与${prevName}相比，工作保持稳定推进。`);
+  }
+
+  // 效率洞察——如果产出不变但交互减少
+  if (gitData && gitData.commits > 0 && reqPct !== null && reqPct < 0) {
+    lines.push('> 在工作量调整的同时，持续保持代码产出，工作效率稳定。');
+  }
+
+  return lines.length > 0 ? lines : null;
+}
+
+/**
+ * Boss 报告的费用——工作日计算，包装为"技术工具投入"
+ */
+function buildBossCost(usageData, periodName) {
+  if (!usageData.estimatedCost || usageData.estimatedCost <= 0) return null;
+  const lines = [];
+
+  const activeDays = usageData.activeDays || 1;
+  const dailyCost = usageData.estimatedCost / activeDays;
+
+  lines.push(`本期技术工具投入约 **$${usageData.estimatedCost.toFixed(0)}**（日均 $${dailyCost.toFixed(0)}），用于 AI 辅助编码、代码分析等研发提效工具。`);
+  lines.push('');
+
+  // 工作日计算月度预估——不把周末算进去
+  if (periodName !== '今日') {
+    const workdays = Math.min(activeDays, periodName === '本周' ? 5 : 22);
+    const workdayDaily = usageData.estimatedCost / workdays;
+    const monthlyEst = workdayDaily * 22;  // 按每月22个工作日算
+    lines.push(`按工作日折算，月度工具预算约 $${monthlyEst.toFixed(0)}。`);
+    lines.push('');
+  }
+
+  return lines;
+}
+
 export function generateWorkReport(usageData, gitData, period, startDate, endDate, prevData, options) {
   // 向后兼容：options 可以是字符串（旧 platform 参数）
   const opts = typeof options === 'string'
@@ -1353,6 +2010,14 @@ export function generateWorkReport(usageData, gitData, period, startDate, endDat
     sections.push({ title: '代码产出', lines: sectionLines });
   }
 
+  // 板块：效率指标
+  {
+    const effLines = buildEfficiencyMetrics(usageData, gitData);
+    if (effLines) {
+      sections.push({ title: '效率指标', lines: effLines });
+    }
+  }
+
   // 板块：成本与效率
   if (usageData.estimatedCost) {
     const sectionLines = [];
@@ -1386,6 +2051,16 @@ export function generateWorkReport(usageData, gitData, period, startDate, endDat
         sectionLines.push(`- ${s}`);
       }
     }
+
+    // 成本结构分析
+    const costStructure = buildCostStructureAnalysis(usageData);
+    if (costStructure) {
+      sectionLines.push('');
+      for (const l of costStructure) {
+        sectionLines.push(l);
+      }
+    }
+
     sectionLines.push('');
     const costInsight = buildCostInsight(usageData);
     if (costInsight) {
@@ -1395,54 +2070,10 @@ export function generateWorkReport(usageData, gitData, period, startDate, endDat
     sections.push({ title: '成本与效率', lines: sectionLines });
   }
 
-  // 板块：工具使用模式
-  if (usageData.tools && Object.keys(usageData.tools).length > 0) {
-    const sectionLines = [];
-    const sortedTools = Object.entries(usageData.tools).sort((a, b) => b[1] - a[1]);
-    const totalCalls = sortedTools.reduce((s, [, v]) => s + v, 0) || 1;
-
-    // 分类统计
-    const categories = { '代码编辑': 0, '代码阅读': 0, '执行/运行': 0, '规划管理': 0, '搜索研究': 0, '其他': 0 };
-    const TOOL_CATEGORIES = {
-      Write: '代码编辑', Edit: '代码编辑', NotebookEdit: '代码编辑', replace_symbol_body: '代码编辑',
-      replace_content: '代码编辑', insert_before_symbol: '代码编辑', insert_after_symbol: '代码编辑',
-      write: '代码编辑', edit: '代码编辑',
-      Read: '代码阅读', Glob: '代码阅读', Grep: '代码阅读', find_symbol: '代码阅读',
-      find_declaration: '代码阅读', find_referencing_symbols: '代码阅读', find_implementations: '代码阅读',
-      get_symbols_overview: '代码阅读', initial_instructions: '代码阅读', get_diagnostics_for_file: '代码阅读',
-      glob: '代码阅读', read: '代码阅读',
-      Bash: '执行/运行', shell_command: '执行/运行', bash: '执行/运行',
-      TaskCreate: '规划管理', TaskUpdate: '规划管理', TaskList: '规划管理', Agent: '规划管理',
-      EnterPlanMode: '规划管理', ExitPlanMode: '规划管理', update_plan: '规划管理', todowrite: '规划管理',
-      WebSearch: '搜索研究', WebFetch: '搜索研究', view_image: '代码阅读',
-    };
-
-    for (const [name, count] of sortedTools) {
-      let cat = TOOL_CATEGORIES[name];
-      if (!cat) {
-        // MCP 工具按前缀分类
-        if (name.startsWith('mcp__Playwright') || name.startsWith('browser_')) cat = '执行/运行';
-        else if (name.startsWith('mcp__context7') || name.startsWith('mcp__open-websearch') || name.startsWith('mcp__mcp-deepwiki') || name.startsWith('mcp__web_reader')) cat = '搜索研究';
-        else if (name.startsWith('mcp__serena')) cat = '代码编辑';
-        else cat = '其他';
-      }
-      categories[cat] += count;
-    }
-
-    const activeCats = Object.entries(categories).filter(([, v]) => v > 0).sort((a, b) => b[1] - a[1]);
-    for (const [cat, count] of activeCats) {
-      const pct = Math.round((count / totalCalls) * 100);
-      sectionLines.push(`- **${cat}**：${pct}%（${formatInt(count)} 次）`);
-    }
-
-    // Top 3 工具
-    const top3 = sortedTools.slice(0, 3);
-    if (top3.length > 0) {
-      sectionLines.push('');
-      sectionLines.push(`> 使用最频繁的工具：${top3.map(([n, c]) => `${n}（${formatInt(c)} 次）`).join('、')}。`);
-    }
-    sectionLines.push('');
-    sections.push({ title: '工具使用模式', lines: sectionLines });
+  // 板块：工具使用与分析（合并模式展示 + 深度分析）
+  const toolSectionLines = buildToolAnalysis(usageData);
+  if (toolSectionLines) {
+    sections.push({ title: '工具使用分析', lines: toolSectionLines });
   }
 
   // 统一渲染板块，动态编号
@@ -1459,6 +2090,291 @@ export function generateWorkReport(usageData, gitData, period, startDate, endDat
   return adaptPlatformOutput(lines.join('\n'), fmt);
 }
 
+/**
+ * 工具使用数据分析——从数据中提炼现象、规律和洞察
+ */
+function buildToolAnalysis(usageData) {
+  if (!usageData.tools || Object.keys(usageData.tools).length === 0) return null;
+
+  const lines = [];
+
+  // ── 基础数据准备 ──
+  const sortedTools = Object.entries(usageData.tools).sort((a, b) => toolCalls(b[1]) - toolCalls(a[1]));
+  const totalCalls = sortedTools.reduce((s, [, v]) => s + toolCalls(v), 0) || 1;
+  const uniqueToolCount = sortedTools.length;
+
+  // ── 样本量校验 ──
+  const lowSample = totalCalls < 20;
+  const veryLowSample = totalCalls < 5;
+  if (veryLowSample) {
+    lines.push(`> 样本量过少（仅 ${totalCalls} 次工具调用），以下分析仅供参考，统计结论可靠性有限。`);
+    lines.push('');
+  } else if (lowSample) {
+    lines.push(`> 样本量较少（${totalCalls} 次工具调用），分析结论的统计意义有限。`);
+    lines.push('');
+  }
+
+  // ── 分类统计 ──
+  const TOOL_CATEGORIES = {
+    Write: '代码编辑', Edit: '代码编辑', NotebookEdit: '代码编辑', replace_symbol_body: '代码编辑',
+    replace_content: '代码编辑', insert_before_symbol: '代码编辑', insert_after_symbol: '代码编辑',
+    write: '代码编辑', edit: '代码编辑',
+    Read: '代码阅读', Glob: '代码阅读', Grep: '代码阅读', find_symbol: '代码阅读',
+    find_declaration: '代码阅读', find_referencing_symbols: '代码阅读', find_implementations: '代码阅读',
+    get_symbols_overview: '代码阅读', initial_instructions: '代码阅读', get_diagnostics_for_file: '代码阅读',
+    glob: '代码阅读', read: '代码阅读',
+    Bash: '执行/运行', shell_command: '执行/运行', bash: '执行/运行',
+    TaskCreate: '规划管理', TaskUpdate: '规划管理', TaskList: '规划管理', Agent: '规划管理',
+    EnterPlanMode: '规划管理', ExitPlanMode: '规划管理', update_plan: '规划管理', todowrite: '规划管理',
+    WebSearch: '搜索研究', WebFetch: '搜索研究', view_image: '代码阅读',
+  };
+  const catCalls = { '代码编辑': 0, '代码阅读': 0, '执行/运行': 0, '规划管理': 0, '搜索研究': 0, '其他': 0 };
+
+  for (const [name, val] of sortedTools) {
+    const calls = toolCalls(val);
+    let cat = TOOL_CATEGORIES[name];
+    if (!cat) {
+      if (name.startsWith('mcp__Playwright') || name.startsWith('browser_')) cat = '执行/运行';
+      else if (name.startsWith('mcp__context7') || name.startsWith('mcp__open-websearch') || name.startsWith('mcp__mcp-deepwiki') || name.startsWith('mcp__web_reader')) cat = '搜索研究';
+      else if (name.startsWith('mcp__serena')) cat = '代码编辑';
+      else cat = '其他';
+    }
+    catCalls[cat] += calls;
+  }
+
+  const activeCats = Object.entries(catCalls).filter(([, v]) => v > 0).sort((a, b) => b[1] - a[1]);
+  if (activeCats.length === 0) return null;
+
+  // ══════════════════════════════════════
+  // 零、分类概览（原"工具使用模式"的数据展示）
+  // ══════════════════════════════════════
+  for (const [cat, count] of activeCats) {
+    const rawPct = (count / totalCalls) * 100;
+    const pct = rawPct < 1 ? '<1' : Math.round(rawPct);
+    lines.push(`- **${cat}**：${pct}%（${formatInt(count)} 次）`);
+  }
+
+  // Top 3 工具
+  const top3 = sortedTools.slice(0, 3);
+  if (top3.length > 0) {
+    lines.push('');
+    lines.push(`> 使用最频繁的工具：${top3.map(([n, val]) => {
+      const c = toolCalls(val);
+      return `${n}（${formatInt(c)} 次）`;
+    }).join('、')}。`);
+  }
+  lines.push('');
+
+  // ══════════════════════════════════════
+  // 一、工作模式判断
+  // ══════════════════════════════════════
+  const patterns = [];
+  const catPcts = {};
+  for (const [cat, count] of activeCats) {
+    catPcts[cat] = Math.round((count / totalCalls) * 100);
+  }
+
+  // 判断主导工作模式
+  const dominant = activeCats[0];
+  const dominantPct = catPcts[dominant[0]];
+
+  if (catPcts['代码编辑'] >= 40) {
+    patterns.push('以**深度开发**为主——大量使用代码编辑类工具，处于密集编码阶段');
+  } else if (catPcts['代码阅读'] >= 35) {
+    patterns.push('以**代码审查与理解**为主——大量阅读代码，可能在熟悉代码库或进行 code review');
+  } else if (catPcts['搜索研究'] >= 30) {
+    patterns.push('以**调研探索**为主——频繁使用搜索和文档工具，处于技术调研或方案选型阶段');
+  } else if (catPcts['执行/运行'] >= 25) {
+    patterns.push('以**测试验证**为主——频繁执行命令，可能在调试、运行测试或部署验证');
+  } else if (catPcts['规划管理'] >= 25) {
+    patterns.push('以**任务规划与协调**为主——大量使用任务管理和子代理工具，处于项目管理或任务拆解阶段');
+  }
+
+  // 多模式叠加判断（作为对主模式的补充，避免与主模式矛盾）
+  const mainMode = patterns[0] || '';
+  if (catPcts['代码编辑'] >= 25 && catPcts['代码阅读'] >= 20) {
+    patterns.push('编辑与阅读比例均衡（编辑 ' + catPcts['代码编辑'] + '% : 阅读 ' + catPcts['代码阅读'] + '%），体现出**边读边改**的渐进式开发风格');
+  }
+  if (catPcts['执行/运行'] >= 30 && catPcts['代码阅读'] >= 20 && !mainMode.includes('代码审查')) {
+    patterns.push('执行与阅读联动（执行 ' + catPcts['执行/运行'] + '% : 阅读 ' + catPcts['代码阅读'] + '%），说明在**边查边试**——先阅读理解代码，再执行命令验证');
+  }
+  if (catPcts['代码编辑'] >= 15 && catPcts['执行/运行'] >= 30) {
+    patterns.push('编辑占比 ' + catPcts['代码编辑'] + '% 配合 ' + catPcts['执行/运行'] + '% 的执行量，体现出**快速迭代、频繁验证**的开发节奏');
+  }
+  if (catPcts['搜索研究'] >= 15 && catPcts['代码编辑'] >= 15) {
+    patterns.push('搜索与编辑联动（搜索 ' + catPcts['搜索研究'] + '% : 编辑 ' + catPcts['代码编辑'] + '%），说明在**边查文档边编码**');
+  }
+
+  if (patterns.length === 0 && dominantPct < 40) {
+    patterns.push('工具使用分布较为**均匀多元**，属于**全栈协作模式**——各类工具交替使用，工作节奏多样');
+  }
+
+  lines.push('**工作模式**：' + patterns[0]);
+  for (let i = 1; i < patterns.length; i++) {
+    lines.push('');
+    lines.push('> ' + patterns[i]);
+  }
+
+  // ══════════════════════════════════════
+  // 二、迭代度分析（Calls / Uses 比率）
+  // ══════════════════════════════════════
+  lines.push('');
+  lines.push('**迭代度分析**：');
+
+  const iterativeTools = [];
+  for (const [name, val] of sortedTools) {
+    const calls = toolCalls(val);
+    const uses = toolUses(val);
+    if (uses > 0 && calls > uses * 1.5 && calls >= 5) {
+      iterativeTools.push({ name, calls, uses, ratio: (calls / uses).toFixed(1) });
+    }
+  }
+  iterativeTools.sort((a, b) => b.ratio - a.ratio);
+
+  if (iterativeTools.length === 0) {
+    lines.push('各工具的调用/使用比接近 1:1，说明工具调用**目标明确**，较少在同一轮对话中重复调用同一工具。');
+  } else {
+    const topIterative = iterativeTools.slice(0, 3);
+    const insights = topIterative.map(t => {
+      const meaning = getIterativeInsight(t.name, t.ratio);
+      return `**${t.name}**（调用 ${formatInt(t.calls)} 次 / 使用 ${formatInt(t.uses)} 次，比率 ${t.ratio}×）——${meaning}`;
+    });
+    for (const ins of insights) {
+      lines.push('- ' + ins);
+    }
+
+    // 综合判断
+    const hasHighIteration = iterativeTools.some(t => parseFloat(t.ratio) >= 3);
+    if (hasHighIteration) {
+      lines.push('');
+      lines.push('> 存在高迭代工具（比率 ≥ 3×），整体工作风格偏向**渐进式打磨**——在单次交互中反复调整，直到达到预期效果。');
+    } else {
+      lines.push('');
+      lines.push('> 迭代倍率适中（均 < 3×），说明虽然存在重复调用，但**收敛速度较快**，每次调整的方向性较强。');
+    }
+  }
+
+  // ══════════════════════════════════════
+  // 三、集中度与多样性
+  // ══════════════════════════════════════
+  lines.push('');
+  lines.push('**工具分布特征**：');
+
+  const top1Pct = Math.round((toolCalls(sortedTools[0][1]) / totalCalls) * 100);
+  const top3Calls = sortedTools.slice(0, Math.min(3, sortedTools.length)).reduce((s, [, v]) => s + toolCalls(v), 0);
+  const top3Pct = Math.round((top3Calls / totalCalls) * 100);
+
+  if (top1Pct >= 50) {
+    lines.push(`最常用工具 **${sortedTools[0][0]}** 占比达 ${top1Pct}%，存在明显的**单工具依赖**现象。`);
+    lines.push(`> 高度集中在单一工具上，可能意味着工作内容比较单一，或该工具承载了过多的操作类型。建议关注是否有更细粒度的工具可以替代部分操作。`);
+  } else if (top3Pct >= 70) {
+    lines.push(`前 3 个工具合计占比 ${top3Pct}%（其中 ${sortedTools[0][0]} ${top1Pct}%），呈现**适度集中**的分布。`);
+    lines.push(`> 核心工具集明确，同时保留了足够的工具多样性。这是一个健康的工作模式——核心流程稳定，辅助工具按需调用。`);
+  } else if (top3Pct >= 50) {
+    lines.push(`前 3 个工具合计占比 ${top3Pct}%，分布**相对分散**，使用了 ${uniqueToolCount} 种不同的工具。`);
+    lines.push(`> 工具使用面较广，说明工作内容**多样化**——不局限于单一操作类型，覆盖了开发链路的多个环节。`);
+  } else {
+    lines.push(`工具分布**高度分散**，前 3 个工具仅占 ${top3Pct}%，共使用了 ${uniqueToolCount} 种工具。`);
+    lines.push(`> 极其多元的工具使用，说明工作内容复杂度高，涉及多个维度的操作。这也可能意味着任务类型跨度较大。`);
+  }
+
+  // ══════════════════════════════════════
+  // 四、关键发现
+  // ══════════════════════════════════════
+  const findings = [];
+
+  // 发现1：编辑/阅读比率
+  const editCalls = catCalls['代码编辑'];
+  const readCalls = catCalls['代码阅读'];
+  if (editCalls > 0 && readCalls > 0) {
+    const editReadRatio = editCalls / readCalls;
+    if (editReadRatio >= 3) {
+      findings.push('编辑/阅读比达 **' + editReadRatio.toFixed(1) + ':1**，远高于均衡值。说明对代码库已有较高熟悉度，以"写"为主——可能处于功能快速落地阶段。');
+    } else if (editReadRatio >= 1.5) {
+      findings.push('编辑/阅读比约 **' + editReadRatio.toFixed(1) + ':1**，略偏编辑。说明在"先理解再修改"的节奏中，修改动作更加频繁，属于**高效迭代**的工作状态。');
+    } else if (editReadRatio >= 0.7) {
+      findings.push('编辑/阅读比约 **' + editReadRatio.toFixed(1) + ':1**，接近均衡。体现出**审慎的工程习惯**——先充分理解再动手修改，降低出错风险。');
+    } else {
+      findings.push('编辑/阅读比仅 **' + editReadRatio.toFixed(1) + ':1**，以阅读为主。可能正在**熟悉新代码库、做技术评审或排查问题**。');
+    }
+  }
+
+  // 发现2：Agent/子代理使用
+  const agentTool = sortedTools.find(([n]) => n === 'Agent');
+  if (agentTool) {
+    const agentCalls = toolCalls(agentTool[1]);
+    const agentPct = Math.round((agentCalls / totalCalls) * 100);
+    if (agentPct >= 15) {
+      findings.push('Agent（子代理）调用占比达 **' + agentPct + '%**，大量使用并行/委托式工作模式。说明善于利用**任务拆解和并行执行**来提升效率。');
+    } else if (agentPct >= 5) {
+      findings.push('Agent（子代理）调用占 **' + agentPct + '%**，适度使用了子代理进行任务委派。');
+    }
+  }
+
+  // 发现3：MCP工具使用
+  const mcpTools = sortedTools.filter(([n]) => n.startsWith('mcp__'));
+  if (mcpTools.length >= 3) {
+    const mcpCalls = mcpTools.reduce((s, [, v]) => s + toolCalls(v), 0);
+    const mcpPct = Math.round((mcpCalls / totalCalls) * 100);
+    const mcpServers = new Set(mcpTools.map(([n]) => n.split('__')[1]?.split('_')[0]).filter(Boolean));
+    findings.push('使用了 **' + mcpTools.length + ' 种** MCP 工具（来自 ' + mcpServers.size + ' 个 MCP 服务），占总调用的 **' + mcpPct + '%**。说明充分利用了外部工具生态，扩展了 AI 的能力边界。');
+  }
+
+  // 发现4：搜索工具依赖
+  const searchCalls = catCalls['搜索研究'];
+  if (searchCalls > 0) {
+    const searchPct = Math.round((searchCalls / totalCalls) * 100);
+    if (searchPct >= 25) {
+      findings.push('搜索研究类工具占比 **' + searchPct + '%**，对外部信息有较高依赖。说明当前工作中有大量**需要参考文档、查证资料**的场景。');
+    }
+  }
+
+  if (findings.length > 0) {
+    lines.push('');
+    lines.push('**关键发现**：');
+    for (const f of findings) {
+      lines.push('- ' + f);
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * 根据工具名称和迭代比率，返回有意义的分析文案
+ */
+function getIterativeInsight(toolName, ratio) {
+  const r = parseFloat(ratio);
+  const level = r >= 5 ? '极高频' : r >= 3 ? '高频' : '中频';
+
+  const insights = {
+    'Bash': level + '迭代执行——可能在**反复调试命令、逐步修正参数**，或执行多步部署/测试流程',
+    'Edit': level + '迭代编辑——在同一段代码上**反复打磨**，体现出精细化的代码调整过程',
+    'Write': level + '迭代写入——可能在**分步骤创建多个文件**，或反复重写同一文件',
+    'Read': level + '迭代阅读——在同一次对话中**反复查阅**同一文件或多个文件，可能在深入理解代码逻辑',
+    'Grep': level + '迭代搜索——**多轮搜索不同关键词**，说明在进行系统性的代码定位或模式分析',
+    'Glob': level + '迭代搜索文件——**多轮文件匹配**，可能在探索项目结构或定位特定类型的文件',
+    'Agent': level + '迭代派发子任务——在单次对话中**多次委派不同子任务**，说明任务复杂度较高，需要多步骤协调',
+    'WebSearch': level + '迭代搜索——在单次对话中**多次搜索不同话题**，说明调研范围较广',
+  };
+
+  if (insights[toolName]) return insights[toolName];
+
+  // MCP 工具的特殊处理
+  if (toolName.startsWith('mcp__Playwright') || toolName.startsWith('browser_')) {
+    return level + '迭代浏览器操作——可能在**反复调试页面交互**，或多步骤自动化测试';
+  }
+  if (toolName.startsWith('mcp__serena')) {
+    return level + '迭代代码操作——使用 Serena 进行**多步骤代码重构或分析**';
+  }
+  if (toolName.startsWith('mcp__context7') || toolName.startsWith('mcp__open-websearch') || toolName.startsWith('mcp__web_reader')) {
+    return level + '迭代信息检索——**多轮查证不同文档**，在进行系统性的技术调研';
+  }
+
+  return level + '迭代调用——在单次对话中重复使用该工具，说明对该工具的**操作具有多步骤特性**';
+}
+
+
 function buildSuggestions(stats) {
   const tips = [];
   // 缓存命中率