purecontext-mcp 1.1.1 → 1.1.2

package/docs/dev/PHASE5_TASKS.md

@@ -1,835 +0,0 @@
-# Phase 5 — Task Breakdown
-
-**Goal**: Deliver framework adapters for Python and Go (whose handlers already exist), then add four new language handlers — PHP, Ruby, Kotlin, and C — with their accompanying framework adapters. This phase brings PureContext to near-parity with jCodeMunch's language breadth for the most widely-used web and systems languages.
-
-**Scope rationale**: Phase 4 completed Rust, Java, and C# handlers along with Angular, NestJS, Express, and Fastify adapters. Python and Go handlers were completed in Phase 3 but their framework ecosystems (Flask, Django, FastAPI, Gin, Echo, Fiber) were left unaddressed. PHP, Ruby, and Kotlin are the next three languages on jCodeMunch's list that PureContext is missing. C is a systems-language quick win — its grammar is official and stable, its AST is flat and straightforward. Delivering all of these together in Phase 5 closes the largest competitive gap in a single phase.
-
-**Approach**: Tasks are sequenced so each one builds on the previous. Complete them in order. Each task should be independently testable before moving to the next. Framework adapter tasks for Python and Go come first — they have no handler dependency and deliver immediate value. Language handler tasks are sequenced from simplest (C) to most complex (Ruby, Kotlin). Each handler is paired immediately with its framework adapters before moving to the next language.
-
----
-
-## Task 43: Extend SymbolKind for New Languages
-
-Extend the `SymbolKind` union type in `src/core/types.ts` before any new handler can be compiled. All downstream type checks depend on this union being complete.
-
-**Deliverables:**
-- Update `src/core/types.ts` — extend the `SymbolKind` union:
-  ```typescript
-  export type SymbolKind =
-    // Existing (unchanged)
-    | 'function' | 'class' | 'method' | 'const' | 'type'
-    | 'interface' | 'enum' | 'component' | 'composable'
-    | 'hook' | 'route' | 'decorator' | 'middleware'
-    // Phase 5 additions
-    | 'model'     // ORM models: Django Model, Rails ActiveRecord, Laravel Eloquent
-    | 'view'      // Django views, Rails controllers (request handler entry points)
-    | 'struct'    // C/C++ struct — distinct from class; plain data container
-    | 'macro'     // C/C++ #define object-like macros; distinct from const
-    | 'signal';   // Django signals, framework event emitters
-  ```
-
-**Rationale for each addition:**
-- `model`: AI agents frequently navigate to ORM models by name. Using `class` loses the distinction in projects where every file is a class.
-- `view`: Django views and Rails controllers are the request-handler entry points agents most often need. A dedicated kind avoids grep over all classes.
-- `struct`: C (and later C++) projects have a clear semantic distinction between `struct` (pure data) and `class` (data + behaviour). Collapsing them into `class` confuses AI navigation.
-- `macro`: C `#define NAME value` is not a constant in the language-theoretic sense. A separate kind prevents AI agents from conflating `#define MAX_SIZE 1024` with `const int maxSize = 1024`.
-- `signal`: Django signal receivers and similar event hooks are a frequent query target; using `function` or `decorator` is ambiguous.
-
-**Backward-compatibility:** All five additions are appended to the union. Existing tests reference specific kind values and will not break. The SQLite `kind` column stores TEXT — no migration needed; existing indexed repos simply won't have the new kinds until re-indexed.
-
-**Verify:** `npm run build` succeeds with no type errors after the change. All existing tests still pass.
-
-**Tests:** Add a type-level test asserting all new kinds are accepted by functions that take `SymbolKind`. No runtime tests needed — this is a compile-time change.
-
----
-
-## Task 44: Flask Adapter
-
-Extract route and view symbols from Flask applications. Flask's route registration uses Python function decorators, which are already parsed cleanly by the Python handler from Phase 3.
-
-**Deliverables:**
-- `src/adapters/flask.ts` — implements `FrameworkAdapter`
-  - `name`: `'flask'`
-  - `extensions()`: `[]` — `.py` files are already handled by the Python handler
-  - `detect(projectRoot)`:
-    - Read `requirements.txt` if present — check for a line matching `/^\s*[Ff]lask[>=\s]/`
-    - Read `pyproject.toml` if present — check `project.dependencies` or `tool.poetry.dependencies` array for `"flask"` (case-insensitive)
-    - Return `true` if either check matches
-  - `fileFilter(filePath)`: returns `true` for `.py` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `decorated_definition` nodes whose decorator chain includes a `call` node matching `/^(app|bp|blueprint)\.(route|get|post|put|delete|patch|head|options)\s*\(/`
-    - For each matched decorated function:
-      - Emit kind `'route'`
-      - Name: the decorated function name
-      - Extract the route path string literal from the first decorator argument
-      - Extract HTTP methods from the `methods=[...]` keyword argument if present; default to `['GET']` if absent
-      - `frameworkMeta.http_methods`: string array of methods
-      - `frameworkMeta.route_path`: the extracted path string
-      - `frameworkMeta.flask_route: true`
-    - Scan for `class_definition` nodes whose base classes include `MethodView` or `View` (Flask class-based views):
-      - Emit kind `'view'`
-      - `frameworkMeta.flask_class_view: true`
-  - `enrichMetadata(symbol)`: no-op (route metadata is set during extraction)
-  - Register via `registerAdapter(flaskAdapter)` at module level
-
-**Key technical notes:**
-- Flask supports both `@app.route('/path')` and shorthand `@app.get('/path')`, `@app.post('/path')` — both patterns must be detected
-- Blueprint routes use a variable name that may not be `bp` — detect by checking if the variable was assigned from `Blueprint(...)` call in the same file. As a simpler heuristic: match any decorator whose method part matches `route|get|post|put|delete|patch`
-- Path parameters use `<type:name>` syntax (e.g. `<int:user_id>`) — emit the path as-is in `frameworkMeta.route_path`; normalise to `:name` format for the symbol `name` field
-
-**Verify:** Index `test/fixtures/flask-project/` (created in Task 60). Verify `@app.route('/users')` produces a `route` symbol. Verify `@app.get('/users/<int:id>')` produces a route. Verify a plain function without decorator is not extracted.
-
-**Tests:** `@app.route` with GET (default), `@app.route` with explicit methods, `@app.get` / `@app.post` shorthand, blueprint route, class-based view, non-route function (not extracted).
-
----
-
-## Task 45: FastAPI Adapter
-
-Extract route symbols from FastAPI applications. FastAPI's decorator API is nearly identical to Flask's shorthand decorators but detected from a different dependency.
-
-**Deliverables:**
-- `src/adapters/fastapi.ts` — implements `FrameworkAdapter`
-  - `name`: `'fastapi'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `requirements.txt` — check for `/^\s*fastapi[>=\s]/i`
-    - Read `pyproject.toml` — check dependencies for `"fastapi"` (case-insensitive)
-  - `fileFilter(filePath)`: `.py` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `decorated_definition` nodes whose decorator matches `/^(app|router|api)\.(get|post|put|delete|patch|options|head)\s*\(/`
-    - For each matched function:
-      - Emit kind `'route'`
-      - Extract path from first positional argument
-      - `frameworkMeta.http_method`: uppercase method name
-      - `frameworkMeta.route_path`: extracted path
-      - `frameworkMeta.fastapi_route: true`
-    - Scan for `class_definition` nodes inheriting from `APIRouter` — emit kind `'class'` with `frameworkMeta.fastapi_router: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(fastapiAdapter)` at module level
-
-**Key technical notes:**
-- FastAPI uses `APIRouter` for route grouping (analogous to Flask blueprints) — detect `router.get(...)` patterns with the same regex
-- FastAPI path parameters use `{param_name}` syntax (not Flask's `<type:name>`) — preserve as-is
-- Response models and dependencies (`Depends(...)`) are not extracted — they are type annotations, not symbols
-
-**Verify:** Index `test/fixtures/fastapi-project/`. Verify `@app.get('/items/{item_id}')` produces a route. Verify `APIRouter` usage produces routes. Verify async functions are handled identically to sync functions.
-
-**Tests:** `@app.get`, `@app.post`, `@router.get` (APIRouter), async route function, dependency injection (not extracted), non-route function (not extracted).
-
----
-
-## Task 46: Django Adapter
-
-Extract models, views, and URL routes from Django applications. Django's conventions are file-path-based (`models.py`, `views.py`, `urls.py`) making the adapter more file-aware than Flask/FastAPI.
-
-**Deliverables:**
-- `src/adapters/django.ts` — implements `FrameworkAdapter`
-  - `name`: `'django'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check `requirements.txt` or `pyproject.toml` for `django` or `Django`
-    - OR check for the presence of `manage.py` at the project root (Django's canonical marker file)
-  - `fileFilter(filePath)`:
-    - Returns `true` for any `.py` file (broad filter; extraction is scoped by content/path)
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-
-    **Models** (any `.py` file):
-    - Scan for `class_definition` nodes whose base class list includes `models.Model`, `Model`, or `BaseModel` (DRF)
-    - Emit kind `'model'`
-    - `frameworkMeta.django_model: true`
-
-    **Views** (any `.py` file):
-    - Function-based views: `decorated_definition` or `function_definition` nodes where the decorator includes `login_required`, `permission_required`, or `api_view` — emit kind `'view'` with `frameworkMeta.django_fbv: true`
-    - Class-based views: `class_definition` nodes inheriting from `View`, `APIView`, `ModelViewSet`, `ViewSet`, `GenericAPIView`, `ListAPIView`, `CreateAPIView`, `RetrieveAPIView`, `UpdateAPIView`, `DestroyAPIView`, or `ListCreateAPIView` — emit kind `'view'` with `frameworkMeta.django_cbv: true`
-
-    **URL patterns** (files named `urls.py`):
-    - Scan for `call` nodes matching `path(...)` or `re_path(...)` or `url(...)` at module level
-    - For each call: extract the first argument (route string) and second argument (view name)
-    - Emit kind `'route'`
-    - `frameworkMeta.django_url_pattern: true`, `frameworkMeta.route_path`, `frameworkMeta.view_name`
-
-    **Signal receivers** (any `.py` file):
-    - Scan for `decorated_definition` nodes whose decorator matches `receiver(...)` from `django.dispatch`
-    - Emit kind `'signal'`
-    - `frameworkMeta.django_signal: true`
-
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(djangoAdapter)` at module level
-
-**Key decisions:**
-- Model detection via inheritance is more reliable than filename detection (`models.py` is a convention, not a requirement)
-- URL patterns are only extracted from files literally named `urls.py` (or matching `*/urls.py`) to avoid false positives
-- DRF (Django REST Framework) viewsets and generic views are included in CBV detection — they are the dominant Django API pattern
-
-**Verify:** Index `test/fixtures/django-project/`. Verify `User(models.Model)` produces kind `'model'`. Verify a CBV inheriting `APIView` produces kind `'view'`. Verify `path('/users/', UserListView.as_view())` in `urls.py` produces kind `'route'`.
-
-**Tests:** `models.Model` subclass (model), `APIView` subclass (CBV view), `@login_required` function (FBV view), `path(...)` in urls.py (route), `@receiver(post_save)` (signal), plain class not inheriting Model (not extracted as model).
-
----
-
-## Task 47: Gin Adapter
-
-Extract route symbols from Gin web framework applications. Go's procedural routing uses method calls on the router, not decorators — the same call-expression scanning approach used by the Express adapter.
-
-**Deliverables:**
-- `src/adapters/gin.ts` — implements `FrameworkAdapter`
-  - `name`: `'gin'`
-  - `extensions()`: `[]` — `.go` files already handled by the Go handler
-  - `detect(projectRoot)`:
-    - Read `go.mod` if present — check for a line containing `github.com/gin-gonic/gin`
-  - `fileFilter(filePath)`: `.go` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan raw source bytes for call expressions matching the pattern:
-      `/<identifier>\.(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|Any)\s*\(/gi`
-    - For each match:
-      - Extract the route path string literal from the first argument (next string after the opening paren)
-      - Skip if the path is not a string literal (variable or expression — too dynamic)
-      - Emit kind `'route'`
-      - `frameworkMeta.http_method`: matched method name (uppercase)
-      - `frameworkMeta.route_path`: extracted path string
-      - `frameworkMeta.gin_route: true`
-    - Scan for `router.Group(...)` calls — extract group prefix string, apply as prefix to child routes in the same scope
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(ginAdapter)` at module level
-
-**Key technical notes:**
-- Go does not use decorators — route registration is via method calls on a `*gin.Engine` or `*gin.RouterGroup` variable
-- Route groups: `r.Group("/api")` returns a sub-router; routes registered on it are prefixed. Static detection of group nesting is approximated by proximity in source; don't over-engineer
-- Middleware registration: `r.Use(authMiddleware)` — emit kind `'middleware'` with `frameworkMeta.gin_middleware: true` only if the argument is a named function reference (not an inline function literal)
-
-**Verify:** Index `test/fixtures/gin-project/`. Verify `r.GET("/users", handler)` produces a route symbol. Verify `r.POST("/users", ...)` produces a route. Verify a non-route method call is not extracted.
-
-**Tests:** `r.GET`, `r.POST`, `r.PUT`, `r.DELETE`, `router.GET` (alternate variable name), dynamic path (`"/users/:id"`), group prefix, `r.Use` middleware.
-
----
-
-## Task 48: Echo Adapter
-
-Extract route symbols from Echo web framework applications. Structurally identical to the Gin adapter with different detection and method names.
-
-**Deliverables:**
-- `src/adapters/echo.ts` — implements `FrameworkAdapter`
-  - `name`: `'echo'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `go.mod` — check for `github.com/labstack/echo`
-  - `fileFilter(filePath)`: `.go` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Same regex approach as the Gin adapter: match `<identifier>.(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|Any)\s*\(`
-    - Extract path from first string argument
-    - Emit kind `'route'`
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.echo_route: true`
-    - Echo groups: `e.Group("/api")` — detect and apply prefix
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(echoAdapter)` at module level
-
-**Key technical notes:**
-- Echo's API is nearly identical to Gin's — the adapter is a thin wrapper around the same extraction logic. Extract the shared route-scanning logic into `src/adapters/go-router-utils.ts` if duplication becomes significant.
-- Echo middleware: `e.Use(middleware.Logger())` — same pattern as Gin middleware extraction
-
-**Verify:** Index `test/fixtures/echo-project/`. Verify `e.GET("/users", handler)` produces a route.
-
-**Tests:** Same cases as Gin adapter but with Echo variable names and import detection.
-
----
-
-## Task 49: Fiber Adapter
-
-Extract route symbols from Fiber web framework applications. Fiber's API mirrors Express.js closely but is written in Go.
-
-**Deliverables:**
-- `src/adapters/fiber.ts` — implements `FrameworkAdapter`
-  - `name`: `'fiber'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `go.mod` — check for `github.com/gofiber/fiber`
-  - `fileFilter(filePath)`: `.go` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Match `<identifier>.(Get|Post|Put|Delete|Patch|Head|Options|All)\s*\(` (Fiber uses title-case method names)
-    - Extract path string, emit kind `'route'`
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.fiber_route: true`
-    - Fiber groups: `app.Group("/api")` — detect prefix
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(fiberAdapter)` at module level
-
-**Key technical notes:**
-- Fiber's method names are title-case (`Get`, `Post`) unlike Gin/Echo (all-caps `GET`, `POST`) — regex must match both forms or be case-insensitive
-- Fiber middleware: `app.Use(...)` — same extraction pattern
-
-**Verify:** Index `test/fixtures/fiber-project/`. Verify `app.Get("/users", handler)` produces a route.
-
-**Tests:** `app.Get`, `app.Post`, `app.Group` prefix, middleware via `app.Use`.
-
----
-
-## Task 50: PHP Language Handler
-
-Add PHP as the first non-Go/Python new language handler in Phase 5. PHP's official tree-sitter grammar is mature and well-maintained.
-
-**Deliverables:**
-- Download and bundle `grammars/tree-sitter-php.wasm`
-  - Source: `tree-sitter-php` npm package
-  - Build: `npx tree-sitter build-wasm node_modules/tree-sitter-php` → copy output to `grammars/`
-- `src/handlers/php.ts` — implements `LanguageHandler`
-  - `extensions()`: `['.php']`
-  - `grammarPath()`: path to `tree-sitter-php.wasm`
-  - `extractSymbols(tree, source)`:
-    - PHP files begin with a `php_tag` node — skip it and iterate remaining top-level children
-    - `function_definition` → kind `'function'`
-    - `class_declaration` → kind `'class'`
-    - `interface_declaration` → kind `'interface'`
-    - `trait_declaration` → kind `'interface'` (PHP traits are closest to interfaces for navigation)
-    - `enum_declaration` → kind `'enum'` (PHP 8.1+)
-    - `method_declaration` inside `declaration_list` of a class/interface/trait → kind `'method'`, name = `ClassName::methodName`
-    - `const_declaration` → kind `'const'`
-    - `namespace_definition` → recurse into its body, applying namespace prefix to all extracted symbol names
-    - Visibility filter: `method_declaration` nodes — check `visibility_modifier` child for `public` or `protected`; skip `private`
-  - `extractImports(tree, source)`:
-    - `use_declaration` nodes → iterate `namespace_use_clause` children
-    - Each clause has a `qualified_name` child (the imported class path) and optionally a `namespace_aliasing_clause` (the alias after `as`)
-    - `specifier`: the qualified name text (e.g. `App\Http\Controllers\Controller`)
-    - `importedNames`: the simple class name (last segment of the qualified name)
-    - `resolvedPath`: `null` (Composer autoload — no local path resolution)
-  - `extractDocstring(node)`:
-    - Walk `previousNamedSibling` chain to find a `comment` node
-    - Must start with `/**` (PHP docblock)
-    - Strip `/**`, `*/`, and leading ` * ` from each line
-    - Return first sentence (up to first `.` or 200 chars)
-- Update `src/handlers/handler-registry.ts` — add entry: `'php' → ['.php']`
-- Update `src/index.ts` — call `registerHandler(new PhpHandler())` in bootstrap
-
-**Signature building:**
-- Functions: `function name(params): returnType`
-- Classes: `class Name extends Base implements Interface`
-- Methods: `public/protected function name(params): returnType`
-- Constants: `const NAME = value` or `public const NAME: Type = value`
-- Keep signatures under 120 chars; truncate parameter lists with `...` if needed
-
-**Key technical notes:**
-- PHP files may have content before `<?php` (e.g. HTML) — the grammar models this as `text` nodes before `php_tag`. Skip all nodes before and including the first `php_tag`.
-- Namespaces: `namespace App\Http\Controllers;` changes the fully-qualified name of all subsequent declarations. Track the current namespace string and prefix symbol names accordingly (e.g. `App\Http\Controllers\UserController`)
-- PHP 8 attributes (`#[Attribute]`) appear as `attribute_list` nodes preceding declarations — include the first attribute in the signature string but do not emit them as separate symbols
-- PHP 8.1 readonly properties and constructor promotion are inside `method_declaration` — handle `constructor_promotion` parameter nodes when extracting constructor signatures
-
-**Verify:** Index `test/fixtures/php-project/`. Verify classes, interfaces, methods (with visibility), constants, and namespace-qualified names are extracted correctly. Verify PHPDoc `/** */` docstrings are captured.
-
-**Tests:** Top-level function, class with public/protected/private methods (private skipped), interface, trait, enum, `const`, namespace declaration qualifying names, `use` import with alias, PHPDoc docstring.
-
----
-
-## Task 51: Laravel Adapter
-
-Extract routes, controllers, and Eloquent models from Laravel applications.
-
-**Deliverables:**
-- `src/adapters/laravel.ts` — implements `FrameworkAdapter`
-  - `name`: `'laravel'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `composer.json` — check `require` object for key `"laravel/framework"`
-  - `fileFilter(filePath)`:
-    - `routes/web.php`, `routes/api.php`, `routes/*.php` → route files
-    - `app/Http/Controllers/**/*.php` → controllers
-    - `app/Models/**/*.php` → Eloquent models
-    - `app/Http/Middleware/**/*.php` → middleware
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-
-    **Route files** (`routes/*.php`):
-    - Scan for `call` nodes matching `Route::(get|post|put|delete|patch|options|any)\s*\(`
-    - Extract path string literal (first argument) and handler (second argument — string or array or closure)
-    - Emit kind `'route'`
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.laravel_route: true`
-    - Also detect `Route::resource(name, Controller::class)` → emit multiple route symbols (index, show, store, update, destroy)
-    - Detect `Route::group(['prefix' => '/api'], ...)` — apply prefix to child routes
-
-    **Controllers** (`app/Http/Controllers/**`):
-    - Class inheriting `Controller` → emit kind `'class'` with `frameworkMeta.laravel_controller: true`
-    - Public methods inside controllers → emit kind `'view'` (they are request handlers)
-    - `frameworkMeta.laravel_action: true`
-
-    **Models** (`app/Models/**`):
-    - Class inheriting `Model` or `Illuminate\Database\Eloquent\Model` → emit kind `'model'`
-    - `frameworkMeta.laravel_model: true`
-
-    **Middleware** (`app/Http/Middleware/**`):
-    - Class with a `handle(Request $request, Closure $next)` method → emit kind `'middleware'`
-    - `frameworkMeta.laravel_middleware: true`
-
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(laravelAdapter)` at module level
-
-**Verify:** Index `test/fixtures/laravel-project/`. Verify `Route::get('/users', ...)` produces a route. Verify `User extends Model` produces kind `'model'`. Verify a controller's public methods produce kind `'view'`.
-
-**Tests:** `Route::get`, `Route::post`, `Route::resource` (multiple routes), route group with prefix, Eloquent model detection, controller action as `'view'`, middleware detection.
-
----
-
-## Task 52: Symfony Adapter
-
-Extract routes and controllers from Symfony applications. Symfony supports both annotation/attribute-based routing and YAML/XML config routing.
-
-**Deliverables:**
-- `src/adapters/symfony.ts` — implements `FrameworkAdapter`
-  - `name`: `'symfony'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `composer.json` — check `require` for `"symfony/framework-bundle"` or `"symfony/symfony"`
-  - `fileFilter(filePath)`: `src/**/*.php` (Symfony sources live in `src/`)
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Attribute-based routes** (PHP 8.0+ `#[Route(...)]`):
-      - Scan for `attribute_list` nodes containing `Route` attribute
-      - Extract `path` argument from the attribute
-      - Extract `methods` argument if present
-      - Emit kind `'route'` for each method in `methods` (or one route for no restriction)
-      - `frameworkMeta.symfony_route: true`, `frameworkMeta.route_path`, `frameworkMeta.http_method`
-    - **Annotation-based routes** (older `@Route(...)` in docblock):
-      - Scan `/** */` comment nodes for `@Route` annotation
-      - Same extraction as above but from the comment string
-    - **Services / Controllers**:
-      - Class annotated with `#[AsController]` or inheriting `AbstractController` → emit kind `'class'` with `frameworkMeta.symfony_controller: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(symfonyAdapter)` at module level
-
-**Key technical notes:**
-- Symfony's YAML/XML route config files are out of scope for Phase 5 — only PHP attribute and annotation routing
-- Symfony 6+ strongly prefers PHP attributes over annotations — annotations remain supported for backward compat
-- Entity classes (`@ORM\Entity` or `#[ORM\Entity]`) could be emitted as `'model'` — defer to a future task; not enough ROI to add in Phase 5
-
-**Verify:** Index `test/fixtures/symfony-project/`. Verify `#[Route('/users', methods: ['GET'])]` produces a route symbol. Verify a class annotated `#[AsController]` produces a controller symbol.
-
-**Tests:** `#[Route]` with path only, `#[Route]` with methods array, `@Route` annotation in docblock, `#[AsController]` class, non-controller class (not extracted as controller).
-
----
-
-## Task 53: Ruby Language Handler
-
-Add Ruby as the fourth new language handler. Ruby's expression-based AST requires context tracking to distinguish top-level `def` from class-level `def`.
-
-**Deliverables:**
-- Download and bundle `grammars/tree-sitter-ruby.wasm`
-  - Source: `tree-sitter-ruby` npm package (official tree-sitter grammar)
-  - Build: `npx tree-sitter build-wasm node_modules/tree-sitter-ruby`
-- `src/handlers/ruby.ts` — implements `LanguageHandler`
-  - `extensions()`: `['.rb']`
-  - `grammarPath()`: path to `tree-sitter-ruby.wasm`
-  - `extractSymbols(tree, source)`:
-    - Use a recursive `walkNode(node, context: { className: string | null })` helper
-    - `method` node at root scope (no class ancestor) → kind `'function'`
-    - `method` node inside a `class` or `module` body → kind `'method'`, name = `ClassName#methodName`
-    - `singleton_method` node (e.g. `def self.foo`) → kind `'method'`, name = `ClassName.methodName`
-    - `class` node → kind `'class'`, recurse into body with updated className context
-    - `module` node → kind `'type'`, recurse into body with updated className context (modules are namespaces + mixins)
-    - Constants: `assignment` nodes at class/module scope where the LHS is a `constant` node (uppercase identifier) → kind `'const'`
-    - Skip `alias` nodes, `attr_accessor`/`attr_reader`/`attr_writer` call nodes (too noisy, not true definitions)
-  - `extractImports(tree, source)`:
-    - Scan for `call` nodes at root scope where the `method` child text is `require` or `require_relative`
-    - First argument must be a `string` node
-    - `specifier`: the string value (strip quotes)
-    - `resolvedPath`: for `require_relative` apply relative resolution against the file path; for `require` return `null` (gem or stdlib)
-    - `importedNames`: `[]` (Ruby `require` brings the whole file into scope, not named symbols)
-    - `isTypeOnly`: always `false`
-  - `extractDocstring(node)`:
-    - Walk `previousNamedSibling` chain to find consecutive `comment` nodes (`#` prefix)
-    - Strip `# ` prefix, concatenate, return first paragraph
-
-**Signature building:**
-- Top-level methods: `def name(params)`
-- Class methods: `def self.name(params)`
-- Instance methods: `def name(params)`
-- Classes: `class Name < SuperClass` or `class Name`
-- Modules: `module Name`
-- Constants: `NAME = value` (truncate if > 80 chars)
-- Keep signatures under 120 chars
-
-**Key technical notes:**
-- `method` node has a `name` child (identifier) and optionally `method_parameters`
-- `singleton_method` has an `object` child (the receiver, typically `self`) and a `name` child
-- Context tracking: when entering a `class` or `module` node, push its name to a context stack; pop when leaving. The class name for method qualification is the top of the stack.
-- Ruby does not have access modifiers like Java/PHP. `public`, `private`, and `protected` are method calls that affect subsequent method definitions — do not attempt to track visibility in Phase 5; extract all `method` nodes
-- `module_function` pattern: some modules use `module_function` to make methods available as both instance and module methods — treat as a regular method
-
-**Verify:** Index `test/fixtures/ruby-project/`. Verify top-level `def` is kind `'function'`, class-level `def` is kind `'method'`, `def self.foo` is kind `'method'` with name `ClassName.foo`. Verify `# comment` preceding a method is captured as docstring.
-
-**Tests:** Top-level `def`, class with instance methods, `def self.` singleton method, module with methods, constant assignment, `require` import, `require_relative` import, Ruby comment docstring, nested class method name qualification.
-
----
-
-## Task 54: Rails Adapter
-
-Extract models, controllers, and routes from Ruby on Rails applications. Rails follows strict file-path conventions making detection straightforward.
-
-**Deliverables:**
-- `src/adapters/rails.ts` — implements `FrameworkAdapter`
-  - `name`: `'rails'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `Gemfile` — check for line matching `/^\s*gem\s+['"]rails['"]/m`
-  - `fileFilter(filePath)`:
-    - `app/models/**/*.rb` → models
-    - `app/controllers/**/*.rb` → controllers
-    - `app/jobs/**/*.rb` → background jobs
-    - `config/routes.rb` → routes
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-
-    **Models** (`app/models/**`):
-    - Class inheriting from `ApplicationRecord`, `ActiveRecord::Base`, or `ActiveModel::Model` → emit kind `'model'`
-    - `frameworkMeta.rails_model: true`
-    - Detect `has_many`, `belongs_to`, `has_one` call nodes → `frameworkMeta.associations: string[]`
-
-    **Controllers** (`app/controllers/**`):
-    - Class inheriting from `ApplicationController` or `ActionController::Base` → emit kind `'class'` with `frameworkMeta.rails_controller: true`
-    - Public `method` nodes inside the controller → emit kind `'view'` (Rails actions are request handlers)
-    - `frameworkMeta.rails_action: true`
-
-    **Routes** (`config/routes.rb`):
-    - Scan for `call` nodes matching `(get|post|put|delete|patch)\s*\(` → emit kind `'route'`
-    - Scan for `resources :name` and `resource :name` → emit `route` symbols for each REST action
-    - Scan for `namespace :name` → apply prefix to child routes
-    - `frameworkMeta.rails_route: true`, `frameworkMeta.route_path`, `frameworkMeta.http_method`
-
-    **Jobs** (`app/jobs/**`):
-    - Class inheriting `ApplicationJob` or `ActiveJob::Base` → emit kind `'class'` with `frameworkMeta.rails_job: true`
-
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(railsAdapter)` at module level
-
-**Verify:** Index `test/fixtures/rails-project/`. Verify `User < ApplicationRecord` produces kind `'model'`. Verify `UsersController < ApplicationController` produces kind `'class'` with controller metadata. Verify controller public methods produce kind `'view'`. Verify `get '/users', to: 'users#index'` in `routes.rb` produces a route.
-
-**Tests:** Model with `has_many`, controller with actions, `get`/`post` route, `resources :users` (generates CRUD routes), `namespace` prefix.
-
----
-
-## Task 55: Sinatra Adapter
-
-Extract route symbols from Sinatra applications. Sinatra's DSL is closer to Flask/Express than to Rails.
-
-**Deliverables:**
-- `src/adapters/sinatra.ts` — implements `FrameworkAdapter`
-  - `name`: `'sinatra'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `Gemfile` — check for `/gem\s+['"]sinatra['"]/`
-    - OR check for `require 'sinatra'` / `require "sinatra"` in any `.rb` file at root level (shallow scan)
-  - `fileFilter(filePath)`: `.rb` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `call` nodes matching the Sinatra route DSL:
-      - `(get|post|put|delete|patch)\s+\(?\s*['"]` at top-level or inside a class body
-    - Extract the path string literal
-    - Emit kind `'route'`
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.sinatra_route: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(sinatraAdapter)` at module level
-
-**Key technical notes:**
-- Sinatra routes can be at top-level (classic style) or inside a class inheriting `Sinatra::Base` (modular style) — the regex captures both
-- Sinatra path parameters use `:param` syntax, same as Express — preserve as-is
-
-**Verify:** Index `test/fixtures/sinatra-project/` (a minimal fixture with classic and modular style). Verify `get '/users' do` produces a route.
-
-**Tests:** Classic style `get`, modular style `post` inside class, dynamic path (`:id`), non-route call (not extracted).
-
----
-
-## Task 56: Kotlin Language Handler
-
-Add Kotlin as the fifth new language handler. Kotlin's grammar is community-maintained but stable and widely used (Neovim, VS Code Kotlin plugins).
-
-**Deliverables:**
-- Download and bundle `grammars/tree-sitter-kotlin.wasm`
-  - Source: `tree-sitter-kotlin` npm package
-  - Build: `npx tree-sitter build-wasm node_modules/tree-sitter-kotlin`
-- `src/handlers/kotlin.ts` — implements `LanguageHandler`
-  - `extensions()`: `['.kt', '.kts']`
-  - `grammarPath()`: path to `tree-sitter-kotlin.wasm`
-  - `extractSymbols(tree, source)`:
-    - `function_declaration` at top-level → kind `'function'`
-    - `class_declaration` → kind `'class'`
-      - `data class`, `sealed class`, `abstract class` are all `class_declaration` nodes — check `class_modifiers` child for distinguishing modifiers; emit all as `'class'`
-    - `interface_declaration` or `class_declaration` with `interface` keyword → kind `'interface'`
-    - `object_declaration` (Kotlin singleton) → kind `'class'` with `frameworkMeta.kotlin_object: true`
-    - `enum_class_declaration` → kind `'enum'`
-    - `type_alias` → kind `'type'`
-    - `function_declaration` inside `class_body` or `object_declaration` body → kind `'method'`, name = `ClassName.methodName`
-    - `companion_object` body `function_declaration` → kind `'method'`, name = `ClassName.methodName` (or `ClassName.Companion.methodName` if companion is named)
-    - `property_declaration` at top-level with `val` and uppercase name → kind `'const'`
-    - Visibility: extract `visibility_modifier` child from `modifiers` node; skip `private` and `internal`; include `public`, `protected`, and declarations with no modifier (Kotlin default is `public`)
-  - `extractImports(tree, source)`:
-    - `import_header` nodes under `source_file`
-    - `specifier`: the full qualified import path (e.g. `io.ktor.server.application.Application`)
-    - `importedNames`: last segment (simple class/function name)
-    - `isTypeOnly`: `false` (Kotlin has no type-only imports)
-    - `resolvedPath`: `null` (Gradle/Maven classpath)
-  - `extractDocstring(node)`:
-    - Look for `multiline_comment` node immediately preceding the declaration starting with `/**` (KDoc)
-    - OR `line_comment` nodes (`//`) directly preceding — less common in Kotlin but valid
-    - Strip `/**`, `*/`, and ` * ` prefixes; return first paragraph
-
-**Signature building:**
-- Functions: `fun name(params): ReturnType`
-- Classes: `[data/sealed/abstract] class Name(primaryConstructorParams) : SuperType`
-- Interfaces: `interface Name`
-- Object declarations: `object Name : SuperType`
-- Methods: `fun name(params): ReturnType` (class context implied by name prefix)
-- Type aliases: `typealias Name = Type`
-- Constants: `val NAME: Type = value`
-- Keep signatures under 120 chars
-
-**Key technical notes:**
-- Kotlin primary constructors are part of the `class_declaration` header (not a separate node) — extract constructor params for the class signature
-- Annotations appear as `annotation` children inside `modifiers` — include the first annotation in the signature (e.g. `@Component class UserService`)
-- Extension functions: `fun ReceiverType.methodName(...)` — the receiver type is a `user_type` child before the function name; emit as `'function'` with name `ReceiverType.methodName`
-- `suspend` functions: `suspend` is a `function_modifier` inside `modifiers` — include `suspend` in the signature
-
-**Verify:** Index `test/fixtures/kotlin-project/`. Verify `fun topLevel()` is kind `'function'`, class method is kind `'method'`, data class is kind `'class'`, companion object function is kind `'method'`. Verify KDoc comment is captured.
-
-**Tests:** Top-level fun, class with methods, data class, sealed class, object declaration, companion object with function, extension function, `typealias`, import declaration, KDoc comment.
-
----
-
-## Task 57: Ktor Adapter
-
-Extract route symbols from Ktor server applications. Ktor uses a Kotlin DSL for routing — structured function calls that define route hierarchies.
-
-**Deliverables:**
-- `src/adapters/ktor.ts` — implements `FrameworkAdapter`
-  - `name`: `'ktor'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `build.gradle` or `build.gradle.kts` — check for string `io.ktor`
-    - Read `pom.xml` if present — check for `<groupId>io.ktor</groupId>`
-  - `fileFilter(filePath)`: `.kt` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `call_expression` nodes matching Ktor routing DSL:
-      - `route(path) { ... }` → container, extract path, apply as prefix to nested routes
-      - `get(path) { ... }`, `post(path) { ... }`, `put(...)`, `delete(...)`, `patch(...)`, `head(...)`, `options(...)` → emit kind `'route'`
-      - `authenticate { ... }` blocks — recurse to extract nested routes, add `frameworkMeta.authenticated: true`
-    - Extract path string from first argument of each HTTP method call
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.ktor_route: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(ktorAdapter)` at module level
-
-**Key technical notes:**
-- Ktor routes are defined inside `routing { ... }` blocks (an `Application` extension function call) — the DSL is nested via trailing lambdas
-- Path parameters use `{param}` syntax — preserve as-is
-- Ktor 2.x introduced a type-safe routing API — out of scope for Phase 5; handle only string-literal routes
-
-**Verify:** Index `test/fixtures/ktor-project/`. Verify `get("/users") { ... }` produces a route. Verify nested `route("/api") { get("/users") ... }` produces a route with combined path `/api/users`.
-
-**Tests:** `get`/`post` with path, nested `route` prefix, `authenticate` block wrapper, non-route call (not extracted).
-
----
-
-## Task 58: Spring Kotlin Adapter
-
-Extract routes, controllers, and services from Spring Boot applications written in Kotlin. Spring uses the same decorator-based model as its Java equivalent.
-
-**Deliverables:**
-- `src/adapters/spring-kotlin.ts` — implements `FrameworkAdapter`
-  - `name`: `'spring-kotlin'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Read `build.gradle` or `build.gradle.kts` — check for `org.springframework.boot`
-    - OR read `pom.xml` — check for `<artifactId>spring-boot-starter</artifactId>`
-  - `fileFilter(filePath)`: `.kt` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `class_declaration` nodes with annotations:
-      - `@RestController` or `@Controller` → emit kind `'class'` with `frameworkMeta.spring_controller: true`
-        - Scan class body for `function_declaration` nodes with `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, `@PatchMapping`, `@RequestMapping` annotations → emit kind `'route'`
-        - Extract path from annotation argument; combine with class-level `@RequestMapping` prefix if present
-      - `@Service` → emit kind `'class'` with `frameworkMeta.spring_service: true`
-      - `@Component` → emit kind `'class'` with `frameworkMeta.spring_component: true`
-      - `@Repository` → emit kind `'class'` with `frameworkMeta.spring_repository: true`
-    - `frameworkMeta.http_method`, `frameworkMeta.route_path` for route symbols
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(springKotlinAdapter)` at module level
-
-**Key technical notes:**
-- Spring Kotlin supports both annotation-style and functional routing DSL — only annotation style in Phase 5
-- `@RequestMapping` at class level provides a base path prefix — combine with method-level mapping for full path
-- `@PathVariable` and `@RequestParam` are parameter annotations, not route symbols — ignore
-
-**Verify:** Index `test/fixtures/spring-kotlin-project/`. Verify `@RestController` with `@GetMapping("/users")` produces a route symbol. Verify `@Service` class produces kind `'class'` with service metadata.
-
-**Tests:** `@RestController` with `@GetMapping`, class-level `@RequestMapping` prefix combined with method-level mapping, `@Service`, `@Repository`, non-Spring class (no Spring metadata).
-
----
-
-## Task 59: C Language Handler
-
-Add C as the sixth new language handler in Phase 5. C's grammar is official and its AST is flat — the simplest handler in this phase.
-
-**Deliverables:**
-- Download and bundle `grammars/tree-sitter-c.wasm`
-  - Source: `tree-sitter-c` npm package (official tree-sitter grammar)
-  - Build: `npx tree-sitter build-wasm node_modules/tree-sitter-c`
-- `src/handlers/c.ts` — implements `LanguageHandler`
-  - `extensions()`: `['.c', '.h']`
-  - `grammarPath()`: path to `tree-sitter-c.wasm`
-  - `extractSymbols(tree, source)`:
-    - `function_definition` → kind `'function'`
-      - Extract name by unwrapping `function_declarator` → may be nested inside `pointer_declarator`; recurse to find the `identifier` leaf
-      - Skip if `declaration_specifiers` contains `storage_class_specifier` with text `static`
-    - `declaration` with `function_declarator` (forward declarations in headers) → kind `'function'`
-    - `type_definition` containing `struct_specifier` → kind `'struct'`
-      - Name: the identifier after the closing `}` (typedef alias) or inside the struct tag
-    - `type_definition` containing `union_specifier` → kind `'struct'` (union is a data-layout variant)
-    - `type_definition` containing `enum_specifier` → kind `'enum'`
-    - `type_definition` with bare `type_identifier` → kind `'type'` (typedef alias)
-    - `preproc_def` (object-like `#define NAME value`) → kind `'macro'`
-      - Skip `preproc_function_def` (function-like macros — `#define MAX(a,b) ...`) — too noisy
-      - Skip macros with no value (header guards like `#define HEADER_H`)
-    - `struct_specifier` at top-level without typedef → kind `'struct'` (anonymous or tagged struct)
-    - `enum_specifier` at top-level → kind `'enum'`
-  - `extractImports(tree, source)`:
-    - `preproc_include` nodes → specifier = the included path (strip `<>` or `""`)
-    - `resolvedPath`: for `"local.h"` (double-quoted) attempt relative resolution; for `<system.h>` (angle-bracket) return `null`
-    - `importedNames`: `[]` (C `#include` brings the whole header into scope)
-    - `isTypeOnly`: `false`
-  - `extractDocstring(node)`:
-    - Walk `previousNamedSibling` to find a `comment` node
-    - Handle both `//` and `/* */` style
-    - Strip prefixes, return first sentence
-
-**Signature building:**
-- Functions: `returnType name(params)` — extract from `declaration_specifiers` + `function_declarator` source slice
-- Structs: `struct Name { field1; field2; ... }` (show first 2 fields; `{ ... }` if more)
-- Enums: `enum Name { CONSTANT1, CONSTANT2, ... }` (show first 3 constants)
-- Typedefs: `typedef originalType Name`
-- Macros: `#define NAME value`
-- Keep signatures under 120 chars
-
-**Key technical notes:**
-- C function names can be nested inside pointer declarators: `int *(*func_ptr)(int)` — the `extractFunctionName` helper must recursively unwrap `pointer_declarator` and `parenthesized_declarator` nodes to reach the `identifier`
-- Header files (`.h`): forward declarations are common and should be indexed (they define the public API). Do not skip `.h` files.
-- `static` functions are internal to the translation unit — skip them (they are implementation details, not API surface)
-- Variadic functions (`...` parameter) — handle in signature building; the AST has a `...` child inside the parameter list
-
-**Verify:** Index `test/fixtures/c-project/`. Verify non-static functions, typedef structs, enums, and object-like macros are extracted. Verify static functions are skipped. Verify `#include "local.h"` resolves locally.
-
-**Tests:** Non-static function, static function (skipped), pointer-return function (name extraction), typedef struct, anonymous struct, typedef enum, `#define` object macro, `#define` function macro (skipped), `#include` local and system.
-
----
-
-## Task 60: Phase 5 Test Fixtures and Integration Tests
-
-Validate the full Phase 5 pipeline end-to-end across all new handlers, adapters, and the SymbolKind extension.
-
-**Deliverables:**
-
-- `test/fixtures/flask-project/` — minimal Flask application:
-  - `requirements.txt` with `Flask>=3.0`
-  - `app.py` — `@app.route`, `@app.get`, `@app.post` routes, one class-based view
-  - `blueprints/users.py` — Blueprint with routes
-  - `models/user.py` — plain Python class (not extracted as model — no ORM)
-
-- `test/fixtures/fastapi-project/` — minimal FastAPI application:
-  - `requirements.txt` with `fastapi>=0.100`
-  - `main.py` — `@app.get`, `@app.post`, `@router.get` (APIRouter)
-  - `models.py` — Pydantic models (BaseModel subclasses, not ORM)
-
-- `test/fixtures/django-project/` — minimal Django application:
-  - `requirements.txt` with `Django>=4.2`
-  - `manage.py` (empty — triggers detection)
-  - `myapp/models.py` — `User(models.Model)`, `Post(models.Model)`
-  - `myapp/views.py` — function-based view with `@login_required`, class-based `APIView`
-  - `myapp/urls.py` — `path(...)` route definitions
-  - `myapp/signals.py` — `@receiver(post_save)` signal handler
-
-- `test/fixtures/gin-project/` — minimal Gin application:
-  - `go.mod` with `require github.com/gin-gonic/gin v1.9.1`
-  - `main.go` — `r.GET`, `r.POST`, `r.Group` routes
-
-- `test/fixtures/php-project/` — representative PHP project:
-  - `src/Controller/UserController.php` — class with public methods, namespace
-  - `src/Model/User.php` — plain PHP class
-  - `src/Service/AuthService.php` — interface + implementation
-  - `tests/UserControllerTest.php` — test class (lower priority)
-
-- `test/fixtures/laravel-project/` — minimal Laravel application:
-  - `composer.json` with `laravel/framework`
-  - `routes/web.php` — `Route::get`, `Route::resource`
-  - `app/Models/User.php` — `User extends Model`
-  - `app/Http/Controllers/UserController.php` — extends `Controller`
-
-- `test/fixtures/ruby-project/` — representative Ruby project:
-  - `lib/auth_service.rb` — class with instance and singleton methods, docstrings
-  - `lib/user.rb` — class with constants
-  - `lib/utils.rb` — top-level functions, `require_relative`
-
-- `test/fixtures/rails-project/` — minimal Rails application:
-  - `Gemfile` with `gem 'rails'`
-  - `app/models/user.rb` — `User < ApplicationRecord` with `has_many`
-  - `app/controllers/users_controller.rb` — `UsersController < ApplicationController`
-  - `config/routes.rb` — `get`, `resources`
-
-- `test/fixtures/kotlin-project/` — representative Kotlin project:
-  - `src/main/kotlin/AuthService.kt` — class with methods, KDoc
-  - `src/main/kotlin/models/User.kt` — data class
-  - `src/main/kotlin/utils/Extensions.kt` — extension functions
-
-- `test/fixtures/ktor-project/` — minimal Ktor application:
-  - `build.gradle.kts` with `io.ktor:ktor-server-core`
-  - `src/main/kotlin/Application.kt` — `get`, `post`, `route` DSL
-
-- `test/fixtures/c-project/` — representative C project:
-  - `src/auth.c` + `include/auth.h` — functions, structs, forward declarations
-  - `src/utils.c` — static functions (should be skipped), non-static helpers
-  - `include/constants.h` — `#define` macros, typedef structs, enums
-
-- Integration tests `test/integration/phase5.test.ts`:
-  1. Flask: `@app.route('/users')` produces route, `@app.get('/users/<int:id>')` produces route with path
-  2. Flask: plain function without decorator not extracted as route
-  3. FastAPI: `@app.get('/items/{id}')` produces route, async route handled
-  4. Django: `User(models.Model)` produces kind `'model'`, `@login_required` FBV produces kind `'view'`
-  5. Django: `path('/users/', ...)` in `urls.py` produces kind `'route'`
-  6. Django: `@receiver(post_save)` produces kind `'signal'`
-  7. Gin: `r.GET("/users", handler)` produces route, non-route call not extracted
-  8. PHP handler: class with public/protected/private methods — private skipped
-  9. PHP handler: namespace prefix applied to class names
-  10. Laravel: `Route::get('/users', ...)` produces route, `User extends Model` produces `'model'`
-  11. Ruby handler: top-level `def` is kind `'function'`, class-level `def` is kind `'method'`
-  12. Ruby handler: `# comment` docstring captured
-  13. Rails: `User < ApplicationRecord` produces kind `'model'`, controller action produces kind `'view'`
-  14. Kotlin handler: `data class` produces kind `'class'`, companion object function produces kind `'method'`
-  15. Ktor: `get("/users") { }` produces route, nested `route` prefix combined
-  16. C handler: non-static function extracted, static function skipped, `#define` macro produces kind `'macro'`
-  17. C handler: typedef struct produces kind `'struct'`
-  18. SymbolKind: `search-symbols` with `kind: 'model'` returns only model symbols across all fixtures
-  19. SymbolKind: `search-symbols` with `kind: 'macro'` returns only C macros
-  20. Full suite regression: all Phase 1–4 tests still green
-
-- **Performance benchmark** `test/benchmarks/phase5.bench.ts`:
-  - Index each language fixture, record time and symbol count
-  - Compare against jCodeMunch baseline on Express.js repo using same 5 queries from `reference/jcodemunch-mcp/benchmarks/tasks.json`
-  - Report token efficiency ratio: PureContext search tokens vs. baseline full-file tokens
-
-**Verify:** `npm run test` passes entirely — all Phase 1–5 tests green. No regressions.
-
----
-
-## Order of Execution
-
-```
-Task 43: Extend SymbolKind                 ██░░░░░░░░ Foundation
-Task 44: Flask adapter                     ███░░░░░░░ Python/Go frameworks
-Task 45: FastAPI adapter                   ███░░░░░░░ Python/Go frameworks
-Task 46: Django adapter                    ████░░░░░░ Python/Go frameworks
-Task 47: Gin adapter                       ████░░░░░░ Python/Go frameworks
-Task 48: Echo adapter                      ████░░░░░░ Python/Go frameworks
-Task 49: Fiber adapter                     █████░░░░░ Python/Go frameworks
-Task 50: PHP language handler              ██████░░░░ PHP
-Task 51: Laravel adapter                   ███████░░░ PHP
-Task 52: Symfony adapter                   ███████░░░ PHP
-Task 53: Ruby language handler             ████████░░ Ruby
-Task 54: Rails adapter                     █████████░ Ruby
-Task 55: Sinatra adapter                   █████████░ Ruby
-Task 56: Kotlin language handler           █████████░ Kotlin
-Task 57: Ktor adapter                      ██████████ Kotlin
-Task 58: Spring Kotlin adapter             ██████████ Kotlin
-Task 59: C language handler                ██████████ C
-Task 60: Fixtures + integration tests      ██████████ Polish
-```
-
-Tasks 44–49 (Python/Go framework adapters) are fully independent of each other and of the new handlers — they can be developed in parallel or in any order. Tasks 50–52 (PHP + adapters) form a dependency chain: 50 must be complete before 51 and 52. The same applies to 53–55 (Ruby) and 56–58 (Kotlin). Task 59 (C) is independent of all language groups and can be worked at any point after Task 43. Task 60 requires all previous tasks.
-
-**After Phase 5 is complete**, move to Phase 6: C++ handler, Lua handler, Dart handler, and Flutter adapter.