@arcbridge/core 0.4.2 → 0.6.0

package/dist/index.js

@@ -54,7 +54,8 @@ var ArcBridgeConfigSchema = z2.object({
     "api-service",
     "dotnet-webapi",
     "unity-game",
-    "angular-app"
+    "angular-app",
+    "fullstack-nextjs-dotnet"
   ]).default("nextjs-app-router"),
   services: z2.array(ServiceSchema).default([]),
   platforms: z2.array(z2.enum(["claude", "copilot", "gemini", "codex", "opencode"])).default(["claude"]),
@@ -809,6 +810,46 @@ function configTemplate6(input) {
   };
 }
 
+// src/templates/config/fullstack-nextjs-dotnet.ts
+function configTemplate7(input) {
+  return {
+    schema_version: 1,
+    project_name: input.name,
+    project_type: "fullstack-nextjs-dotnet",
+    services: [
+      { name: "frontend", path: "frontend", type: "nextjs", tsconfig: "frontend/tsconfig.json" },
+      { name: "api", path: "api", type: "dotnet" }
+    ],
+    platforms: input.platforms,
+    quality_priorities: input.quality_priorities,
+    indexing: {
+      include: [
+        "frontend/src/**/*",
+        "frontend/app/**/*",
+        "api/**/*.cs",
+        "shared/**/*",
+        "contracts/**/*"
+      ],
+      exclude: ["node_modules", "dist", ".next", "bin", "obj", "coverage"],
+      default_mode: "fast",
+      csharp_indexer: "auto"
+    },
+    testing: {
+      test_command: "npm test",
+      timeout_ms: 6e4
+    },
+    drift: {
+      ignore_paths: []
+    },
+    metrics: { auto_record: false },
+    sync: {
+      auto_detect_drift: true,
+      drift_severity_threshold: "warning",
+      propose_updates_on: "phase-complete"
+    }
+  };
+}
+
 // src/generators/config-generator.ts
 var configTemplates = {
   "nextjs-app-router": configTemplate,
@@ -816,7 +857,8 @@ var configTemplates = {
   "api-service": configTemplate3,
   "dotnet-webapi": configTemplate4,
   "unity-game": configTemplate5,
-  "angular-app": configTemplate6
+  "angular-app": configTemplate6,
+  "fullstack-nextjs-dotnet": configTemplate7
 };
 function generateConfig(targetDir, input) {
   const templateFn = configTemplates[input.template] ?? configTemplate;
@@ -845,7 +887,7 @@ function introductionTemplate(input) {
 
 ## Requirements Overview
 
-${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "angular-app" ? "Angular application with standalone components" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : input.template === "unity-game" ? "Unity game built with a code-heavy C# architecture" : "web application"}.
+${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "angular-app" ? "Angular application with standalone components" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : input.template === "unity-game" ? "Unity game built with a code-heavy C# architecture" : input.template === "fullstack-nextjs-dotnet" ? "fullstack application with a Next.js frontend and .NET API backend" : "web application"}.
 
 ### Key Features
 
@@ -1047,7 +1089,66 @@ function getEntrypoints(template, srcPrefix, appPrefix) {
 function buildingBlocksTemplate(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const layout = detectProjectLayout(input.projectRoot, input.template);
-  const defaultBlocks = input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : input.template === "unity-game" ? buildUnityBlocks() : input.template === "angular-app" ? buildAngularBlocks(layout) : buildJsBlocks(input, layout);
+  const defaultBlocks = input.template === "fullstack-nextjs-dotnet" ? buildFullstackBlocks() : input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : input.template === "unity-game" ? buildUnityBlocks() : input.template === "angular-app" ? buildAngularBlocks(layout) : buildJsBlocks(input, layout);
+  function buildFullstackBlocks() {
+    return [
+      {
+        id: "frontend-shell",
+        name: "Frontend Shell",
+        level: 1,
+        code_paths: ["frontend/app/", "frontend/src/app/"],
+        interfaces: [],
+        quality_scenarios: ["PERF-01"],
+        adrs: [],
+        responsibility: "Next.js App Router layouts, pages, and top-level page structure",
+        service: "frontend"
+      },
+      {
+        id: "frontend-components",
+        name: "Frontend Components",
+        level: 1,
+        code_paths: ["frontend/src/components/", "frontend/components/"],
+        interfaces: [],
+        quality_scenarios: ["A11Y-01"],
+        adrs: [],
+        responsibility: "Shared, reusable React UI components",
+        service: "frontend"
+      },
+      {
+        id: "api-controllers",
+        name: "API Controllers",
+        level: 1,
+        code_paths: ["api/Controllers/"],
+        interfaces: [],
+        quality_scenarios: ["SEC-03"],
+        adrs: [],
+        responsibility: "ASP.NET Core API endpoint definitions and request handling",
+        service: "api"
+      },
+      {
+        id: "api-services",
+        name: "API Services",
+        level: 1,
+        code_paths: ["api/Services/"],
+        interfaces: ["api-controllers"],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Business logic, use cases, and orchestration between domain and infrastructure",
+        service: "api"
+      },
+      {
+        id: "shared-contracts",
+        name: "Shared Contracts",
+        level: 1,
+        code_paths: ["shared/", "contracts/"],
+        interfaces: ["frontend-shell", "api-controllers"],
+        quality_scenarios: ["MAINT-01"],
+        adrs: [],
+        responsibility: "API types, schemas, and contracts shared between the Next.js frontend and .NET backend",
+        service: "api"
+      }
+    ];
+  }
   function buildJsBlocks(inp, lt) {
     const src = lt.srcPrefix;
     const entries = lt.entrypoints;
@@ -2275,13 +2376,169 @@ var ANGULAR_SCENARIOS = {
     }
   ]
 };
+var FULLSTACK_NEXTJS_DOTNET_SCENARIOS = {
+  security: [
+    {
+      id: "SEC-02",
+      name: "No secrets in client bundles or source",
+      category: "security",
+      priority: "must",
+      scenario: "Client-side JavaScript bundle and .NET source/config files are analyzed",
+      expected: "No API keys, tokens, or secrets are found in client-side code or hardcoded in appsettings",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-shell", "api-controllers"],
+      verification: "automatic",
+      status: "untested"
+    },
+    {
+      id: "SEC-04",
+      name: "CORS policy restricts origins",
+      category: "security",
+      priority: "should",
+      scenario: "A cross-origin request is made from an untrusted domain",
+      expected: "Request is rejected by CORS middleware; only the frontend origin is allowed",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["api-controllers"],
+      verification: "automatic",
+      status: "untested"
+    },
+    {
+      id: "SEC-05",
+      name: "Cross-service auth token handling",
+      category: "security",
+      priority: "must",
+      scenario: "Frontend sends an auth token to the .NET API on every protected request",
+      expected: "Token is validated server-side; expired or invalid tokens return 401; tokens are never stored in localStorage",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-shell", "api-services"],
+      verification: "automatic",
+      status: "untested"
+    }
+  ],
+  performance: [
+    {
+      id: "PERF-01",
+      name: "Initial page load under 3s",
+      category: "performance",
+      priority: "should",
+      scenario: "User loads the landing page on a 3G connection",
+      expected: "Largest Contentful Paint (LCP) is under 3 seconds",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-shell"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-03",
+      name: "Frontend bundle under 200KB gzipped",
+      category: "performance",
+      priority: "should",
+      scenario: "Production build output is analyzed",
+      expected: "Main JavaScript bundle is under 200KB gzipped",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-shell", "frontend-components"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-04",
+      name: "Async all the way in .NET API",
+      category: "performance",
+      priority: "must",
+      scenario: "I/O-bound operations in the API are reviewed",
+      expected: "All I/O operations use async/await; no sync-over-async or blocking calls",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["api-controllers", "api-services"],
+      verification: "semi-automatic",
+      status: "untested"
+    }
+  ],
+  reliability: [
+    {
+      id: "REL-02",
+      name: "Health check covers dependencies",
+      category: "reliability",
+      priority: "should",
+      scenario: "Orchestrator calls the /health endpoint",
+      expected: "Returns degraded or unhealthy if database or critical external service is unreachable",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["api-controllers"],
+      verification: "automatic",
+      status: "untested"
+    },
+    {
+      id: "REL-03",
+      name: "Structured logging with correlation",
+      category: "reliability",
+      priority: "should",
+      scenario: "A request flows through frontend to API and back",
+      expected: "All log entries share a correlation ID across services; logs are structured JSON",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["api-services"],
+      verification: "semi-automatic",
+      status: "untested"
+    }
+  ],
+  accessibility: [
+    {
+      id: "A11Y-01",
+      name: "WCAG 2.1 AA compliance",
+      category: "accessibility",
+      priority: "should",
+      scenario: "All pages are audited with axe-core",
+      expected: "No critical or serious accessibility violations",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-components"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "A11Y-02",
+      name: "Keyboard navigation",
+      category: "accessibility",
+      priority: "should",
+      scenario: "User navigates the entire application using only keyboard",
+      expected: "All interactive elements are reachable and operable via keyboard",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["frontend-components"],
+      verification: "manual",
+      status: "untested"
+    }
+  ],
+  maintainability: [
+    {
+      id: "MAINT-03",
+      name: "API contract consistency",
+      category: "maintainability",
+      priority: "must",
+      scenario: "Frontend type definitions are compared against API OpenAPI spec or shared contracts",
+      expected: "All frontend API types match the backend contract; CI check prevents drift",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["shared-contracts"],
+      verification: "automatic",
+      status: "untested"
+    }
+  ]
+};
 var TEMPLATE_SCENARIOS = {
   "nextjs-app-router": FRONTEND_SCENARIOS,
   "react-vite": FRONTEND_SCENARIOS,
   "angular-app": ANGULAR_SCENARIOS,
   "api-service": API_SCENARIOS,
   "dotnet-webapi": DOTNET_SCENARIOS,
-  "unity-game": UNITY_GAME_SCENARIOS
+  "unity-game": UNITY_GAME_SCENARIOS,
+  "fullstack-nextjs-dotnet": FULLSTACK_NEXTJS_DOTNET_SCENARIOS
 };
 function mergeScenarios(template, category) {
   const shared = SHARED_SCENARIOS[category] ?? [];
@@ -3949,45 +4206,401 @@ function phaseTasksTemplate6(_input, phaseId) {
   return tasksByPhase[phaseId] ?? null;
 }
 
-// src/generators/plan-generator.ts
-var planTemplates = {
-  "nextjs-app-router": { plan: phasePlanTemplate, tasks: phaseTasksTemplate },
-  "react-vite": { plan: phasePlanTemplate2, tasks: phaseTasksTemplate2 },
-  "api-service": { plan: phasePlanTemplate3, tasks: phaseTasksTemplate3 },
-  "dotnet-webapi": { plan: phasePlanTemplate4, tasks: phaseTasksTemplate4 },
-  "unity-game": { plan: phasePlanTemplate5, tasks: phaseTasksTemplate5 },
-  "angular-app": { plan: phasePlanTemplate6, tasks: phaseTasksTemplate6 }
-};
-function generatePlan(targetDir, input) {
-  const planDir = join5(targetDir, ".arcbridge", "plan");
-  const tasksDir = join5(planDir, "tasks");
-  mkdirSync3(planDir, { recursive: true });
-  mkdirSync3(tasksDir, { recursive: true });
-  const tmpl = planTemplates[input.template] ?? planTemplates["nextjs-app-router"];
-  const phasePlan = tmpl.plan(input);
-  writeFileSync3(join5(planDir, "phases.yaml"), stringify3(phasePlan), "utf-8");
-  for (const phase of phasePlan.phases) {
-    const taskFile = tmpl.tasks(input, phase.id);
-    if (taskFile) {
-      writeFileSync3(
-        join5(tasksDir, `${phase.id}.yaml`),
-        stringify3(taskFile),
-        "utf-8"
-      );
+// src/templates/phases/fullstack-nextjs-dotnet.ts
+function phasePlanTemplate7(_input) {
+  const phases = [
+    {
+      id: "phase-0-setup",
+      name: "Monorepo Setup",
+      phase_number: 0,
+      status: "planned",
+      description: "Initialize monorepo structure, scaffold Next.js frontend and .NET API backend, configure shared tooling",
+      gate_requirements: [
+        "Monorepo structure with frontend/ and api/ directories",
+        "Next.js app builds and runs at localhost:3000",
+        ".NET API builds and runs with health check at /health",
+        "Shared dev scripts (start, build, test) work from root"
+      ]
+    },
+    {
+      id: "phase-1-api-foundation",
+      name: "API Foundation",
+      phase_number: 1,
+      status: "planned",
+      description: "Build .NET API controllers, services, authentication middleware, and database access layer",
+      gate_requirements: [
+        "Auth middleware protects API endpoints",
+        "Global exception handler returns ProblemDetails",
+        "Database access layer configured with migrations",
+        "OpenAPI/Swagger documentation generated",
+        "Quality scenarios SEC-01, SEC-02 verified"
+      ]
+    },
+    {
+      id: "phase-2-frontend-foundation",
+      name: "Frontend Foundation",
+      phase_number: 2,
+      status: "planned",
+      description: "Build Next.js layouts, reusable components, API client layer, and authentication UI",
+      gate_requirements: [
+        "App shell with layout and navigation working",
+        "API client layer communicates with .NET backend",
+        "Auth UI (login, register, protected routes) functional",
+        "Component library with consistent styling",
+        "Quality scenarios A11Y-01, PERF-01 verified"
+      ]
+    },
+    {
+      id: "phase-3-feature-integration",
+      name: "Feature Integration",
+      phase_number: 3,
+      status: "planned",
+      description: "Implement end-to-end features across frontend and backend, API contract synchronization, and shared types",
+      gate_requirements: [
+        "At least one full CRUD feature works end-to-end",
+        "API contracts validated between frontend and backend",
+        "Shared type definitions keep frontend and API in sync",
+        "Integration tests cover cross-service workflows"
+      ]
+    },
+    {
+      id: "phase-4-production",
+      name: "Production Readiness",
+      phase_number: 4,
+      status: "planned",
+      description: "CI/CD pipeline, deployment configuration, monitoring, and performance optimization",
+      gate_requirements: [
+        "CI pipeline builds and tests both services",
+        "Docker Compose or equivalent runs the full stack",
+        "Rate limiting and CORS configured for production",
+        "All quality scenarios passing",
+        "Production deployment successful"
+      ]
     }
-  }
-  writeFileSync3(
-    join5(planDir, "sync-log.md"),
-    `# Sync Log
-
-Architecture sync events are recorded here.
-`,
-    "utf-8"
-  );
+  ];
+  return { schema_version: 1, phases };
 }
-
-// src/generators/agent-generator.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+function phaseTasksTemplate7(_input, phaseId) {
+  const tasksByPhase = {
+    "phase-0-setup": {
+      schema_version: 1,
+      phase_id: "phase-0-setup",
+      tasks: [
+        {
+          id: "task-0.1-monorepo-structure",
+          title: "Set up monorepo structure with frontend and api directories",
+          status: "todo",
+          building_block: "frontend-shell",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Root package.json with workspace scripts",
+            "frontend/ directory with Next.js app (App Router)",
+            "api/ directory with ASP.NET Core Web API project",
+            "Shared .editorconfig and linting configuration"
+          ]
+        },
+        {
+          id: "task-0.2-frontend-scaffold",
+          title: "Scaffold Next.js frontend with App Router",
+          status: "todo",
+          building_block: "frontend-shell",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "Next.js app created with TypeScript and App Router",
+            "Root layout with metadata and font configuration",
+            "Landing page renders at localhost:3000",
+            "ESLint and Prettier configured"
+          ]
+        },
+        {
+          id: "task-0.3-api-scaffold",
+          title: "Scaffold .NET API with health check",
+          status: "todo",
+          building_block: "api-controllers",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ASP.NET Core Web API project created",
+            "Health check endpoint responds at /health",
+            "DI container configured with core services",
+            "Logging and configuration in place"
+          ]
+        },
+        {
+          id: "task-0.4-shared-tooling",
+          title: "Configure shared development tooling and scripts",
+          status: "todo",
+          building_block: "shared-contracts",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "Root-level scripts to start, build, and test both services",
+            "Shared TypeScript types or OpenAPI contract directory",
+            "Testing infrastructure for both frontend and backend",
+            "Git hooks for linting and formatting"
+          ]
+        }
+      ]
+    },
+    "phase-1-api-foundation": {
+      schema_version: 1,
+      phase_id: "phase-1-api-foundation",
+      tasks: [
+        {
+          id: "task-1.1-api-auth",
+          title: "Implement API authentication and authorization",
+          status: "todo",
+          building_block: "api-services",
+          quality_scenarios: ["SEC-01", "SEC-02"],
+          acceptance_criteria: [
+            "JWT bearer auth configured in .NET API",
+            "Authorization policies defined for role-based access",
+            "Auth middleware applied to protected endpoints",
+            "Token validation and refresh logic implemented"
+          ]
+        },
+        {
+          id: "task-1.2-api-controllers",
+          title: "Build core API controllers and endpoints",
+          status: "todo",
+          building_block: "api-controllers",
+          quality_scenarios: ["SEC-03"],
+          acceptance_criteria: [
+            "RESTful controllers for core resources",
+            "Input validation via FluentValidation or data annotations",
+            "Consistent response format with ProblemDetails for errors",
+            "OpenAPI/Swagger documentation generated and accessible"
+          ]
+        },
+        {
+          id: "task-1.3-api-services",
+          title: "Implement business logic and service layer",
+          status: "todo",
+          building_block: "api-services",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "Service classes encapsulate business logic",
+            "Repository pattern for data access",
+            "EF Core or Dapper configured with migrations",
+            "Unit tests cover service layer logic"
+          ]
+        },
+        {
+          id: "task-1.4-api-middleware",
+          title: "Configure middleware pipeline and error handling",
+          status: "todo",
+          building_block: "api-controllers",
+          quality_scenarios: ["REL-01"],
+          acceptance_criteria: [
+            "Global exception handler returns RFC 7807 ProblemDetails",
+            "Request/response logging with correlation IDs",
+            "CORS policy configured for frontend origin",
+            "No stack traces leaked in production"
+          ]
+        }
+      ]
+    },
+    "phase-2-frontend-foundation": {
+      schema_version: 1,
+      phase_id: "phase-2-frontend-foundation",
+      tasks: [
+        {
+          id: "task-2.1-frontend-layout",
+          title: "Build app shell with layouts and navigation",
+          status: "todo",
+          building_block: "frontend-shell",
+          quality_scenarios: ["A11Y-01"],
+          acceptance_criteria: [
+            "Root layout with header, sidebar, and main content area",
+            "Navigation component with active state indicators",
+            "Responsive layout that works on mobile and desktop",
+            "Loading and error boundary components"
+          ]
+        },
+        {
+          id: "task-2.2-frontend-components",
+          title: "Create reusable UI component library",
+          status: "todo",
+          building_block: "frontend-components",
+          quality_scenarios: ["A11Y-02"],
+          acceptance_criteria: [
+            "Button, Input, Card, Modal, and Table components",
+            "Consistent styling with design tokens or Tailwind",
+            "All components meet WCAG 2.1 AA accessibility",
+            "Component documentation or Storybook setup"
+          ]
+        },
+        {
+          id: "task-2.3-api-client",
+          title: "Build API client layer for backend communication",
+          status: "todo",
+          building_block: "shared-contracts",
+          quality_scenarios: ["REL-01"],
+          acceptance_criteria: [
+            "Typed API client generated from OpenAPI spec or manually defined",
+            "Error handling with user-friendly messages",
+            "Auth token injection in request headers",
+            "Request/response interceptors for logging and retry"
+          ]
+        },
+        {
+          id: "task-2.4-frontend-auth",
+          title: "Implement frontend authentication UI and flow",
+          status: "todo",
+          building_block: "frontend-shell",
+          quality_scenarios: ["SEC-01"],
+          acceptance_criteria: [
+            "Login and registration pages",
+            "Protected route middleware or layout",
+            "Token storage and refresh handling",
+            "Auth state management (context or store)"
+          ]
+        }
+      ]
+    },
+    "phase-3-feature-integration": {
+      schema_version: 1,
+      phase_id: "phase-3-feature-integration",
+      tasks: [
+        {
+          id: "task-3.1-e2e-feature",
+          title: "Implement first end-to-end CRUD feature",
+          status: "todo",
+          building_block: "api-controllers",
+          quality_scenarios: ["PERF-02"],
+          acceptance_criteria: [
+            "Full CRUD operations from frontend through API to database",
+            "Optimistic UI updates where appropriate",
+            "Server-side validation reflected in frontend forms",
+            "List, detail, create, edit, and delete views working"
+          ]
+        },
+        {
+          id: "task-3.2-contract-sync",
+          title: "Set up API contract synchronization",
+          status: "todo",
+          building_block: "shared-contracts",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "OpenAPI spec or shared type definitions in contracts directory",
+            "Frontend types generated from or validated against API contract",
+            "CI check prevents contract drift between frontend and backend",
+            "Documentation for updating contracts when API changes"
+          ]
+        },
+        {
+          id: "task-3.3-integration-tests",
+          title: "Write cross-service integration tests",
+          status: "todo",
+          building_block: "shared-contracts",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "Integration tests exercise frontend-to-API workflows",
+            "Test environment starts both services",
+            "Auth flow tested end-to-end",
+            "Error scenarios covered (API down, validation failures)"
+          ]
+        }
+      ]
+    },
+    "phase-4-production": {
+      schema_version: 1,
+      phase_id: "phase-4-production",
+      tasks: [
+        {
+          id: "task-4.1-ci-cd",
+          title: "Set up CI/CD pipeline for both services",
+          status: "todo",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "CI builds and tests both frontend and API",
+            "Lint, type-check, and test steps for each service",
+            "Build artifacts produced for deployment",
+            "Pipeline fails fast on errors"
+          ]
+        },
+        {
+          id: "task-4.2-deployment",
+          title: "Configure deployment for full stack",
+          status: "todo",
+          quality_scenarios: ["REL-01"],
+          acceptance_criteria: [
+            "Docker Compose for local full-stack development",
+            "Dockerfiles for frontend and API",
+            "Environment-specific configuration (dev, staging, prod)",
+            "Database migration runs as part of deployment"
+          ]
+        },
+        {
+          id: "task-4.3-monitoring",
+          title: "Add monitoring, logging, and rate limiting",
+          status: "todo",
+          building_block: "api-services",
+          quality_scenarios: ["PERF-02", "SEC-04"],
+          acceptance_criteria: [
+            "Structured logging in API with Serilog or similar",
+            "Frontend error tracking (Sentry or similar)",
+            "Rate limiting configured on API endpoints",
+            "Health check dashboard or monitoring alerts"
+          ]
+        },
+        {
+          id: "task-4.4-performance",
+          title: "Optimize performance across the stack",
+          status: "todo",
+          building_block: "frontend-shell",
+          quality_scenarios: ["PERF-01", "PERF-03"],
+          acceptance_criteria: [
+            "Frontend bundle size optimized (code splitting, tree shaking)",
+            "API response times meet p95 < 200ms target",
+            "Database queries optimized with proper indexing",
+            "Static assets cached with appropriate headers"
+          ]
+        }
+      ]
+    }
+  };
+  return tasksByPhase[phaseId] ?? null;
+}
+
+// src/generators/plan-generator.ts
+var planTemplates = {
+  "nextjs-app-router": { plan: phasePlanTemplate, tasks: phaseTasksTemplate },
+  "react-vite": { plan: phasePlanTemplate2, tasks: phaseTasksTemplate2 },
+  "api-service": { plan: phasePlanTemplate3, tasks: phaseTasksTemplate3 },
+  "dotnet-webapi": { plan: phasePlanTemplate4, tasks: phaseTasksTemplate4 },
+  "unity-game": { plan: phasePlanTemplate5, tasks: phaseTasksTemplate5 },
+  "angular-app": { plan: phasePlanTemplate6, tasks: phaseTasksTemplate6 },
+  "fullstack-nextjs-dotnet": { plan: phasePlanTemplate7, tasks: phaseTasksTemplate7 }
+};
+function generatePlan(targetDir, input) {
+  const planDir = join5(targetDir, ".arcbridge", "plan");
+  const tasksDir = join5(planDir, "tasks");
+  mkdirSync3(planDir, { recursive: true });
+  mkdirSync3(tasksDir, { recursive: true });
+  const tmpl = planTemplates[input.template] ?? planTemplates["nextjs-app-router"];
+  const phasePlan = tmpl.plan(input);
+  writeFileSync3(join5(planDir, "phases.yaml"), stringify3(phasePlan), "utf-8");
+  for (const phase of phasePlan.phases) {
+    const taskFile = tmpl.tasks(input, phase.id);
+    if (taskFile) {
+      writeFileSync3(
+        join5(tasksDir, `${phase.id}.yaml`),
+        stringify3(taskFile),
+        "utf-8"
+      );
+    }
+  }
+  writeFileSync3(
+    join5(planDir, "sync-log.md"),
+    `# Sync Log
+
+Architecture sync events are recorded here.
+`,
+    "utf-8"
+  );
+}
+
+// src/generators/agent-generator.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join6 } from "path";
 import matter2 from "gray-matter";
 
