autosnippet 3.4.1 → 3.4.2

package/dist/lib/core/ast/lang-dart.js

@@ -76,7 +76,16 @@ function _walkNode(node, ctx, parentClassName) {
                 }
                 break;
             }
-            case 'function_signature':
+            case 'function_signature': {
+                // 顶层 function_signature 同样需要向前看兄弟 function_body
+                const nextSib = node.namedChild(i + 1);
+                const bodyNode = nextSib?.type === 'function_body' ? nextSib : null;
+                const func = _parseDartMethod(child, parentClassName, bodyNode);
+                if (func) {
+                    ctx.methods.push(func);
+                }
+                break;
+            }
             case 'function_definition':
             case 'top_level_definition': {
                 const func = _parseFunctionDef(child, parentClassName);
@@ -167,9 +176,19 @@ function _walkClassBody(body, ctx, className) {
         const child = body.namedChild(i);
         switch (child.type) {
             case 'method_signature':
-            case 'function_definition':
             case 'getter_signature':
             case 'setter_signature': {
+                // tree-sitter-dart: method_signature 和 function_body 是兄弟节点
+                // 需要向前看下一个兄弟，合并传递给解析器
+                const nextSibling = body.namedChild(i + 1);
+                const bodyNode = nextSibling?.type === 'function_body' ? nextSibling : null;
+                const method = _parseDartMethod(child, className, bodyNode);
+                if (method) {
+                    ctx.methods.push(method);
+                }
+                break;
+            }
+            case 'function_definition': {
                 const method = _parseFunctionDef(child, className);
                 if (method) {
                     ctx.methods.push(method);
@@ -264,9 +283,72 @@ function _parseEnumDecl(node, ctx) {
     });
 }
 // ── Function / Method ────────────────────────────────────────
+/**
+ * 解析 Dart class body 中的 method_signature / getter_signature / setter_signature。
+ * tree-sitter-dart 中这些节点的 identifier 嵌在 function_signature 子节点内，
+ * 且 function_body 是兄弟节点而非子节点。
+ */
+function _parseDartMethod(sigNode, className, bodyNode) {
+    // 递归搜索第一个 identifier（跳过类型标识符）
+    const name = _findMethodName(sigNode);
+    if (!name) {
+        return null;
+    }
+    const text = sigNode.text;
+    const isStatic = text.includes('static ');
+    const isAsync = bodyNode
+        ? bodyNode.text.includes('async') || bodyNode.text.includes('async*')
+        : false;
+    const isOverride = text.includes('@override');
+    const bodyLines = bodyNode ? bodyNode.endPosition.row - bodyNode.startPosition.row + 1 : 0;
+    const complexity = bodyNode ? _estimateComplexity(bodyNode) : 1;
+    const nestingDepth = bodyNode ? _maxNesting(bodyNode, 0) : 0;
+    let kind = 'definition';
+    if (sigNode.type === 'getter_signature') {
+        kind = 'getter';
+    }
+    if (sigNode.type === 'setter_signature') {
+        kind = 'setter';
+    }
+    return {
+        name,
+        className: className || null,
+        isClassMethod: isStatic,
+        isExported: !name.startsWith('_'),
+        isAsync,
+        isOverride,
+        paramCount: _countChildParams(sigNode),
+        bodyLines,
+        complexity,
+        nestingDepth,
+        line: sigNode.startPosition.row + 1,
+        kind,
+    };
+}
+function _findMethodName(node) {
+    // method_signature > function_signature > identifier
+    // getter_signature > identifier
+    // setter_signature > identifier
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c.type === 'identifier') {
+            return c.text;
+        }
+        if (c.type === 'function_signature') {
+            const id = c.namedChildren.find((n) => n.type === 'identifier');
+            if (id) {
+                return id.text;
+            }
+        }
+    }
+    return null;
+}
 function _parseFunctionDef(node, className) {
-    const nameNode = node.namedChildren.find((c) => c.type === 'identifier' || c.type === 'function_name');
-    const name = nameNode?.text;
+    // 先尝试直接子节点，再递归搜索
+    let name = node.namedChildren.find((c) => c.type === 'identifier' || c.type === 'function_name')?.text;
+    if (!name) {
+        name = _findMethodName(node);
+    }
     if (!name) {
         return null;
     }
@@ -294,11 +376,40 @@ function _parseFunctionDef(node, className) {
 }
 // ── Property / Field ─────────────────────────────────────────
 function _parsePropertyDecl(node, className) {
-    const nameNode = node.namedChildren.find((c) => c.type === 'identifier' || c.type === 'initialized_identifier');
-    if (!nameNode) {
+    // tree-sitter-dart property 结构:
+    //   declaration > type_identifier + initialized_identifier_list > initialized_identifier > identifier
+    //   declaration > identifier (简单)
+    //   static_final_declaration > identifier
+    let name = null;
+    // 1. 直接子节点 identifier
+    const directId = node.namedChildren.find((c) => c.type === 'identifier');
+    if (directId) {
+        name = directId.text;
+    }
+    // 2. 嵌套在 initialized_identifier_list > initialized_identifier > identifier
+    if (!name) {
+        const idList = node.namedChildren.find((c) => c.type === 'initialized_identifier_list');
+        if (idList) {
+            const initId = idList.namedChildren.find((c) => c.type === 'initialized_identifier');
+            if (initId) {
+                const id = initId.namedChildren.find((c) => c.type === 'identifier');
+                if (id) {
+                    name = id.text;
+                }
+            }
+        }
+    }
+    // 3. 直接 initialized_identifier
+    if (!name) {
+        const initId = node.namedChildren.find((c) => c.type === 'initialized_identifier');
+        if (initId) {
+            const id = initId.namedChildren.find((c) => c.type === 'identifier');
+            name = id?.text || initId.text;
+        }
+    }
+    if (!name) {
         return null;
     }
-    const name = nameNode.text;
     const text = node.text;
     const isFinal = text.includes('final ');
     const isLate = text.includes('late ');

package/dist/lib/core/ast/lang-java.js

@@ -172,10 +172,8 @@ function _parseJavaClass(node) {
             }
         }
     }
-    // 提取注解
-    const annotations = node.namedChildren
-        .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
-        .map((a) => a.text);
+    // 提取注解（tree-sitter-java: 注解在 modifiers 子节点内）
+    const annotations = _extractAnnotations(node);
     // 修饰符
     const modifiers = node.namedChildren.find((c) => c.type === 'modifiers');
     const isAbstract = modifiers?.text?.includes('abstract') || false;
@@ -216,9 +214,7 @@ function _parseJavaMethod(node, className) {
     const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
     const complexity = body ? _estimateComplexity(body) : 1;
     const nestingDepth = body ? _maxNesting(body, 0) : 0;
-    const annotations = node.namedChildren
-        .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
-        .map((a) => a.text);
+    const annotations = _extractAnnotations(node);
     return {
         name,
         className,
@@ -241,9 +237,7 @@ function _parseJavaField(node, className) {
     const isStatic = modifiers?.text?.includes('static') || false;
     const isFinal = modifiers?.text?.includes('final') || false;
     const isPrivate = modifiers?.text?.includes('private') || false;
-    const annotations = node.namedChildren
-        .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
-        .map((a) => a.text);
+    const annotations = _extractAnnotations(node);
     // Phase 5.3: Extract field type for DI resolution
     // field_declaration: [modifiers] type_identifier variable_declarator
     let typeAnnotation = null;
@@ -267,6 +261,27 @@ function _parseJavaField(node, className) {
         line: node.startPosition.row + 1,
     };
 }
+/**
+ * tree-sitter-java 中注解位于 modifiers 子节点内，而非声明节点的直接子节点。
+ * 此辅助函数同时搜索两层：node.namedChildren + modifiers.namedChildren。
+ */
+function _extractAnnotations(node) {
+    // 1. 直接子节点（兼容其他可能的 AST 结构）
+    const direct = node.namedChildren
+        .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
+        .map((a) => a.text);
+    if (direct.length > 0) {
+        return direct;
+    }
+    // 2. modifiers 子节点
+    const modifiers = node.namedChildren.find((c) => c.type === 'modifiers');
+    if (modifiers) {
+        return modifiers.namedChildren
+            .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
+            .map((a) => a.text);
+    }
+    return [];
+}
 // ── Java 模式检测 ──
 function detectJavaPatterns(root, lang, methods, properties, classes) {
     const patterns = [];

package/dist/lib/core/ast/lang-javascript.js

@@ -75,9 +75,69 @@ function _walkJSClassBody(body, ctx, className) {
         else if (child.type === 'field_definition' || child.type === 'public_field_definition') {
             const name = child.namedChildren.find((c) => c.type === 'property_identifier')?.text;
             if (name) {
-                ctx.properties.push({ name, className, line: child.startPosition.row + 1 });
+                const isStatic = child.text.trimStart().startsWith('static');
+                ctx.properties.push({
+                    name,
+                    className,
+                    isStatic,
+                    isConstant: false,
+                    line: child.startPosition.row + 1,
+                });
+            }
+        }
+    }
+    // 从 constructor 中提取 this.xxx = ... 赋值属性
+    _extractConstructorProperties(body, ctx, className);
+}
+function _extractConstructorProperties(body, ctx, className) {
+    if (!body) {
+        return;
+    }
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (child.type !== 'method_definition') {
+            continue;
+        }
+        const nameNode = child.namedChildren.find((c) => c.type === 'property_identifier' || c.type === 'identifier');
+        if (nameNode?.text !== 'constructor') {
+            continue;
+        }
+        const stmtBlock = child.namedChildren.find((c) => c.type === 'statement_block');
+        if (!stmtBlock) {
+            continue;
+        }
+        const seen = new Set(ctx.properties.filter((p) => p.className === className).map((p) => p.name));
+        _walkForThisAssignments(stmtBlock, ctx, className, seen);
+    }
+}
+function _walkForThisAssignments(node, ctx, className, seen) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child.type === 'expression_statement') {
+            const expr = child.namedChildren.find((c) => c.type === 'assignment_expression');
+            if (expr) {
+                const left = expr.namedChildren[0];
+                if (left?.type === 'member_expression') {
+                    const obj = left.namedChildren.find((c) => c.type === 'this');
+                    const prop = left.namedChildren.find((c) => c.type === 'property_identifier');
+                    if (obj && prop && !seen.has(prop.text)) {
+                        seen.add(prop.text);
+                        ctx.properties.push({
+                            name: prop.text,
+                            className,
+                            isStatic: false,
+                            isConstant: false,
+                            line: child.startPosition.row + 1,
+                        });
+                    }
+                }
             }
         }
+        else if (child.namedChildCount > 0 &&
+            child.type !== 'function' &&
+            child.type !== 'arrow_function') {
+            _walkForThisAssignments(child, ctx, className, seen);
+        }
     }
 }
 function _parseJSClass(node) {
@@ -85,12 +145,10 @@ function _parseJSClass(node) {
     let superclass = null;
     for (const child of node.namedChildren) {
         if (child.type === 'class_heritage') {
-            const ext = child.namedChildren.find((c) => c.type === 'extends_clause');
-            if (ext) {
-                const typeNode = ext.namedChildren.find((c) => c.type === 'identifier' || c.type === 'member_expression');
-                if (typeNode) {
-                    superclass = typeNode.text;
-                }
+            // tree-sitter-javascript: class_heritage → identifier (直接子节点, 无 extends_clause 包装)
+            const typeNode = child.namedChildren.find((c) => c.type === 'identifier' || c.type === 'member_expression');
+            if (typeNode) {
+                superclass = typeNode.text;
             }
         }
     }
@@ -142,6 +200,44 @@ function _parseJSVariableDecl(node, ctx, parentClassName) {
 }
 function detectJSPatterns(root, lang, methods, properties, classes) {
     const patterns = [];
+    // 按 className 分组
+    const methodsByClass = new Map();
+    const propsByClass = new Map();
+    for (const m of methods) {
+        const k = m.className || '';
+        if (!methodsByClass.has(k)) {
+            methodsByClass.set(k, []);
+        }
+        methodsByClass.get(k).push(m);
+    }
+    for (const p of properties) {
+        const k = p.className || '';
+        if (!propsByClass.has(k)) {
+            propsByClass.set(k, []);
+        }
+        propsByClass.get(k).push(p);
+    }
+    for (const cls of classes) {
+        const clsMethods = methodsByClass.get(cls.name) || [];
+        const clsProps = propsByClass.get(cls.name) || [];
+        // ── Singleton: static getInstance() / static instance ──
+        const hasGetInstance = clsMethods.some((m) => m.isClassMethod && /^getInstance$|^shared$/.test(m.name));
+        const hasStaticInstance = clsProps.some((p) => p.isStatic && /^instance$|^shared$|^default$/.test(p.name));
+        if (hasGetInstance || hasStaticInstance) {
+            patterns.push({ type: 'singleton', className: cls.name, line: cls.line, confidence: 0.9 });
+        }
+        // ── Observer / EventEmitter ──
+        const emitMethods = clsMethods.filter((m) => /^on$|^emit$|^addEventListener$|^removeEventListener$|^subscribe$|^addListener$/.test(m.name));
+        if (emitMethods.length >= 2) {
+            patterns.push({ type: 'observer', className: cls.name, line: cls.line, confidence: 0.85 });
+        }
+        // ── Middleware ──
+        if (/middleware|interceptor/i.test(cls.name) ||
+            clsMethods.some((m) => /^use$|^handle$/.test(m.name) && m.isClassMethod === false)) {
+            patterns.push({ type: 'middleware', className: cls.name, line: cls.line, confidence: 0.8 });
+        }
+    }
+    // 自由函数级别的模式
     for (const m of methods) {
         if (/^use[A-Z]/.test(m.name) && !m.className) {
             patterns.push({ type: 'react-hook', methodName: m.name, line: m.line, confidence: 0.9 });
@@ -155,15 +251,6 @@ function detectJSPatterns(root, lang, methods, properties, classes) {
                 confidence: 0.8,
             });
         }
-        if (/^on[A-Z]|^emit$|^addEventListener$|^subscribe$/.test(m.name)) {
-            patterns.push({
-                type: 'observer',
-                className: m.className,
-                methodName: m.name,
-                line: m.line,
-                confidence: 0.7,
-            });
-        }
     }
     return patterns;
 }

package/dist/lib/core/ast/lang-objc.d.ts

@@ -3,7 +3,7 @@
  * @description ObjC AST Walker 插件 - 从 AstAnalyzer.js 迁移
  */
 declare function walkObjC(root: any, ctx: any): void;
-declare function detectObjCPatterns(root: any, lang: any, methods: any, properties: any, classes: any): never[];
+declare function detectObjCPatterns(root: any, lang: any, methods: any, properties: any, classes: any): any[];
 declare function getGrammar(): any;
 export declare function setGrammar(grammar: any): void;
 export declare const plugin: {

package/dist/lib/core/ast/lang-objc.js

@@ -257,9 +257,86 @@ function _parseObjCProperty(node, className) {
 }
 // ── ObjC 模式检测 ──
 function detectObjCPatterns(root, lang, methods, properties, classes) {
-    // ObjC 特有的模式检测交由 AstAnalyzer 内的通用 _detectPatterns 处理
-    // 此函数可扩展 ObjC 特有模式（如 Category 模式）
-    return [];
+    const patterns = [];
+    // 按 className 分组
+    const methodsByClass = new Map();
+    const propsByClass = new Map();
+    for (const m of methods) {
+        const k = m.className || '';
+        if (!methodsByClass.has(k)) {
+            methodsByClass.set(k, []);
+        }
+        methodsByClass.get(k).push(m);
+    }
+    for (const p of properties) {
+        const k = p.className || '';
+        if (!propsByClass.has(k)) {
+            propsByClass.set(k, []);
+        }
+        propsByClass.get(k).push(p);
+    }
+    for (const cls of classes) {
+        const clsMethods = methodsByClass.get(cls.name) || [];
+        const clsProps = propsByClass.get(cls.name) || [];
+        // ── Singleton: +sharedInstance / +shared / +defaultManager ──
+        const singletonMethod = clsMethods.find((m) => m.isClassMethod && /^shared|^default|^current|^instance$/.test(m.name));
+        if (singletonMethod) {
+            patterns.push({
+                type: 'singleton',
+                className: cls.name,
+                methodName: singletonMethod.name,
+                line: singletonMethod.line,
+                confidence: 0.9,
+            });
+        }
+        // ── Delegate: @property (weak) id<XXXDelegate> delegate ──
+        for (const p of clsProps) {
+            if (/delegate/i.test(p.name)) {
+                const isWeak = (p.attributes || []).some((a) => a === 'weak');
+                patterns.push({
+                    type: 'delegate',
+                    className: cls.name,
+                    propertyName: p.name,
+                    isWeakRef: isWeak,
+                    line: p.line,
+                    confidence: 0.95,
+                });
+            }
+            if (/dataSource/i.test(p.name)) {
+                patterns.push({
+                    type: 'delegate',
+                    className: cls.name,
+                    propertyName: p.name,
+                    isWeakRef: true,
+                    line: p.line,
+                    confidence: 0.85,
+                });
+            }
+        }
+        // ── Factory: +classWithXxx / +xxxWithYyy (class factory methods) ──
+        for (const m of clsMethods) {
+            if (m.isClassMethod && /With[A-Z]/.test(m.name)) {
+                patterns.push({
+                    type: 'factory',
+                    className: cls.name,
+                    methodName: m.name,
+                    line: m.line,
+                    confidence: 0.8,
+                });
+            }
+        }
+        // ── KVO Observer: observeValueForKeyPath / addObserver ──
+        const hasKVO = clsMethods.some((m) => /^observeValueForKeyPath$|^addObserver$|^removeObserver$/.test(m.name));
+        if (hasKVO) {
+            patterns.push({ type: 'observer', className: cls.name, line: cls.line, confidence: 0.85 });
+        }
+        // ── Notification Observer: NSNotificationCenter pattern ──
+        const hasNSNotif = clsMethods.some((m) => /notification|handleNotification|didReceiveNotification/i.test(m.name));
+        if (hasNSNotif) {
+            patterns.push({ type: 'observer', className: cls.name, line: cls.line, confidence: 0.7 });
+        }
+    }
+    return patterns;
 }
 // ── 工具函数 ──
 function _findIdentifier(node) {

package/dist/lib/core/ast/lang-swift.d.ts

@@ -5,7 +5,7 @@
  * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 declare function walkSwift(root: any, ctx: any): void;
-declare function detectSwiftPatterns(root: any, lang: any, methods: any, properties: any, classes: any): never[];
+declare function detectSwiftPatterns(root: any, _lang: any, methods: any, properties: any, classes: any): any[];
 /**
  * 从 Swift AST root 提取所有调用点
  * 遍历 function_declaration 中的 function_body → call_expression

package/dist/lib/core/ast/lang-swift.js

@@ -23,9 +23,29 @@ function _walkSwiftNode(node, ctx, parentClassName) {
             case 'class_declaration':
             case 'struct_declaration':
             case 'enum_declaration': {
+                // tree-sitter-swift maps protocol/extension to class_declaration too.
+                // Detect the actual keyword child and dispatch accordingly.
+                const keyword = _findKeywordChild(child);
+                if (keyword === 'protocol') {
+                    const protoInfo = _parseSwiftProtocol(child);
+                    ctx.protocols.push(protoInfo);
+                    break;
+                }
+                if (keyword === 'extension') {
+                    const extInfo = _parseSwiftExtension(child);
+                    ctx.categories.push(extInfo);
+                    const extBody = child.namedChildren.find((c) => c.type === 'class_body' || c.type === 'extension_body');
+                    if (extBody) {
+                        _walkSwiftNode(extBody, ctx, extInfo.className);
+                    }
+                    break;
+                }
                 const classInfo = _parseSwiftTypeDecl(child);
                 ctx.classes.push(classInfo);
-                const body = child.namedChildren.find((c) => c.type === 'class_body' || c.type === 'struct_body' || c.type === 'enum_body');
+                const body = child.namedChildren.find((c) => c.type === 'class_body' ||
+                    c.type === 'struct_body' ||
+                    c.type === 'enum_body' ||
+                    c.type === 'enum_class_body');
                 if (body) {
                     _walkSwiftNode(body, ctx, classInfo.name);
                 }
@@ -66,9 +86,22 @@ function _walkSwiftNode(node, ctx, parentClassName) {
         }
     }
 }
+/** Detect the actual Swift keyword from a class_declaration node's children. */
+const _swiftKeywords = ['struct', 'class', 'enum', 'actor', 'protocol', 'extension'];
+function _findKeywordChild(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const childType = node.child(i).type;
+        if (_swiftKeywords.includes(childType)) {
+            return childType;
+        }
+    }
+    return 'class';
+}
 function _parseSwiftTypeDecl(node) {
     const name = node.namedChildren.find((c) => c.type === 'type_identifier' || c.type === 'simple_identifier')?.text || 'Unknown';
-    const kind = node.type.replace('_declaration', '');
+    // tree-sitter-swift maps struct/class/enum/actor all to `class_declaration`.
+    // Detect the actual kind from the keyword child node (e.g. struct="struct").
+    const kind = _findKeywordChild(node);
     const _superclass = null;
     const protocols = [];
     for (const child of node.namedChildren) {
@@ -132,7 +165,7 @@ function _parseSwiftExtension(node) {
         }
     }
     const methods = [];
-    const body = node.namedChildren.find((c) => c.type === 'extension_body');
+    const body = node.namedChildren.find((c) => c.type === 'extension_body' || c.type === 'class_body');
     if (body) {
         for (const child of body.namedChildren) {
             if (child.type === 'function_declaration') {
@@ -196,8 +229,150 @@ function _parseSwiftProperty(node, className) {
     };
 }
 // ── Swift 模式检测 ──
-function detectSwiftPatterns(root, lang, methods, properties, classes) {
-    return [];
+function detectSwiftPatterns(root, _lang, methods, properties, classes) {
+    const patterns = [];
+    // Index properties by className for quick lookup
+    const propsByClass = new Map();
+    for (const p of properties) {
+        if (p.className) {
+            const arr = propsByClass.get(p.className) || [];
+            arr.push(p);
+            propsByClass.set(p.className, arr);
+        }
+    }
+    // Index methods by className
+    const methodsByClass = new Map();
+    for (const m of methods) {
+        if (m.className && m.kind === 'definition') {
+            const arr = methodsByClass.get(m.className) || [];
+            arr.push(m);
+            methodsByClass.set(m.className, arr);
+        }
+    }
+    for (const cls of classes) {
+        const kind = cls.kind;
+        const className = cls.name;
+        const clsProps = propsByClass.get(className) || [];
+        const clsMethods = methodsByClass.get(className) || [];
+        // ── 1. Singleton: `static let shared = ...` 属性 ──
+        const sharedProp = clsProps.find((p) => p.isStatic &&
+            (p.isConstant || p.isConst) &&
+            /^shared$|^default$|^instance$|^current$/.test(p.name));
+        if (sharedProp) {
+            patterns.push({
+                type: 'singleton',
+                className,
+                propertyName: sharedProp.name,
+                line: sharedProp.line,
+                confidence: 0.95,
+            });
+        }
+        // ── 2. Delegate: `weak var delegate` 属性或 protocol 命名以 Delegate/DataSource 结尾 ──
+        for (const p of clsProps) {
+            if (/delegate/i.test(p.name) && !p.name.startsWith('_')) {
+                patterns.push({
+                    type: 'delegate',
+                    className,
+                    propertyName: p.name,
+                    isWeakRef: /weak/.test(`${(p.attributes || []).join(' ')} ${p.modifiers || ''}`),
+                    line: p.line,
+                    confidence: 0.95,
+                });
+            }
+        }
+        // ── 3. Factory: `static func make/create/from/build` ──
+        for (const m of clsMethods) {
+            if (m.isClassMethod && /^make|^create|^from|^build/.test(m.name)) {
+                patterns.push({
+                    type: 'factory',
+                    className,
+                    methodName: m.name,
+                    line: m.line,
+                    confidence: 0.85,
+                });
+            }
+        }
+        // ── 4. Actor: Swift concurrency primitive ──
+        if (kind === 'actor') {
+            patterns.push({
+                type: 'actor',
+                className,
+                line: cls.line,
+                confidence: 0.95,
+            });
+        }
+        // ── 5. Value type (struct): immutable-by-default semantics ──
+        if (kind === 'struct' && !className.endsWith('Error')) {
+            // Only flag structs with methods (not pure data containers)
+            if (clsMethods.length > 0) {
+                patterns.push({
+                    type: 'value-type',
+                    className,
+                    methodCount: clsMethods.length,
+                    line: cls.line,
+                    confidence: 0.9,
+                });
+            }
+        }
+        // ── 6. Protocol-oriented default implementation ──
+        // (detected via categories/extensions that match a protocol name)
+        // Handled below after the class loop.
+        // ── 7. ViewModel: class name ends with ViewModel ──
+        if (/ViewModel$/.test(className)) {
+            patterns.push({
+                type: 'viewmodel',
+                className,
+                line: cls.line,
+                confidence: 0.9,
+            });
+        }
+        // ── 8. Coordinator pattern ──
+        if (/Coordinator$/.test(className)) {
+            patterns.push({
+                type: 'coordinator',
+                className,
+                line: cls.line,
+                confidence: 0.85,
+            });
+        }
+        // ── 9. Error type: enum conforming to Error ──
+        if (kind === 'enum') {
+            const conformsError = (cls.protocols || []).some((p) => p === 'Error' || p === 'LocalizedError');
+            if (conformsError || className.endsWith('Error')) {
+                patterns.push({
+                    type: 'error-type',
+                    className,
+                    line: cls.line,
+                    confidence: 0.9,
+                });
+            }
+        }
+        // ── 10. Middleware / Interceptor pattern ──
+        if (/Middleware$|Interceptor$/.test(className)) {
+            patterns.push({
+                type: 'middleware',
+                className,
+                line: cls.line,
+                confidence: 0.85,
+            });
+        }
+    }
+    // ── 11. Observer: methods matching didChange/willChange/observe/subscribe ──
+    for (const m of methods) {
+        if (m.kind !== 'definition') {
+            continue;
+        }
+        if (/^didChange|^willChange|^observe|^addObserver|^subscribe|^on[A-Z]/.test(m.name)) {
+            patterns.push({
+                type: 'observer',
+                className: m.className,
+                methodName: m.name,
+                line: m.line,
+                confidence: 0.7,
+            });
+        }
+    }
+    return patterns;
 }
 // ── 工具函数 ──
 function _findIdentifier(node) {
@@ -281,7 +456,10 @@ function _collectSwiftScopes(root) {
                 child.type === 'struct_declaration' ||
                 child.type === 'enum_declaration') {
                 const name = child.namedChildren.find((c) => c.type === 'type_identifier' || c.type === 'simple_identifier')?.text;
-                const body = child.namedChildren.find((c) => c.type === 'class_body' || c.type === 'struct_body' || c.type === 'enum_body');
+                const body = child.namedChildren.find((c) => c.type === 'class_body' ||
+                    c.type === 'struct_body' ||
+                    c.type === 'enum_body' ||
+                    c.type === 'enum_class_body');
                 if (body) {
                     visit(body, name || className);
                 }

package/dist/lib/external/mcp/handlers/bootstrap/MissionBriefingBuilder.d.ts

@@ -67,6 +67,7 @@ interface CompressedProtocol {
 /** 压缩后的 AST 类 */
 interface CompressedAstClass {
     name: string;
+    kind?: string;
     superclass?: string | null;
     file?: string | null;
     methodCount: number;
@@ -78,7 +79,11 @@ interface MissionBriefing {
     ast: {
         available: boolean;
         compressionLevel?: string;
-        summary?: string;
+        summary?: string | {
+            text: string;
+            kindDistribution: Record<string, number>;
+            insight: string;
+        };
         classes: CompressedAstClass[];
         protocols: CompressedProtocol[];
         categories?: {
@@ -96,6 +101,32 @@ interface MissionBriefing {
             longMethods?: number;
         } | null;
     };
+    architectureOverview?: {
+        style: string;
+        layers: {
+            name: string;
+            modules: string[];
+            fileCount: number;
+            role: string;
+        }[];
+        externalDeps: {
+            name: string;
+            role: string;
+        }[];
+        keyInsights: string[];
+    } | null;
+    technologyStack?: {
+        name: string;
+        role: string;
+        usedBy: string[];
+    }[] | null;
+    keyAbstractions?: {
+        name: string;
+        kind: string;
+        module: string;
+        significance: string;
+        detail: string;
+    }[] | null;
     codeEntityGraph: {
         totalEntities: number;
         totalEdges: number;
@@ -110,6 +141,7 @@ interface MissionBriefing {
             id: string;
             label: string;
             fileCount?: number;
+            dependentCount?: number;
         }[];
         edges: unknown[];
     } | null;

package/dist/lib/external/mcp/handlers/bootstrap/MissionBriefingBuilder.js

@@ -609,6 +609,7 @@ function compressAstForBriefing(astProjectSummary, fileCount) {
         .slice(0, topN);
     const compressedClasses = sortedClasses.map((c) => ({
         name: c.name,
+        kind: c.kind || 'class',
         superclass: c.superclass || null,
         file: c.file || c.relativePath || null,
         methodCount: c.methodCount || c.methods?.length || 0,
@@ -628,8 +629,43 @@ function compressAstForBriefing(astProjectSummary, fileCount) {
             .map((m) => (typeof m === 'string' ? m : m.name))
             .slice(0, 10),
     }));
-    const summary = `${classes.length} classes, ${protocols.length} protocols, ${categories.length} categories, ${astProjectSummary.projectMetrics?.totalMethods || 0} methods`;
-    // 压缩 patternStats: 保留计数，移除详细列表
+    // ── 结构化 summary: 含 kindDistribution + insight ──
+    const kindDist = {};
+    for (const c of dedupedClasses) {
+        const k = c.kind || 'class';
+        kindDist[k] = (kindDist[k] || 0) + 1;
+    }
+    const totalTypes = dedupedClasses.length;
+    const kindParts = Object.entries(kindDist)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, v]) => `${v} ${k}`);
+    const summaryText = `${totalTypes} types (${kindParts.join(', ')}), ${protocols.length} protocols, ${categories.length} ${categories.length > 0 && categories[0]?.baseClass ? 'categories' : 'extensions'}, ${astProjectSummary.projectMetrics?.totalMethods || 0} methods`;
+    // 生成 insight
+    const valueTypeCount = (kindDist.struct || 0) + (kindDist.enum || 0);
+    const refTypeCount = kindDist.class || 0;
+    const actorCount = kindDist.actor || 0;
+    let insight = '';
+    if (totalTypes > 0) {
+        const vtRatio = Math.round((valueTypeCount / totalTypes) * 100);
+        if (vtRatio >= 60) {
+            insight = `Value types (struct+enum) account for ${vtRatio}% — project favors value semantics`;
+        }
+        else if (refTypeCount > valueTypeCount) {
+            insight = `Reference types (class) account for ${Math.round((refTypeCount / totalTypes) * 100)}% — OOP-heavy codebase`;
+        }
+        else {
+            insight = `Balanced mix of value types (${vtRatio}%) and reference types (${Math.round((refTypeCount / totalTypes) * 100)}%)`;
+        }
+        if (actorCount > 0) {
+            insight += `; ${actorCount} actors indicate structured concurrency adoption`;
+        }
+    }
+    const summary = {
+        text: summaryText,
+        kindDistribution: kindDist,
+        insight,
+    };
+    // ── 压缩 patternStats: 保留计数 + 代表性类名 ──
     const rawPatterns = astProjectSummary.patternStats || {};
     const compressedPatterns = {};
     for (const [key, val] of Object.entries(rawPatterns)) {
@@ -640,17 +676,29 @@ function compressAstForBriefing(astProjectSummary, fileCount) {
             compressedPatterns[key] = val.length; // 数组 → 计数
         }
         else if (val && typeof val === 'object') {
-            // 嵌套对象: 保留 count/总数，或递归压缩为浅层概要
             const sub = {};
             for (const [sk, sv] of Object.entries(val)) {
                 if (typeof sv === 'number' || typeof sv === 'string' || typeof sv === 'boolean') {
                     sub[sk] = sv;
                 }
                 else if (Array.isArray(sv)) {
-                    sub[sk] = sv.length;
+                    // instances 数组: 提取 top-3 类名作为 representatives
+                    if (sk === 'instances' && sv.length > 0 && typeof sv[0] === 'object') {
+                        sub[sk] = sv.length;
+                        const classNames = sv
+                            .map((inst) => inst.className || '')
+                            .filter(Boolean);
+                        const unique = [...new Set(classNames)].slice(0, 3);
+                        if (unique.length > 0) {
+                            sub.representatives = unique.join(', ');
+                        }
+                    }
+                    else {
+                        sub[sk] = sv.length;
+                    }
                 }
                 else if (sv && typeof sv === 'object') {
-                    sub[sk] = Object.keys(sv).length; // 深层对象 → key 计数
+                    sub[sk] = Object.keys(sv).length;
                 }
             }
             compressedPatterns[key] = sub;
@@ -804,6 +852,300 @@ function buildExecutionPlan(activeDimensions) {
         workflow: '对每个维度: (1) 用你的原生能力阅读代码分析 → (2) 调用 autosnippet_submit_knowledge_batch 批量提交候选（**每维度最少 3 条，目标 5 条**，将不同关注点拆分为独立候选，1-2 条视为不合格） → (3) 调用 autosnippet_dimension_complete 完成维度（必须传 referencedFiles=[分析过的文件路径] 和 keyFindings=[3-5条关键发现]）',
     };
 }
+// ── Architecture Overview 自动推断 ────────────────────────
+/** 知名外部依赖的角色映射 */
+const KNOWN_DEPENDENCIES = {
+    // Swift / iOS
+    alamofire: 'HTTP networking',
+    moya: 'Network abstraction over Alamofire',
+    rxswift: 'Reactive programming (ReactiveX)',
+    rxcocoa: 'RxSwift UIKit bindings',
+    combine: 'Apple reactive framework',
+    kingfisher: 'Image downloading & caching',
+    sdwebimage: 'Image downloading & caching',
+    snapkit: 'Auto Layout DSL',
+    lottie: 'Animation rendering',
+    realm: 'Mobile database',
+    coredata: 'Apple persistence framework',
+    swiftui: 'Declarative UI framework',
+    // JavaScript / TypeScript
+    react: 'UI component framework',
+    vue: 'Progressive UI framework',
+    angular: 'Full-featured UI framework',
+    express: 'HTTP server framework',
+    nestjs: 'Enterprise Node.js framework',
+    axios: 'HTTP client',
+    prisma: 'Database ORM',
+    sequelize: 'SQL ORM',
+    mongoose: 'MongoDB ODM',
+    tailwindcss: 'Utility-first CSS',
+    webpack: 'Module bundler',
+    vite: 'Frontend build tool',
+    jest: 'Testing framework',
+    vitest: 'Vite-native testing',
+    redux: 'State management',
+    zustand: 'Lightweight state management',
+    // Go
+    gin: 'HTTP web framework',
+    echo: 'HTTP web framework',
+    gorm: 'Go ORM',
+    cobra: 'CLI framework',
+    // Python
+    django: 'Full-stack web framework',
+    flask: 'Micro web framework',
+    fastapi: 'Async web framework',
+    sqlalchemy: 'SQL toolkit & ORM',
+    pytorch: 'Deep learning framework',
+    tensorflow: 'Machine learning framework',
+    pandas: 'Data analysis library',
+    numpy: 'Numerical computing',
+};
+/**
+ * 从 targets + depGraph + localPackageModules 自动推断架构概览
+ */
+function buildArchitectureOverview(targets, depGraphData, localPackageModules) {
+    if (!targets || targets.length === 0) {
+        return null;
+    }
+    // ── 分层: 按 inferredRole 分组 ──
+    const roleGroups = {};
+    for (const t of targets) {
+        const role = t.inferredRole || 'unknown';
+        if (!roleGroups[role]) {
+            roleGroups[role] = { modules: [], fileCount: 0 };
+        }
+        roleGroups[role].modules.push(t.name);
+        roleGroups[role].fileCount += t.fileCount || 0;
+    }
+    // 层级命名映射
+    const ROLE_LAYER_MAP = {
+        app: {
+            name: 'App Shell',
+            priority: 0,
+            role: 'Application entry point, coordinators, DI assembly',
+        },
+        core: {
+            name: 'Core Infrastructure',
+            priority: 2,
+            role: 'Shared infrastructure libraries, base classes, utilities',
+        },
+        networking: {
+            name: 'Networking',
+            priority: 2,
+            role: 'Network client, middleware, API definitions',
+        },
+        feature: {
+            name: 'Feature Modules',
+            priority: 1,
+            role: 'Per-feature UI, view models, business logic',
+        },
+        ui: { name: 'UI Components', priority: 2, role: 'Shared UI components, themes, extensions' },
+        test: { name: 'Tests', priority: 3, role: 'Unit tests, integration tests, mocks' },
+        unknown: { name: 'Other', priority: 3, role: 'Uncategorized modules' },
+    };
+    const layers = [];
+    for (const [role, group] of Object.entries(roleGroups)) {
+        if (role === 'test') {
+            continue;
+        } // 测试模块不加入架构层
+        const layerDef = ROLE_LAYER_MAP[role] || ROLE_LAYER_MAP.unknown;
+        // 合并同优先级的层
+        const existing = layers.find((l) => l.name === layerDef.name);
+        if (existing) {
+            existing.modules.push(...group.modules);
+            existing.fileCount += group.fileCount;
+        }
+        else {
+            layers.push({
+                name: layerDef.name,
+                modules: [...group.modules],
+                fileCount: group.fileCount,
+                role: layerDef.role,
+            });
+        }
+    }
+    // 按 priority 排序 (App Shell → Features → Core → Other)
+    layers.sort((a, b) => {
+        const pa = Object.values(ROLE_LAYER_MAP).find((v) => v.name === a.name)?.priority ?? 99;
+        const pb = Object.values(ROLE_LAYER_MAP).find((v) => v.name === b.name)?.priority ?? 99;
+        return pa - pb;
+    });
+    // ── 外部依赖识别 ──
+    const externalDeps = [];
+    const localModuleNames = new Set(targets.map((t) => t.name));
+    if (depGraphData?.nodes) {
+        for (const n of depGraphData.nodes) {
+            const id = typeof n === 'string' ? n : n.id || '';
+            const label = typeof n === 'string' ? n : n.label || id;
+            if (!localModuleNames.has(id) && !localModuleNames.has(label)) {
+                const knownRole = KNOWN_DEPENDENCIES[label.toLowerCase()];
+                externalDeps.push({
+                    name: label,
+                    role: knownRole || 'third-party dependency',
+                });
+            }
+        }
+    }
+    // ── 关键洞察 ──
+    const insights = [];
+    const totalFiles = targets.reduce((s, t) => s + (t.fileCount || 0), 0);
+    const featureGroup = roleGroups.feature;
+    const coreGroup = roleGroups.core;
+    const networkGroup = roleGroups.networking;
+    // 本地子包占比
+    if (localPackageModules && localPackageModules.length > 0) {
+        const pkgFiles = localPackageModules.reduce((s, m) => s + m.fileCount, 0);
+        const pct = totalFiles > 0 ? Math.round((pkgFiles / totalFiles) * 100) : 0;
+        insights.push(`${localPackageModules.length} local packages provide ${pct}% of the codebase (${pkgFiles}/${totalFiles} files)`);
+    }
+    // Feature 模块特征
+    if (featureGroup) {
+        const avgFiles = Math.round(featureGroup.fileCount / featureGroup.modules.length);
+        if (avgFiles <= 5) {
+            insights.push(`Feature modules are thin (avg ${avgFiles} files) — business logic likely concentrates in core infrastructure`);
+        }
+        else {
+            insights.push(`Feature modules average ${avgFiles} files each — self-contained feature architecture`);
+        }
+    }
+    // 最大基础设施模块
+    if (coreGroup || networkGroup) {
+        const infraModules = [...(coreGroup?.modules || []), ...(networkGroup?.modules || [])];
+        const heaviest = targets
+            .filter((t) => infraModules.includes(t.name))
+            .sort((a, b) => (b.fileCount || 0) - (a.fileCount || 0));
+        if (heaviest.length > 0 && heaviest[0].fileCount) {
+            insights.push(`${heaviest[0].name} (${heaviest[0].fileCount} files) is the heaviest infrastructure module`);
+        }
+    }
+    // 推断架构风格
+    let style = 'Monolithic application';
+    if (localPackageModules && localPackageModules.length >= 2) {
+        style = 'Modular monolith (local packages)';
+    }
+    else if (targets.length >= 5 && featureGroup && featureGroup.modules.length >= 3) {
+        style = 'Feature-modular architecture';
+    }
+    return { style, layers, externalDeps, keyInsights: insights };
+}
+/**
+ * 从外部依赖图中提取技术栈信息
+ */
+function buildTechnologyStack(depGraphData, targets) {
+    if (!depGraphData?.nodes || !depGraphData?.edges) {
+        return null;
+    }
+    const localModuleNames = new Set(targets.map((t) => t.name));
+    const stack = [];
+    for (const n of depGraphData.nodes) {
+        const id = typeof n === 'string' ? n : n.id || '';
+        const label = typeof n === 'string' ? n : n.label || id;
+        if (localModuleNames.has(id) || localModuleNames.has(label)) {
+            continue;
+        }
+        const role = KNOWN_DEPENDENCIES[label.toLowerCase()] || 'third-party dependency';
+        // 找出哪些模块依赖它
+        const usedBy = (depGraphData.edges || [])
+            .filter((e) => {
+            const edge = e;
+            return edge.to === id || edge.to === label;
+        })
+            .map((e) => e.from)
+            .filter((f) => localModuleNames.has(f))
+            .slice(0, 5);
+        stack.push({ name: label, role, usedBy });
+    }
+    return stack.length > 0 ? stack : null;
+}
+/**
+ * 提取项目关键抽象 — 从继承热点、协议遵从数、模块入口类中识别
+ */
+function buildKeyAbstractions(astData, targets) {
+    if (!astData) {
+        return null;
+    }
+    const classes = astData.classes || [];
+    const protocols = astData.protocols || [];
+    const abstractions = [];
+    // §1: 高继承热点 — 被多个子类继承的基类
+    const subclassCount = {};
+    for (const cls of classes) {
+        if (cls.superclass) {
+            subclassCount[cls.superclass] = (subclassCount[cls.superclass] || 0) + 1;
+        }
+    }
+    const topBases = Object.entries(subclassCount)
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    for (const [baseName, count] of topBases) {
+        const baseCls = classes.find((c) => c.name === baseName);
+        const module = baseCls?.targetName || _inferModule(baseCls?.file || baseCls?.relativePath, targets);
+        abstractions.push({
+            name: baseName,
+            kind: baseCls?.kind || 'class',
+            module,
+            significance: `Base class with ${count} subclasses`,
+            detail: `Subclasses: ${classes
+                .filter((c) => c.superclass === baseName)
+                .map((c) => c.name)
+                .slice(0, 5)
+                .join(', ')}`,
+        });
+    }
+    // §2: 高方法数类 — 复杂度热点
+    const methodHeavy = classes
+        .filter((c) => (c.methodCount || 0) >= 15)
+        .sort((a, b) => (b.methodCount || 0) - (a.methodCount || 0))
+        .slice(0, 3);
+    for (const cls of methodHeavy) {
+        // 跳过已在继承热点中出现的
+        if (abstractions.some((a) => a.name === cls.name)) {
+            continue;
+        }
+        const module = cls.targetName || _inferModule(cls.file || cls.relativePath, targets);
+        abstractions.push({
+            name: cls.name,
+            kind: cls.kind || 'class',
+            module,
+            significance: `Complexity hotspot (${cls.methodCount} methods)`,
+            detail: cls.superclass ? `extends ${cls.superclass}` : 'root class',
+        });
+    }
+    // §3: 高遵从协议 — 核心抽象接口
+    const protoWithConformers = protocols
+        .filter((p) => (p.conformers?.length || 0) >= 2 || (p.methodCount || 0) >= 3)
+        .sort((a, b) => (b.conformers?.length || 0) - (a.conformers?.length || 0))
+        .slice(0, 5);
+    for (const proto of protoWithConformers) {
+        const module = proto.targetName || _inferModule(proto.file || proto.relativePath, targets);
+        const conformerCount = proto.conformers?.length || 0;
+        abstractions.push({
+            name: proto.name,
+            kind: 'protocol',
+            module,
+            significance: conformerCount > 0
+                ? `Protocol with ${conformerCount} conformers`
+                : `Protocol with ${proto.methodCount || 0} method requirements`,
+            detail: conformerCount > 0
+                ? `Conformers: ${proto.conformers.slice(0, 5).join(', ')}`
+                : `${proto.methodCount || 0} required methods`,
+        });
+    }
+    return abstractions.length > 0 ? abstractions.slice(0, 10) : null;
+}
+/** 从文件路径推断模块名 */
+function _inferModule(filePath, targets) {
+    if (!filePath) {
+        return 'unknown';
+    }
+    for (const t of targets) {
+        if (filePath.includes(t.name)) {
+            return t.name;
+        }
+    }
+    return filePath.split('/')[0] || 'unknown';
+}
 // ── Panorama 摘要构建 ──────────────────────────────────────
 /**
  * 从 PanoramaResult 提取 layers / couplingHotspots / cycles / gaps
@@ -928,28 +1270,58 @@ localPackageModules, // 本地子包模块信息
         EXAMPLE_TEMPLATES[lang.toLowerCase()] ||
         EXAMPLE_TEMPLATES._default;
     // ── 组装 ──
+    // ── 依赖图节点去重 ──
+    const dedupedDepNodes = [];
+    if (depGraphData?.nodes) {
+        const nodeMap = new Map();
+        for (const n of depGraphData.nodes) {
+            const id = typeof n === 'string' ? n : n.id || '';
+            const label = typeof n === 'string' ? n : n.label || id;
+            const fileCount = typeof n === 'string' ? undefined : n.fileCount;
+            if (!nodeMap.has(id)) {
+                nodeMap.set(id, { id, label, fileCount, dependentCount: 0 });
+            }
+            else if (fileCount && !nodeMap.get(id).fileCount) {
+                nodeMap.get(id).fileCount = fileCount;
+            }
+        }
+        // 计算每个节点被多少模块依赖（fan-in）
+        for (const e of depGraphData.edges || []) {
+            const edge = e;
+            if (edge.to && nodeMap.has(edge.to)) {
+                nodeMap.get(edge.to).dependentCount++;
+            }
+        }
+        for (const node of nodeMap.values()) {
+            dedupedDepNodes.push(node);
+        }
+    }
+    // ── targets 构建 ──
+    const builtTargets = (targets || []).map((t) => ({
+        name: typeof t === 'string' ? t : t.name,
+        type: typeof t === 'string' ? 'target' : t.type || 'target',
+        inferredRole: typeof t === 'string' ? undefined : t.inferredRole,
+        fileCount: typeof t === 'string' ? undefined : t.fileCount,
+    }));
     const briefing = {
         projectMeta,
         ast: compressAstForBriefing(astData ?? null, projectMeta.fileCount || 0),
+        // 高层次架构概览 — Agent 一目了然项目结构
+        architectureOverview: buildArchitectureOverview(builtTargets, depGraphData ?? null, localPackageModules),
+        // 技术栈 — 外部依赖的角色识别
+        technologyStack: buildTechnologyStack(depGraphData ?? null, builtTargets),
+        // 关键抽象 — Agent 优先分析的核心类/协议
+        keyAbstractions: buildKeyAbstractions(astData ?? null, builtTargets),
         codeEntityGraph: summarizeEntityGraph(codeEntityResult ?? null),
         callGraph: summarizeCallGraph(callGraphResult ?? null),
-        dependencyGraph: depGraphData
+        dependencyGraph: dedupedDepNodes.length > 0
             ? {
-                nodes: (depGraphData.nodes || []).map((n) => ({
-                    id: typeof n === 'string' ? n : n.id || '',
-                    label: typeof n === 'string' ? n : n.label || '',
-                    fileCount: typeof n === 'string' ? undefined : n.fileCount,
-                })),
-                edges: (depGraphData.edges || []).slice(0, 100), // 限制边数
+                nodes: dedupedDepNodes,
+                edges: (depGraphData?.edges || []).slice(0, 100),
             }
             : null,
         guardFindings: summarizeGuardFindings(guardAudit ?? null),
-        targets: (targets || []).map((t) => ({
-            name: typeof t === 'string' ? t : t.name,
-            type: typeof t === 'string' ? 'target' : t.type || 'target',
-            inferredRole: typeof t === 'string' ? undefined : t.inferredRole,
-            fileCount: typeof t === 'string' ? undefined : t.fileCount,
-        })),
+        targets: builtTargets,
         dimensions,
         // §7.1: 语言扩展信息 (反模式、Guard 规则、Agent 注意事项)
         languageExtension: languageExtension || null,
@@ -1022,10 +1394,11 @@ localPackageModules, // 本地子包模块信息
         }
         else {
             // ── Level 4-5: 高代价压缩 (移除辅助数据) ──
-            // Level 4: 移除 evidenceStarters (体积优先)
+            // Level 4: 移除 evidenceStarters + technologyStack (体积优先)
             for (const dim of briefing.dimensions) {
                 delete dim.evidenceStarters;
             }
+            briefing.technologyStack = null;
             // Level 5: SOP 降级为紧凑文本 + 移除 FAIL_EXAMPLES
             for (const dim of briefing.dimensions) {
                 if (dim.analysisGuide && typeof dim.analysisGuide === 'object') {

package/dist/lib/types/project-snapshot.d.ts

@@ -63,6 +63,7 @@ export interface AstSummary {
 }
 export interface AstClassInfo {
     name: string;
+    kind?: string;
     superclass?: string;
     methodCount?: number;
     methods?: unknown[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosnippet",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "description": "Extract code patterns into a knowledge base for AI coding assistants",
   "type": "module",
   "main": "dist/lib/bootstrap.js",