opencroc 1.8.1 → 1.8.2

package/dist/index.js

@@ -9208,8 +9208,553 @@ function cleanJsonResponse(response) {
 function sanitizeId2(id) {
   return id.replace(/[^a-zA-Z0-9_]/g, "_");
 }
+
+// src/agents/role-registry.ts
+init_esm_shims();
+var CORE_ROLES = [
+  {
+    id: "parser-croc",
+    name: "\u89E3\u6790\u9CC4",
+    nameEn: "Parser Croc",
+    category: "core",
+    description: "\u89E3\u6790\u9879\u76EE\u7ED3\u6784\u3001\u63D0\u53D6\u5B9E\u4F53\u548C\u5173\u7CFB",
+    sprite: "parser",
+    color: "#34d399",
+    priority: 0,
+    triggers: { custom: () => true },
+    // Always summoned
+    systemPrompt: "You are an expert code parser. Analyze the project structure, extract all entities (classes, functions, APIs, models) and their relationships.",
+    outputType: "analysis",
+    tags: ["core", "parser", "structure"]
+  },
+  {
+    id: "analyzer-croc",
+    name: "\u5206\u6790\u9CC4",
+    nameEn: "Analyzer Croc",
+    category: "core",
+    description: "\u6784\u5EFA\u77E5\u8BC6\u56FE\u8C31\u3001\u5206\u6790\u4F9D\u8D56\u5173\u7CFB",
+    sprite: "analyzer",
+    color: "#60a5fa",
+    priority: 1,
+    triggers: { custom: () => true },
+    systemPrompt: "You are an expert software architect. Build a knowledge graph of the project, analyze dependencies, coupling, and cohesion.",
+    outputType: "diagram",
+    tags: ["core", "graph", "architecture"]
+  },
+  {
+    id: "tester-croc",
+    name: "\u6D4B\u8BD5\u9CC4",
+    nameEn: "Tester Croc",
+    category: "core",
+    description: "\u751F\u6210\u548C\u6267\u884C E2E \u6D4B\u8BD5",
+    sprite: "tester",
+    color: "#a78bfa",
+    priority: 2,
+    triggers: { custom: () => true },
+    systemPrompt: "You are an expert test engineer. Generate comprehensive E2E test cases covering all critical paths, edge cases, and error scenarios.",
+    outputType: "analysis",
+    tags: ["core", "testing", "e2e"]
+  },
+  {
+    id: "healer-croc",
+    name: "\u4FEE\u590D\u9CC4",
+    nameEn: "Healer Croc",
+    category: "core",
+    description: "\u81EA\u52A8\u4FEE\u590D\u6D4B\u8BD5\u5931\u8D25\u548C\u4EE3\u7801\u95EE\u9898",
+    sprite: "healer",
+    color: "#f87171",
+    priority: 3,
+    triggers: { custom: () => true },
+    systemPrompt: "You are an expert debugger and code fixer. Analyze test failures, diagnose root causes, and propose minimal targeted fixes.",
+    outputType: "fix",
+    tags: ["core", "healing", "debug"]
+  },
+  {
+    id: "planner-croc",
+    name: "\u89C4\u5212\u9CC4",
+    nameEn: "Planner Croc",
+    category: "core",
+    description: "\u5236\u5B9A\u6D4B\u8BD5\u7B56\u7565\u548C\u6267\u884C\u8BA1\u5212",
+    sprite: "planner",
+    color: "#fbbf24",
+    priority: 4,
+    triggers: { custom: () => true },
+    systemPrompt: "You are an expert project planner. Create test strategies, prioritize test execution order, and optimize the testing pipeline.",
+    outputType: "analysis",
+    tags: ["core", "planning", "strategy"]
+  },
+  {
+    id: "reporter-croc",
+    name: "\u6C47\u62A5\u9CC4",
+    nameEn: "Reporter Croc",
+    category: "core",
+    description: "\u751F\u6210\u591A\u89C6\u89D2\u5206\u6790\u62A5\u544A",
+    sprite: "reporter",
+    color: "#22d3ee",
+    priority: 5,
+    triggers: { custom: () => true },
+    systemPrompt: "You are an expert technical writer. Generate clear, actionable reports from multiple perspectives (developer, architect, tester, product, executive).",
+    outputType: "report",
+    tags: ["core", "reporting", "documentation"]
+  }
+];
+var LANGUAGE_ROLES = [
+  {
+    id: "python-croc",
+    name: "Python\u4E13\u5BB6\u9CC4",
+    nameEn: "Python Expert Croc",
+    category: "language",
+    description: "Python \u751F\u6001\u4E13\u5BB6\uFF1ADjango/Flask/FastAPI/SQLAlchemy",
+    sprite: "language",
+    color: "#3776ab",
+    priority: 10,
+    triggers: { languages: ["python"] },
+    systemPrompt: "You are a Python ecosystem expert. Analyze Python code for best practices, type safety, async patterns, Django/Flask/FastAPI conventions, SQLAlchemy usage, and Python-specific security issues.",
+    outputType: "review",
+    tags: ["language", "python", "django", "flask", "fastapi"]
+  },
+  {
+    id: "go-croc",
+    name: "Go\u4E13\u5BB6\u9CC4",
+    nameEn: "Go Expert Croc",
+    category: "language",
+    description: "Go \u751F\u6001\u4E13\u5BB6\uFF1Agoroutine/channel/\u63A5\u53E3\u8BBE\u8BA1",
+    sprite: "language",
+    color: "#00add8",
+    priority: 10,
+    triggers: { languages: ["go"] },
+    systemPrompt: "You are a Go ecosystem expert. Analyze Go code for goroutine safety, channel patterns, interface design, error handling, and Go-specific performance concerns.",
+    outputType: "review",
+    tags: ["language", "go", "golang", "concurrency"]
+  },
+  {
+    id: "java-croc",
+    name: "Java\u4E13\u5BB6\u9CC4",
+    nameEn: "Java Expert Croc",
+    category: "language",
+    description: "Java/Kotlin \u751F\u6001\u4E13\u5BB6\uFF1ASpring Boot/JPA/\u5FAE\u670D\u52A1",
+    sprite: "language",
+    color: "#ed8b00",
+    priority: 10,
+    triggers: { languages: ["java", "kotlin"] },
+    systemPrompt: "You are a Java/Kotlin ecosystem expert. Analyze Spring Boot applications for bean lifecycle issues, JPA N+1 queries, transaction management, and microservice patterns.",
+    outputType: "review",
+    tags: ["language", "java", "kotlin", "spring"]
+  },
+  {
+    id: "rust-croc",
+    name: "Rust\u4E13\u5BB6\u9CC4",
+    nameEn: "Rust Expert Croc",
+    category: "language",
+    description: "Rust \u751F\u6001\u4E13\u5BB6\uFF1A\u6240\u6709\u6743/\u751F\u547D\u5468\u671F/unsafe",
+    sprite: "language",
+    color: "#dea584",
+    priority: 10,
+    triggers: { languages: ["rust"] },
+    systemPrompt: "You are a Rust ecosystem expert. Analyze Rust code for ownership patterns, lifetime issues, unsafe code safety, and performance optimization.",
+    outputType: "review",
+    tags: ["language", "rust", "ownership", "safety"]
+  }
+];
+var FRAMEWORK_ROLES = [
+  {
+    id: "react-croc",
+    name: "React\u4E13\u5BB6\u9CC4",
+    nameEn: "React Expert Croc",
+    category: "framework",
+    description: "React/Next.js \u524D\u7AEF\u6027\u80FD\u548C\u67B6\u6784\u4E13\u5BB6",
+    sprite: "framework",
+    color: "#61dafb",
+    priority: 15,
+    triggers: { frameworks: ["React", "Next.js"] },
+    systemPrompt: "You are a React/Next.js expert. Analyze component architecture, render performance, state management, SSR/SSG patterns, and React-specific anti-patterns.",
+    outputType: "review",
+    tags: ["framework", "react", "nextjs", "frontend"]
+  },
+  {
+    id: "vue-croc",
+    name: "Vue\u4E13\u5BB6\u9CC4",
+    nameEn: "Vue Expert Croc",
+    category: "framework",
+    description: "Vue/Nuxt \u4E13\u5BB6\uFF1A\u7EC4\u5408\u5F0FAPI/\u54CD\u5E94\u5F0F/SSR",
+    sprite: "framework",
+    color: "#42b883",
+    priority: 15,
+    triggers: { frameworks: ["Vue", "Nuxt"] },
+    systemPrompt: "You are a Vue/Nuxt expert. Analyze Composition API usage, reactivity patterns, Pinia stores, SSR hydration, and Vue-specific best practices.",
+    outputType: "review",
+    tags: ["framework", "vue", "nuxt", "frontend"]
+  },
+  {
+    id: "express-croc",
+    name: "Express\u4E13\u5BB6\u9CC4",
+    nameEn: "Express Expert Croc",
+    category: "framework",
+    description: "Express/Koa/Fastify \u8DEF\u7531\u548C\u4E2D\u95F4\u4EF6\u4E13\u5BB6",
+    sprite: "framework",
+    color: "#68a063",
+    priority: 15,
+    triggers: { frameworks: ["Express", "Koa", "Fastify"] },
+    systemPrompt: "You are a Node.js backend expert. Analyze Express/Koa/Fastify middleware chains, route organization, error handling, authentication patterns, and performance.",
+    outputType: "review",
+    tags: ["framework", "express", "koa", "fastify", "nodejs"]
+  },
+  {
+    id: "django-croc",
+    name: "Django\u4E13\u5BB6\u9CC4",
+    nameEn: "Django Expert Croc",
+    category: "framework",
+    description: "Django/DRF \u4E13\u5BB6\uFF1AORM/\u5E8F\u5217\u5316/\u6743\u9650",
+    sprite: "framework",
+    color: "#092e20",
+    priority: 15,
+    triggers: { frameworks: ["Django", "DRF"] },
+    systemPrompt: "You are a Django/DRF expert. Analyze ORM query efficiency, serializer design, view permissions, middleware, and Django-specific security practices.",
+    outputType: "review",
+    tags: ["framework", "django", "drf", "python"]
+  },
+  {
+    id: "spring-croc",
+    name: "SpringBoot\u4E13\u5BB6\u9CC4",
+    nameEn: "Spring Boot Expert Croc",
+    category: "framework",
+    description: "Spring Boot/Cloud \u5FAE\u670D\u52A1\u67B6\u6784\u4E13\u5BB6",
+    sprite: "framework",
+    color: "#6db33f",
+    priority: 15,
+    triggers: { frameworks: ["Spring Boot", "Spring Cloud"] },
+    systemPrompt: "You are a Spring Boot/Cloud expert. Analyze bean configurations, transaction management, service discovery, circuit breakers, and microservice communication patterns.",
+    outputType: "review",
+    tags: ["framework", "spring", "springboot", "microservice"]
+  }
+];
+var DOMAIN_ROLES = [
+  {
+    id: "security-croc",
+    name: "\u5B89\u5168\u5BA1\u8BA1\u9CC4",
+    nameEn: "Security Auditor Croc",
+    category: "domain",
+    description: "\u5B89\u5168\u6F0F\u6D1E\u68C0\u6D4B\uFF1A\u6CE8\u5165/XSS/CSRF/\u8BA4\u8BC1/\u6388\u6743",
+    sprite: "security",
+    color: "#ef4444",
+    priority: 8,
+    triggers: {
+      riskCategories: ["security"],
+      custom: (ctx) => ctx.hasAPIs
+    },
+    systemPrompt: "You are a security auditor. Scan for OWASP Top 10 vulnerabilities: SQL injection, XSS, CSRF, broken authentication, sensitive data exposure, insecure deserialization, and missing access controls.",
+    outputType: "report",
+    tags: ["domain", "security", "owasp", "audit"]
+  },
+  {
+    id: "performance-croc",
+    name: "\u6027\u80FD\u5206\u6790\u9CC4",
+    nameEn: "Performance Analyst Croc",
+    category: "domain",
+    description: "\u6027\u80FD\u74F6\u9888\u68C0\u6D4B\uFF1AN+1\u67E5\u8BE2/\u5185\u5B58\u6CC4\u6F0F/\u6162\u63A5\u53E3",
+    sprite: "performance",
+    color: "#f59e0b",
+    priority: 9,
+    triggers: {
+      minEntities: 50,
+      custom: (ctx) => ctx.hasModels && ctx.hasAPIs
+    },
+    systemPrompt: "You are a performance analyst. Detect N+1 queries, memory leaks, slow API endpoints, missing indexes, unnecessary data loading, and recommend caching strategies.",
+    outputType: "report",
+    tags: ["domain", "performance", "optimization", "n+1"]
+  },
+  {
+    id: "architecture-croc",
+    name: "\u67B6\u6784\u8BC4\u5BA1\u9CC4",
+    nameEn: "Architecture Reviewer Croc",
+    category: "domain",
+    description: "\u67B6\u6784\u8D28\u91CF\u8BC4\u5BA1\uFF1A\u8026\u5408\u5EA6/\u5185\u805A\u6027/\u5206\u5C42/DDD",
+    sprite: "architecture",
+    color: "#8b5cf6",
+    priority: 7,
+    triggers: {
+      minEntities: 30
+    },
+    systemPrompt: "You are a software architect. Evaluate coupling, cohesion, layering, dependency injection, SOLID principles, DDD patterns, and recommend architectural improvements.",
+    outputType: "review",
+    tags: ["domain", "architecture", "solid", "ddd"]
+  },
+  {
+    id: "data-modeling-croc",
+    name: "\u6570\u636E\u5EFA\u6A21\u9CC4",
+    nameEn: "Data Modeling Croc",
+    category: "domain",
+    description: "\u6570\u636E\u6A21\u578B\u8BC4\u5BA1\uFF1A\u8303\u5F0F/\u7D22\u5F15/\u5173\u8054/\u8FC1\u79FB",
+    sprite: "database",
+    color: "#06b6d4",
+    priority: 9,
+    triggers: {
+      custom: (ctx) => ctx.hasModels,
+      frameworks: ["Sequelize", "Prisma", "TypeORM", "Drizzle", "SQLAlchemy", "Django"]
+    },
+    systemPrompt: "You are a database expert. Review data models for normalization, index design, relationship integrity, migration safety, cascade delete risks, and query optimization.",
+    outputType: "review",
+    tags: ["domain", "database", "modeling", "orm"]
+  },
+  {
+    id: "devops-croc",
+    name: "\u8FD0\u7EF4\u90E8\u7F72\u9CC4",
+    nameEn: "DevOps Croc",
+    category: "domain",
+    description: "CI/CD\u3001Docker\u3001K8s \u90E8\u7F72\u548C\u8FD0\u7EF4\u4E13\u5BB6",
+    sprite: "devops",
+    color: "#2563eb",
+    priority: 12,
+    triggers: {
+      custom: (ctx) => ctx.hasDocker || ctx.hasCI,
+      filePatterns: ["Dockerfile", "docker-compose*", ".github/workflows/*", ".gitlab-ci*", "Jenkinsfile"]
+    },
+    systemPrompt: "You are a DevOps expert. Analyze Dockerfile efficiency, compose orchestration, CI/CD pipeline design, secret management, health checks, and deployment strategies.",
+    outputType: "review",
+    tags: ["domain", "devops", "docker", "ci/cd", "kubernetes"]
+  },
+  {
+    id: "api-design-croc",
+    name: "API\u8BBE\u8BA1\u9CC4",
+    nameEn: "API Design Croc",
+    category: "domain",
+    description: "RESTful API \u8BBE\u8BA1\u8BC4\u5BA1\uFF1A\u547D\u540D/\u7248\u672C/\u5206\u9875/\u9519\u8BEF\u5904\u7406",
+    sprite: "api",
+    color: "#10b981",
+    priority: 11,
+    triggers: {
+      custom: (ctx) => ctx.hasAPIs,
+      minEntities: 10
+    },
+    systemPrompt: "You are an API design expert. Review REST API naming conventions, versioning strategy, pagination, filtering, error response format, rate limiting, and documentation completeness.",
+    outputType: "review",
+    tags: ["domain", "api", "rest", "design"]
+  },
+  {
+    id: "refactor-croc",
+    name: "\u91CD\u6784\u5EFA\u8BAE\u9CC4",
+    nameEn: "Refactoring Croc",
+    category: "domain",
+    description: "\u4EE3\u7801\u8D28\u91CF\u8BC4\u4F30\uFF1A\u6280\u672F\u503A/\u590D\u6742\u5EA6/\u91CD\u590D\u4EE3\u7801",
+    sprite: "refactor",
+    color: "#ec4899",
+    priority: 13,
+    triggers: {
+      riskCategories: ["maintainability"],
+      minEntities: 40
+    },
+    systemPrompt: "You are a refactoring expert. Identify code smells, duplicated logic, high cyclomatic complexity, god classes, feature envy, and suggest targeted refactoring strategies with minimal risk.",
+    outputType: "review",
+    tags: ["domain", "refactoring", "quality", "tech-debt"]
+  },
+  {
+    id: "microservice-croc",
+    name: "\u670D\u52A1\u6CBB\u7406\u9CC4",
+    nameEn: "Microservice Governance Croc",
+    category: "domain",
+    description: "\u5FAE\u670D\u52A1\u67B6\u6784\u6CBB\u7406\uFF1A\u670D\u52A1\u8FB9\u754C/\u7194\u65AD/\u94FE\u8DEF\u8FFD\u8E2A",
+    sprite: "microservice",
+    color: "#7c3aed",
+    priority: 14,
+    triggers: {
+      projectTypes: ["microservice", "monorepo"],
+      custom: (ctx) => ctx.entityCount > 100
+    },
+    systemPrompt: "You are a microservice governance expert. Analyze service boundaries, inter-service communication, circuit breakers, distributed tracing, service mesh, and API gateway patterns.",
+    outputType: "review",
+    tags: ["domain", "microservice", "governance", "distributed"]
+  }
+];
+var RoleRegistry = class {
+  roles = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const role of [...CORE_ROLES, ...LANGUAGE_ROLES, ...FRAMEWORK_ROLES, ...DOMAIN_ROLES]) {
+      this.roles.set(role.id, role);
+    }
+  }
+  /** Register a new role (community or custom) */
+  register(role) {
+    if (this.roles.has(role.id)) {
+      throw new Error(`Role "${role.id}" is already registered`);
+    }
+    this.roles.set(role.id, role);
+  }
+  /** Unregister a role */
+  unregister(id) {
+    return this.roles.delete(id);
+  }
+  /** Get a role by ID */
+  get(id) {
+    return this.roles.get(id);
+  }
+  /** List all registered roles */
+  list() {
+    return Array.from(this.roles.values());
+  }
+  /** List roles by category */
+  listByCategory(category) {
+    return this.list().filter((r) => r.category === category);
+  }
+  /** Search roles by tags */
+  search(query) {
+    const q = query.toLowerCase();
+    return this.list().filter(
+      (r) => r.name.toLowerCase().includes(q) || r.nameEn.toLowerCase().includes(q) || r.description.toLowerCase().includes(q) || r.tags.some((t) => t.includes(q))
+    );
+  }
+  /** Total number of registered roles */
+  get size() {
+    return this.roles.size;
+  }
+};
+var _registry = null;
+function getRoleRegistry() {
+  if (!_registry) {
+    _registry = new RoleRegistry();
+  }
+  return _registry;
+}
+
+// src/agents/task-router.ts
+init_esm_shims();
+function buildMatchContext(scan) {
+  const languages = scan.languages;
+  const frameworks = scan.frameworks.map((f) => f.name);
+  const frontendFrameworks = ["React", "Vue", "Angular", "Svelte", "Next.js", "Nuxt"];
+  const backendFrameworks = ["Express", "Fastify", "NestJS", "Django", "Flask", "Spring Boot", "Gin", "Actix"];
+  const hasFE = frameworks.some((f) => frontendFrameworks.includes(f));
+  const hasBE = frameworks.some((f) => backendFrameworks.includes(f));
+  const projectType = hasFE && hasBE ? "fullstack" : hasFE ? "frontend" : hasBE ? "backend" : "unknown";
+  const entityTypes = new Set(scan.entities.map((e) => e.type));
+  const hasModels = entityTypes.has("model") || entityTypes.has("class");
+  const hasAPIs = entityTypes.has("api") || entityTypes.has("route");
+  const hasFrontend = hasFE || (languages["html"] ?? 0) > 10 || (languages["css"] ?? 0) > 5;
+  const allPaths = scan.files.map((f) => f.path);
+  const hasDocker = allPaths.some(
+    (p) => p.includes("Dockerfile") || p.includes("docker-compose")
+  );
+  const hasCI = allPaths.some(
+    (p) => p.includes(".github/workflows") || p.includes(".gitlab-ci") || p.includes("Jenkinsfile")
+  );
+  const riskCategories = [];
+  return {
+    languages,
+    frameworks,
+    projectType,
+    fileCount: scan.files.length,
+    entityCount: scan.entities.length,
+    riskCategories,
+    hasModels,
+    hasAPIs,
+    hasFrontend,
+    hasDocker,
+    hasCI
+  };
+}
+function matchesTriggers(trigger, ctx) {
+  const reasons = [];
+  let score = 0;
+  let checks = 0;
+  if (trigger.languages && trigger.languages.length > 0) {
+    checks++;
+    const matched = trigger.languages.filter((l) => (ctx.languages[l] ?? 0) > 0);
+    if (matched.length > 0) {
+      score++;
+      reasons.push(`\u8BED\u8A00\u5339\u914D: ${matched.join(", ")}`);
+    }
+  }
+  if (trigger.frameworks && trigger.frameworks.length > 0) {
+    checks++;
+    const matched = trigger.frameworks.filter(
+      (f) => ctx.frameworks.some((cf) => cf.toLowerCase() === f.toLowerCase())
+    );
+    if (matched.length > 0) {
+      score++;
+      reasons.push(`\u6846\u67B6\u5339\u914D: ${matched.join(", ")}`);
+    }
+  }
+  if (trigger.projectTypes && trigger.projectTypes.length > 0) {
+    checks++;
+    if (trigger.projectTypes.includes(ctx.projectType)) {
+      score++;
+      reasons.push(`\u9879\u76EE\u7C7B\u578B\u5339\u914D: ${ctx.projectType}`);
+    }
+  }
+  if (trigger.minEntities !== void 0) {
+    checks++;
+    if (ctx.entityCount >= trigger.minEntities) {
+      score++;
+      reasons.push(`\u5B9E\u4F53\u6570\u91CF\u6EE1\u8DB3: ${ctx.entityCount} \u2265 ${trigger.minEntities}`);
+    }
+  }
+  if (trigger.riskCategories && trigger.riskCategories.length > 0) {
+    checks++;
+    const matched = trigger.riskCategories.filter((r) => ctx.riskCategories.includes(r));
+    if (matched.length > 0) {
+      score++;
+      reasons.push(`\u98CE\u9669\u7C7B\u522B\u5339\u914D: ${matched.join(", ")}`);
+    }
+  }
+  if (trigger.custom) {
+    checks++;
+    try {
+      if (trigger.custom(ctx)) {
+        score++;
+        reasons.push("\u81EA\u5B9A\u4E49\u6761\u4EF6\u6EE1\u8DB3");
+      }
+    } catch {
+    }
+  }
+  const matches = checks === 0 ? false : score > 0;
+  const confidence = checks > 0 ? score / checks : 0;
+  return {
+    matches,
+    reason: reasons.join("; ") || "\u65E0\u5339\u914D",
+    confidence
+  };
+}
+function planSummon(scan, maxRoles = 8, riskCategories = []) {
+  const registry = getRoleRegistry();
+  const ctx = buildMatchContext(scan);
+  ctx.riskCategories = riskCategories;
+  const summoned = [];
+  const reasoning = [];
+  const allRoles = registry.list();
+  const coreRoles = allRoles.filter((r) => r.category === "core");
+  for (const role of coreRoles) {
+    summoned.push({ role, reason: "\u6838\u5FC3\u89D2\u8272(\u59CB\u7EC8\u53EC\u5524)", confidence: 1 });
+    reasoning.push(`\u2705 ${role.name} \u2014 \u6838\u5FC3\u89D2\u8272`);
+  }
+  const nonCore = allRoles.filter((r) => r.category !== "core");
+  const candidates = [];
+  for (const role of nonCore) {
+    const result = matchesTriggers(role.triggers, ctx);
+    if (result.matches) {
+      candidates.push({
+        role,
+        reason: result.reason,
+        confidence: result.confidence
+      });
+    }
+  }
+  candidates.sort((a, b) => {
+    if (a.role.priority !== b.role.priority) return a.role.priority - b.role.priority;
+    return b.confidence - a.confidence;
+  });
+  const selected = candidates.slice(0, maxRoles);
+  for (const s of selected) {
+    summoned.push(s);
+    reasoning.push(`\u{1F40A} ${s.role.name} \u2014 ${s.reason} (\u7F6E\u4FE1\u5EA6: ${(s.confidence * 100).toFixed(0)}%)`);
+  }
+  const skipped = candidates.slice(maxRoles);
+  for (const s of skipped) {
+    reasoning.push(`\u23ED\uFE0F ${s.role.name} \u2014 \u5339\u914D\u4F46\u8D85\u51FA\u9650\u5236 (\u7F6E\u4FE1\u5EA6: ${(s.confidence * 100).toFixed(0)}%)`);
+  }
+  return { roles: summoned, reasoning, context: ctx };
+}
 export {
   NetworkMonitor,
+  RoleRegistry,
   SYSTEM_PROMPTS,
   TokenTracker,
   COMMANDS as VSCODE_COMMANDS,
@@ -9227,6 +9772,7 @@ export {
   buildFailureSummary,
   buildGraph,
   buildKnowledgeGraph,
+  buildMatchContext,
   buildModuleTree,
   buildPath,
   buildStatusTree,
@@ -9296,6 +9842,7 @@ export {
   getGraphStats,
   getModulePreset,
   getNeighbors,
+  getRoleRegistry,
   inferDependencies,
   inferRelatedTables,
   listCiPlatforms,
@@ -9313,6 +9860,7 @@ export {
   parseModuleModels,
   parsePlaywrightReport,
   parseValidatorRules,
+  planSummon,
   printOrchestrationSummary,
   queryNodes,
   recoverJSON,