@@ -4630,7 +5243,7 @@ You cannot see screenshots, but you CAN reason about UI quality through code:
 }
 
 // src/generators/agent-generator.ts
-var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "angular-app", "unity-game"]);
+var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "angular-app", "unity-game", "fullstack-nextjs-dotnet"]);
 function writeAgentRole(dir, role) {
   const { system_prompt, ...frontmatter } = role;
   const content = matter2.stringify(system_prompt, frontmatter);
@@ -4964,8 +5577,9 @@ function ensureGitignore(targetDir) {
 }
 
 // src/indexer/index.ts
-import { relative as relative5, join as join14 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import ts6 from "typescript";
+import { relative as relative5, join as join16 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import YAML from "yaml";
 
@@ -5333,7 +5947,7 @@ function buildSymbolLookup(symbols) {
 function extractDependencies(sourceFile, checker, relativePath, projectRoot, lookup) {
   const deps = [];
   const seen = /* @__PURE__ */ new Set();
-  function addDep2(sourceId, targetId, kind) {
+  function addDep4(sourceId, targetId, kind) {
     const key = `${sourceId}|${targetId}|${kind}`;
     if (seen.has(key)) return;
     if (!lookup.allIds.has(sourceId) || !lookup.allIds.has(targetId)) return;
@@ -5369,7 +5983,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
           if (!targetId) continue;
           const fileSymbols = getFileTopLevelSymbols(relativePath, lookup);
           for (const sourceId of fileSymbols) {
-            addDep2(sourceId, targetId, "imports");
+            addDep4(sourceId, targetId, "imports");
           }
         }
       }
@@ -5381,7 +5995,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
           if (targetId) {
             const fileSymbols = getFileTopLevelSymbols(relativePath, lookup);
             for (const sourceId of fileSymbols) {
-              addDep2(sourceId, targetId, "imports");
+              addDep4(sourceId, targetId, "imports");
             }
           }
         }
@@ -5403,7 +6017,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
               const resolved = exprSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(exprSymbol) : exprSymbol;
               const targetId = resolveSymbolId(resolved);
               if (targetId) {
-                addDep2(classId, targetId, kind);
+                addDep4(classId, targetId, kind);
               }
             }
           }
@@ -5426,7 +6040,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = calledSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(calledSymbol) : calledSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "calls");
+              addDep4(ownerId, targetId, "calls");
             }
           }
         }
