autosnippet 3.2.7 → 3.2.8

package/lib/service/chat/tools/ast-graph.js

@@ -1,16 +1,17 @@
 /**
- * ast-graph.js — AST 结构化分析 + Agent Memory 工具 (10)
+ * ast-graph.js — AST 结构化分析 + Agent Memory 工具 (11)
  *
  * 44. get_project_overview  项目 AST 概览
  * 45. get_class_hierarchy   类继承层级
- * 46. get_class_info        类详细信息
- * 47. get_protocol_info     协议详细信息
+ * 46. get_class_info        类/结构体详细信息 (跨语言)
+ * 47. get_protocol_info     协议/接口/trait 详细信息 (跨语言)
  * 48. get_method_overrides  方法覆写查询
- * 49. get_category_map      Category 扩展映射
+ * 49. get_category_map      Category/Extension 扩展映射
  * 50. get_previous_analysis 前序维度分析结果
  * 51. note_finding          记录关键发现
  * 52. get_previous_evidence 检索前序维度证据
  * 53. query_code_graph      查询代码实体图谱
+ * 54. query_call_graph      查询方法调用链 (Phase 5)
  */
 
 // ════════════════════════════════════════════════════════════
@@ -36,7 +37,8 @@ function _getProjectGraph(ctx) {
 export const getProjectOverview = {
   name: 'get_project_overview',
   description:
-    '获取项目的整体结构概览：文件统计、模块列表、入口点、类/协议/Category 数量。' +
+    '获取项目的整体结构概览：文件统计、语言分布、模块列表、入口点、类/协议/Category 数量。' +
+    '支持所有语言 (Swift/ObjC/Java/Kotlin/Python/TS/JS/Dart/Rust/Go 等)。' +
     '适用场景：了解项目规模和架构布局，规划探索路径。',
   parameters: {
     type: 'object',
@@ -49,13 +51,30 @@ export const getProjectOverview = {
     }
 
     const o = graph.getOverview();
+
+    // §P2: 从文件扩展名统计语言分布
+    const langStats = {};
+    for (const filePath of graph.getAllFilePaths?.() || []) {
+      const ext = filePath.split('.').pop();
+      if (ext) langStats[ext] = (langStats[ext] || 0) + 1;
+    }
+
     const lines = [
       `📊 项目 AST 概览 (构建耗时 ${o.buildTimeMs}ms)`,
       ``,
-      `文件: ${o.totalFiles} | 类: ${o.totalClasses} | 协议: ${o.totalProtocols} | Category: ${o.totalCategories} | 方法: ${o.totalMethods}`,
-      ``,
-      `── 模块 ──`,
+      `文件: ${o.totalFiles} | 类: ${o.totalClasses} | 协议/接口: ${o.totalProtocols} | Category/Extension: ${o.totalCategories} | 方法: ${o.totalMethods}`,
     ];
+
+    // 语言分布
+    const langEntries = Object.entries(langStats).sort((a, b) => b[1] - a[1]);
+    if (langEntries.length > 0) {
+      lines.push(``, `── 语言分布 ──`);
+      for (const [ext, count] of langEntries) {
+        lines.push(`  .${ext}: ${count} 个文件`);
+      }
+    }
+
+    lines.push(``, `── 模块 ──`);
     for (const mod of o.topLevelModules) {
       const count = o.classesPerModule[mod] || 0;
       lines.push(`  ${mod}/ — ${count} 个类`);
@@ -76,7 +95,8 @@ export const getProjectOverview = {
 export const getClassHierarchy = {
   name: 'get_class_hierarchy',
   description:
-    '查看指定类的继承链（向上到根类）和直接子类列表。' +
+    '查看指定类/结构体的继承链（向上到根类）和直接子类列表。' +
+    '支持所有语言的类继承体系 (Swift class/struct, Java/Kotlin class, Python class, TS class, Dart class, Rust struct, Go struct 等)。' +
     '传入 className 查看指定类，不传则返回项目中所有根类及其子树。',
   parameters: {
     type: 'object',
@@ -138,7 +158,9 @@ export const getClassHierarchy = {
 // ────────────────────────────────────────────────────────────
 export const getClassInfo = {
   name: 'get_class_info',
-  description: '获取指定类的详细信息: 属性、方法签名、导入、继承关系、Category 扩展。',
+  description:
+    '获取指定类/结构体的详细信息: 属性、方法签名、导入、继承关系、扩展。' +
+    '跨语言通用：ObjC @interface, Swift class/struct, Java/Kotlin class, Python class, TS/JS class, Dart class, Rust struct impl, Go struct 等。',
   parameters: {
     type: 'object',
     properties: {
@@ -169,7 +191,7 @@ export const getClassInfo = {
     ];
 
     if (info.protocols.length > 0) {
-      lines.push(`遵循: <${info.protocols.join(', ')}>`);
+      lines.push(`实现: ${info.protocols.join(', ')}`);
     }
 
     if (info.properties.length > 0) {
@@ -195,7 +217,7 @@ export const getClassInfo = {
     }
 
     if (cats.length > 0) {
-      lines.push(``, `── Category 扩展 (${cats.length}) ──`);
+      lines.push(``, `── 扩展 (${cats.length}) ──`);
       for (const cat of cats) {
         const methodNames = cat.methods.map((m) => m.selector).join(', ');
         lines.push(`  ${info.name}(${cat.categoryName}) — ${cat.filePath} — [${methodNames}]`);
@@ -218,7 +240,9 @@ export const getClassInfo = {
 // ────────────────────────────────────────────────────────────
 export const getProtocolInfo = {
   name: 'get_protocol_info',
-  description: '获取指定协议的定义（必选/可选方法）及所有遵循该协议的类。',
+  description:
+    '获取指定协议/接口/trait 的定义（必选/可选方法）及所有实现者列表。' +
+    '跨语言通用：ObjC @protocol, Swift protocol, Java/Kotlin interface, Python ABC, TS interface, Dart abstract class, Rust trait, Go interface 等。',
   parameters: {
     type: 'object',
     properties: {
@@ -235,36 +259,36 @@ export const getProtocolInfo = {
     const protocolName = params.protocolName || params.protocol_name;
     const info = graph.getProtocolInfo(protocolName);
     if (!info) {
-      return `未找到协议 "${protocolName}"。可以使用 get_project_overview 查看项目中的所有协议。`;
+      return `未找到协议/接口 "${protocolName}"。可以使用 get_project_overview 查看项目中的所有协议/接口。`;
     }
 
-    const lines = [`📋 @protocol ${info.name}`, `文件: ${info.filePath}:${info.line}`];
+    const lines = [`📋 ${info.name}`, `文件: ${info.filePath}:${info.line}`];
 
     if (info.inherits.length > 0) {
-      lines.push(`继承: <${info.inherits.join(', ')}>`);
+      lines.push(`继承: ${info.inherits.join(', ')}`);
     }
 
     if (info.requiredMethods.length > 0) {
-      lines.push(``, `── @required (${info.requiredMethods.length}) ──`);
+      lines.push(``, `── 必须实现 (${info.requiredMethods.length}) ──`);
       for (const m of info.requiredMethods) {
         lines.push(`  ${m.isClassMethod ? '+' : '-'} ${m.selector} → ${m.returnType}`);
       }
     }
 
     if (info.optionalMethods.length > 0) {
-      lines.push(``, `── @optional (${info.optionalMethods.length}) ──`);
+      lines.push(``, `── 可选实现 (${info.optionalMethods.length}) ──`);
       for (const m of info.optionalMethods) {
         lines.push(`  ${m.isClassMethod ? '+' : '-'} ${m.selector} → ${m.returnType}`);
       }
     }
 
     if (info.conformers.length > 0) {
-      lines.push(``, `── 遵循者 (${info.conformers.length}) ──`);
+      lines.push(``, `── 实现者 (${info.conformers.length}) ──`);
       for (const c of info.conformers) {
         lines.push(`  ${c}`);
       }
     } else {
-      lines.push(``, `⚠️ 暂未发现遵循此协议的类`);
+      lines.push(``, `⚠️ 暂未发现实现此协议/接口的类`);
     }
 
     return lines.join('\n');
@@ -276,7 +300,9 @@ export const getProtocolInfo = {
 // ────────────────────────────────────────────────────────────
 export const getMethodOverrides = {
   name: 'get_method_overrides',
-  description: '查找覆写了指定方法的所有子类。适用于理解方法在继承树中的多态行为。',
+  description:
+    '查找覆写了指定方法的所有子类。适用于理解方法在继承树中的多态行为。' +
+    '跨语言通用：支持 ObjC/Swift/Java/Kotlin/Python/TS/Dart 等语言的方法覆写。',
   parameters: {
     type: 'object',
     properties: {
@@ -314,7 +340,9 @@ export const getMethodOverrides = {
 export const getCategoryMap = {
   name: 'get_category_map',
   description:
-    '获取指定类或整个项目的 ObjC Category 扩展映射。Category 是 ObjC 的核心模式，了解它有助于发现功能划分。',
+    '获取指定类的 Category/Extension 扩展映射。' +
+    'ObjC Category、Swift Extension 等语言的类扩展机制。了解它有助于发现功能划分。' +
+    '不传 className 则返回整个项目中有扩展的类列表。',
   parameters: {
     type: 'object',
     properties: {
@@ -455,7 +483,9 @@ export const noteFinding = {
     const coordinator = ctx._memoryCoordinator;
     if (coordinator) {
       const finding = params.finding || '';
-      const evidence = params.evidence || '';
+      // P0 Fix: AI 可能传入 array/object，强制转为 string
+      const rawEvidence = params.evidence;
+      const evidence = typeof rawEvidence === 'string' ? rawEvidence : Array.isArray(rawEvidence) ? rawEvidence.join(', ') : rawEvidence ? String(rawEvidence) : '';
       const importance = params.importance || 5;
       const round = ctx._currentRound || 0;
       const scopeId = ctx._dimensionScopeId || undefined;
@@ -547,8 +577,8 @@ export const queryCodeGraph = {
       },
       entity_type: {
         type: 'string',
-        enum: ['class', 'protocol', 'category', 'module', 'pattern'],
-        description: '实体类型过滤 (可选)',
+        enum: ['class', 'protocol', 'category', 'module', 'pattern', 'method'],
+        description: '实体类型过滤 (可选，含 Phase 5 method 类型)',
       },
       max_depth: {
         type: 'number',
@@ -559,14 +589,17 @@ export const queryCodeGraph = {
   },
   handler: async (params, ctx) => {
     try {
-      const { CodeEntityGraph } = await import('../../knowledge/CodeEntityGraph.js');
-      const db = ctx?.container?.get('database');
-      if (!db) {
-        return '代码实体图谱不可用: 数据库未初始化';
+      // 优先从 container 获取单例 CEG，避免每次创建新实例
+      let ceg = ctx?.container?.get?.('codeEntityGraph');
+      if (!ceg) {
+        const { CodeEntityGraph } = await import('../../knowledge/CodeEntityGraph.js');
+        const db = ctx?.container?.get?.('database');
+        if (!db) {
+          return '代码实体图谱不可用: 数据库未初始化';
+        }
+        const projectRoot = ctx?.projectRoot || process.env.ASD_PROJECT_DIR || '';
+        ceg = new CodeEntityGraph(db, { projectRoot });
       }
-
-      const projectRoot = ctx?.projectRoot || process.env.ASD_PROJECT_DIR || '';
-      const ceg = new CodeEntityGraph(db, { projectRoot });
       const maxDepth = params.max_depth || 3;
 
       switch (params.action) {
@@ -680,3 +713,167 @@ export const queryCodeGraph = {
     }
   },
 };
+
+// ────────────────────────────────────────────────────────────
+// 54. query_call_graph — 查询方法调用链 (Phase 5)
+// ────────────────────────────────────────────────────────────
+export const queryCallGraph = {
+  name: 'query_call_graph',
+  description:
+    '查询方法的调用链上下文 (Call Graph)。支持 10+ 种编程语言 (Swift/ObjC/Java/Kotlin/Python/TS/JS/Dart/Rust/Go)。\n' +
+    '• callers: 谁调用了这个方法？(向上追踪调用者链)\n' +
+    '• callees: 这个方法调用了谁？(向下追踪依赖链)\n' +
+    '• both: 同时获取调用者和被调用者\n' +
+    '• impact: 修改此方法的影响半径分析 (受影响文件数)\n' +
+    '• search: 按名称搜索方法实体\n' +
+    '⚠️ 需要先完成 bootstrap 才有数据。方法名格式: "ClassName.methodName" 或简写 "methodName"。',
+  parameters: {
+    type: 'object',
+    properties: {
+      methodName: {
+        type: 'string',
+        description:
+          '方法名 (e.g. "UserService.getUser", "viewDidLoad", "handleClick")。' +
+          'search 模式下为搜索关键词。',
+      },
+      direction: {
+        type: 'string',
+        enum: ['callers', 'callees', 'both', 'impact', 'search'],
+        description:
+          'callers=调用者 | callees=被调用者 | both=双向 | impact=影响分析 | search=搜索方法实体',
+      },
+      maxDepth: {
+        type: 'number',
+        description: '最大遍历深度 (1-5, 默认 2)',
+      },
+    },
+    required: ['methodName'],
+  },
+  handler: async (params, ctx) => {
+    try {
+      // 前置: 必填参数校验 (fail-fast)
+      const methodName = params.methodName || params.method_name;
+      if (!methodName) {
+        return '请提供 methodName 参数。';
+      }
+
+      // 优先从 container 获取单例 CEG，避免每次创建新实例
+      let ceg = ctx?.container?.get?.('codeEntityGraph');
+      if (!ceg) {
+        // fallback: 手动构建
+        const { CodeEntityGraph } = await import('../../knowledge/CodeEntityGraph.js');
+        const db = ctx?.container?.get?.('database');
+        if (!db) {
+          return '调用图查询不可用: 数据库未初始化。';
+        }
+        const projectRoot = ctx?.projectRoot || process.env.ASD_PROJECT_DIR || '';
+        ceg = new CodeEntityGraph(db, { projectRoot });
+      }
+
+      const direction = params.direction || 'both';
+      const maxDepth = Math.min(Math.max(Number(params.maxDepth || params.max_depth) || 2, 1), 5);
+
+      // search 模式: 按名称搜索方法实体
+      if (direction === 'search') {
+        const results = ceg.searchEntities(methodName, { type: 'method', limit: 15 });
+        if (results.length === 0) {
+          // 降级: 不限类型搜索
+          const allResults = ceg.searchEntities(methodName, { limit: 15 });
+          if (allResults.length === 0) {
+            return `未找到匹配 "${methodName}" 的实体。请确认 bootstrap 已完成。`;
+          }
+          const lines = [`🔍 搜索 "${methodName}" (${allResults.length} 条, 无 method 类型匹配):`];
+          for (const e of allResults) {
+            lines.push(`  • [${e.entityType}] ${e.name}${e.filePath ? ` (${e.filePath})` : ''}`);
+          }
+          lines.push(``, `💡 提示: 调用图查询需使用 method 实体的 entityId。`);
+          return lines.join('\n');
+        }
+        const lines = [`🔍 方法搜索 "${methodName}" (${results.length} 条):`];
+        for (const e of results) {
+          lines.push(`  • ${e.name}${e.filePath ? ` (${e.filePath})` : ''}`);
+        }
+        lines.push(``, `💡 复制上面的完整方法名，用 callers/callees/both/impact 查询其调用链。`);
+        return lines.join('\n');
+      }
+
+      // impact 模式
+      if (direction === 'impact') {
+        const impact = ceg.getCallImpactRadius(methodName);
+        const lines = [
+          `⚡ 修改 "${methodName}" 的影响半径:`,
+          `  直接调用者: ${impact.directCallers}`,
+          `  传递性调用者 (depth≤3): ${impact.transitiveCallers}`,
+        ];
+        if (impact.affectedFiles.length > 0) {
+          lines.push(`  受影响文件 (${impact.affectedFiles.length}):`);
+          for (const f of impact.affectedFiles.slice(0, 15)) {
+            lines.push(`    📄 ${f}`);
+          }
+          if (impact.affectedFiles.length > 15) {
+            lines.push(`    ... 还有 ${impact.affectedFiles.length - 15} 个文件`);
+          }
+        } else {
+          lines.push(`  未发现受影响文件 (可能是叶子方法或 bootstrap 无调用图数据)。`);
+        }
+        return lines.join('\n');
+      }
+
+      // callers / callees / both 模式
+      const result = {};
+      if (direction === 'callers' || direction === 'both') {
+        result.callers = ceg.getCallers(methodName, maxDepth);
+      }
+      if (direction === 'callees' || direction === 'both') {
+        result.callees = ceg.getCallees(methodName, maxDepth);
+      }
+
+      const totalCallers = result.callers?.length || 0;
+      const totalCallees = result.callees?.length || 0;
+
+      if (totalCallers === 0 && totalCallees === 0) {
+        return (
+          `"${methodName}" 在调用图中没有找到调用关系。\n\n` +
+          `可能原因:\n` +
+          `  1. 方法名拼写不匹配 — 尝试 search 模式: query_call_graph({methodName:"关键词", direction:"search"})\n` +
+          `  2. 该方法是入口点/叶子节点，无上下游\n` +
+          `  3. bootstrap 尚未执行或不包含此文件`
+        );
+      }
+
+      const lines = [`📞 "${methodName}" 的调用链 (depth≤${maxDepth}):`];
+
+      if (result.callers?.length > 0) {
+        lines.push(``, `── 调用者 (谁调用了它, ${result.callers.length} 条) ──`);
+        for (const c of result.callers.slice(0, 20)) {
+          const indent = '  '.repeat(c.depth);
+          const typeTag = c.callType !== 'unknown' ? ` [${c.callType}]` : '';
+          lines.push(`${indent}⬆ ${c.caller}${typeTag}`);
+        }
+        if (result.callers.length > 20) {
+          lines.push(`  ... 还有 ${result.callers.length - 20} 个调用者`);
+        }
+      }
+
+      if (result.callees?.length > 0) {
+        lines.push(``, `── 被调用者 (它调用了谁, ${result.callees.length} 条) ──`);
+        for (const c of result.callees.slice(0, 20)) {
+          const indent = '  '.repeat(c.depth);
+          const typeTag = c.callType !== 'unknown' ? ` [${c.callType}]` : '';
+          lines.push(`${indent}⬇ ${c.callee}${typeTag}`);
+        }
+        if (result.callees.length > 20) {
+          lines.push(`  ... 还有 ${result.callees.length - 20} 个被调用者`);
+        }
+      }
+
+      return lines.join('\n');
+    } catch (err) {
+      // 表不存在 → 未 bootstrap
+      if (err.message?.includes('no such table')) {
+        return '调用图数据不可用 — knowledge_edges 表不存在，请先运行 bootstrap。';
+      }
+      return `调用图查询失败: ${err.message}`;
+    }
+  },
+};

package/lib/service/chat/tools/index.js

@@ -11,7 +11,7 @@ import {
   refineBootstrapCandidates,
   summarizeCode,
 } from './ai-analysis.js';
-// ── AST 结构化分析 + Agent Memory (10) ──
+// ── AST 结构化分析 + Agent Memory (11) ──
 import {
   getCategoryMap,
   getClassHierarchy,
@@ -22,6 +22,7 @@ import {
   getProjectOverview,
   getProtocolInfo,
   noteFinding,
+  queryCallGraph,
   queryCodeGraph,
 } from './ast-graph.js';
 // ── 组合工具 + 元工具 (6) ──
@@ -158,6 +159,8 @@ export {
   getPreviousEvidence,
   // 代码实体图谱
   queryCodeGraph,
+  // 调用图查询 (Phase 5)
+  queryCallGraph,
 };
 
 // ── ALL_TOOLS 数组（与原始 tools.js 顺序一致）──
@@ -234,6 +237,8 @@ export const ALL_TOOLS = [
   getPreviousEvidence,
   // 代码实体图谱 (1) — Phase E
   queryCodeGraph,
+  // 调用图查询 (1) — Phase 5
+  queryCallGraph,
 ];
 
 export default ALL_TOOLS;

package/lib/service/chat/tools/infrastructure.js

@@ -206,6 +206,10 @@ export const bootstrapKnowledgeTool = {
         type: 'boolean',
         description: '是否加载 Skills 增强维度定义（推荐开启），默认 true',
       },
+      skipAsyncFill: {
+        type: 'boolean',
+        description: '跳过异步 AI 填充（CLI 非 --wait 模式下使用，避免 DB 断连）',
+      },
     },
   },
   handler: async (params, ctx) => {
@@ -218,6 +222,7 @@ export const bootstrapKnowledgeTool = {
         skipGuard: params.skipGuard || false,
         contentMaxLines: params.contentMaxLines || 120,
         loadSkills: params.loadSkills ?? true,
+        skipAsyncFill: params.skipAsyncFill || false,
       }
     );
     // bootstrapKnowledge 返回 envelope JSON string，解析提取 data

package/lib/service/cursor/CursorDeliveryPipeline.js

@@ -35,11 +35,12 @@ export class CursorDeliveryPipeline {
    * @param {string} [options.projectName] - 项目名称
    * @param {Object} [options.logger] - 日志器
    */
-  constructor({ knowledgeService, projectRoot, projectName, logger }) {
+  constructor({ knowledgeService, projectRoot, projectName, logger, database }) {
     this.knowledgeService = knowledgeService;
     this.projectRoot = projectRoot;
     this.projectName = projectName || this._inferProjectName(projectRoot);
     this.logger = logger || console;
+    this.database = database || null;
 
     // 子模块
     this.compressor = new KnowledgeCompressor();
@@ -87,6 +88,18 @@ export class CursorDeliveryPipeline {
       const channelB = this._generateChannelB(patterns, facts);
       stats.channelB = channelB;
 
+      // ── Channel B+: Call Graph Architecture Rules (Phase 5.2) ──
+      const archResult = this._generateCallGraphArchitectureRules();
+      if (archResult) {
+        stats.channelB.topicCount++;
+        stats.channelB.totalTokens += archResult.tokensUsed;
+        stats.channelB.topics['call-architecture'] = {
+          patternsCount: archResult.insightsCount,
+          factsCount: 0,
+          tokensUsed: archResult.tokensUsed,
+        };
+      }
+
       // ── Channel C: Skills Sync ──
       const channelC = await this._generateChannelC();
       stats.channelC = channelC;
@@ -326,6 +339,159 @@ export class CursorDeliveryPipeline {
     return result;
   }
 
+  /**
+   * Channel B+ — Call Graph Architecture Rules (Phase 5.2)
+   * 从调用图拓扑分析架构分层，生成 architecture smart rule
+   * @private
+   * @returns {{ insightsCount: number, tokensUsed: number, filePath: string }|null}
+   */
+  _generateCallGraphArchitectureRules() {
+    if (!this.database) return null;
+
+    try {
+      const db = typeof this.database.getDb === 'function' ? this.database.getDb() : this.database;
+
+      // 查询调用边中的跨目录调用模式
+      const callEdges = db.prepare(
+        `SELECT from_id, to_id, metadata_json FROM knowledge_edges
+         WHERE relation = 'calls' AND metadata_json LIKE '%phase5%'`
+      ).all();
+
+      if (!callEdges || callEdges.length < 5) return null;
+
+      // 提取 caller/callee 对应的文件路径
+      const entityFiles = new Map();
+      const entities = db.prepare(
+        `SELECT entity_id, file_path FROM code_entities WHERE entity_type = 'method'`
+      ).all();
+      for (const e of entities) {
+        entityFiles.set(e.entity_id, e.file_path);
+      }
+
+      // 构建目录级调用矩阵
+      const dirCalls = new Map(); // 'src/controllers' → Map('src/services' → count)
+      for (const edge of callEdges) {
+        const callerFile = entityFiles.get(edge.from_id);
+        const calleeFile = entityFiles.get(edge.to_id);
+        if (!callerFile || !calleeFile || callerFile === calleeFile) continue;
+
+        const callerDir = this._extractLayerDir(callerFile);
+        const calleeDir = this._extractLayerDir(calleeFile);
+        if (!callerDir || !calleeDir || callerDir === calleeDir) continue;
+
+        if (!dirCalls.has(callerDir)) dirCalls.set(callerDir, new Map());
+        const targets = dirCalls.get(callerDir);
+        targets.set(calleeDir, (targets.get(calleeDir) || 0) + 1);
+      }
+
+      if (dirCalls.size === 0) return null;
+
+      // 检测架构层: 入度高(被调用多)的目录是底层服务, 出度高(调用多)的是上层
+      const dirInDegree = new Map();
+      const dirOutDegree = new Map();
+      for (const [from, targets] of dirCalls) {
+        for (const [to, count] of targets) {
+          dirOutDegree.set(from, (dirOutDegree.get(from) || 0) + count);
+          dirInDegree.set(to, (dirInDegree.get(to) || 0) + count);
+        }
+      }
+
+      // 生成架构洞察
+      const lines = [];
+      lines.push('## Call Graph Architecture');
+      lines.push('');
+
+      // 分层推断: 按 (inDegree - outDegree) 排序, 值越大 = 越底层
+      const allDirs = new Set([...dirInDegree.keys(), ...dirOutDegree.keys()]);
+      const layers = [...allDirs].map((dir) => ({
+        dir,
+        inDegree: dirInDegree.get(dir) || 0,
+        outDegree: dirOutDegree.get(dir) || 0,
+        layerScore: (dirInDegree.get(dir) || 0) - (dirOutDegree.get(dir) || 0),
+      })).sort((a, b) => b.layerScore - a.layerScore);
+
+      // 分层标签
+      const total = layers.length;
+      let insightsCount = 0;
+
+      if (total >= 2) {
+        lines.push('### Architecture Layers (inferred from call graph)');
+        lines.push('');
+
+        for (let i = 0; i < layers.length && i < 10; i++) {
+          const l = layers[i];
+          let layerLabel;
+          if (i < total * 0.33) layerLabel = '🔽 low-level (service/repository)';
+          else if (i < total * 0.66) layerLabel = '↔️ mid-level (business logic)';
+          else layerLabel = '🔼 high-level (controller/UI)';
+
+          lines.push(`- \`${l.dir}/\` — ${layerLabel} (in:${l.inDegree} out:${l.outDegree})`);
+          insightsCount++;
+        }
+        lines.push('');
+      }
+
+      // 核心调用链
+      const hotPaths = [...dirCalls.entries()]
+        .flatMap(([from, targets]) =>
+          [...targets.entries()].map(([to, count]) => ({ from, to, count }))
+        )
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 8);
+
+      if (hotPaths.length > 0) {
+        lines.push('### Key Call Paths');
+        lines.push('');
+        for (const p of hotPaths) {
+          lines.push(`- \`${p.from}/\` → \`${p.to}/\` (${p.count} calls)`);
+          insightsCount++;
+        }
+        lines.push('');
+      }
+
+      if (insightsCount === 0) return null;
+
+      // 构建 description (用于 smart rule 关联性判断)
+      const dirList = layers.map((l) => l.dir).join(', ');
+      const description = `Architecture layer analysis for ${this.projectName}. ` +
+        `Relevant when editing files in: ${dirList}. ` +
+        `Call graph shows ${callEdges.length} cross-file call relationships.`;
+
+      const body = lines.join('\n');
+      const writeResult = this.rulesGenerator.writeSmartRules('call-architecture', body, description);
+
+      this.logger.info?.(
+        `[CursorDelivery] Channel B+: call-architecture — ${insightsCount} insights → ${writeResult.filePath}`
+      );
+
+      return {
+        insightsCount,
+        tokensUsed: writeResult.tokensUsed,
+        filePath: writeResult.filePath,
+      };
+    } catch (err) {
+      this.logger.warn?.(`[CursorDelivery] Call graph architecture rules failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 从文件路径中提取层级目录 (第一或第二级有意义的目录)
+   * @private
+   */
+  _extractLayerDir(filePath) {
+    if (!filePath) return null;
+    const parts = filePath.split('/').filter(Boolean);
+    // 跳过 src/ lib/ app/ 等通用前缀
+    const skipPrefixes = new Set(['src', 'lib', 'app', 'pkg', 'internal', 'cmd']);
+    let startIdx = 0;
+    if (parts.length > 1 && skipPrefixes.has(parts[0])) {
+      startIdx = 1;
+    }
+    // 取第一个有意义的目录
+    return parts[startIdx] || parts[0] || null;
+  }
+
   /**
    * Channel C 生成
    * @private