opencroc 1.8.1 → 1.8.2

package/dist/cli/index.js

@@ -6511,12 +6511,430 @@ var init_studio_store = __esm({
   }
 });
 
+// src/agents/role-registry.ts
+var role_registry_exports = {};
+__export(role_registry_exports, {
+  RoleRegistry: () => RoleRegistry,
+  getRoleRegistry: () => getRoleRegistry
+});
+function getRoleRegistry() {
+  if (!_registry) {
+    _registry = new RoleRegistry();
+  }
+  return _registry;
+}
+var CORE_ROLES, LANGUAGE_ROLES, FRAMEWORK_ROLES, DOMAIN_ROLES, RoleRegistry, _registry;
+var init_role_registry = __esm({
+  "src/agents/role-registry.ts"() {
+    "use strict";
+    init_esm_shims();
+    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"]
+      }
+    ];
+    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"]
+      }
+    ];
+    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"]
+      }
+    ];
+    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"]
+      }
+    ];
+    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;
+      }
+    };
+    _registry = null;
+  }
+});
+
 // src/server/routes/studio.ts
 function restoreStore(snapshotStore) {
   return snapshotStore?.load() ?? { ...EMPTY_STUDIO_STORE };
 }
 function registerStudioRoutes(app, office, snapshotStore) {
   const store = restoreStore(snapshotStore);
+  let lastScanResult = null;
   if (store.graph) {
     office.log(`\u267B\uFE0F Restored Studio snapshot: ${store.graph.nodes.length} nodes, ${store.risks.length} risks`, "info");
   }
@@ -6578,6 +6996,7 @@ function registerStudioRoutes(app, office, snapshotStore) {
       store.risks = risks;
       store.scanTime = Date.now();
       store.source = target;
+      lastScanResult = scanResult;
       persistStore();
       broadcastGraph();
       return {
@@ -6826,6 +7245,90 @@ function registerStudioRoutes(app, office, snapshotStore) {
       snapshots: snapshotStore.list()
     };
   });
+  app.get("/api/studio/roles", async (req) => {
+    const { getRoleRegistry: getRoleRegistry2 } = await Promise.resolve().then(() => (init_role_registry(), role_registry_exports));
+    const registry = getRoleRegistry2();
+    const category = req.query.category;
+    const search = req.query.search;
+    let roles = registry.list();
+    if (category) roles = roles.filter((r) => r.category === category);
+    if (search) roles = registry.search(search);
+    return {
+      total: roles.length,
+      categories: {
+        core: roles.filter((r) => r.category === "core").length,
+        language: roles.filter((r) => r.category === "language").length,
+        framework: roles.filter((r) => r.category === "framework").length,
+        domain: roles.filter((r) => r.category === "domain").length,
+        community: roles.filter((r) => r.category === "community").length
+      },
+      roles: roles.map((r) => ({
+        id: r.id,
+        name: r.name,
+        nameEn: r.nameEn,
+        category: r.category,
+        description: r.description,
+        color: r.color,
+        sprite: r.sprite,
+        priority: r.priority,
+        tags: r.tags,
+        outputType: r.outputType
+      }))
+    };
+  });
+  app.post("/api/studio/summon", async (_req, reply) => {
+    if (!lastScanResult) {
+      reply.code(400).send({ error: "No project scanned. Run /api/studio/scan first." });
+      return;
+    }
+    const riskCategories = [...new Set(store.risks.map((r) => r.category))];
+    const plan = await office.summonForProject(lastScanResult, riskCategories);
+    return {
+      ok: true,
+      totalAgents: office.getAgents().length,
+      coreAgents: 6,
+      dynamicAgents: office.getAgents().length - 6,
+      reasoning: plan.reasoning,
+      agents: office.getAgents().map((a) => ({
+        id: a.id,
+        name: a.name,
+        role: a.role,
+        sprite: a.sprite,
+        status: a.status,
+        category: a.category,
+        color: a.color,
+        description: a.description
+      })),
+      context: {
+        languages: plan.context.languages,
+        frameworks: plan.context.frameworks,
+        projectType: plan.context.projectType,
+        entityCount: plan.context.entityCount,
+        hasAPIs: plan.context.hasAPIs,
+        hasModels: plan.context.hasModels,
+        hasFrontend: plan.context.hasFrontend,
+        hasDocker: plan.context.hasDocker,
+        hasCI: plan.context.hasCI
+      }
+    };
+  });
+  app.get("/api/studio/agents", async () => {
+    const info = office.getSummonPlan();
+    return {
+      ...info,
+      agents: info.agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        role: a.role,
+        sprite: a.sprite,
+        status: a.status,
+        currentTask: a.currentTask,
+        category: a.category,
+        color: a.color,
+        description: a.description
+      }))
+    };
+  });
 }
 var init_studio = __esm({
   "src/server/routes/studio.ts"() {
@@ -6838,6 +7341,155 @@ var init_studio = __esm({
   }
 });
 
+// src/agents/task-router.ts
+var task_router_exports = {};
+__export(task_router_exports, {
+  buildMatchContext: () => buildMatchContext,
+  planSummon: () => planSummon
+});
+function buildMatchContext(scan2) {
+  const languages = scan2.languages;
+  const frameworks = scan2.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(scan2.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 = scan2.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: scan2.files.length,
+    entityCount: scan2.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(scan2, maxRoles = 8, riskCategories = []) {
+  const registry = getRoleRegistry();
+  const ctx = buildMatchContext(scan2);
+  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 };
+}
+var init_task_router = __esm({
+  "src/agents/task-router.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_role_registry();
+  }
+});
+
 // src/execution/coordinator.ts
 var coordinator_exports = {};
 __export(coordinator_exports, {
@@ -7216,7 +7868,7 @@ var init_croc_office = __esm({
       { id: "planner-croc", name: "\u89C4\u5212\u9CC4", role: "planner", sprite: "planner", status: "idle", tokensUsed: 0 },
       { id: "reporter-croc", name: "\u6C47\u62A5\u9CC4", role: "reporter", sprite: "reporter", status: "idle", tokensUsed: 0 }
     ];
-    CrocOffice = class {
+    CrocOffice = class _CrocOffice {
       config;
       cwd;
       clients = /* @__PURE__ */ new Set();
@@ -7228,6 +7880,10 @@ var init_croc_office = __esm({
       lastExecutionMetrics = null;
       lastExecutionQuality = null;
       lastReports = [];
+      static ACTIVE_AGENT_STATUSES = /* @__PURE__ */ new Set([
+        "working",
+        "thinking"
+      ]);
       constructor(config, cwd) {
         this.config = config;
         this.cwd = cwd;
@@ -7262,10 +7918,34 @@ var init_croc_office = __esm({
       updateAgent(id, update) {
         const agent = this.agents.find((a) => a.id === id);
         if (agent) {
+          const wasActive = this.isAgentActive(agent.status);
           Object.assign(agent, update);
+          const isActive = this.isAgentActive(agent.status);
           this.broadcast("agent:update", this.agents);
+          if (!wasActive && isActive) {
+            this.broadcast("agent:assigned", {
+              id: agent.id,
+              name: agent.name,
+              role: agent.role,
+              status: agent.status,
+              currentTask: agent.currentTask ?? null,
+              at: Date.now()
+            });
+          } else if (wasActive && !isActive) {
+            this.broadcast("agent:released", {
+              id: agent.id,
+              name: agent.name,
+              role: agent.role,
+              status: agent.status,
+              currentTask: agent.currentTask ?? null,
+              at: Date.now()
+            });
+          }
         }
       }
+      isAgentActive(status) {
+        return _CrocOffice.ACTIVE_AGENT_STATUSES.has(status);
+      }
       isRunning() {
         return this.running;
       }
@@ -7395,12 +8075,75 @@ var init_croc_office = __esm({
       /** Reset all agents to idle */
       resetAgents() {
         for (const agent of this.agents) {
+          const wasActive = this.isAgentActive(agent.status);
           agent.status = "idle";
           agent.currentTask = void 0;
           agent.progress = void 0;
+          if (wasActive) {
+            this.broadcast("agent:released", {
+              id: agent.id,
+              name: agent.name,
+              role: agent.role,
+              status: agent.status,
+              currentTask: null,
+              at: Date.now()
+            });
+          }
         }
         this.broadcast("agent:update", this.agents);
       }
+      /**
+       * Dynamically summon crocs based on a project scan result.
+       * Core 6 are always present; additional expert crocs are added based on project characteristics.
+       */
+      async summonForProject(scan2, riskCategories = []) {
+        const { planSummon: planSummon2 } = await Promise.resolve().then(() => (init_task_router(), task_router_exports));
+        const plan = planSummon2(scan2, 8, riskCategories);
+        const coreIds = new Set(DEFAULT_AGENTS.map((a) => a.id));
+        this.agents = DEFAULT_AGENTS.map((a) => ({ ...a }));
+        for (const summoned of plan.roles) {
+          if (coreIds.has(summoned.role.id)) continue;
+          const agent = {
+            id: summoned.role.id,
+            name: summoned.role.name,
+            role: summoned.role.id.replace(/-croc$/, ""),
+            sprite: summoned.role.sprite,
+            status: "idle",
+            tokensUsed: 0,
+            category: summoned.role.category,
+            color: summoned.role.color,
+            description: summoned.role.description
+          };
+          this.agents.push(agent);
+        }
+        this.broadcast("agent:update", this.agents);
+        for (const line of plan.reasoning) {
+          this.log(line);
+        }
+        this.log(`\u{1F40A} \u5171\u53EC\u5524 ${this.agents.length} \u4E2A\u9CC4\u9C7C\u4E13\u5BB6 (${plan.roles.length - DEFAULT_AGENTS.length} \u4E2A\u52A8\u6001\u89D2\u8272)`);
+        const dynamicAgents = this.agents.filter((a) => !coreIds.has(a.id));
+        for (let i = 0; i < dynamicAgents.length; i++) {
+          const agent = dynamicAgents[i];
+          setTimeout(() => {
+            this.updateAgent(agent.id, { status: "working", currentTask: "\u5206\u6790\u9879\u76EE\u4E2D\u2026" });
+            setTimeout(() => {
+              this.updateAgent(agent.id, { status: "idle", currentTask: void 0 });
+            }, 2e3 + Math.random() * 1e3);
+          }, 300 * i);
+        }
+        return plan;
+      }
+      /** Get the current summon plan context */
+      getSummonPlan() {
+        const coreIds = new Set(DEFAULT_AGENTS.map((a) => a.id));
+        const coreCount = this.agents.filter((a) => coreIds.has(a.id)).length;
+        return {
+          agentCount: this.agents.length,
+          coreCount,
+          dynamicCount: this.agents.length - coreCount,
+          agents: this.agents
+        };
+      }
       /** Get last pipeline result */
       getLastPipelineResult() {
         return this.lastPipelineResult;
@@ -7827,7 +8570,8 @@ async function startServer(opts) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
-      decorateReply: false
+      decorateReply: false,
+      index: false
     });
   }
   const office = new CrocOffice(opts.config, opts.cwd);
@@ -7841,17 +8585,20 @@ async function startServer(opts) {
       socket.on("close", () => office.removeClient(socket));
     });
   });
+  app.get("/index-studio.html", (_req, reply) => {
+    reply.redirect("/studio");
+  });
+  app.get("/index-v2-pixel.html", (_req, reply) => {
+    reply.redirect("/pixel");
+  });
   app.setNotFoundHandler((req, reply) => {
     if (req.url.startsWith("/api/")) {
       reply.code(404).send({ error: "Not found" });
       return;
     }
-    const studioPath = join17(webDir, "index-studio.html");
-    const indexPath = join17(webDir, "index.html");
-    if (existsSync20(studioPath)) {
-      reply.sendFile("index-studio.html");
-    } else if (existsSync20(indexPath)) {
-      reply.sendFile("index.html");
+    const builtIndexPath = join17(webDir, "dist", "index.html");
+    if (existsSync20(builtIndexPath)) {
+      reply.sendFile("dist/index.html");
     } else {
       reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
     }