@@ -5456,7 +6070,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
                     const resolved = calledSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(calledSymbol) : calledSymbol;
                     const targetId = resolveSymbolId(resolved);
                     if (targetId) {
-                      addDep2(callOwnerId, targetId, "calls");
+                      addDep4(callOwnerId, targetId, "calls");
                     }
                   }
                 }
@@ -5488,7 +6102,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = typeSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(typeSymbol) : typeSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "uses_type");
+              addDep4(ownerId, targetId, "uses_type");
             }
           }
         }
@@ -5512,7 +6126,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = jsxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(jsxSymbol) : jsxSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "renders");
+              addDep4(ownerId, targetId, "renders");
             }
           }
           if (ts4.isPropertyAccessExpression(tagName) && ts4.isIdentifier(tagName.name) && tagName.name.text === "Provider") {
@@ -5521,7 +6135,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
               const resolved = ctxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(ctxSymbol) : ctxSymbol;
               const targetId = resolveSymbolId(resolved);
               if (targetId) {
-                addDep2(ownerId, targetId, "provides_context");
+                addDep4(ownerId, targetId, "provides_context");
               }
             }
           }
@@ -5568,7 +6182,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = ctxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(ctxSymbol) : ctxSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "consumes_context");
+              addDep4(ownerId, targetId, "consumes_context");
             }
           }
         }
@@ -5902,7 +6516,7 @@ function analyzeRoutes(projectRoot, db, service = "main") {
     }
   }
   walkAppDir(appDir, "/", routes, layoutStack, service, projectRoot);
-  writeRoutes(db, routes);
+  writeRoutes(db, routes, service);
   return routes.length;
 }
 function walkAppDir(dir, routePath, routes, layoutStack, service, projectRoot) {
@@ -5985,9 +6599,9 @@ function extractHttpMethods(filePath) {
   }
   return methods;
 }
