opencroc 1.8.0 → 1.8.2

package/dist/cli/index.js

@@ -6324,8 +6324,640 @@ var init_insight = __esm({
   }
 });
 
+// src/server/studio-store.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname6 } from "path";
+function isSerializedSnapshotFile(value) {
+  return "snapshots" in value && Array.isArray(value.snapshots);
+}
+var EMPTY_STUDIO_STORE, FileStudioSnapshotStore;
+var init_studio_store = __esm({
+  "src/server/studio-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    EMPTY_STUDIO_STORE = {
+      graph: null,
+      risks: [],
+      scanTime: 0,
+      source: ""
+    };
+    FileStudioSnapshotStore = class {
+      filePath;
+      maxSnapshots;
+      constructor(filePath, maxSnapshots = 12) {
+        this.filePath = filePath;
+        this.maxSnapshots = maxSnapshots;
+      }
+      load() {
+        const data = this.readFile();
+        if (!data || !data.currentSnapshotId) return null;
+        const current = data.snapshots.find((snapshot) => snapshot.id === data.currentSnapshotId);
+        return current ? this.toProjectStore(current) : null;
+      }
+      save(snapshot) {
+        const data = this.readFile() ?? { version: 2, currentSnapshotId: null, snapshots: [] };
+        const record = this.toSnapshotRecord(snapshot);
+        data.currentSnapshotId = record.id;
+        data.snapshots = [record, ...data.snapshots].slice(0, this.maxSnapshots);
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+      }
+      list() {
+        const data = this.readFile();
+        if (!data) return [];
+        return data.snapshots.map((snapshot) => ({
+          id: snapshot.id,
+          name: snapshot.name,
+          source: snapshot.source,
+          scanTime: snapshot.scanTime,
+          nodeCount: snapshot.graph?.nodes.length ?? 0,
+          riskCount: snapshot.risks.length,
+          current: snapshot.id === data.currentSnapshotId,
+          pinned: Boolean(snapshot.pinned),
+          tags: Array.isArray(snapshot.tags) ? snapshot.tags : []
+        })).sort((left, right) => {
+          if (left.pinned !== right.pinned) return left.pinned ? -1 : 1;
+          return right.scanTime - left.scanTime;
+        });
+      }
+      loadById(id) {
+        const data = this.readFile();
+        if (!data) return null;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return null;
+        data.currentSnapshotId = record.id;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return this.toProjectStore(record);
+      }
+      rename(id, name) {
+        const nextName = name.trim();
+        if (!nextName) return false;
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.name = nextName;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      delete(id) {
+        const data = this.readFile();
+        if (!data) return false;
+        const nextSnapshots = data.snapshots.filter((snapshot) => snapshot.id !== id);
+        if (nextSnapshots.length === data.snapshots.length) return false;
+        data.snapshots = nextSnapshots;
+        if (data.currentSnapshotId === id) {
+          data.currentSnapshotId = nextSnapshots[0]?.id ?? null;
+        }
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      pin(id, pinned) {
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.pinned = pinned;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      updateTags(id, tags) {
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.tags = this.normalizeTags(tags);
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      readFile() {
+        if (!existsSync18(this.filePath)) return null;
+        try {
+          const raw = readFileSync6(this.filePath, "utf-8");
+          const parsed = JSON.parse(raw);
+          return this.normalize(parsed);
+        } catch {
+          return null;
+        }
+      }
+      normalize(parsed) {
+        if (isSerializedSnapshotFile(parsed)) {
+          return {
+            version: 2,
+            currentSnapshotId: typeof parsed.currentSnapshotId === "string" ? parsed.currentSnapshotId : null,
+            snapshots: parsed.snapshots.map((snapshot) => ({
+              id: snapshot.id,
+              name: snapshot.name,
+              pinned: Boolean(snapshot.pinned),
+              tags: this.normalizeTags(snapshot.tags),
+              graph: snapshot.graph ?? null,
+              risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+              scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : 0,
+              source: typeof snapshot.source === "string" ? snapshot.source : ""
+            }))
+          };
+        }
+        const legacyStore = parsed;
+        const legacy = this.toSnapshotRecord({
+          graph: legacyStore.graph ?? null,
+          risks: Array.isArray(legacyStore.risks) ? legacyStore.risks : [],
+          scanTime: typeof legacyStore.scanTime === "number" ? legacyStore.scanTime : 0,
+          source: typeof legacyStore.source === "string" ? legacyStore.source : ""
+        });
+        return {
+          version: 2,
+          currentSnapshotId: legacy.id,
+          snapshots: [legacy]
+        };
+      }
+      toSnapshotRecord(snapshot) {
+        const name = snapshot.graph?.projectInfo?.name || this.deriveName(snapshot.source);
+        return {
+          id: `${snapshot.scanTime || Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+          name,
+          pinned: false,
+          tags: [],
+          graph: snapshot.graph ?? null,
+          risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+          scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : Date.now(),
+          source: typeof snapshot.source === "string" ? snapshot.source : ""
+        };
+      }
+      toProjectStore(snapshot) {
+        return {
+          graph: snapshot.graph ?? null,
+          risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+          scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : 0,
+          source: typeof snapshot.source === "string" ? snapshot.source : ""
+        };
+      }
+      deriveName(source) {
+        if (!source) return "unknown-project";
+        const parts = source.split(/[\\/]/).filter(Boolean);
+        return parts[parts.length - 1] || source;
+      }
+      normalizeTags(tags) {
+        if (!Array.isArray(tags)) return [];
+        return [...new Set(
+          tags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean)
+        )];
+      }
+    };
+  }
+});
+
+// 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 registerStudioRoutes(app, office) {
+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");
+  }
+  const persistStore = () => {
+    snapshotStore?.save(store);
+  };
+  const broadcastGraph = () => {
+    if (!store.graph) return;
+    office.broadcast("graph:update", {
+      nodes: store.graph.nodes.map((n) => ({
+        id: n.id,
+        label: n.label,
+        type: n.type,
+        module: n.module,
+        status: n.status
+      })),
+      edges: store.graph.edges.map((e) => ({
+        source: e.source,
+        target: e.target,
+        relation: e.relation
+      }))
+    });
+  };
   app.post("/api/studio/scan", async (req, reply) => {
     const { target, branch, useLlm } = req.body || {};
     if (!target || typeof target !== "string") {
@@ -6364,20 +6996,9 @@ function registerStudioRoutes(app, office) {
       store.risks = risks;
       store.scanTime = Date.now();
       store.source = target;
-      office.broadcast("graph:update", {
-        nodes: graph.nodes.map((n) => ({
-          id: n.id,
-          label: n.label,
-          type: n.type,
-          module: n.module,
-          status: n.status
-        })),
-        edges: graph.edges.map((e) => ({
-          source: e.source,
-          target: e.target,
-          relation: e.relation
-        }))
-      });
+      lastScanResult = scanResult;
+      persistStore();
+      broadcastGraph();
       return {
         ok: true,
         project: graph.projectInfo,
@@ -6511,8 +7132,204 @@ function registerStudioRoutes(app, office) {
       source: store.source
     };
   });
+  app.get("/api/studio/snapshots", async () => {
+    const snapshots = snapshotStore?.list() ?? [];
+    return {
+      total: snapshots.length,
+      snapshots
+    };
+  });
+  app.post("/api/studio/snapshots/:id/load", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const restored = snapshotStore.loadById(req.params.id);
+    if (!restored) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    store.graph = restored.graph;
+    store.risks = restored.risks;
+    store.scanTime = restored.scanTime;
+    store.source = restored.source;
+    office.log(`\u267B\uFE0F Restored snapshot: ${store.source || "unknown source"}`, "info");
+    broadcastGraph();
+    return {
+      ok: true,
+      source: store.source,
+      scanTime: store.scanTime,
+      graph: store.graph ? {
+        nodeCount: store.graph.nodes.length,
+        edgeCount: store.graph.edges.length
+      } : null,
+      risks: store.risks.length
+    };
+  });
+  app.post("/api/studio/snapshots/:id/rename", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const name = req.body?.name?.trim();
+    if (!name) {
+      reply.code(400).send({ error: "Snapshot name is required." });
+      return;
+    }
+    const renamed = snapshotStore.rename(req.params.id, name);
+    if (!renamed) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/pin", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const pinned = Boolean(req.body?.pinned);
+    const updated = snapshotStore.pin(req.params.id, pinned);
+    if (!updated) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/tags", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const rawTags = Array.isArray(req.body?.tags) ? req.body.tags : [];
+    const tags = [...new Set(
+      rawTags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean)
+    )];
+    const updated = snapshotStore.updateTags(req.params.id, tags);
+    if (!updated) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/delete", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const deleted = snapshotStore.delete(req.params.id);
+    if (!deleted) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    const current = snapshotStore.load();
+    store.graph = current?.graph ?? null;
+    store.risks = current?.risks ?? [];
+    store.scanTime = current?.scanTime ?? 0;
+    store.source = current?.source ?? "";
+    if (store.graph) {
+      broadcastGraph();
+    }
+    return {
+      ok: true,
+      hasCurrent: Boolean(current?.graph),
+      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 store;
 var init_studio = __esm({
   "src/server/routes/studio.ts"() {
     "use strict";
@@ -6520,12 +7337,156 @@ var init_studio = __esm({
     init_github_cloner();
     init_graph();
     init_insight();
-    store = {
-      graph: null,
-      risks: [],
-      scanTime: 0,
-      source: ""
-    };
+    init_studio_store();
+  }
+});
+
+// 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();
   }
 });
 
@@ -6728,14 +7689,14 @@ var runtime_bootstrap_exports = {};
 __export(runtime_bootstrap_exports, {
   createRuntimeBootstrap: () => createRuntimeBootstrap
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname6, join as join16 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname7, join as join16 } from "path";
 function ensureFile(filePath, content, force) {
-  if (existsSync18(filePath) && !force) {
+  if (existsSync19(filePath) && !force) {
     return false;
   }
-  mkdirSync11(dirname6(filePath), { recursive: true });
-  writeFileSync10(filePath, content, "utf-8");
+  mkdirSync12(dirname7(filePath), { recursive: true });
+  writeFileSync11(filePath, content, "utf-8");
   return true;
 }
 function createRuntimeBootstrap(config) {
@@ -6907,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();
@@ -6919,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;
@@ -6953,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;
       }
@@ -7034,13 +8023,13 @@ var init_croc_office = __esm({
           const fullResult = await pipeline.run(["scan", "er-diagram", "api-chain", "plan", "codegen"]);
           this.lastPipelineResult = fullResult;
           this.lastGeneratedFiles = fullResult.generatedFiles;
-          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
-          const { dirname: dirname8 } = await import("path");
+          const { writeFileSync: writeFileSync14, mkdirSync: mkdirSync15 } = await import("fs");
+          const { dirname: dirname9 } = await import("path");
           let filesWritten = 0;
           for (const file of fullResult.generatedFiles) {
             const fullPath = resolvePath(this.cwd, file.filePath);
-            mkdirSync14(dirname8(fullPath), { recursive: true });
-            writeFileSync13(fullPath, file.content, "utf-8");
+            mkdirSync15(dirname9(fullPath), { recursive: true });
+            writeFileSync14(fullPath, file.content, "utf-8");
             filesWritten++;
           }
           this.updateNodeStatus("controller", "passed");
@@ -7086,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;
@@ -7124,14 +8176,14 @@ var init_croc_office = __esm({
         let backendStatus;
         try {
           const { resolve: resolvePath } = await import("path");
-          const { existsSync: existsSync21 } = await import("fs");
+          const { existsSync: existsSync22 } = await import("fs");
           const { createExecutionCoordinator: createExecutionCoordinator2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
           const { createBackendManager: createBackendManager2 } = await Promise.resolve().then(() => (init_backend_manager(), backend_manager_exports));
           const { createRuntimeBootstrap: createRuntimeBootstrap2 } = await Promise.resolve().then(() => (init_runtime_bootstrap(), runtime_bootstrap_exports));
           const { createAuthProvisioner: createAuthProvisioner2 } = await Promise.resolve().then(() => (init_auth_provisioner(), auth_provisioner_exports));
           const { buildExecutionQualityGate: buildExecutionQualityGate2 } = await Promise.resolve().then(() => (init_quality_gate(), quality_gate_exports));
           const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
-          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync21(f));
+          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync22(f));
           if (testFiles.length === 0) {
             this.log("\u26A0\uFE0F No test files found on disk", "warn");
             return { ok: false, task: "execute", duration: Date.now() - start, error: "No test files found on disk" };
@@ -7258,12 +8310,12 @@ var init_croc_office = __esm({
           });
           this.lastReports = reports;
           const { resolve: resolvePath } = await import("path");
-          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
+          const { writeFileSync: writeFileSync14, mkdirSync: mkdirSync15 } = await import("fs");
           const outDir = resolvePath(this.cwd, this.config.outDir || "./opencroc-output");
-          mkdirSync14(outDir, { recursive: true });
+          mkdirSync15(outDir, { recursive: true });
           for (const report2 of reports) {
             const fullPath = resolvePath(outDir, report2.filename);
-            writeFileSync13(fullPath, report2.content, "utf-8");
+            writeFileSync14(fullPath, report2.content, "utf-8");
             this.log(`\u{1F4C4} Generated ${report2.format} report: ${report2.filename}`);
           }
           this.updateAgent("reporter-croc", { status: "done", currentTask: `${reports.length} reports generated`, progress: 100 });
@@ -7508,40 +8560,45 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, join as join17, resolve as resolve11 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { dirname as dirname8, join as join17, resolve as resolve11 } from "path";
+import { existsSync as existsSync20 } from "fs";
 async function startServer(opts) {
   const app = Fastify({ logger: false });
   await app.register(fastifyWebsocket);
   const webDir = resolve11(__dirname2, "../web");
-  if (existsSync19(webDir)) {
+  if (existsSync20(webDir)) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
-      decorateReply: false
+      decorateReply: false,
+      index: false
     });
   }
   const office = new CrocOffice(opts.config, opts.cwd);
+  const snapshotStore = new FileStudioSnapshotStore(resolve11(opts.cwd, ".opencroc/studio-snapshot.json"));
   registerProjectRoutes(app, office);
   registerAgentRoutes(app, office);
-  registerStudioRoutes(app, office);
+  registerStudioRoutes(app, office, snapshotStore);
   app.register(async (fastify) => {
     fastify.get("/ws", { websocket: true }, (socket) => {
       office.addClient(socket);
       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 (existsSync19(studioPath)) {
-      reply.sendFile("index-studio.html");
-    } else if (existsSync19(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());
     }
@@ -7691,8 +8748,9 @@ var init_server = __esm({
     init_agents();
     init_studio();
     init_croc_office();
+    init_studio_store();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname7(__filename2);
+    __dirname2 = dirname8(__filename2);
   }
 });