-function writeRoutes(db, routes) {
+function writeRoutes(db, routes, service) {
+  db.prepare("DELETE FROM routes WHERE service = ?").run(service);
   if (routes.length === 0) return;
-  db.prepare("DELETE FROM routes").run();
   const insert = db.prepare(`
     INSERT OR IGNORE INTO routes (
       id, route_path, kind, http_methods, has_auth, parent_layout, service
@@ -5996,7 +6610,7 @@ function writeRoutes(db, routes) {
   transaction(db, () => {
     for (const r of routes) {
       insert.run(
-        r.id,
+        `${service}::${r.id}`,
         r.routePath,
         r.kind,
         JSON.stringify(r.httpMethods),
@@ -6015,36 +6629,37 @@ function hashContent(content) {
 }
 
 // src/indexer/db-writer.ts
-function getExistingHashes(db, service) {
-  const rows = db.prepare(
-    "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ?"
-  ).all(service);
+function getExistingHashes(db, service, language) {
+  const query = language ? "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ? AND language = ?" : "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ?";
+  const params = language ? [service, language] : [service];
+  const rows = db.prepare(query).all(...params);
   const map = /* @__PURE__ */ new Map();
   for (const row of rows) {
     map.set(row.file_path, row.content_hash);
   }
   return map;
 }
-function removeSymbolsForFiles(db, filePaths) {
+function removeScopedSymbolsForFiles(db, filePaths, service, language) {
   if (filePaths.length === 0) return;
-  const deleteSymbols = db.prepare(
-    "DELETE FROM symbols WHERE file_path = ?"
-  );
+  const scope = "file_path = ? AND service = ? AND language = ?";
   const deleteDepsSource = db.prepare(
-    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE ${scope})`
   );
   const deleteDepsTarget = db.prepare(
-    "DELETE FROM dependencies WHERE target_symbol IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM dependencies WHERE target_symbol IN (SELECT id FROM symbols WHERE ${scope})`
   );
   const deleteComponents = db.prepare(
-    "DELETE FROM components WHERE symbol_id IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM components WHERE symbol_id IN (SELECT id FROM symbols WHERE ${scope})`
+  );
+  const deleteSymbols = db.prepare(
+    `DELETE FROM symbols WHERE ${scope}`
   );
   transaction(db, () => {
     for (const fp of filePaths) {
-      deleteDepsSource.run(fp);
-      deleteDepsTarget.run(fp);
-      deleteComponents.run(fp);
-      deleteSymbols.run(fp);
+      deleteDepsSource.run(fp, service, language);
+      deleteDepsTarget.run(fp, service, language);
+      deleteComponents.run(fp, service, language);
+      deleteSymbols.run(fp, service, language);
     }
   });
 }
@@ -6177,11 +6792,11 @@ function hasGlobalTool() {
   return false;
 }
 function resolveIndexerProject() {
-  const currentDir2 = dirname2(fileURLToPath(import.meta.url));
+  const currentDir4 = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve(currentDir2, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
-    resolve(currentDir2, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
-    resolve(currentDir2, "../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj")
+    resolve(currentDir4, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
+    resolve(currentDir4, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
+    resolve(currentDir4, "../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj")
   ];
   for (const candidate of candidates) {
     if (existsSync5(candidate)) return candidate;
@@ -6247,7 +6862,7 @@ function indexDotnetProjectRoslyn(db, options) {
       "No .sln or .csproj file found in project root. The .NET indexer requires a project or solution file."
     );
   }
-  const existingHashes = getExistingHashes(db, service);
+  const existingHashes = getExistingHashes(db, service, "csharp");
   const hashesJson = JSON.stringify(Object.fromEntries(existingHashes));
   const stdout = runDotnetIndexer(dotnetProject, hashesJson, projectRoot);
   const lines = stdout.trim().split("\n");
@@ -6264,7 +6879,7 @@ function indexDotnetProjectRoslyn(db, options) {
     );
   }
   const filesToClean = [...output.changedFiles, ...output.removedFiles];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "csharp");
   const symbols = output.symbols.map((s) => ({
     id: s.id,
     name: s.name,
@@ -6301,7 +6916,7 @@ function indexDotnetProjectRoslyn(db, options) {
     transaction(db, () => {
       for (const route of output.routes) {
         insertRoute.run(
-          route.id,
+          `${service}::${route.id}`,
           route.routePath,
           route.kind,
           JSON.stringify(route.httpMethods),
@@ -7184,7 +7799,7 @@ async function indexCSharpTreeSitter(db, options) {
     ignore: ignorePatterns,
     absolute: false
   });
-  const existingHashes = getExistingHashes(db, service);
+  const existingHashes = getExistingHashes(db, service, "csharp");
   const currentPaths = /* @__PURE__ */ new Set();
   const fileCache = /* @__PURE__ */ new Map();
   const changedFiles = [];
@@ -7211,7 +7826,7 @@ async function indexCSharpTreeSitter(db, options) {
     }
   }
   const filesToClean = [...removed, ...changedFiles];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "csharp");
   const allNewSymbols = [];
   for (const relPath of changedFiles) {
     const cached = fileCache.get(relPath);
@@ -7220,7 +7835,7 @@ async function indexCSharpTreeSitter(db, options) {
     allNewSymbols.push(...symbols);
   }
   writeSymbols(db, allNewSymbols, service, "csharp");
-  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ?").all(service);
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'csharp'").all(service);
   const symbolLookup = buildCSharpSymbolLookup(allDbSymbols);
   const allDeps = [];
   for (const [relPath, cached] of fileCache) {
@@ -7245,7 +7860,7 @@ async function indexCSharpTreeSitter(db, options) {
     transaction(db, () => {
       for (const route of allRoutes) {
         insertRoute.run(
-          route.id,
+          `${service}::${route.id}`,
           route.routePath,
           route.kind,
           JSON.stringify(route.httpMethods),
@@ -7267,54 +7882,1580 @@ async function indexCSharpTreeSitter(db, options) {
   };
 }
 
-// src/indexer/package-deps.ts
+// src/indexer/python/indexer.ts
+import { readFileSync as readFileSync5 } from "fs";
 import { join as join12 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
-function indexPackageDependencies(db, projectRoot, service = "main") {
-  const deps = [];
-  const pkgJsonPath = join12(projectRoot, "package.json");
-  if (existsSync6(pkgJsonPath)) {
-    deps.push(...parsePackageJson(pkgJsonPath));
-  }
-  const csprojFiles = findCsprojFiles(projectRoot);
-  for (const csproj of csprojFiles) {
-    deps.push(...parseCsproj(csproj));
+import { globbySync as globbySync2 } from "globby";
+
+// src/indexer/python/parser.ts
+import { accessSync as accessSync3, constants as constants3 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import "web-tree-sitter";
+var currentDir2 = dirname4(fileURLToPath3(import.meta.url));
+var cachedParser2 = null;
+var initPromise2 = null;
+function resolveGrammarPath2() {
+  const candidates = [
+    resolve3(currentDir2, "../../../wasm/tree-sitter-python.wasm"),
+    // from src/indexer/python/
+    resolve3(currentDir2, "../wasm/tree-sitter-python.wasm")
+    // from dist/ (tsup flat bundle)
+  ];
+  for (const candidate of candidates) {
+    try {
+      accessSync3(candidate, constants3.R_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
   }
-  if (deps.length === 0) return 0;
-  db.prepare("DELETE FROM package_dependencies WHERE service = ?").run(service);
-  const insert = db.prepare(
-    "INSERT OR IGNORE INTO package_dependencies (name, version, source, service) VALUES (?, ?, ?, ?)"
+  throw new Error(
+    "Could not find tree-sitter-python.wasm. Ensure the wasm/ directory is present in the @arcbridge/core package."
   );
-  transaction(db, () => {
-    for (const dep of deps) {
-      insert.run(dep.name, dep.version, dep.source, service);
+}
+async function ensurePythonParser() {
+  if (cachedParser2) return cachedParser2;
+  if (initPromise2) return initPromise2;
+  initPromise2 = (async () => {
+    try {
+      const TreeSitter = await import("web-tree-sitter");
+      await TreeSitter.Parser.init();
+      const grammarPath = resolveGrammarPath2();
+      const Python = await TreeSitter.Language.load(grammarPath);
+      const parser = new TreeSitter.Parser();
+      parser.setLanguage(Python);
+      cachedParser2 = parser;
+      return parser;
+    } catch (err) {
+      initPromise2 = null;
+      throw err;
     }
-  });
-  return deps.length;
+  })();
+  return initPromise2;
 }
-function parsePackageJson(filePath) {
-  try {
-    const content = readFileSync5(filePath, "utf-8");
-    const pkg = JSON.parse(content);
-    const deps = [];
-    if (pkg.dependencies) {
-      for (const [name, version] of Object.entries(pkg.dependencies)) {
-        deps.push({ name, version, source: "npm" });
+function parsePython(content) {
+  if (!cachedParser2) {
+    throw new Error(
+      "Python parser not initialized. Call await ensurePythonParser() first."
+    );
+  }
+  const tree = cachedParser2.parse(content);
+  if (!tree) {
+    throw new Error("Failed to parse Python content");
+  }
+  return tree;
+}
+
+// src/indexer/python/symbol-extractor.ts
+function extractPythonSymbols(tree, relativePath, contentHash) {
+  const symbols = [];
+  const root = tree.rootNode;
+  for (const child of root.namedChildren) {
+    walkNode2(child, null, relativePath, contentHash, symbols);
+  }
+  return symbols;
+}
+function walkNode2(node, currentClassName, relativePath, contentHash, symbols) {
+  switch (node.type) {
+    case "decorated_definition": {
+      const decorators = extractDecorators(node);
+      const definition = findChild4(node, "function_definition") ?? findChild4(node, "class_definition");
+      if (definition) {
+        walkDefinitionNode(definition, currentClassName, relativePath, contentHash, symbols, decorators);
       }
+      return;
     }
-    if (pkg.devDependencies) {
-      for (const [name, version] of Object.entries(pkg.devDependencies)) {
-        deps.push({ name, version, source: "npm-dev" });
+    case "function_definition":
+    case "class_definition":
+      walkDefinitionNode(node, currentClassName, relativePath, contentHash, symbols, []);
+      return;
+    case "expression_statement": {
+      if (!currentClassName) {
+        extractAssignment(node, relativePath, contentHash, symbols);
       }
+      return;
     }
-    return deps;
-  } catch {
-    return [];
   }
-}
-function parseCsproj(filePath) {
-  try {
-    const content = readFileSync5(filePath, "utf-8");
+  for (const child of node.namedChildren) {
+    walkNode2(child, currentClassName, relativePath, contentHash, symbols);
+  }
+}
+function walkDefinitionNode(node, currentClassName, relativePath, contentHash, symbols, decorators) {
+  if (node.type === "function_definition") {
+    const name = getIdentifierName2(node);
+    if (!name) return;
+    const isMethod = currentClassName !== null;
+    const qualifiedName = isMethod ? `${currentClassName}.${name}` : name;
+    const isAsync = hasAsyncKeyword(node);
+    const signature = extractFunctionSignature(node);
+    const returnType = extractReturnType2(node);
+    const docComment = extractDocstring(node);
+    const decoratorText = decorators.length > 0 ? decorators.join("\n") : null;
+    const fullDocComment = decoratorText ? docComment ? `${decoratorText}
+${docComment}` : decoratorText : docComment;
+    symbols.push(makeSymbol2({
+      name,
+      qualifiedName,
+      kind: "function",
+      node,
+      relativePath,
+      contentHash,
+      isExported: !name.startsWith("_"),
+      isAsync,
+      signature,
+      returnType,
+      docComment: fullDocComment
+    }));
+    return;
+  }
+  if (node.type === "class_definition") {
+    const name = getIdentifierName2(node);
+    if (!name) return;
+    const qualifiedName = currentClassName ? `${currentClassName}.${name}` : name;
+    const docComment = extractDocstring(node);
+    const decoratorText = decorators.length > 0 ? decorators.join("\n") : null;
+    const fullDocComment = decoratorText ? docComment ? `${decoratorText}
+${docComment}` : decoratorText : docComment;
+    symbols.push(makeSymbol2({
+      name,
+      qualifiedName,
+      kind: "class",
+      node,
+      relativePath,
+      contentHash,
+      isExported: !name.startsWith("_"),
+      docComment: fullDocComment
+    }));
+    const body = findChild4(node, "block");
+    if (body) {
+      for (const child of body.namedChildren) {
+        walkNode2(child, qualifiedName, relativePath, contentHash, symbols);
+      }
+    }
+    return;
+  }
+}
+function extractAssignment(node, relativePath, contentHash, symbols) {
+  const assignment = findChild4(node, "assignment");
+  if (!assignment) return;
+  const left = assignment.childForFieldName("left") ?? assignment.namedChildren[0];
+  if (!left || left.type !== "identifier") return;
+  const name = left.text;
+  if (name.startsWith("__") && name.endsWith("__")) return;
+  const isAllCaps = /^[A-Z][A-Z0-9_]*$/.test(name);
+  const kind = isAllCaps ? "constant" : "variable";
+  const typeNode = assignment.childForFieldName("type");
+  const returnType = typeNode ? typeNode.text : null;
+  symbols.push(makeSymbol2({
+    name,
+    qualifiedName: name,
+    kind,
+    node: assignment,
+    relativePath,
+    contentHash,
+    isExported: !name.startsWith("_"),
+    returnType
+  }));
+}
+function makeSymbol2(args) {
+  const { name, qualifiedName, kind, node, relativePath, contentHash } = args;
+  return {
+    id: `${relativePath}::${qualifiedName}#${kind}`,
+    name,
+    qualifiedName,
+    kind,
+    filePath: relativePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startCol: node.startPosition.column + 1,
+    endCol: node.endPosition.column + 1,
+    signature: args.signature ?? null,
+    returnType: args.returnType ?? null,
+    docComment: args.docComment ?? null,
+    isExported: args.isExported ?? true,
+    isAsync: args.isAsync ?? false,
+    contentHash
+  };
+}
+function getIdentifierName2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function findChild4(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function hasAsyncKeyword(node) {
+  for (const child of node.children) {
+    if (child.type === "async") return true;
+    if (child.type === "def") break;
+  }
+  return false;
+}
+function extractFunctionSignature(node) {
+  const params = node.childForFieldName("parameters") ?? findChild4(node, "parameters");
+  if (!params) return null;
+  const name = getIdentifierName2(node) ?? "func";
+  return `${name}${params.text}`;
+}
+function extractReturnType2(node) {
+  const returnType = node.childForFieldName("return_type");
+  if (returnType) return returnType.text;
+  return null;
+}
+function extractDocstring(node) {
+  const body = findChild4(node, "block");
+  if (!body || body.namedChildren.length === 0) return null;
+  const firstStmt = body.namedChildren[0];
+  if (firstStmt.type !== "expression_statement") return null;
+  const expr = firstStmt.namedChildren[0];
+  if (!expr || expr.type !== "string") return null;
+  let text = expr.text;
+  if (text.startsWith('"""') && text.endsWith('"""')) {
+    text = text.slice(3, -3);
+  } else if (text.startsWith("'''") && text.endsWith("'''")) {
+    text = text.slice(3, -3);
+  } else if (text.startsWith('"') && text.endsWith('"')) {
+    text = text.slice(1, -1);
+  } else if (text.startsWith("'") && text.endsWith("'")) {
+    text = text.slice(1, -1);
+  }
+  return text.trim() || null;
+}
+function extractDecorators(node) {
+  const decorators = [];
+  for (const child of node.namedChildren) {
+    if (child.type === "decorator") {
+      decorators.push(child.text);
+    }
+  }
+  return decorators;
+}
+
+// src/indexer/python/dependency-extractor.ts
+function buildPythonSymbolLookup(symbols) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const existing = lookup.get(sym.name);
+    if (existing) {
+      existing.push(sym.id);
+    } else {
+      lookup.set(sym.name, [sym.id]);
+    }
+  }
+  return lookup;
+}
+function extractPythonDependencies(tree, relativePath, allSymbols, symbolLookup) {
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fileSymbols = allSymbols.filter((s) => s.filePath === relativePath);
+  walkForDependencies2(tree.rootNode, fileSymbols, symbolLookup, deps, seen);
+  return deps;
+}
+function walkForDependencies2(node, fileSymbols, lookup, deps, seen) {
+  switch (node.type) {
+    case "class_definition":
+      extractInheritanceDeps2(node, fileSymbols, lookup, deps, seen);
+      break;
+    case "call":
+      extractCallDeps2(node, fileSymbols, lookup, deps, seen);
+      break;
+  }
+  if (node.type === "typed_parameter" || node.type === "typed_default_parameter") {
+    extractTypeAnnotationDeps(node, fileSymbols, lookup, deps, seen);
+  }
+  for (const child of node.namedChildren) {
+    walkForDependencies2(child, fileSymbols, lookup, deps, seen);
+  }
+}
+function extractInheritanceDeps2(node, fileSymbols, lookup, deps, seen) {
+  const className = getNodeIdentifier2(node);
+  if (!className) return;
+  const sourceSymbol = findEnclosingSymbol2(className, fileSymbols, "class");
+  if (!sourceSymbol) return;
+  const argList = node.childForFieldName("superclasses") ?? findChild5(node, "argument_list");
+  if (!argList) return;
+  for (const child of argList.namedChildren) {
+    const baseName = extractSimpleTypeName2(child);
+    if (!baseName || baseName === className) continue;
+    const targetIds = lookup.get(baseName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === sourceSymbol.id) continue;
+      addDep2(deps, seen, sourceSymbol.id, targetId, "extends");
+    }
+  }
+}
+function extractCallDeps2(node, fileSymbols, lookup, deps, seen) {
+  const calledName = extractCalledFunctionName(node);
+  if (!calledName) return;
+  const enclosing = findEnclosingFunctionForNode(node, fileSymbols);
+  if (!enclosing) return;
+  const targetIds = lookup.get(calledName);
+  if (!targetIds) return;
+  for (const targetId of targetIds) {
+    if (targetId === enclosing.id) continue;
+    addDep2(deps, seen, enclosing.id, targetId, "calls");
+  }
+}
+function extractTypeAnnotationDeps(node, fileSymbols, lookup, deps, seen) {
+  const typeNames = collectTypeIdentifiers2(node);
+  if (typeNames.length === 0) return;
+  const enclosing = findEnclosingSymbolForNode2(node, fileSymbols);
+  if (!enclosing) return;
+  for (const typeName of typeNames) {
+    const targetIds = lookup.get(typeName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === enclosing.id) continue;
+      addDep2(deps, seen, enclosing.id, targetId, "uses_type");
+    }
+  }
+}
+function addDep2(deps, seen, source, target, kind) {
+  const key = `${source}|${target}|${kind}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  deps.push({ sourceSymbolId: source, targetSymbolId: target, kind });
+}
+function findChild5(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function getNodeIdentifier2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function extractSimpleTypeName2(node) {
+  if (node.type === "identifier") return node.text;
+  if (node.type === "attribute") {
+    const attrNode = node.childForFieldName("attribute");
+    return attrNode?.text ?? null;
+  }
+  if (node.type === "subscript") {
+    const value = node.childForFieldName("value") ?? node.namedChildren[0];
+    if (value) return extractSimpleTypeName2(value);
+  }
+  if (node.type === "keyword_argument") {
+    const value = node.childForFieldName("value") ?? node.namedChildren[1];
+    if (value) return extractSimpleTypeName2(value);
+  }
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function extractCalledFunctionName(node) {
+  const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+  if (!funcNode) return null;
+  if (funcNode.type === "identifier") return funcNode.text;
+  if (funcNode.type === "attribute") {
+    const attrNode = funcNode.childForFieldName("attribute");
+    return attrNode?.text ?? null;
+  }
+  return null;
+}
+function findEnclosingSymbol2(name, fileSymbols, ...kinds) {
+  return fileSymbols.find(
+    (s) => s.name === name && kinds.includes(s.kind)
+  );
+}
+function findEnclosingFunctionForNode(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function findEnclosingSymbolForNode2(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        const found = fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+        if (found) return found;
+      }
+    }
+    if (current.type === "class_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.name === name && s.kind === "class"
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function collectTypeIdentifiers2(node) {
+  const names = [];
+  collectTypeIdentifiersRecursive2(node, names);
+  return [...new Set(names)];
+}
+function collectTypeIdentifiersRecursive2(node, names) {
+  if (node.type === "attribute") {
+    const attrNode = node.childForFieldName("attribute");
+    if (attrNode && attrNode.type === "identifier") {
+      names.push(attrNode.text);
+    }
+    return;
+  }
+  if (node.type === "identifier" && isTypeContext2(node)) {
+    names.push(node.text);
+  }
+  for (const child of node.namedChildren) {
+    collectTypeIdentifiersRecursive2(child, names);
+  }
+}
+function isTypeContext2(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  return parent.type === "type" || parent.type === "subscript" || // In typed_parameter, the type annotation is the second named child
+  parent.type === "typed_parameter" && node !== parent.childForFieldName("name") || parent.type === "typed_default_parameter" && node !== parent.childForFieldName("name");
+}
+
+// src/indexer/python/route-analyzer.ts
+var FASTAPI_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+]);
+function extractPythonRoutes(tree, _relativePath) {
+  const routes = [];
+  const decoratedDefs = findAllNodes2(tree.rootNode, "decorated_definition");
+  for (const decorated of decoratedDefs) {
+    const decorators = decorated.namedChildren.filter(
+      (c) => c.type === "decorator"
+    );
+    for (const decorator of decorators) {
+      const routeInfo = parseDecorator(decorator);
+      if (!routeInfo) continue;
+      for (const method of routeInfo.methods) {
+        const routePath = routeInfo.path.startsWith("/") ? routeInfo.path : `/${routeInfo.path}`;
+        const id = `route::${routePath.slice(1)}::${method}`;
+        routes.push({
+          id,
+          routePath,
+          kind: "api-route",
+          httpMethods: [method],
+          hasAuth: routeInfo.hasAuth
+        });
+      }
+    }
+  }
+  return routes;
+}
+function parseDecorator(decorator) {
+  const callNode = findFirstChild(decorator, "call");
+  if (!callNode) return null;
+  const funcNode = callNode.childForFieldName("function");
+  if (!funcNode || funcNode.type !== "attribute") return null;
+  const attrName = funcNode.childForFieldName("attribute");
+  if (!attrName) return null;
+  const methodName = attrName.text;
+  if (FASTAPI_HTTP_METHODS.has(methodName)) {
+    const path = getFirstStringArgument2(callNode);
+    if (path === null) return null;
+    const hasAuth = detectAuthInCall(callNode);
+    return {
+      path,
+      methods: [methodName.toUpperCase()],
+      hasAuth
+    };
+  }
+  if (methodName === "route") {
+    const path = getFirstStringArgument2(callNode);
+    if (path === null) return null;
+    const methods = getMethodsKeywordArgument(callNode).map((m) => m.toUpperCase());
+    const hasAuth = detectAuthInCall(callNode);
+    return {
+      path,
+      methods: methods.length > 0 ? methods : ["GET"],
+      hasAuth
+    };
+  }
+  return null;
+}
+function detectAuthInCall(callNode) {
+  const args = callNode.childForFieldName("arguments");
+  if (!args) return false;
+  const text = args.text;
+  if (/Depends\s*\(\s*auth/.test(text)) return true;
+  if (/login_required|auth_required|require_auth|jwt_required/.test(text))
+    return true;
+  return false;
+}
+function getFirstStringArgument2(callNode) {
+  const args = callNode.childForFieldName("arguments");
+  if (!args) return null;
+  for (const child of args.namedChildren) {
+    if (child.type === "keyword_argument") continue;
+    if (child.type === "string") {
+      return stripQuotes(child.text);
+    }
+    const strNode = findFirstChild(child, "string");
+    if (strNode) {
+      return stripQuotes(strNode.text);
+    }
+  }
+  return null;
+}
+function getMethodsKeywordArgument(callNode) {
+  const args = callNode.childForFieldName("arguments");
+  if (!args) return [];
+  for (const child of args.namedChildren) {
+    if (child.type !== "keyword_argument") continue;
+    const nameNode = child.childForFieldName("name");
+    if (!nameNode || nameNode.text !== "methods") continue;
+    const valueNode = child.childForFieldName("value");
+    if (!valueNode) continue;
+    return extractStringListValues(valueNode);
+  }
+  return [];
+}
+function extractStringListValues(node) {
+  const values = [];
+  if (node.type === "list") {
+    for (const child of node.namedChildren) {
+      if (child.type === "string") {
+        values.push(stripQuotes(child.text));
+      }
+    }
+  }
+  return values;
+}
+function findAllNodes2(root, type) {
+  const results = [];
+  function walk(node) {
+    if (node.type === type) results.push(node);
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return results;
+}
+function findFirstChild(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  for (const child of node.children) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function stripQuotes(text) {
+  return text.replace(/^[fFrRbBuU]*["']|["']$/g, "");
+}
+
+// src/indexer/python/indexer.ts
+async function indexPythonTreeSitter(db, options) {
+  const start = Date.now();
+  await ensurePythonParser();
+  const service = options.service ?? "main";
+  const projectRoot = options.projectRoot;
+  const ignorePatterns = [
+    "**/__pycache__/**",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/.tox/**",
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.eggs/**",
+    "**/*.egg-info/**"
+  ];
+  const pyFiles = globbySync2("**/*.py", {
+    cwd: projectRoot,
+    ignore: ignorePatterns,
+    absolute: false
+  });
+  const existingHashes = getExistingHashes(db, service, "python");
+  const currentPaths = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  const changedFiles = [];
+  let filesSkipped = 0;
+  for (const filePath of pyFiles) {
+    const relPath = filePath.replace(/\\/g, "/");
+    currentPaths.add(relPath);
+    const fullPath = join12(projectRoot, relPath);
+    const content = readFileSync5(fullPath, "utf-8");
+    const hash = hashContent(content);
+    const tree = parsePython(content);
+    fileCache.set(relPath, { content, tree, hash });
+    const existingHash = existingHashes.get(relPath);
+    if (existingHash === hash) {
+      filesSkipped++;
+    } else {
+      changedFiles.push(relPath);
+    }
+  }
+  const removed = [];
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      removed.push(existingPath);
+    }
+  }
+  const filesToClean = [...removed, ...changedFiles];
+  removeScopedSymbolsForFiles(db, filesToClean, service, "python");
+  const allNewSymbols = [];
+  for (const relPath of changedFiles) {
+    const cached = fileCache.get(relPath);
+    if (!cached) continue;
+    const symbols = extractPythonSymbols(cached.tree, relPath, cached.hash);
+    allNewSymbols.push(...symbols);
+  }
+  writeSymbols(db, allNewSymbols, service, "python");
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'python'").all(service);
+  const symbolLookup = buildPythonSymbolLookup(allDbSymbols);
+  const allDeps = [];
+  for (const [relPath, cached] of fileCache) {
+    const fileDeps = extractPythonDependencies(cached.tree, relPath, allDbSymbols, symbolLookup);
+    allDeps.push(...fileDeps);
+  }
+  db.prepare(
+    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'python')"
+  ).run(service);
+  writeDependencies(db, allDeps);
+  const allRoutes = [];
+  for (const [relPath, cached] of fileCache) {
+    const routes = extractPythonRoutes(cached.tree, relPath);
+    allRoutes.push(...routes);
+  }
+  db.prepare("DELETE FROM routes WHERE service = ?").run(service);
+  if (allRoutes.length > 0) {
+    const insertRoute = db.prepare(`
+      INSERT OR REPLACE INTO routes (id, route_path, kind, http_methods, has_auth, service)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    transaction(db, () => {
+      for (const route of allRoutes) {
+        insertRoute.run(
+          `${service}::${route.id}`,
+          route.routePath,
+          route.kind,
+          JSON.stringify(route.httpMethods),
+          route.hasAuth ? 1 : 0,
+          service
+        );
+      }
+    });
+  }
+  return {
+    symbolsIndexed: allNewSymbols.length,
+    dependenciesIndexed: allDeps.length,
+    componentsAnalyzed: 0,
+    routesAnalyzed: allRoutes.length,
+    filesProcessed: changedFiles.length,
+    filesSkipped,
+    filesRemoved: removed.length,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/indexer/go/indexer.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join13 } from "path";
+import { globbySync as globbySync3 } from "globby";
+
+// src/indexer/go/parser.ts
+import { accessSync as accessSync4, constants as constants4 } from "fs";
+import { dirname as dirname5, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import "web-tree-sitter";
+var currentDir3 = dirname5(fileURLToPath4(import.meta.url));
+var cachedParser3 = null;
+var initPromise3 = null;
+function resolveGrammarPath3() {
+  const candidates = [
+    resolve4(currentDir3, "../../../wasm/tree-sitter-go.wasm"),
+    // from src/indexer/go/
+    resolve4(currentDir3, "../wasm/tree-sitter-go.wasm")
+    // from dist/ (tsup flat bundle)
+  ];
+  for (const candidate of candidates) {
+    try {
+      accessSync4(candidate, constants4.R_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    "Could not find tree-sitter-go.wasm. Ensure the wasm/ directory is present in the @arcbridge/core package."
+  );
+}
+async function ensureGoParser() {
+  if (cachedParser3) return cachedParser3;
+  if (initPromise3) return initPromise3;
+  initPromise3 = (async () => {
+    try {
+      const TreeSitter = await import("web-tree-sitter");
+      await TreeSitter.Parser.init();
+      const grammarPath = resolveGrammarPath3();
+      const Go = await TreeSitter.Language.load(grammarPath);
+      const parser = new TreeSitter.Parser();
+      parser.setLanguage(Go);
+      cachedParser3 = parser;
+      return parser;
+    } catch (err) {
+      initPromise3 = null;
+      throw err;
+    }
+  })();
+  return initPromise3;
+}
+function parseGo(content) {
+  if (!cachedParser3) {
+    throw new Error(
+      "Go parser not initialized. Call await ensureGoParser() first."
+    );
+  }
+  const tree = cachedParser3.parse(content);
+  if (!tree) {
+    throw new Error("Failed to parse Go content");
+  }
+  return tree;
+}
+
+// src/indexer/go/symbol-extractor.ts
+function extractGoSymbols(tree, relativePath, contentHash) {
+  const symbols = [];
+  const root = tree.rootNode;
+  for (const child of root.namedChildren) {
+    walkNode3(child, relativePath, contentHash, symbols);
+  }
+  return symbols;
+}
+function walkNode3(node, relativePath, contentHash, symbols) {
+  switch (node.type) {
+    case "function_declaration": {
+      const name = getFieldName(node);
+      if (!name) break;
+      const signature = extractFunctionSignature2(node, name);
+      const returnType = extractReturnType3(node);
+      symbols.push(makeSymbol3({
+        name,
+        qualifiedName: name,
+        kind: "function",
+        node,
+        relativePath,
+        contentHash,
+        docComment: extractDocComment2(node),
+        signature,
+        returnType
+      }));
+      return;
+    }
+    case "method_declaration": {
+      const name = getFieldName(node);
+      if (!name) break;
+      const receiverType = extractReceiverType(node);
+      const qualifiedName = receiverType ? `${receiverType}.${name}` : name;
+      const signature = extractFunctionSignature2(node, name);
+      const returnType = extractReturnType3(node);
+      symbols.push(makeSymbol3({
+        name,
+        qualifiedName,
+        kind: "function",
+        node,
+        relativePath,
+        contentHash,
+        docComment: extractDocComment2(node),
+        signature,
+        returnType
+      }));
+      return;
+    }
+    case "type_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "type_spec") {
+          extractTypeSpec(child, node, relativePath, contentHash, symbols);
+        }
+      }
+      return;
+    }
+    case "const_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "const_spec") {
+          const names = getSpecNames(child);
+          const doc = extractDocComment2(child) ?? extractDocComment2(node);
+          for (const name of names) {
+            symbols.push(makeSymbol3({
+              name,
+              qualifiedName: name,
+              kind: "constant",
+              node: child,
+              relativePath,
+              contentHash,
+              docComment: doc
+            }));
+          }
+        }
+      }
+      return;
+    }
+    case "var_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "var_spec") {
+          const names = getSpecNames(child);
+          const doc = extractDocComment2(child) ?? extractDocComment2(node);
+          for (const name of names) {
+            symbols.push(makeSymbol3({
+              name,
+              qualifiedName: name,
+              kind: "variable",
+              node: child,
+              relativePath,
+              contentHash,
+              docComment: doc
+            }));
+          }
+        }
+      }
+      return;
+    }
+  }
+  for (const child of node.namedChildren) {
+    walkNode3(child, relativePath, contentHash, symbols);
+  }
+}
+function extractTypeSpec(spec, parentDecl, relativePath, contentHash, symbols) {
+  const name = getFieldName(spec);
+  if (!name) return;
+  const typeNode = spec.childForFieldName("type");
+  let kind = "type";
+  if (typeNode) {
+    if (typeNode.type === "struct_type") {
+      kind = "class";
+    } else if (typeNode.type === "interface_type") {
+      kind = "interface";
+    }
+  }
+  symbols.push(makeSymbol3({
+    name,
+    qualifiedName: name,
+    kind,
+    node: spec,
+    relativePath,
+    contentHash,
+    docComment: extractDocComment2(spec) ?? extractDocComment2(parentDecl)
+  }));
+}
+function makeSymbol3(args) {
+  const { name, qualifiedName, kind, node, relativePath, contentHash, docComment } = args;
+  return {
+    id: `${relativePath}::${qualifiedName}#${kind}`,
+    name,
+    qualifiedName,
+    kind,
+    filePath: relativePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startCol: node.startPosition.column + 1,
+    endCol: node.endPosition.column + 1,
+    signature: args.signature ?? null,
+    returnType: args.returnType ?? null,
+    docComment,
+    isExported: /^[A-Z]/.test(name),
+    isAsync: false,
+    contentHash
+  };
+}
+function getFieldName(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function getSpecNames(node) {
+  const names = [];
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") {
+      names.push(child.text);
+    } else {
+      break;
+    }
+  }
+  return names;
+}
+function extractReceiverType(node) {
+  const receiver = node.childForFieldName("receiver");
+  if (!receiver) return null;
+  for (const child of receiver.namedChildren) {
+    if (child.type === "parameter_declaration") {
+      const typeNode = child.childForFieldName("type");
+      if (typeNode) {
+        if (typeNode.type === "pointer_type") {
+          const inner = typeNode.namedChildren[0];
+          return inner ? inner.text : typeNode.text.replace(/^\*/, "");
+        }
+        return typeNode.text;
+      }
+    }
+  }
+  return null;
+}
+function extractDocComment2(node) {
+  const comments = [];
+  let sibling = node.previousSibling;
+  while (sibling) {
+    if (sibling.type === "comment" && sibling.text.startsWith("//")) {
+      comments.unshift(sibling.text);
+    } else {
+      break;
+    }
+    sibling = sibling.previousSibling;
+  }
+  if (comments.length === 0) return null;
+  return comments.map((c) => c.replace(/^\s*\/\/\s?/, "").trim()).filter(Boolean).join(" ");
+}
+function extractFunctionSignature2(node, name) {
+  const params = node.childForFieldName("parameters");
+  if (!params) return null;
+  return `${name}${params.text}`;
+}
+function extractReturnType3(node) {
+  const result = node.childForFieldName("result");
+  if (!result) return null;
+  return result.text;
+}
+
+// src/indexer/go/dependency-extractor.ts
+function buildGoSymbolLookup(symbols) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const existing = lookup.get(sym.name);
+    if (existing) {
+      existing.push(sym.id);
+    } else {
+      lookup.set(sym.name, [sym.id]);
+    }
+  }
+  return lookup;
+}
+function extractGoDependencies(tree, relativePath, allSymbols, symbolLookup) {
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fileSymbols = allSymbols.filter((s) => s.filePath === relativePath);
+  walkForDependencies3(tree.rootNode, fileSymbols, symbolLookup, deps, seen);
+  return deps;
+}
+function walkForDependencies3(node, fileSymbols, lookup, deps, seen) {
+  switch (node.type) {
+    case "type_declaration":
+      for (const child of node.namedChildren) {
+        if (child.type === "type_spec") {
+          extractEmbeddingDeps(child, fileSymbols, lookup, deps, seen);
+        }
+      }
+      break;
+    case "call_expression":
+      extractCallDeps3(node, fileSymbols, lookup, deps, seen);
+      break;
+  }
+  if (node.type === "parameter_declaration" || node.type === "field_declaration" || node.type === "var_spec") {
+    extractTypeRefDeps2(node, fileSymbols, lookup, deps, seen);
+  }
+  for (const child of node.namedChildren) {
+    walkForDependencies3(child, fileSymbols, lookup, deps, seen);
+  }
+}
+function extractEmbeddingDeps(typeSpec, fileSymbols, lookup, deps, seen) {
+  const typeName = getNodeIdentifier3(typeSpec);
+  if (!typeName) return;
+  const sourceSymbol = findEnclosingSymbol3(typeName, fileSymbols, "class", "interface");
+  if (!sourceSymbol) return;
+  const typeNode = typeSpec.childForFieldName("type");
+  if (!typeNode) return;
+  if (typeNode.type === "struct_type" || typeNode.type === "interface_type") {
+    const fieldList = findChild6(typeNode, "field_declaration_list") ?? typeNode;
+    for (const field of fieldList.namedChildren) {
+      if (field.type === "field_declaration") {
+        const nameNode = field.childForFieldName("name");
+        if (nameNode) continue;
+        const embeddedTypeName = extractSimpleTypeName3(field);
+        if (!embeddedTypeName || embeddedTypeName === typeName) continue;
+        const targetIds = lookup.get(embeddedTypeName);
+        if (!targetIds) continue;
+        for (const targetId of targetIds) {
+          if (targetId === sourceSymbol.id) continue;
+          addDep3(deps, seen, sourceSymbol.id, targetId, "extends");
+        }
+      }
+      if (field.type === "type_name" || field.type === "qualified_type" || field.type === "type_identifier") {
+        const embeddedName = extractSimpleTypeNameFromNode(field);
+        if (!embeddedName || embeddedName === typeName) continue;
+        const targetIds = lookup.get(embeddedName);
+        if (!targetIds) continue;
+        for (const targetId of targetIds) {
+          if (targetId === sourceSymbol.id) continue;
+          addDep3(deps, seen, sourceSymbol.id, targetId, "extends");
+        }
+      }
+    }
+  }
+}
+function extractCallDeps3(node, fileSymbols, lookup, deps, seen) {
+  const calledName = extractCalledFunctionName2(node);
+  if (!calledName) return;
+  const enclosing = findEnclosingFunctionForNode2(node, fileSymbols);
+  if (!enclosing) return;
+  const targetIds = lookup.get(calledName);
+  if (!targetIds) return;
+  for (const targetId of targetIds) {
+    if (targetId === enclosing.id) continue;
+    addDep3(deps, seen, enclosing.id, targetId, "calls");
+  }
+}
+function extractTypeRefDeps2(node, fileSymbols, lookup, deps, seen) {
+  const typeNames = collectTypeIdentifiers3(node);
+  if (typeNames.length === 0) return;
+  const enclosing = findEnclosingSymbolForNode3(node, fileSymbols);
+  if (!enclosing) return;
+  for (const typeName of typeNames) {
+    const targetIds = lookup.get(typeName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === enclosing.id) continue;
+      addDep3(deps, seen, enclosing.id, targetId, "uses_type");
+    }
+  }
+}
+function addDep3(deps, seen, source, target, kind) {
+  const key = `${source}|${target}|${kind}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  deps.push({ sourceSymbolId: source, targetSymbolId: target, kind });
+}
+function findChild6(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function getNodeIdentifier3(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier" || child.type === "type_identifier") return child.text;
+  }
+  return null;
+}
+function extractSimpleTypeName3(node) {
+  for (const child of node.namedChildren) {
+    if (child.type === "type_identifier" || child.type === "identifier") return child.text;
+    if (child.type === "pointer_type") {
+      const inner = child.namedChildren[0];
+      return inner ? extractSimpleTypeNameFromNode(inner) : null;
+    }
+    if (child.type === "qualified_type") {
+      const parts = child.text.split(".");
+      return parts[parts.length - 1];
+    }
+  }
+  return null;
+}
+function extractSimpleTypeNameFromNode(node) {
+  if (node.type === "type_identifier" || node.type === "identifier") return node.text;
+  if (node.type === "qualified_type") {
+    const parts = node.text.split(".");
+    return parts[parts.length - 1];
+  }
+  return null;
+}
+function extractCalledFunctionName2(node) {
+  const funcNode = node.childForFieldName("function");
+  if (!funcNode) return node.namedChildren[0]?.text ?? null;
+  if (funcNode.type === "selector_expression") {
+    const fieldNode = funcNode.childForFieldName("field");
+    return fieldNode?.text ?? null;
+  }
+  if (funcNode.type === "identifier") {
+    return funcNode.text;
+  }
+  return null;
+}
+function findEnclosingSymbol3(name, fileSymbols, ...kinds) {
+  return fileSymbols.find(
+    (s) => s.name === name && kinds.includes(s.kind)
+  );
+}
+function findEnclosingFunctionForNode2(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_declaration" || current.type === "method_declaration") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function findEnclosingSymbolForNode3(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_declaration" || current.type === "method_declaration") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        const found = fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+        if (found) return found;
+      }
+    }
+    if (current.type === "type_spec") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.name === name && (s.kind === "class" || s.kind === "interface")
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function collectTypeIdentifiers3(node) {
+  const names = [];
+  collectTypeIdentifiersRecursive3(node, names);
+  return [...new Set(names)];
+}
+function collectTypeIdentifiersRecursive3(node, names) {
+  if (node.type === "type_identifier") {
+    names.push(node.text);
+  } else if (node.type === "qualified_type") {
+    const parts = node.text.split(".");
+    names.push(parts[parts.length - 1]);
+  } else if (node.type === "pointer_type") {
+    for (const child of node.namedChildren) {
+      collectTypeIdentifiersRecursive3(child, names);
+    }
+    return;
+  }
+  for (const child of node.namedChildren) {
+    collectTypeIdentifiersRecursive3(child, names);
+  }
+}
+
+// src/indexer/go/route-analyzer.ts
+var GIN_METHODS = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE",
+  PATCH: "PATCH",
+  HEAD: "HEAD",
+  OPTIONS: "OPTIONS"
+};
+var CHI_METHODS = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Delete: "DELETE",
+  Patch: "PATCH",
+  Head: "HEAD",
+  Options: "OPTIONS"
+};
+var NET_HTTP_METHODS = /* @__PURE__ */ new Set(["HandleFunc", "Handle"]);
+function extractGoRoutes(tree, _relativePath) {
+  const routes = [];
+  const scopedPrefixes = extractGroupPrefixes2(tree.rootNode);
+  const authScopes = findAuthUseScopes(tree.rootNode);
+  const calls = findAllNodes3(tree.rootNode, "call_expression");
+  for (const call of calls) {
+    const funcNode = call.childForFieldName("function");
+    if (!funcNode || funcNode.type !== "selector_expression") continue;
+    const fieldNode = funcNode.childForFieldName("field");
+    if (!fieldNode) continue;
+    const methodName = fieldNode.text;
+    const receiverNode = funcNode.childForFieldName("operand");
+    const receiverName = receiverNode?.type === "identifier" ? receiverNode.text : null;
+    let httpMethods = null;
+    let isNetHttp = false;
+    if (GIN_METHODS[methodName]) {
+      httpMethods = [GIN_METHODS[methodName]];
+    } else if (CHI_METHODS[methodName]) {
+      httpMethods = [CHI_METHODS[methodName]];
+    } else if (NET_HTTP_METHODS.has(methodName)) {
+      httpMethods = [];
+      isNetHttp = true;
+    }
+    if (httpMethods === null) continue;
+    const routeTemplate = getFirstStringArgument3(call);
+    if (routeTemplate === null) continue;
+    const prefix = receiverName ? resolvePrefix(receiverName, call, scopedPrefixes) : "";
+    let routePath;
+    if (prefix && routeTemplate) {
+      routePath = `${prefix}/${routeTemplate}`.replace(/\/{2,}/g, "/");
+    } else if (prefix) {
+      routePath = prefix;
+    } else {
+      routePath = routeTemplate;
+    }
+    routePath = routePath.startsWith("/") ? routePath : `/${routePath}`;
+    routePath = routePath.replace(/\/{2,}/g, "/").replace(/\/+$/, "") || "/";
+    let hasAuth = false;
+    if (!isNetHttp) {
+      hasAuth = hasAuthArgument(call);
+      if (!hasAuth && authScopes.length > 0) {
+        hasAuth = isInsideAuthScope(call, authScopes);
+      }
+    }
+    const cleanPath = routePath.slice(1) || "";
+    const idMethod = httpMethods.length > 0 ? httpMethods.join(",") : "ANY";
+    const id = `route::${cleanPath}::${idMethod}`;
+    routes.push({
+      id,
+      routePath,
+      kind: "api-route",
+      httpMethods,
+      hasAuth
+    });
+  }
+  return routes;
+}
+function extractGroupPrefixes2(root) {
+  const prefixes = [];
+  const calls = findAllNodes3(root, "call_expression");
+  for (const call of calls) {
+    const funcNode = call.childForFieldName("function");
+    if (funcNode?.type !== "selector_expression") continue;
+    const fieldNode = funcNode.childForFieldName("field");
+    const methodName = fieldNode?.text;
+    if (methodName !== "Group" && methodName !== "Route") continue;
+    const prefix = getFirstStringArgument3(call);
+    if (prefix === null) continue;
+    const assignNode = findAncestor(call, ["short_var_declaration", "assignment_statement"]);
+    if (assignNode) {
+      const left = assignNode.childForFieldName("left");
+      if (left) {
+        const varNode = left.type === "expression_list" ? left.namedChildren[0] : left;
+        if (varNode?.type === "identifier") {
+          const scope = findAncestor(call, [
+            "func_literal",
+            "function_declaration",
+            "method_declaration"
+          ]);
+          prefixes.push({ varName: varNode.text, prefix, scope });
+        }
+      }
+    }
+    if (methodName === "Route") {
+      const argList = findChild7(call, "argument_list");
+      if (argList) {
+        for (const arg of argList.namedChildren) {
+          if (arg.type === "func_literal") {
+            const paramList = arg.childForFieldName("parameters");
+            if (paramList) {
+              const firstParam = paramList.namedChildren[0];
+              if (firstParam?.type === "parameter_declaration") {
+                const paramName = firstParam.childForFieldName("name");
+                if (paramName?.type === "identifier") {
+                  prefixes.push({ varName: paramName.text, prefix, scope: arg });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return prefixes;
+}
+function resolvePrefix(receiverName, callNode, scopedPrefixes) {
+  let best = null;
+  for (const sp of scopedPrefixes) {
+    if (sp.varName !== receiverName) continue;
+    if (sp.scope === null) {
+      if (!best) best = sp;
+    } else {
+      if (isDescendantOf(callNode, sp.scope)) {
+        if (!best || best.scope === null || isDescendantOf(sp.scope, best.scope)) {
+          best = sp;
+        }
+      }
+    }
+  }
+  return best?.prefix ?? "";
+}
+function isSameNode(a, b) {
+  return a.type === b.type && a.startPosition.row === b.startPosition.row && a.startPosition.column === b.startPosition.column && a.endPosition.row === b.endPosition.row && a.endPosition.column === b.endPosition.column;
+}
+function isDescendantOf(node, ancestor) {
+  let current = node.parent;
+  while (current) {
+    if (isSameNode(current, ancestor)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function findAncestor(node, types) {
+  let current = node.parent;
+  while (current) {
+    if (types.includes(current.type)) return current;
+    current = current.parent;
+  }
+  return null;
+}
+function findAuthUseScopes(root) {
+  const scopes = [];
+  const calls = findAllNodes3(root, "call_expression");
+  for (const call of calls) {
+    const funcNode = call.childForFieldName("function");
+    if (funcNode?.type !== "selector_expression") continue;
+    const fieldNode = funcNode.childForFieldName("field");
+    if (fieldNode?.text !== "Use") continue;
+    if (hasAuthArgument(call)) {
+      let scope = call.parent;
+      while (scope && scope.type !== "func_literal" && scope.type !== "function_declaration" && scope.type !== "method_declaration") {
+        scope = scope.parent;
+      }
+      if (scope) {
+        scopes.push(scope);
+      }
+    }
+  }
+  return scopes;
+}
+function isInsideAuthScope(node, scopes) {
+  let current = node.parent;
+  while (current) {
+    for (const scope of scopes) {
+      if (isSameNode(current, scope)) return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function hasAuthArgument(call) {
+  const argList = findChild7(call, "argument_list");
+  if (!argList) return false;
+  for (const arg of argList.namedChildren) {
+    const text = arg.text;
+    if (/[Aa]uth/.test(text)) return true;
+  }
+  return false;
+}
+function findChild7(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function findAllNodes3(root, type) {
+  const results = [];
+  function walk(node) {
+    if (node.type === type) results.push(node);
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return results;
+}
+function getFirstStringArgument3(node) {
+  const argList = findChild7(node, "argument_list");
+  if (!argList) return null;
+  for (const arg of argList.namedChildren) {
+    if (arg.type === "interpreted_string_literal") {
+      return arg.text.replace(/^"|"$/g, "");
+    }
+    if (arg.type === "raw_string_literal") {
+      return arg.text.replace(/^`|`$/g, "");
+    }
+  }
+  return null;
+}
+
+// src/indexer/go/indexer.ts
+async function indexGoTreeSitter(db, options) {
+  const start = Date.now();
+  await ensureGoParser();
+  const service = options.service ?? "main";
+  const projectRoot = options.projectRoot;
+  const ignorePatterns = [
+    "**/vendor/**",
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/testdata/**",
+    "**/*_test.go",
+    "**/*_gen.go",
+    "**/*_generated.go",
+    "**/*.pb.go"
+  ];
+  const goFiles = globbySync3("**/*.go", {
+    cwd: projectRoot,
+    ignore: ignorePatterns,
+    absolute: false
+  });
+  const existingHashes = getExistingHashes(db, service, "go");
+  const currentPaths = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  const changedFiles = [];
+  let filesSkipped = 0;
+  for (const filePath of goFiles) {
+    const relPath = filePath.replace(/\\/g, "/");
+    currentPaths.add(relPath);
+    const fullPath = join13(projectRoot, relPath);
+    const content = readFileSync6(fullPath, "utf-8");
+    const hash = hashContent(content);
+    const tree = parseGo(content);
+    fileCache.set(relPath, { content, tree, hash });
+    const existingHash = existingHashes.get(relPath);
+    if (existingHash === hash) {
+      filesSkipped++;
+    } else {
+      changedFiles.push(relPath);
+    }
+  }
+  const removed = [];
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      removed.push(existingPath);
+    }
+  }
+  const filesToClean = [...removed, ...changedFiles];
+  removeScopedSymbolsForFiles(db, filesToClean, service, "go");
+  const allNewSymbols = [];
+  for (const relPath of changedFiles) {
+    const cached = fileCache.get(relPath);
+    if (!cached) continue;
+    const symbols = extractGoSymbols(cached.tree, relPath, cached.hash);
+    allNewSymbols.push(...symbols);
+  }
+  writeSymbols(db, allNewSymbols, service, "go");
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'go'").all(service);
+  const symbolLookup = buildGoSymbolLookup(allDbSymbols);
+  const allDeps = [];
+  for (const [relPath, cached] of fileCache) {
+    const fileDeps = extractGoDependencies(cached.tree, relPath, allDbSymbols, symbolLookup);
+    allDeps.push(...fileDeps);
+  }
+  db.prepare(
+    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'go')"
+  ).run(service);
+  writeDependencies(db, allDeps);
+  const allRoutes = [];
+  for (const [relPath, cached] of fileCache) {
+    const routes = extractGoRoutes(cached.tree, relPath);
+    allRoutes.push(...routes);
+  }
+  db.prepare("DELETE FROM routes WHERE service = ?").run(service);
+  if (allRoutes.length > 0) {
+    const insertRoute = db.prepare(`
+      INSERT OR REPLACE INTO routes (id, route_path, kind, http_methods, has_auth, service)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    transaction(db, () => {
+      for (const route of allRoutes) {
+        insertRoute.run(
+          `${service}::${route.id}`,
+          route.routePath,
+          route.kind,
+          JSON.stringify(route.httpMethods),
+          route.hasAuth ? 1 : 0,
+          service
+        );
+      }
+    });
+  }
+  return {
+    symbolsIndexed: allNewSymbols.length,
+    dependenciesIndexed: allDeps.length,
+    componentsAnalyzed: 0,
+    routesAnalyzed: allRoutes.length,
+    filesProcessed: changedFiles.length,
+    filesSkipped,
+    filesRemoved: removed.length,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/indexer/package-deps.ts
+import { join as join14 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "fs";
+function indexPackageDependencies(db, projectRoot, service = "main") {
+  const deps = [];
+  const pkgJsonPath = join14(projectRoot, "package.json");
+  if (existsSync6(pkgJsonPath)) {
+    deps.push(...parsePackageJson(pkgJsonPath));
+  }
+  const csprojFiles = findCsprojFiles(projectRoot);
+  for (const csproj of csprojFiles) {
+    deps.push(...parseCsproj(csproj));
+  }
+  if (deps.length === 0) return 0;
+  db.prepare("DELETE FROM package_dependencies WHERE service = ?").run(service);
+  const insert = db.prepare(
+    "INSERT OR IGNORE INTO package_dependencies (name, version, source, service) VALUES (?, ?, ?, ?)"
+  );
+  transaction(db, () => {
+    for (const dep of deps) {
+      insert.run(dep.name, dep.version, dep.source, service);
+    }
+  });
+  return deps.length;
+}
+function parsePackageJson(filePath) {
+  try {
+    const content = readFileSync7(filePath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = [];
+    if (pkg.dependencies) {
+      for (const [name, version] of Object.entries(pkg.dependencies)) {
+        deps.push({ name, version, source: "npm" });
+      }
+    }
+    if (pkg.devDependencies) {
+      for (const [name, version] of Object.entries(pkg.devDependencies)) {
+        deps.push({ name, version, source: "npm-dev" });
+      }
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+function parseCsproj(filePath) {
+  try {
+    const content = readFileSync7(filePath, "utf-8");
     const deps = [];
     const pattern = /<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?[^>]*\/?>/gi;
     let match;
@@ -7332,13 +9473,13 @@ function parseCsproj(filePath) {
 }
 function findCsprojFiles(dir, maxDepth = 4) {
   const results = [];
-  function walk(currentDir2, depth) {
+  function walk(currentDir4, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = readdirSync5(currentDir2, { withFileTypes: true });
+      const entries = readdirSync5(currentDir4, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules" || entry.name === ".git") continue;
-        const fullPath = join12(currentDir2, entry.name);
+        const fullPath = join14(currentDir4, entry.name);
         if (entry.isFile() && entry.name.endsWith(".csproj")) {
           results.push(fullPath);
         } else if (entry.isDirectory()) {
@@ -7353,13 +9494,13 @@ function findCsprojFiles(dir, maxDepth = 4) {
 }
 
 // src/config/loader.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join15 } from "path";
 import yaml from "yaml";
 function loadConfig(projectRoot) {
-  const configPath = join13(projectRoot, ".arcbridge", "config.yaml");
+  const configPath = join15(projectRoot, ".arcbridge", "config.yaml");
   try {
-    const raw = readFileSync6(configPath, "utf-8");
+    const raw = readFileSync8(configPath, "utf-8");
     const parsed = ArcBridgeConfigSchema.safeParse(yaml.parse(raw));
     if (parsed.success) {
       return { config: parsed.data, error: null };
@@ -7376,12 +9517,16 @@ function loadConfig(projectRoot) {
 
 // src/indexer/index.ts
 function detectProjectLanguage(projectRoot) {
-  if (existsSync7(join14(projectRoot, "ProjectSettings")) && existsSync7(join14(projectRoot, "Assets"))) {
+  if (existsSync7(join16(projectRoot, "ProjectSettings")) && existsSync7(join16(projectRoot, "Assets"))) {
     return "csharp";
   }
-  if (existsSync7(join14(projectRoot, "tsconfig.json"))) return "typescript";
-  if (existsSync7(join14(projectRoot, "package.json"))) return "typescript";
+  if (existsSync7(join16(projectRoot, "tsconfig.json"))) return "typescript";
   if (findDotnetProject(projectRoot)) return "csharp";
+  if (existsSync7(join16(projectRoot, "go.mod"))) return "go";
+  if (existsSync7(join16(projectRoot, "pyproject.toml")) || existsSync7(join16(projectRoot, "requirements.txt")) || existsSync7(join16(projectRoot, "setup.py"))) {
+    return "python";
+  }
+  if (existsSync7(join16(projectRoot, "package.json"))) return "typescript";
   return "typescript";
 }
 async function indexProject(db, options) {
@@ -7401,14 +9546,43 @@ async function indexProject(db, options) {
       service: options.service
     });
   }
-  return indexTypeScriptProject(db, options);
+  if (resolvedLanguage === "python") {
+    return await indexPythonTreeSitter(db, {
+      projectRoot: options.projectRoot,
+      service: options.service
+    });
+  }
+  if (resolvedLanguage === "go") {
+    return await indexGoTreeSitter(db, {
+      projectRoot: options.projectRoot,
+      service: options.service
+    });
+  }
+  const resolvedTsconfigPath = options.tsconfigPath ?? ts6.findConfigFile(options.projectRoot, ts6.sys.fileExists, "tsconfig.json");
+  if (!resolvedTsconfigPath) {
+    return {
+      symbolsIndexed: 0,
+      dependenciesIndexed: 0,
+      componentsAnalyzed: 0,
+      routesAnalyzed: 0,
+      filesProcessed: 0,
+      filesSkipped: 0,
+      filesRemoved: 0,
+      durationMs: 0,
+      skippedReason: "no tsconfig.json found"
+    };
+  }
+  return indexTypeScriptProject(db, {
+    ...options,
+    tsconfigPath: resolvedTsconfigPath
+  });
 }
 function resolveCSharpBackend(projectRoot) {
   const { config, error } = loadConfig(projectRoot);
   let setting = config?.indexing?.csharp_indexer;
   if (!setting && error) {
     try {
-      const raw = readFileSync7(join14(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
+      const raw = readFileSync9(join16(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
       const parsed = YAML.parse(raw);
       const rawSetting = parsed?.indexing?.csharp_indexer;
       if (rawSetting === "roslyn" || rawSetting === "tree-sitter") {
@@ -7439,7 +9613,7 @@ function indexTypeScriptProject(db, options) {
   const start = Date.now();
   const service = options.service ?? "main";
   const { checker, sourceFiles, projectRoot } = createTsProgram(options);
-  const existingHashes = getExistingHashes(db, service);
+  const existingHashes = getExistingHashes(db, service, "typescript");
   const changed = [];
   const currentPaths = /* @__PURE__ */ new Set();
   let filesSkipped = 0;
@@ -7464,18 +9638,18 @@ function indexTypeScriptProject(db, options) {
     ...removed,
     ...changed.map((f) => f.relativePath)
   ];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "typescript");
   const allSymbols = changed.flatMap(
     (f) => extractSymbols(f.sourceFile, checker, f.relativePath, f.hash)
   );
   writeSymbols(db, allSymbols, service, "typescript");
-  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name FROM symbols WHERE service = ?").all(service);
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name FROM symbols WHERE service = ? AND language = 'typescript'").all(service);
   const lookup = buildSymbolLookup(allDbSymbols);
   const allDeps = sourceFiles.flatMap((sf) => {
     const relPath = relative5(projectRoot, sf.fileName);
     return extractDependencies(sf, checker, relPath, projectRoot, lookup);
   });
-  db.prepare("DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ?)").run(service);
+  db.prepare("DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'typescript')").run(service);
   writeDependencies(db, allDeps);
   const CLIENT_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["react-vite", "angular-app"]);
   const projectType = db.prepare("SELECT value FROM arcbridge_meta WHERE key = 'project_type'").get()?.value;
@@ -7806,21 +9980,21 @@ function safeParseJson(value, fallback) {
 }
 
 // src/sync/yaml-writer.ts
-import { join as join15 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
 import { parse as parse2, stringify as stringify4 } from "yaml";
 function readTaskFile(projectRoot, phaseId) {
-  const path = join15(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+  const path = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
   if (!existsSync8(path)) return { error: "not-found" };
-  const raw = readFileSync8(path, "utf-8");
+  const raw = readFileSync10(path, "utf-8");
   const result = TaskFileSchema.safeParse(parse2(raw));
   if (!result.success) return { error: "invalid" };
   return { data: result.data, path };
 }
 function readPhasesFile(projectRoot) {
-  const path = join15(projectRoot, ".arcbridge", "plan", "phases.yaml");
+  const path = join17(projectRoot, ".arcbridge", "plan", "phases.yaml");
   if (!existsSync8(path)) return { error: "not-found" };
-  const raw = readFileSync8(path, "utf-8");
+  const raw = readFileSync10(path, "utf-8");
   const result = PhasesFileSchema.safeParse(parse2(raw));
   if (!result.success) return { error: "invalid" };
   return { data: result.data, path };
@@ -7840,14 +10014,14 @@ function syncTaskToYaml(projectRoot, phaseId, taskId, status, completedAt) {
   writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
 }
 function addTaskToYaml(projectRoot, phaseId, task) {
-  const tasksDir = join15(projectRoot, ".arcbridge", "plan", "tasks");
+  const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
   mkdirSync5(tasksDir, { recursive: true });
   const readResult = readTaskFile(projectRoot, phaseId);
   const taskFile = "error" in readResult ? { schema_version: 1, phase_id: phaseId, tasks: [] } : readResult.data;
   if (!taskFile.tasks.some((t) => t.id === task.id)) {
     taskFile.tasks.push(task);
   }
-  const taskPath = join15(tasksDir, `${phaseId}.yaml`);
+  const taskPath = join17(tasksDir, `${phaseId}.yaml`);
   writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
 }
 function syncPhaseToYaml(projectRoot, phaseId, status, startedAt, completedAt) {
@@ -7880,9 +10054,9 @@ function addPhaseToYaml(projectRoot, phase) {
         warning: `Phase number ${phase.phase_number} already used by '${conflicting?.id}'`
       };
     }
-    const tasksDir = join15(projectRoot, ".arcbridge", "plan", "tasks");
+    const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
     mkdirSync5(tasksDir, { recursive: true });
-    const taskFilePath = join15(tasksDir, `${phase.id}.yaml`);
+    const taskFilePath = join17(tasksDir, `${phase.id}.yaml`);
     if (!existsSync8(taskFilePath)) {
       writeFileSync5(
         taskFilePath,
@@ -7912,14 +10086,14 @@ function addPhaseToYaml(projectRoot, phase) {
   }
 }
 function syncScenarioToYaml(projectRoot, scenarioId, status, linkedTests, verification) {
-  const scenarioPath = join15(
+  const scenarioPath = join17(
     projectRoot,
     ".arcbridge",
     "arc42",
     "10-quality-scenarios.yaml"
   );
   if (!existsSync8(scenarioPath)) return;
-  const raw = readFileSync8(scenarioPath, "utf-8");
+  const raw = readFileSync10(scenarioPath, "utf-8");
   const parsed = parse2(raw);
   const result = QualityScenariosFileSchema.safeParse(parsed);
   if (!result.success) return;
@@ -7978,7 +10152,7 @@ function deletePhaseFromYaml(projectRoot, phaseId) {
       return { success: false, warning: `Phase '${phaseId}' not found in phases.yaml` };
     }
     writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
-    const taskFilePath = join15(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+    const taskFilePath = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
     try {
       unlinkSync(taskFilePath);
     } catch (e) {
@@ -8122,7 +10296,7 @@ function safeParseJson2(value, fallback) {
 
 // src/generators/sync-generator.ts
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join16, dirname as dirname4 } from "path";
+import { join as join18, dirname as dirname6 } from "path";
 
 // src/templates/sync/claude-skill.ts
 function claudeSkillTemplate(config) {
@@ -8300,21 +10474,21 @@ To enable automatic sync:
 function generateSyncFiles(targetDir, config) {
   const generated = [];
   const action = githubActionTemplate(config);
-  const actionPath = join16(targetDir, action.relativePath);
-  mkdirSync6(dirname4(actionPath), { recursive: true });
+  const actionPath = join18(targetDir, action.relativePath);
+  mkdirSync6(dirname6(actionPath), { recursive: true });
   writeFileSync6(actionPath, action.content, "utf-8");
   generated.push(action.relativePath);
   if (config.platforms.includes("claude")) {
     const skill = claudeSkillTemplate(config);
-    const skillPath = join16(targetDir, skill.relativePath);
-    mkdirSync6(dirname4(skillPath), { recursive: true });
+    const skillPath = join18(targetDir, skill.relativePath);
+    mkdirSync6(dirname6(skillPath), { recursive: true });
     writeFileSync6(skillPath, skill.content, "utf-8");
     generated.push(skill.relativePath);
   }
   if (config.platforms.includes("copilot")) {
     const hook = copilotHookTemplate(config);
-    const hookPath = join16(targetDir, hook.relativePath);
-    mkdirSync6(dirname4(hookPath), { recursive: true });
+    const hookPath = join18(targetDir, hook.relativePath);
+    mkdirSync6(dirname6(hookPath), { recursive: true });
     writeFileSync6(hookPath, hook.content, "utf-8");
     generated.push(hook.relativePath);
   }
@@ -8323,7 +10497,7 @@ function generateSyncFiles(targetDir, config) {
 
 // src/metrics/activity.ts
 import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function insertActivity(db, params) {
   const totalTokens = params.totalTokens ?? (params.inputTokens != null && params.outputTokens != null ? params.inputTokens + params.outputTokens : null);
   const stmt = db.prepare(`
@@ -8481,7 +10655,7 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
   });
   const rows = result.rows;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const dir = join17(projectRoot, ".arcbridge", "metrics");
+  const dir = join19(projectRoot, ".arcbridge", "metrics");
   mkdirSync7(dir, { recursive: true });
   let content;
   let filename;
@@ -8578,7 +10752,7 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
       break;
     }
   }
-  const filePath = join17(dir, filename);
+  const filePath = join19(dir, filename);
   writeFileSync7(filePath, content, "utf-8");
   return filePath;
 }
@@ -8782,7 +10956,7 @@ function parseStatusCode(code) {
 // src/testing/runner.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve5 } from "path";
 function verifyScenarios(db, projectRoot, options) {
   const results = [];
   const errors = [];
@@ -8819,7 +10993,7 @@ function verifyScenarios(db, projectRoot, options) {
     }
     if (testPaths.length === 0) continue;
     const missingPaths = testPaths.filter(
-      (tp) => !existsSync9(resolve3(projectRoot, tp))
+      (tp) => !existsSync9(resolve5(projectRoot, tp))
     );
     if (missingPaths.length === testPaths.length) {
       results.push({
@@ -8834,7 +11008,7 @@ function verifyScenarios(db, projectRoot, options) {
       continue;
     }
     const existingPaths = testPaths.filter(
-      (tp) => existsSync9(resolve3(projectRoot, tp))
+      (tp) => existsSync9(resolve5(projectRoot, tp))
     );
     const start = Date.now();
     let passed;
@@ -8888,11 +11062,11 @@ ${output}`;
 }
 
 // src/roles/loader.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join20 } from "path";
 import matter4 from "gray-matter";
 function loadRoles(projectRoot) {
-  const agentsDir = join18(projectRoot, ".arcbridge", "agents");
+  const agentsDir = join20(projectRoot, ".arcbridge", "agents");
   const roles = [];
   const errors = [];
   let files;
@@ -8902,9 +11076,9 @@ function loadRoles(projectRoot) {
     return { roles: [], errors: [`Agent directory not found: ${agentsDir}`] };
   }
   for (const file of files) {
-    const filePath = join18(agentsDir, file);
+    const filePath = join20(agentsDir, file);
     try {
-      const raw = readFileSync9(filePath, "utf-8");
+      const raw = readFileSync11(filePath, "utf-8");
       const parsed = matter4(raw);
       const input = {
         ...parsed.data,
@@ -8929,9 +11103,9 @@ function loadRole(projectRoot, roleId) {
   if (!/^[a-z0-9-]+$/.test(roleId)) {
     return { role: null, error: `Invalid role ID: "${roleId}" (must be kebab-case)` };
   }
-  const filePath = join18(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
+  const filePath = join20(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
   try {
-    const raw = readFileSync9(filePath, "utf-8");
+    const raw = readFileSync11(filePath, "utf-8");
     const parsed = matter4(raw);
     const input = {
       ...parsed.data,