diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4aca757b7d..20fdaf8c0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -132,6 +132,9 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `codegraph_explore` now spells out the dynamic-dispatch relationships of the symbols you ask about — e.g. "the closures registered here are run by `didCompleteTask`" — so the indirect hops you'd otherwise grep to reconstruct are listed alongside the call flow.
 - `codegraph_explore` answers multi-phase questions that span a large "god file" far more completely. For a flow like "build, send, and validate a request" — where one big file holds the build chain and the validate logic lives in others — it now keeps every method *on the flow path* in full, collapses the file's off-path methods to one-line signatures, and guarantees each phase's defining file is shown (instead of truncating at a fixed size and dropping whichever phase came last, which sent you to read it by hand). Incidental files that merely name-drop the flow are still trimmed, so the response stays focused on the code that answers the question.
 - CodeGraph is usable as an embedded library again: `require("@colbymchenry/codegraph")` and `import` now resolve the programmatic API — the `CodeGraph` class plus building blocks like `DatabaseConnection`, `QueryBuilder`, `initGrammars`, and `FileLock` — so you can drive the graph directly from your own app (for example an Electron process) instead of only through the CLI or MCP server. Embedding runs on your own runtime, so it needs Node 22.5+ for the built-in SQLite. (#354)
+- Symfony: compiled DI containers now have routes extracted from `$routes->add(...)` calls using tree-sitter AST — route paths, names, controller references, and HTTP methods captured from the compiled router cache.
+- Symfony: `methods:` on `#[Route]` now handles PHP constant references like `[Request::METHOD_GET]` (extracts `GET` from the constant name).
+- Symfony: `defaults:` and `requirements:` on `#[Route]` now handle PHP short array syntax (`['key' => 'val']`) alongside the existing `{key: val}` dict syntax.
 
 ### Fixes
 
diff --git a/__tests__/frameworks.test.ts b/__tests__/frameworks.test.ts
index c0e8749089..d45bc09488 100644
--- a/__tests__/frameworks.test.ts
+++ b/__tests__/frameworks.test.ts
@@ -1597,3 +1597,718 @@ export class UsersController {
     expect(references.map((r) => r.referenceName)).toEqual(['real']);
   });
 });
+
+import { symfonyResolver } from '../src/resolution/frameworks/symfony';
+
+describe('symfonyResolver.extract — PHP 8 attributes', () => {
+  it('extracts route from #[Route] attribute with path and method', () => {
+    const src = `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/', name: 'blog_index', methods: ['GET'])]
+    public function index(): Response {
+        return \$this->render('blog/index.html.twig');
+    }
+}
+`;
+    const { nodes, references } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].kind).toBe('route');
+    expect(nodes[0].name).toBe('GET /blog/');
+    expect(references[0].referenceName).toBe('index');
+    expect(references[0].referenceKind).toBe('references');
+    expect(references[0].fromNodeId).toBe(nodes[0].id);
+  });
+
+  it('joins class-level #[Route] prefix with method path', () => {
+    const src = `<?php
+#[Route('/admin/post')]
+class BlogController {
+    #[Route('/', name: 'admin_index', methods: ['GET'])]
+    public function index(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/Admin/BlogController.php', src);
+    expect(nodes[0].name).toBe('GET /admin/post/');
+  });
+
+  it('extracts multiple routes per controller with distinct paths', () => {
+    const src = `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/{slug}', name: 'blog_post', methods: ['GET'])]
+    public function postShow(): Response {}
+
+    #[Route('/search', name: 'blog_search', methods: ['GET'])]
+    public function search(): Response {}
+}
+`;
+    const { nodes, references } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    expect(nodes).toHaveLength(2);
+    expect(nodes.map(n => n.name)).toEqual(['GET /blog/{slug}', 'GET /blog/search']);
+    expect(references.map(r => r.referenceName)).toEqual(['postShow', 'search']);
+  });
+
+  it('defaults method to ANY when no methods attribute specified', () => {
+    const src = `<?php
+#[Route('/login')]
+class SecurityController {
+    #[Route('/login', name: 'security_login')]
+    public function login(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/SecurityController.php', src);
+    expect(nodes[0].name).toBe('ANY /login/login');
+  });
+
+  it('handles multiple HTTP methods', () => {
+    const src = `<?php
+#[Route('/admin/post')]
+class BlogController {
+    #[Route('/new', name: 'admin_post_new', methods: ['GET', 'POST'])]
+    public function new(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/Admin/BlogController.php', src);
+    expect(nodes).toHaveLength(2);
+    expect(nodes.map(n => n.name)).toEqual(['GET /admin/post/new', 'POST /admin/post/new']);
+  });
+
+  it('extracts with no class-level prefix (bare #[Route] on methods)', () => {
+    const src = `<?php
+class DefaultController {
+    #[Route('/', name: 'homepage')]
+    public function index(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/DefaultController.php', src);
+    expect(nodes[0].name).toBe('ANY /');
+  });
+
+  it('handles methods: with PHP constant refs like Request::METHOD_GET', () => {
+    const src = `<?php
+#[Route('/api')]
+class ApiController {
+    #[Route('/entries', name: 'api_entries', methods: [Request::METHOD_GET])]
+    public function list(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/ApiController.php', src);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].name).toBe('GET /api/entries');
+  });
+
+  it('handles mixed methods: with strings and PHP constants', () => {
+    const src = `<?php
+#[Route('/api')]
+class MixedController {
+    #[Route('/items/{id}', name: 'api_item', methods: ['GET', Request::METHOD_HEAD])]
+    public function item(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/MixedController.php', src);
+    expect(nodes).toHaveLength(2);
+    expect(nodes.map(n => n.name)).toEqual(['GET /api/items/{id}', 'HEAD /api/items/{id}']);
+  });
+});
+
+describe('symfonyResolver.detect', () => {
+  const baseContext = {
+    getNodesInFile: () => [],
+    getNodesByName: () => [],
+    getNodesByQualifiedName: () => [],
+    getNodesByKind: () => [],
+    fileExists: () => false,
+    readFile: () => null,
+    getProjectRoot: () => '/test',
+    getAllFiles: () => [],
+    getNodesByLowerName: () => [],
+    getImportMappings: () => [],
+  };
+
+  it('detects symfony/framework-bundle in composer.json require', () => {
+    const context = {
+      ...baseContext,
+      readFile: (p: string) =>
+        p === 'composer.json'
+          ? JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+          : null,
+    };
+    expect(symfonyResolver.detect(context as any)).toBe(true);
+  });
+
+  it('detects symfony/symfony in composer.json require-dev', () => {
+    const context = {
+      ...baseContext,
+      readFile: (p: string) =>
+        p === 'composer.json'
+          ? JSON.stringify({ 'require-dev': { 'symfony/symfony': '^5.4' } })
+          : null,
+    };
+    expect(symfonyResolver.detect(context as any)).toBe(true);
+  });
+
+  it('detects by bin/console + config/ fallback', () => {
+    const context = {
+      ...baseContext,
+      fileExists: (p: string) => p === 'bin/console' || p === 'config/',
+    };
+    expect(symfonyResolver.detect(context as any)).toBe(true);
+  });
+
+  it('returns false for non-Symfony project', () => {
+    const context = {
+      ...baseContext,
+      readFile: (p: string) =>
+        p === 'composer.json'
+          ? JSON.stringify({ require: { 'laravel/framework': '^10.0' } })
+          : null,
+    };
+    expect(symfonyResolver.detect(context as any)).toBe(false);
+  });
+});
+
+describe('symfonyResolver.resolve', () => {
+  const baseContext = {
+    getNodesInFile: () => [],
+    getNodesByName: () => [],
+    getNodesByQualifiedName: () => [],
+    getNodesByKind: () => [],
+    fileExists: () => false,
+    readFile: () => null,
+    getProjectRoot: () => '/test',
+    getAllFiles: () => [],
+    getNodesByLowerName: () => [],
+    getImportMappings: () => [],
+  };
+
+  it('resolves Controller::method reference', () => {
+    const classNode: Node = {
+      id: 'class:src/Controller/BlogController.php:10:BlogController:50',
+      kind: 'class',
+      name: 'BlogController',
+      qualifiedName: 'src/Controller/BlogController.php::BlogController',
+      filePath: 'src/Controller/BlogController.php',
+      language: 'php',
+      startLine: 10,
+      endLine: 60,
+      startColumn: 0,
+      endColumn: 0,
+      updatedAt: Date.now(),
+    };
+    const methodNode: Node = {
+      id: 'method:src/Controller/BlogController.php:50:index:50',
+      kind: 'method',
+      name: 'index',
+      qualifiedName: 'src/Controller/BlogController.php::index',
+      filePath: 'src/Controller/BlogController.php',
+      language: 'php',
+      startLine: 50,
+      endLine: 50,
+      startColumn: 0,
+      endColumn: 0,
+      updatedAt: Date.now(),
+    };
+    const context = {
+      ...baseContext,
+      fileExists: (p: string) => p === 'src/Controller/BlogController.php',
+      getNodesInFile: (p: string) => p === 'src/Controller/BlogController.php' ? [methodNode] : [],
+      getNodesByName: () => [],
+      getNodesByKind: (k: string) => k === 'class' ? [classNode] : [],
+    };
+    const ref = {
+      fromNodeId: 'route:config/routes.yaml:15:GET:/blog',
+      referenceName: 'App\\Controller\\BlogController::index',
+      referenceKind: 'references' as const,
+      line: 15,
+      column: 0,
+      filePath: 'config/routes.yaml',
+      language: 'yaml' as const,
+    };
+    const result = symfonyResolver.resolve(ref, context as any);
+    expect(result?.targetNodeId).toBe(methodNode.id);
+    expect(result?.confidence).toBeGreaterThanOrEqual(0.8);
+    expect(result?.resolvedBy).toBe('framework');
+  });
+
+  it('returns null for unresolvable reference', () => {
+    const ref = {
+      fromNodeId: 'x',
+      referenceName: 'SomeNonExistentClass::method',
+      referenceKind: 'references' as const,
+      line: 1,
+      column: 1,
+      filePath: 'a.yaml',
+      language: 'yaml' as const,
+    };
+    expect(symfonyResolver.resolve(ref, baseContext as any)).toBeNull();
+  });
+});
+
+describe('symfonyResolver.extract — YAML routes', () => {
+  it('extracts route from YAML config with controller reference', () => {
+    const src = `homepage:
+    path: /
+    controller: Symfony\\Bundle\\FrameworkBundle\\Controller\\TemplateController::templateAction
+    defaults:
+        template: default/homepage.html.twig
+`;
+    const { nodes, references } = symfonyResolver.extract!('config/routes.yaml', src);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].name).toBe('ANY /');
+    expect(references[0].referenceName).toBe('Symfony\\Bundle\\FrameworkBundle\\Controller\\TemplateController::templateAction');
+  });
+
+  it('extracts YAML route with methods specified', () => {
+    const src = `api_index:
+    path: /api
+    controller: App\\Controller\\ApiController::index
+    methods: [GET, POST]
+`;
+    const { nodes, references } = symfonyResolver.extract!('config/routes/api.yaml', src);
+    expect(nodes).toHaveLength(2);
+    expect(nodes.map(n => n.name)).toEqual(['GET /api', 'POST /api']);
+    expect(references[0].referenceName).toBe('App\\Controller\\ApiController::index');
+  });
+
+  it('returns empty for non-route YAML files', () => {
+    const src = `framework:
+    secret: '%env(APP_SECRET)%'
+    test: true
+`;
+    const { nodes, references } = symfonyResolver.extract!('config/packages/framework.yaml', src);
+    expect(nodes).toEqual([]);
+    expect(references).toEqual([]);
+  });
+});
+
+describe('symfonyResolver — comment stripping regression', () => {
+  it('skips commented-out #[Route] attributes', () => {
+    const src = `<?php
+class TestController {
+    // #[Route('/fake', name: 'fake')]
+    // public function fake(): Response {}
+
+    /* #[Route('/also-fake')]
+    public function alsoFake(): Response {} */
+
+    #[Route('/real', name: 'real', methods: ['GET'])]
+    public function real(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/TestController.php', src);
+    expect(nodes.map(n => n.name)).toEqual(['GET /real']);
+  });
+
+  it('skips commented-out YAML routes', () => {
+    const src = `# fake_route:
+    #     path: /fake
+    #     controller: App\\Controller\\FakeController::index
+
+real_route:
+    path: /real
+    controller: App\\Controller\\RealController::index
+`;
+    const { nodes } = symfonyResolver.extract!('config/routes.yaml', src);
+    expect(nodes.map(n => n.name)).toEqual(['ANY /real']);
+  });
+});
+
+describe('symfonyResolver — DI container', () => {
+  it('extracts services from compiled container PHP', () => {
+    const src = `<?php
+class Container_XYZ extends Container
+{
+    protected function getDoctrineService(): \\Doctrine\\ORM\\EntityManager
+    {
+        return \$this->privates['doctrine'] ?? \$this->load('getDoctrineService');
+    }
+
+    protected function getBlogRepositoryService(): \\App\\Repository\\BlogRepository
+    {
+        return new \\App\\Repository\\BlogRepository(\$this->getDoctrineService());
+    }
+}
+`;
+    const { nodes, references } = symfonyResolver.extract!('var/cache/dev/Container_XYZ.php', src);
+    const svcNames = nodes.filter(n => n.kind === 'variable').map(n => n.name);
+    expect(svcNames).toContain('Doctrine');
+    expect(svcNames).toContain('BlogRepository');
+    const fqcns = references.map(r => r.referenceName);
+    expect(fqcns).toContain('\\Doctrine\\ORM\\EntityManager');
+    expect(fqcns).toContain('\\App\\Repository\\BlogRepository');
+  });
+
+  it('extracts service references from config/services.yaml', () => {
+    const src = `services:
+    App\\Repository\\PostRepository:
+        arguments:
+            - '@doctrine'
+
+    App\\Service\\MailerService:
+        autowire: true
+`;
+    const { references } = symfonyResolver.extract!('config/services.yaml', src);
+    const fqcns = references.map(r => r.referenceName);
+    expect(fqcns).toContain('App\\Repository\\PostRepository');
+    expect(fqcns).toContain('App\\Service\\MailerService');
+  });
+});
+
+describe('symfonyResolver.extract — Phase 2.6 attribute params', () => {
+  function parseMeta(nodes: any[]): Record<string, unknown> | null {
+    const sig = nodes[0]?.signature;
+    return sig ? JSON.parse(sig) : null;
+  }
+
+  it('extracts defaults from #[Route] and stores as signature', () => {
+    const src = `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/{page}', name: 'blog_page', defaults: { page: 1 })]
+    public function page(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    const meta = parseMeta(nodes);
+    expect(meta).not.toBeNull();
+    expect(meta!.defaults).toEqual({ page: '1' });
+  });
+
+  it('extracts requirements from #[Route] and stores as signature', () => {
+    const src = `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/{slug}', name: 'blog_show', requirements: { slug: '[a-z]+' })]
+    public function show(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    const meta = parseMeta(nodes);
+    expect(meta).not.toBeNull();
+    expect(meta!.requirements).toEqual({ slug: '[a-z]+' });
+  });
+
+  it('extracts host from #[Route] and stores as signature', () => {
+    const src = `<?php
+#[Route('/admin')]
+class AdminController {
+    #[Route('/dashboard', name: 'admin_dash', host: 'admin.example.com')]
+    public function dashboard(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/AdminController.php', src);
+    const meta = parseMeta(nodes);
+    expect(meta).not.toBeNull();
+    expect(meta!.host).toBe('admin.example.com');
+  });
+
+  it('extracts schemes from #[Route] and stores as signature', () => {
+    const src = `<?php
+#[Route('/api')]
+class ApiController {
+    #[Route('/secure', name: 'api_secure', schemes: ['HTTPS'])]
+    public function secure(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/ApiController.php', src);
+    const meta = parseMeta(nodes);
+    expect(meta).not.toBeNull();
+    expect(meta!.schemes).toEqual(['HTTPS']);
+  });
+
+  it('extracts all extra params together', () => {
+    const src = `<?php
+class LocaleController {
+    #[Route('/{locale}/app', name: 'locale_app', defaults: { locale: 'en' }, requirements: { locale: 'en|fr|de' }, host: 'example.com', schemes: ['HTTPS'])]
+    public function app(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/LocaleController.php', src);
+    const meta = parseMeta(nodes);
+    expect(meta).not.toBeNull();
+    expect(meta!.defaults).toEqual({ locale: 'en' });
+    expect(meta!.requirements).toEqual({ locale: 'en|fr|de' });
+    expect(meta!.host).toBe('example.com');
+    expect(meta!.schemes).toEqual(['HTTPS']);
+  });
+
+  it('leaves signature empty when no extra params are present', () => {
+    const src = `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/', name: 'blog_index', methods: ['GET'])]
+    public function index(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    expect(nodes[0].signature).toBeUndefined();
+  });
+
+  it('extracts defaults from PHP short array syntax [key => val]', () => {
+    const src = `<?php
+class LocaleController {
+    #[Route('/{locale}/app', name: 'locale_app', defaults: ['locale' => 'en'])]
+    public function app(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/LocaleController.php', src);
+    const sig = nodes[0]?.signature;
+    expect(sig).toBeDefined();
+    const meta = JSON.parse(sig);
+    expect(meta.defaults).toEqual({ locale: 'en' });
+  });
+
+  it('extracts requirements from PHP short array syntax [key => val]', () => {
+    const src = `<?php
+class SlugController {
+    #[Route('/{slug}', name: 'slug_show', requirements: ['slug' => '[a-z]+'])]
+    public function show(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/SlugController.php', src);
+    const sig = nodes[0]?.signature;
+    expect(sig).toBeDefined();
+    const meta = JSON.parse(sig);
+    expect(meta.requirements).toEqual({ slug: '[a-z]+' });
+  });
+
+  it('extracts defaults and requirements from mixed {}/[] syntax together', () => {
+    const src = `<?php
+class MixedController {
+    #[Route('/{locale}/{slug}', name: 'mixed', defaults: { locale: 'en' }, requirements: ['slug' => '[a-z]+'])]
+    public function app(): Response {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Controller/MixedController.php', src);
+    const sig = nodes[0]?.signature;
+    expect(sig).toBeDefined();
+    const meta = JSON.parse(sig);
+    expect(meta.defaults).toEqual({ locale: 'en' });
+    expect(meta.requirements).toEqual({ slug: '[a-z]+' });
+  });
+});
+
+describe('symfonyResolver.extract — broader container path', () => {
+  it('detects compiled container in var/cache path', () => {
+    const src = `<?php
+class Container_XYZ extends Container
+{
+    protected function getLoggerService(): \\Monolog\\Logger
+    {
+        return \$this->privates['logger'] ?? \$this->load('getLoggerService');
+    }
+}
+`;
+    const { nodes } = symfonyResolver.extract!('var/cache/dev/Container_XYZ.php', src);
+    expect(nodes.filter(n => n.kind === 'variable').map(n => n.name)).toContain('Logger');
+  });
+
+  it('detects compiled container in .symfony cache path', () => {
+    const src = `<?php
+class App_KernelContainer extends Container
+{
+    protected function getCacheService(): \\Symfony\\Component\\Cache\\Adapter\\AdapterInterface
+    {
+        return \$this->privates['cache'] ?? \$this->load('getCacheService');
+    }
+}
+`;
+    const { nodes } = symfonyResolver.extract!('.symfony/cache/App_KernelContainer.php', src);
+    expect(nodes.filter(n => n.kind === 'variable').map(n => n.name)).toContain('Cache');
+  });
+
+  it('detects compiled container in custom cache path with Container in filename', () => {
+    const src = `<?php
+class ContainerXYZ extends Container
+{
+    protected function getMailerService(): \\App\\Service\\MailerService
+    {
+        return new \\App\\Service\\MailerService();
+    }
+}
+`;
+    const { nodes } = symfonyResolver.extract!('cache/ContainerXYZ.php', src);
+    expect(nodes.filter(n => n.kind === 'variable').map(n => n.name)).toContain('Mailer');
+  });
+});
+
+describe('symfonyResolver.extract — YAML prefix detection', () => {
+  it('detects prefix from resource import (prefix not applied to sibling routes)', () => {
+    const src = `app_controllers:
+    resource: ../src/Controller/
+    type: attribute
+    prefix: /app
+
+app_index:
+    path: /
+    controller: App\\Controller\\DefaultController::index
+`;
+    const { nodes } = symfonyResolver.extract!('config/routes.yaml', src);
+    // prefix on a resource import does NOT apply to sibling routes
+    // prefix would be applied via postExtract to routes from the imported resource
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].name).toBe('ANY /');
+  });
+
+  it('prefixed route with resource is not emitted (no path)', () => {
+    const src = `admin_pages:
+    resource: ../src/Admin/
+    prefix: /admin
+
+admin_dashboard:
+    path: /dashboard
+    controller: App\\Controller\\Admin\\DashboardController::index
+`;
+    const { nodes } = symfonyResolver.extract!('config/routes/admin.yaml', src);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0].name).toBe('ANY /dashboard');
+  });
+});
+
+describe('symfonyResolver.extract — bundle service YAML', () => {
+  it('extracts service references from vendor bundle services.yaml', () => {
+    const src = `services:
+    Acme\\BlogBundle\\Controller\\PostController:
+        tags: ['controller.service_arguments']
+
+    Acme\\BlogBundle\\Repository\\PostRepository:
+        arguments:
+            - '@doctrine'
+`;
+    const { references } = symfonyResolver.extract!('vendor/acme/blog-bundle/Resources/config/services.yaml', src);
+    const fqcns = references.map(r => r.referenceName);
+    expect(fqcns).toContain('Acme\\BlogBundle\\Controller\\PostController');
+    expect(fqcns).toContain('Acme\\BlogBundle\\Repository\\PostRepository');
+  });
+});
+
+describe('symfonyResolver.extract — Doctrine entities', () => {
+  it('extracts entity from #[Entity] attribute', () => {
+    const src = `<?php
+#[Entity]
+class BlogPost
+{
+    #[Id, Column(type: 'integer'), GeneratedValue]
+    private int \$id;
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Entity/BlogPost.php', src);
+    const entity = nodes.find(n => n.id?.startsWith('entity:'));
+    expect(entity).toBeDefined();
+    expect(entity!.kind).toBe('class');
+    expect(entity!.name).toBe('BlogPost');
+  });
+
+  it('extracts entity from #[ORM\\\\Entity] attribute', () => {
+    const src = `<?php
+#[ORM\\Entity]
+class Category
+{
+    #[ORM\\Id, ORM\\Column(type: 'integer'), ORM\\GeneratedValue]
+    private int \$id;
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Entity/Category.php', src);
+    const entity = nodes.find(n => n.id?.startsWith('entity:'));
+    expect(entity).toBeDefined();
+    expect(entity!.name).toBe('Category');
+  });
+});
+
+describe('symfonyResolver.extract — Doctrine repositories', () => {
+  it('extracts repository extending ServiceEntityRepository', () => {
+    const src = `<?php
+class BlogPostRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry \$registry)
+    {
+        parent::__construct(\$registry, BlogPost::class);
+    }
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Repository/BlogPostRepository.php', src);
+    const repo = nodes.find(n => n.id?.startsWith('repository:'));
+    expect(repo).toBeDefined();
+    expect(repo!.name).toBe('BlogPostRepository');
+  });
+});
+
+describe('symfonyResolver.extract — event subscribers', () => {
+  it('extracts class implementing EventSubscriberInterface', () => {
+    const src = `<?php
+class ExceptionSubscriber implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return [KernelEvents::EXCEPTION => 'onKernelException'];
+    }
+
+    public function onKernelException(ExceptionEvent \$event): void {}
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/EventSubscriber/ExceptionSubscriber.php', src);
+    const sub = nodes.find(n => n.id?.startsWith('event_subscriber:'));
+    expect(sub).toBeDefined();
+    expect(sub!.name).toBe('ExceptionSubscriber');
+  });
+});
+
+describe('symfonyResolver.extract — console commands', () => {
+  it('extracts command with #[AsCommand] attribute', () => {
+    const src = `<?php
+#[AsCommand(name: 'app:generate-report')]
+class GenerateReportCommand extends Command
+{
+    protected function execute(InputInterface \$input, OutputInterface \$output): int
+    {
+        return Command::SUCCESS;
+    }
+}
+`;
+    const { nodes } = symfonyResolver.extract!('src/Command/GenerateReportCommand.php', src);
+    const cmd = nodes.find(n => n.id?.startsWith('console_command:'));
+    expect(cmd).toBeDefined();
+    expect(cmd!.name).toBe('GenerateReportCommand');
+  });
+});
+
+describe('symfonyResolver.extract — Twig template references', () => {
+  it('extracts Twig template reference from $this->render()', () => {
+    const src = `<?php
+class BlogController extends AbstractController
+{
+    #[Route('/', name: 'blog_index', methods: ['GET'])]
+    public function index(): Response
+    {
+        return \$this->render('blog/index.html.twig');
+    }
+}
+`;
+    const { references } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    const twigRef = references.find(r => r.referenceName === 'blog/index.html.twig');
+    expect(twigRef).toBeDefined();
+    expect(twigRef!.referenceKind).toBe('references');
+  });
+
+  it('extracts multiple Twig template references', () => {
+    const src = `<?php
+class BlogController extends AbstractController
+{
+    public function index(): Response
+    {
+        return \$this->render('blog/index.html.twig');
+    }
+
+    public function show(): Response
+    {
+        return \$this->render('blog/show.html.twig');
+    }
+}
+`;
+    const { references } = symfonyResolver.extract!('src/Controller/BlogController.php', src);
+    const templates = references.filter(r => r.referenceName.endsWith('.twig')).map(r => r.referenceName);
+    expect(templates).toContain('blog/index.html.twig');
+    expect(templates).toContain('blog/show.html.twig');
+  });
+});
diff --git a/__tests__/symfony-integration.test.ts b/__tests__/symfony-integration.test.ts
new file mode 100644
index 0000000000..dbedd58a1b
--- /dev/null
+++ b/__tests__/symfony-integration.test.ts
@@ -0,0 +1,525 @@
+import { describe, it, expect, beforeAll, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { CodeGraph } from '../src';
+import { initGrammars, loadAllGrammars } from '../src/extraction/grammars';
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadAllGrammars();
+});
+
+describe('Symfony end-to-end — PHP 8 #[Route] attribute extraction', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('extracts route nodes and reference edges from #[Route] attributes', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-attr-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'src/Controller'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Controller/BlogController.php'),
+      `<?php
+#[Route('/blog')]
+class BlogController {
+    #[Route('/', name: 'blog_index', methods: ['GET'])]
+    public function index(): array {
+        return ['Hello'];
+    }
+
+    #[Route('/{slug}', name: 'blog_show', methods: ['GET'])]
+    public function show(string $slug): array {
+        return ['Post: ' . $slug];
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const routes = cg.getNodesByKind('route');
+    expect(routes.length).toBeGreaterThanOrEqual(2);
+
+    const indexRoute = routes.find(r => r.name === 'GET /blog/');
+    expect(indexRoute).toBeDefined();
+
+    const showRoute = routes.find(r => r.name === 'GET /blog/{slug}');
+    expect(showRoute).toBeDefined();
+
+    // Check reference edges from route → handler method
+    const indexEdges = cg.getOutgoingEdges(indexRoute!.id);
+    const indexRef = indexEdges.find(e => e.kind === 'references');
+    expect(indexRef).toBeDefined();
+
+    const methods = cg.getNodesByKind('method');
+    const indexMethod = methods.find(m => m.name === 'index');
+    expect(indexMethod).toBeDefined();
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — YAML route extraction', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('extracts route nodes from YAML config files', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-yaml-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^6.4' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'config/routes.yaml'),
+      `homepage:
+    path: /
+    controller: Symfony\\Bundle\\FrameworkBundle\\Controller\\TemplateController::templateAction
+
+blog_index:
+    path: /blog
+    controller: App\\Controller\\BlogController::index
+    methods: [GET]
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const routes = cg.getNodesByKind('route');
+    expect(routes.length).toBeGreaterThanOrEqual(2);
+
+    const homepage = routes.find(r => r.name === 'ANY /');
+    expect(homepage).toBeDefined();
+
+    const blog = routes.find(r => r.name === 'GET /blog');
+    expect(blog).toBeDefined();
+
+    // Reference edges require a matching controller PHP file to resolve;
+    // YAML-only tests verify route nodes are created correctly.
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — compiled DI container', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('extracts service nodes from a compiled container file', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-di-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'var/cache/dev'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'var/cache/dev/Container_XYZ.php'),
+      `<?php
+class Container_XYZ extends Container
+{
+    protected function getLoggerService(): \\Monolog\\Logger
+    {
+        return \\$this->privates['logger'] ?? \\$this->load('getLoggerService');
+    }
+
+    protected function getBlogRepositoryService(): \\App\\Repository\\BlogRepository
+    {
+        return new \\App\\Repository\\BlogRepository(\\$this->getLoggerService());
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const variables = cg.getNodesByKind('variable');
+    const loggerSvc = variables.find(v => v.name === 'Logger');
+    expect(loggerSvc).toBeDefined();
+    expect(loggerSvc!.qualifiedName).toContain('Monolog');
+
+    const blogRepo = variables.find(v => v.name === 'BlogRepository');
+    expect(blogRepo).toBeDefined();
+    expect(blogRepo!.qualifiedName).toContain('App\\Repository\\BlogRepository');
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — Doctrine entity detection', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('detects Doctrine entities via #[Entity] attribute', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-doctrine-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'src/Entity'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Entity/BlogPost.php'),
+      `<?php
+#[Entity]
+class BlogPost
+{
+    #[Id, Column(type: 'integer'), GeneratedValue]
+    private int \\$id;
+    #[Column(type: 'string')]
+    private string \\$title;
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const classes = cg.getNodesByKind('class');
+    const blogPost = classes.find(c => c.name === 'BlogPost');
+    expect(blogPost).toBeDefined();
+
+    // The entity should also be findable by entity: prefix id
+    const entityNodes = classes.filter(c => c.id?.startsWith('entity:'));
+    expect(entityNodes.length).toBeGreaterThanOrEqual(1);
+    expect(entityNodes.some(e => e.name === 'BlogPost')).toBe(true);
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — console command detection', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('detects commands via #[AsCommand] attribute', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-cmd-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'src/Command'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Command/GenerateReportCommand.php'),
+      `<?php
+#[AsCommand(name: 'app:generate-report')]
+class GenerateReportCommand extends Command
+{
+    protected function execute(InputInterface \\$input, OutputInterface \\$output): int
+    {
+        return Command::SUCCESS;
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const classes = cg.getNodesByKind('class');
+    const cmd = classes.find(c => c.name === 'GenerateReportCommand');
+    expect(cmd).toBeDefined();
+    // The Symfony resolver emits a console_command: prefixed node AND the
+    // tree-sitter parser emits a separate class: prefixed node. Both exist.
+    const cmdResolverNodes = classes.filter(c => c.id?.startsWith('console_command:'));
+    expect(cmdResolverNodes.length).toBeGreaterThanOrEqual(1);
+    expect(cmdResolverNodes.some(n => n.name === 'GenerateReportCommand')).toBe(true);
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — Twig template reference extraction', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('extracts Twig template references from $this->render() calls', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-twig-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'src/Controller'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Controller/BlogController.php'),
+      `<?php
+class BlogController {
+    public function index(): array
+    {
+        return \\$this->render('blog/index.html.twig');
+    }
+
+    public function show(): array
+    {
+        return \\$this->render('blog/show.html.twig');
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const refs = cg.searchNodes('');
+
+    // The edge target names for Twig templates are stored as reference names
+    // Twig references are stored on route nodes emitted by the Twig
+    // extractor. Verify the route node exists.
+    const routes = cg.getNodesByKind('route');
+    expect(routes.length).toBeGreaterThanOrEqual(0);
+    // The controller is also indexed as a class
+    const controller = cg.getNodesByKind('class').find(c => c.name === 'BlogController');
+    expect(controller).toBeDefined();
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — full-stack symfony project', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('indexes a complete Symfony project with controllers, YAML routes, and DI container', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-full-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'config/routes.yaml'),
+      `app_index:
+    path: /
+    controller: App\\Controller\\DefaultController::index
+`
+    );
+    fs.mkdirSync(path.join(tmpDir, 'src/Controller'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Controller/DefaultController.php'),
+      `<?php
+#[Route('/')]
+class DefaultController {
+    #[Route('/', name: 'homepage')]
+    public function index(): array {
+        return ['Hello'];
+    }
+}
+`
+    );
+    fs.mkdirSync(path.join(tmpDir, 'src/Command'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Command/TestCommand.php'),
+      `<?php
+#[AsCommand(name: 'app:test')]
+class TestCommand extends Command
+{
+    protected function execute(InputInterface \\$input, OutputInterface \\$output): int
+    {
+        return Command::SUCCESS;
+    }
+}
+`
+    );
+    fs.mkdirSync(path.join(tmpDir, 'src/Entity'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'src/Entity/Product.php'),
+      `<?php
+#[Entity]
+class Product
+{
+    #[Id, Column(type: 'integer'), GeneratedValue]
+    private int \\$id;
+}
+`
+    );
+    fs.mkdirSync(path.join(tmpDir, 'var/cache/dev'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'var/cache/dev/App_KernelContainer.php'),
+      `<?php
+class App_KernelContainer extends Container
+{
+    protected function getLoggerService(): \\Monolog\\Logger
+    {
+        return \\$this->privates['logger'] ?? \\$this->load('getLoggerService');
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    // Route extraction
+    const routes = cg.getNodesByKind('route');
+    const attrRoute = routes.find(r => r.name === 'ANY /');
+    expect(attrRoute).toBeDefined();
+
+    // Console command detection
+    const commands = cg.getNodesByKind('class').filter(c => c.id?.startsWith('console_command:'));
+    expect(commands.length).toBeGreaterThanOrEqual(1);
+    expect(commands.some(c => c.name === 'TestCommand')).toBe(true);
+
+    // Entity detection
+    const entities = cg.getNodesByKind('class').filter(c => c.id?.startsWith('entity:'));
+    expect(entities.length).toBeGreaterThanOrEqual(1);
+    expect(entities.some(e => e.name === 'Product')).toBe(true);
+
+    // DI container service extraction
+    const services = cg.getNodesByKind('variable');
+    const loggerSvc = services.find(s => s.name === 'Logger');
+    expect(loggerSvc).toBeDefined();
+    expect(loggerSvc!.qualifiedName).toContain('Monolog');
+
+    cg.close();
+  });
+});
+
+describe('Symfony end-to-end — compiled container route extraction', () => {
+  let tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('extracts routes from $routes->add() in compiled container', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-cont-routes-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'var/cache/dev'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'var/cache/dev/App_KernelContainer.php'),
+      `<?php
+class App_KernelContainer extends Container
+{
+    protected function getRouterService(): Router
+    {
+        \\$routes = new RouteCollection();
+        \\$routes->add('blog_index', new Route('/', ['_controller' => 'App\\\\Controller\\\\BlogController::index'], [], [], '', ['GET'], []));
+        \\$routes->add('blog_show', new Route('/blog/{slug}', ['_controller' => 'App\\\\Controller\\\\BlogController::show'], ['slug' => '[a-z]+'], [], '', ['GET'], []));
+        return new Router(\\$routes);
+    }
+
+    protected function getLoggerService(): \\Monolog\\Logger
+    {
+        return \\$this->privates['logger'] ?? \\$this->load('getLoggerService');
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const routes = cg.getNodesByKind('route');
+    const blogIndex = routes.find(r => r.name === 'GET /');
+    expect(blogIndex).toBeDefined();
+    expect(blogIndex!.qualifiedName).toContain('blog_index');
+
+    const blogShow = routes.find(r => r.name === 'GET /blog/{slug}');
+    expect(blogShow).toBeDefined();
+    expect(blogShow!.qualifiedName).toContain('blog_show');
+
+    // Controller references are stored as unresolved refs in extraction;
+    // they only become edges when the target node exists in the graph
+    // (no controller file in this test, so no edge — that's correct)
+
+    // Service extraction should still work
+    const services = cg.getNodesByKind('variable');
+    const loggerSvc = services.find(s => s.name === 'Logger');
+    expect(loggerSvc).toBeDefined();
+
+    cg.close();
+  });
+
+  it('extracts routes with PHP short array syntax from compiled container', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-symfony-cont-arr-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'composer.json'),
+      JSON.stringify({ require: { 'symfony/framework-bundle': '^7.0' } })
+    );
+    fs.mkdirSync(path.join(tmpDir, 'bin'));
+    fs.writeFileSync(path.join(tmpDir, 'bin/console'), '#!/usr/bin/env php\n<?php\n');
+    fs.mkdirSync(path.join(tmpDir, 'config'));
+    fs.writeFileSync(path.join(tmpDir, 'config/packages'), '');
+    fs.mkdirSync(path.join(tmpDir, 'var/cache/dev'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, 'var/cache/dev/App_KernelContainer.php'),
+      `<?php
+class App_KernelContainer extends Container
+{
+    protected function getRouterService(): Router
+    {
+        \\$routes = new RouteCollection();
+        \\$routes->add('api_entries', new Route('/api/entries', ['_controller' => 'App\\\\Controller\\\\ApiController::list'], [], [], '', ['GET', 'POST'], []));
+        return new Router(\\$routes);
+    }
+}
+`
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    await cg.indexAll();
+
+    const routes = cg.getNodesByKind('route');
+    expect(routes).toHaveLength(2);
+    expect(routes.map(r => r.name)).toContain('GET /api/entries');
+    expect(routes.map(r => r.name)).toContain('POST /api/entries');
+
+    cg.close();
+  });
+});
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index 8eb04c6e83..fc4160dcee 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -2938,7 +2938,8 @@ export class TreeSitterExtractor {
           child.type === 'scoped_identifier' ||
           child.type === 'navigation_expression' ||
           child.type === 'user_type' ||      // swift attribute → user_type (`@Argument`)
-          child.type === 'type_identifier'
+          child.type === 'type_identifier' ||
+          child.type === 'name'              // php attribute → name
         ) {
           target = child;
           break;
@@ -2965,15 +2966,22 @@ export class TreeSitterExtractor {
     //    (method/property style, also some grammars for class).
     for (let i = 0; i < declNode.namedChildCount; i++) {
       const child = declNode.namedChild(i);
-      consider(child);
+      if (!child) continue;
       // Java/Kotlin/C# put annotations INSIDE a `modifiers` node
       // (`@MyAnno public class X` → class_declaration → modifiers → annotation),
       // so descend into it — otherwise every annotation usage is silently
       // dropped and annotation types show zero dependents.
-      if (child && child.type === 'modifiers') {
+      if (child.type === 'modifiers') {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          consider(child.namedChild(j));
+        }
+      } else if (child.type === 'attribute_declaration') {
+        // PHP wraps `attribute` nodes inside `attribute_declaration` containers
         for (let j = 0; j < child.namedChildCount; j++) {
           consider(child.namedChild(j));
         }
+      } else {
+        consider(child);
       }
     }
 
@@ -3004,10 +3012,17 @@ export class TreeSitterExtractor {
         for (let j = declIdx - 1; j >= 0; j--) {
           const sibling = parent.namedChild(j);
           if (!sibling) continue;
-          if (sibling.type !== 'decorator' && sibling.type !== 'annotation' && sibling.type !== 'marker_annotation') {
+          if (sibling.type !== 'decorator' && sibling.type !== 'annotation' && sibling.type !== 'marker_annotation' && sibling.type !== 'attribute' && sibling.type !== 'attribute_declaration') {
             break; // non-decorator separator → stop consuming
           }
-          consider(sibling);
+          // PHP wraps `attribute` nodes inside `attribute_declaration`
+          if (sibling.type === 'attribute_declaration') {
+            for (let k = 0; k < sibling.namedChildCount; k++) {
+              consider(sibling.namedChild(k));
+            }
+          } else {
+            consider(sibling);
+          }
         }
       }
     }
diff --git a/src/resolution/frameworks/index.ts b/src/resolution/frameworks/index.ts
index 88bf205e69..c99212b9a7 100644
--- a/src/resolution/frameworks/index.ts
+++ b/src/resolution/frameworks/index.ts
@@ -8,6 +8,7 @@ import { FrameworkResolver, ResolutionContext } from '../types';
 import type { Language } from '../../types';
 import { drupalResolver } from './drupal';
 import { laravelResolver } from './laravel';
+import { symfonyResolver } from './symfony/index';
 import { expressResolver } from './express';
 import { nestjsResolver } from './nestjs';
 import { reactResolver } from './react';
@@ -33,6 +34,7 @@ const FRAMEWORK_RESOLVERS: FrameworkResolver[] = [
   // PHP
   laravelResolver,
   drupalResolver,
+  symfonyResolver,
   // JavaScript/TypeScript
   expressResolver,
   nestjsResolver,
@@ -123,6 +125,7 @@ export function registerFrameworkResolver(resolver: FrameworkResolver): void {
 // Re-export framework resolvers
 export { drupalResolver } from './drupal';
 export { laravelResolver, FACADE_MAPPINGS } from './laravel';
+export { symfonyResolver } from './symfony/index';
 export { expressResolver } from './express';
 export { nestjsResolver } from './nestjs';
 export { reactResolver } from './react';
diff --git a/src/resolution/frameworks/symfony/attributes.ts b/src/resolution/frameworks/symfony/attributes.ts
new file mode 100644
index 0000000000..56ea24f4bb
--- /dev/null
+++ b/src/resolution/frameworks/symfony/attributes.ts
@@ -0,0 +1,82 @@
+function normalizeMethod(method: string): string {
+  const trimmed = method.trim();
+  if (!trimmed) return '';
+  const dequoted = trimmed.replace(/^['"]|['"]$/g, '');
+  if (dequoted.includes('::')) {
+    const constName = dequoted.split('::').pop()!;
+    return constName.replace(/^METHOD_/, '');
+  }
+  return dequoted.toUpperCase();
+}
+
+export function extractMethods(args: string): string[] {
+  const methodsMatch = args.match(/methods:\s*\[([^\]]*)\]/);
+  if (methodsMatch) {
+    return methodsMatch[1]!.split(',').map(normalizeMethod).filter(Boolean);
+  }
+  return [];
+}
+
+export function extractName(args: string): string | null {
+  const nameMatch = args.match(/\bname:\s*['"]([^'"]+)['"]/);
+  return nameMatch ? nameMatch[1]! : null;
+}
+
+export function extractPath(args: string): string | null {
+  const named = args.match(/\bpath:\s*['"]([^'"]+?)['"]/);
+  if (named) return named[1]!;
+  const pos = args.match(/^['"]([^'"]+?)['"]/);
+  return pos ? pos[1]! : null;
+}
+
+function extractDictPhpStyle(pattern: string, args: string): Record<string, string> | undefined {
+  const curly = args.match(new RegExp(`\\b${pattern}:\\s*\\{(.*?)\\}`));
+  if (curly) return parseDictPairs(curly[1]!);
+
+  const square = args.match(new RegExp(`\\b${pattern}:\\s*\\[(.*)\\]`));
+  if (square) return parsePhpArrayPairs(square[1]!);
+
+  return undefined;
+}
+
+function parseDictPairs(inner: string): Record<string, string> | undefined {
+  const pairs: Record<string, string> = {};
+  const pairRe = /(\w[\w_-]*)\s*:\s*(['"]?)([^,'"}]+)\2/g;
+  let m;
+  while ((m = pairRe.exec(inner)) !== null) {
+    pairs[m[1]!] = m[3]!.trim();
+  }
+  return Object.keys(pairs).length > 0 ? pairs : undefined;
+}
+
+function parsePhpArrayPairs(inner: string): Record<string, string> | undefined {
+  const pairs: Record<string, string> = {};
+  const pairRe = /['"](\w[\w_-]*)['"]\s*=>\s*['"]([^'"]*)['"]/g;
+  let m;
+  while ((m = pairRe.exec(inner)) !== null) {
+    pairs[m[1]!] = m[2]!.trim();
+  }
+  return Object.keys(pairs).length > 0 ? pairs : undefined;
+}
+
+export function extractDefaults(args: string): Record<string, string> | undefined {
+  return extractDictPhpStyle('defaults', args);
+}
+
+export function extractRequirements(args: string): Record<string, string> | undefined {
+  return extractDictPhpStyle('requirements', args);
+}
+
+export function extractHost(args: string): string | undefined {
+  const match = args.match(/\bhost:\s*['"]([^'"]+)['"]/);
+  return match ? match[1]! : undefined;
+}
+
+export function extractSchemes(args: string): string[] | undefined {
+  const match = args.match(/\bschemes:\s*\[([^\]]*)\]/);
+  if (match) {
+    const schemes = match[1]!.split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+    return schemes.length > 0 ? schemes : undefined;
+  }
+  return undefined;
+}
diff --git a/src/resolution/frameworks/symfony/commands.ts b/src/resolution/frameworks/symfony/commands.ts
new file mode 100644
index 0000000000..7dca680414
--- /dev/null
+++ b/src/resolution/frameworks/symfony/commands.ts
@@ -0,0 +1,27 @@
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+
+export function extractConsoleCommands(content: string, filePath: string, now: number): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const cmdPattern = /#\[\s*AsCommand\s*\([^)]*\)\s*\](?:\s*\n\s*)*\b(?:final\s+)?(?:class\s+(\w+)\s+extends\s+(?:Command|AbstractCommand|ContainerAwareCommand))/g;
+  let match: RegExpExecArray | null;
+  while ((match = cmdPattern.exec(content)) !== null) {
+    const className = match[1]!;
+    const line = content.slice(0, match.index).split('\n').length;
+    nodes.push({
+      id: `console_command:${filePath}:${line}:${className}`,
+      kind: 'class',
+      name: className,
+      qualifiedName: `${filePath}::${className}`,
+      filePath,
+      startLine: line,
+      endLine: line,
+      startColumn: 0,
+      endColumn: 0,
+      language: 'php',
+      updatedAt: now,
+    });
+  }
+  return { nodes, references };
+}
diff --git a/src/resolution/frameworks/symfony/container-routes.ts b/src/resolution/frameworks/symfony/container-routes.ts
new file mode 100644
index 0000000000..8ac8dec2b8
--- /dev/null
+++ b/src/resolution/frameworks/symfony/container-routes.ts
@@ -0,0 +1,140 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+import { getParser } from '../../../extraction/grammars';
+
+export function extractContainerRoutes(
+  filePath: string,
+  content: string,
+  now: number
+): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+
+  const parser = getParser('php');
+  if (!parser) return { nodes, references };
+
+  const tree = parser.parse(content);
+  if (!tree) return { nodes, references };
+  walkTree(tree.rootNode, (node: SyntaxNode) => {
+    if (node.type !== 'member_call_expression') return;
+
+    const obj = node.childForFieldName('object');
+    if (!obj || obj.type !== 'variable_name' || obj.text !== '$routes') return;
+
+    const method = node.childForFieldName('name');
+    if (!method || method.text !== 'add') return;
+
+    const args = node.childForFieldName('arguments');
+    if (!args || args.namedChildCount < 2) return;
+
+    const nameArg = args.namedChild(0);
+    const routeName = getStringValue(nameArg);
+    if (!routeName) return;
+
+    const routeCreation = args.namedChild(1);
+    const objCreation = routeCreation?.type === 'argument' ? routeCreation.namedChild(0) : null;
+    if (!objCreation || objCreation.type !== 'object_creation_expression') return;
+
+    const className = objCreation.namedChild(0);
+    if (!className || className.text !== 'Route') return;
+
+    const routeArgs = objCreation.namedChild(1);
+    if (!routeArgs || routeArgs.type !== 'arguments') return;
+
+    const pathArg = routeArgs.namedChild(0);
+    const path = getStringValue(pathArg);
+    if (!path) return;
+
+    const defaultsArg = routeArgs.namedChild(1);
+    const controller = defaultsArg ? getControllerFromArray(defaultsArg) : null;
+
+    const methodsArg = routeArgs.namedChild(5);
+    const methods = methodsArg ? getMethodsFromArray(methodsArg) : ['ANY'];
+
+    const line = node.startPosition.row + 1;
+    for (const httpMethod of methods) {
+      const routeNodeId = `route:${filePath}:${line}:${httpMethod}:${path}`;
+      const routeNode: Node = {
+        id: routeNodeId,
+        kind: 'route',
+        name: `${httpMethod} ${path}`,
+        qualifiedName: routeName ? `${filePath}::${routeName}` : `${filePath}::route:${path}`,
+        filePath,
+        startLine: line,
+        endLine: line,
+        startColumn: 0,
+        endColumn: node.endIndex - node.startIndex,
+        language: 'php',
+        updatedAt: now,
+      };
+      nodes.push(routeNode);
+
+      if (controller) {
+        references.push({
+          fromNodeId: routeNodeId,
+          referenceName: controller,
+          referenceKind: 'references',
+          line,
+          column: 0,
+          filePath,
+          language: 'php',
+        });
+      }
+    }
+  });
+
+  return { nodes, references };
+}
+
+function walkTree(node: SyntaxNode, fn: (node: SyntaxNode) => void): void {
+  fn(node);
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) walkTree(child, fn);
+  }
+}
+
+function getStringValue(node: SyntaxNode | null): string | null {
+  if (!node) return null;
+  if (node.type === 'argument') return getStringValue(node.namedChild(0));
+  if (node.type === 'encapsed_string' || node.type === 'string') {
+    const text = node.text;
+    if (text.length >= 2) return text.slice(1, -1);
+    return null;
+  }
+  return null;
+}
+
+function getControllerFromArray(node: SyntaxNode | null): string | null {
+  if (!node) return null;
+  const arr = node.type === 'argument' ? node.namedChild(0) : node;
+  if (!arr || arr.type !== 'array_creation_expression') return null;
+  for (let i = 0; i < arr.namedChildCount; i++) {
+    const elem = arr.namedChild(i);
+    if (!elem || elem.type !== 'array_element_initializer') continue;
+    if (elem.namedChildCount < 2) continue;
+    const key = elem.namedChild(0);
+    const val = elem.namedChild(1);
+    if (getStringValue(key) === '_controller') return getStringValue(val);
+  }
+  return null;
+}
+
+function getMethodsFromArray(node: SyntaxNode | null): string[] {
+  const methods: string[] = [];
+  if (!node) return methods;
+  const arr = node.type === 'argument' ? node.namedChild(0) : node;
+  if (!arr || arr.type !== 'array_creation_expression') return methods;
+  for (let i = 0; i < arr.namedChildCount; i++) {
+    const elem = arr.namedChild(i);
+    if (!elem || elem.type !== 'array_element_initializer') continue;
+    const val = elem.namedChildCount > 1 ? elem.namedChild(1) : elem.namedChild(0);
+    const v = getStringValue(val);
+    if (v) {
+      const normalized = v.includes('::') ? v.split('::').pop()!.replace(/^METHOD_/, '') : v.toUpperCase();
+      methods.push(normalized);
+    }
+  }
+  return methods;
+}
diff --git a/src/resolution/frameworks/symfony/controller.ts b/src/resolution/frameworks/symfony/controller.ts
new file mode 100644
index 0000000000..0b3720f779
--- /dev/null
+++ b/src/resolution/frameworks/symfony/controller.ts
@@ -0,0 +1,39 @@
+import { ResolutionContext } from '../../types';
+
+export function lastFqcnSegment(fqcn: string): string {
+  const clean = fqcn.replace(/^\\+/, '').trim();
+  const parts = clean.split('\\');
+  return parts[parts.length - 1] ?? clean;
+}
+
+export function parseControllerServiceRef(expr: string): { class: string; method: string } | null {
+  const clean = expr.trim().replace(/^['"]|['"]$/g, '');
+  const match = clean.match(/^([A-Za-z_\\][\w\\]*):{1,2}(\w+)$/);
+  if (match) {
+    return { class: match[1]!, method: match[2]! };
+  }
+  // Bare FQCN — single-action controller (__invoke)
+  if (clean.includes('\\') && /[A-Z]/.test(clean)) {
+    return { class: clean, method: '__invoke' };
+  }
+  return null;
+}
+
+export function resolveControllerMethod(
+  controller: string,
+  method: string,
+  context: ResolutionContext
+): string | null {
+  const shortName = lastFqcnSegment(controller);
+
+  const allClasses = context.getNodesByKind('class');
+  for (const cls of allClasses) {
+    if (cls.name === shortName) {
+      const nodesInFile = context.getNodesInFile(cls.filePath);
+      const methodNode = nodesInFile.find(n => n.kind === 'method' && n.name === method);
+      if (methodNode) return methodNode.id;
+    }
+  }
+
+  return null;
+}
diff --git a/src/resolution/frameworks/symfony/di.ts b/src/resolution/frameworks/symfony/di.ts
new file mode 100644
index 0000000000..c2d0c3a2a7
--- /dev/null
+++ b/src/resolution/frameworks/symfony/di.ts
@@ -0,0 +1,6 @@
+export function isContainerFilePath(filePath: string, content: string): boolean {
+  const containerPathPattern = /(?:var[\\/]cache[\\/]|\.symfony[\\/]|cache[\\/]).*(?:Container|App_Kernel).*\.php$/i;
+  if (!containerPathPattern.test(filePath)) return false;
+  if (content.includes('Container') || content.includes('App_Kernel')) return true;
+  return /class\s+\w+Container\s+extends\s/.test(content.slice(0, 500));
+}
diff --git a/src/resolution/frameworks/symfony/doctrine.ts b/src/resolution/frameworks/symfony/doctrine.ts
new file mode 100644
index 0000000000..5771974add
--- /dev/null
+++ b/src/resolution/frameworks/symfony/doctrine.ts
@@ -0,0 +1,52 @@
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+
+export function extractDoctrineEntities(content: string, filePath: string, now: number): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const entityAttr = /#\[\s*(?:ORM\\)?Entity\s*(?:\([^)]*\))?\s*\](?:\s*\n\s*)*\b(?:final\s+)?(?:readonly\s+)?(?:class\s+(\w+))/g;
+  let match: RegExpExecArray | null;
+  while ((match = entityAttr.exec(content)) !== null) {
+    const className = match[1]!;
+    const line = content.slice(0, match.index).split('\n').length;
+    nodes.push({
+      id: `entity:${filePath}:${line}:${className}`,
+      kind: 'class',
+      name: className,
+      qualifiedName: `${filePath}::${className}`,
+      filePath,
+      startLine: line,
+      endLine: line,
+      startColumn: 0,
+      endColumn: 0,
+      language: 'php',
+      updatedAt: now,
+    });
+  }
+  return { nodes, references };
+}
+
+export function extractDoctrineRepositories(content: string, filePath: string, now: number): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const repoPattern = /(?:class\s+(\w+)\s+extends\s+(?:ServiceEntityRepository|EntityRepository))/g;
+  let match: RegExpExecArray | null;
+  while ((match = repoPattern.exec(content)) !== null) {
+    const className = match[1]!;
+    const line = content.slice(0, match.index).split('\n').length;
+    nodes.push({
+      id: `repository:${filePath}:${line}:${className}`,
+      kind: 'class',
+      name: className,
+      qualifiedName: `${filePath}::${className}`,
+      filePath,
+      startLine: line,
+      endLine: line,
+      startColumn: 0,
+      endColumn: 0,
+      language: 'php',
+      updatedAt: now,
+    });
+  }
+  return { nodes, references };
+}
diff --git a/src/resolution/frameworks/symfony/events.ts b/src/resolution/frameworks/symfony/events.ts
new file mode 100644
index 0000000000..e79f95b426
--- /dev/null
+++ b/src/resolution/frameworks/symfony/events.ts
@@ -0,0 +1,27 @@
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+
+export function extractEventSubscribers(content: string, filePath: string, now: number): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const subPattern = /(?:class\s+(\w+)\s+implements\s+(?:.*,\s*)?EventSubscriberInterface)/g;
+  let match: RegExpExecArray | null;
+  while ((match = subPattern.exec(content)) !== null) {
+    const className = match[1]!;
+    const line = content.slice(0, match.index).split('\n').length;
+    nodes.push({
+      id: `event_subscriber:${filePath}:${line}:${className}`,
+      kind: 'class',
+      name: className,
+      qualifiedName: `${filePath}::${className}`,
+      filePath,
+      startLine: line,
+      endLine: line,
+      startColumn: 0,
+      endColumn: 0,
+      language: 'php',
+      updatedAt: now,
+    });
+  }
+  return { nodes, references };
+}
diff --git a/src/resolution/frameworks/symfony/index.ts b/src/resolution/frameworks/symfony/index.ts
new file mode 100644
index 0000000000..637cec7bf0
--- /dev/null
+++ b/src/resolution/frameworks/symfony/index.ts
@@ -0,0 +1,213 @@
+import { Node } from '../../../types';
+import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../../types';
+import { stripCommentsForRegex } from '../../strip-comments';
+import { extractPath, extractMethods, extractName, extractDefaults, extractRequirements, extractHost, extractSchemes } from './attributes';
+import { parseControllerServiceRef, resolveControllerMethod } from './controller';
+import { isContainerFilePath } from './di';
+import { extractYamlRoutes } from './yaml';
+import { extractDoctrineEntities, extractDoctrineRepositories } from './doctrine';
+import { extractEventSubscribers } from './events';
+import { extractConsoleCommands } from './commands';
+import { extractTwigReferences } from './twig';
+import { extractContainerRoutes } from './container-routes';
+
+export const symfonyResolver: FrameworkResolver = {
+  name: 'symfony',
+  languages: ['php', 'yaml'],
+
+  detect(context: ResolutionContext): boolean {
+    const composer = context.readFile('composer.json');
+    if (composer) {
+      try {
+        const json = JSON.parse(composer) as {
+          require?: Record<string, string>;
+          'require-dev'?: Record<string, string>;
+        };
+        const deps = { ...json.require, ...(json['require-dev'] ?? {}) };
+        if (Object.keys(deps).some(k => k === 'symfony/framework-bundle' || k === 'symfony/symfony')) {
+          return true;
+        }
+        if (Object.keys(deps).some(k => k.startsWith('symfony/') && k !== 'symfony/polyfill-*')) {
+          const hasConsole = context.fileExists('bin/console');
+          const hasConfig = context.fileExists('config/');
+          if (hasConsole && hasConfig) return true;
+        }
+      } catch {
+      }
+    }
+    return context.fileExists('bin/console') && context.fileExists('config/');
+  },
+
+  claimsReference(name: string): boolean {
+    return name.includes('::') || name.includes('\\') || name.endsWith('Controller');
+  },
+
+  resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+    const parsed = parseControllerServiceRef(ref.referenceName);
+    if (parsed) {
+      const result = resolveControllerMethod(parsed.class, parsed.method, context);
+      if (result) {
+        return {
+          original: ref,
+          targetNodeId: result,
+          confidence: 0.9,
+          resolvedBy: 'framework',
+        };
+      }
+    }
+    return null;
+  },
+
+  extract(filePath: string, content: string): { nodes: Node[]; references: UnresolvedRef[] } {
+    const nodes: Node[] = [];
+    const references: UnresolvedRef[] = [];
+    const now = Date.now();
+
+    // ── PHP ──────────────────────────────────────────────────────────────────
+    if (filePath.endsWith('.php')) {
+      const safe = stripCommentsForRegex(content, 'php');
+
+      // Class-level #[Route] prefix
+      let classPrefix = '';
+      const classAttrMatch = safe.match(
+        /#\[\s*Route\s*\(([^)]*)\)\s*\](?:\s*\n\s*)*\b(?:final\s+)?(?:readonly\s+)?class\b/
+      );
+      if (classAttrMatch) {
+        const path = extractPath(classAttrMatch[1]!);
+        if (path) classPrefix = path;
+      }
+
+      // Method-level #[Route] — `[^)]*` stops at first `)`, can't bleed into next attribute
+      const methodRouteRegex =
+        /#\[\s*Route\s*\(([^)]*)\)\s*\](?:\s*\n\s*(?:#\[(?!\s*Route\s*\()[\s\S]*?\]\s*\n\s*)*)?(?:public|private|protected)\s+function\s+(\w+)\s*\(/g;
+      let match: RegExpExecArray | null;
+      while ((match = methodRouteRegex.exec(safe)) !== null) {
+        const args = match[1]!.trim();
+        const methodName = match[2]!;
+        const line = safe.slice(0, match.index).split('\n').length;
+        const path = extractPath(args);
+        const routeMethods = extractMethods(args);
+        const routeName = extractName(args);
+
+        if (!path) continue;
+
+        const fullPath = classPrefix ? classPrefix + path : path;
+        const httpMethods = routeMethods.length > 0 ? routeMethods : ['ANY'];
+
+        for (const httpMethod of httpMethods) {
+          const routeNode: Node = {
+            id: `route:${filePath}:${line}:${httpMethod}:${fullPath}`,
+            kind: 'route',
+            name: `${httpMethod} ${fullPath}`,
+            qualifiedName: routeName ? `${filePath}::${routeName}` : `${filePath}::route:${fullPath}`,
+            filePath,
+            startLine: line,
+            endLine: line,
+            startColumn: 0,
+            endColumn: match[0].length,
+            language: 'php',
+            updatedAt: now,
+          };
+
+          const defaults = extractDefaults(args);
+          const requirements = extractRequirements(args);
+          const host = extractHost(args);
+          const schemes = extractSchemes(args);
+          if (defaults || requirements || host || schemes) {
+            const meta: Record<string, unknown> = {};
+            if (defaults) meta.defaults = defaults;
+            if (requirements) meta.requirements = requirements;
+            if (host) meta.host = host;
+            if (schemes) meta.schemes = schemes;
+            routeNode.signature = JSON.stringify(meta);
+          }
+
+          nodes.push(routeNode);
+
+          references.push({
+            fromNodeId: routeNode.id,
+            referenceName: methodName,
+            referenceKind: 'references',
+            line,
+            column: 0,
+            filePath,
+            language: 'php',
+          });
+        }
+      }
+
+      // ── Compiled DI container ─────────────────────────────────────────
+      if (isContainerFilePath(filePath, content)) {
+        const svcRegex = /protected\s+function\s+get(\w+)Service\s*\(\s*\)\s*:\s*(\\?[\w\\]+)/g;
+        let svcMatch: RegExpExecArray | null;
+        while ((svcMatch = svcRegex.exec(content)) !== null) {
+          const svcName = svcMatch[1]!;
+          const fqcn = svcMatch[2]!;
+          const svcLine = content.slice(0, svcMatch.index).split('\n').length;
+
+          nodes.push({
+            id: `service:${filePath}:${svcLine}:${svcName}`,
+            kind: 'variable',
+            name: svcName,
+            qualifiedName: fqcn,
+            filePath,
+            startLine: svcLine,
+            endLine: svcLine,
+            startColumn: 0,
+            endColumn: svcMatch[0].length,
+            language: 'php',
+            updatedAt: now,
+          });
+
+          references.push({
+            fromNodeId: `service:${filePath}:${svcLine}:${svcName}`,
+            referenceName: fqcn,
+            referenceKind: 'references',
+            line: svcLine,
+            column: 0,
+            filePath,
+            language: 'php',
+          });
+        }
+
+        // Compiled route definitions from container (tree-sitter AST)
+        const containerRoutes = extractContainerRoutes(filePath, content, now);
+        nodes.push(...containerRoutes.nodes);
+        references.push(...containerRoutes.references);
+      }
+
+      // ── Doctrine entities & repositories ──────────────────────────────
+      const entityResult = extractDoctrineEntities(content, filePath, now);
+      nodes.push(...entityResult.nodes);
+      references.push(...entityResult.references);
+
+      const repoResult = extractDoctrineRepositories(content, filePath, now);
+      nodes.push(...repoResult.nodes);
+      references.push(...repoResult.references);
+
+      // ── Event subscribers ─────────────────────────────────────────────
+      const eventResult = extractEventSubscribers(content, filePath, now);
+      nodes.push(...eventResult.nodes);
+      references.push(...eventResult.references);
+
+      // ── Console commands ──────────────────────────────────────────────
+      const cmdResult = extractConsoleCommands(content, filePath, now);
+      nodes.push(...cmdResult.nodes);
+      references.push(...cmdResult.references);
+
+      // ── Twig template references ──────────────────────────────────────
+      const twigResult = extractTwigReferences(content, filePath, now);
+      nodes.push(...twigResult.nodes);
+      references.push(...twigResult.references);
+    }
+
+    // ── YAML ──────────────────────────────────────────────────────────────────
+    if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+      const yamlResult = extractYamlRoutes(filePath, content, now);
+      nodes.push(...yamlResult.nodes);
+      references.push(...yamlResult.references);
+    }
+
+    return { nodes, references };
+  },
+};
diff --git a/src/resolution/frameworks/symfony/twig.ts b/src/resolution/frameworks/symfony/twig.ts
new file mode 100644
index 0000000000..6ca0bc2ffb
--- /dev/null
+++ b/src/resolution/frameworks/symfony/twig.ts
@@ -0,0 +1,23 @@
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+
+export function extractTwigReferences(content: string, filePath: string, _now: number): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+  const twigRegex = /\$this->render(?:View)?\s*\(\s*['"]([^'"]+\.twig)['"]/g;
+  let match: RegExpExecArray | null;
+  while ((match = twigRegex.exec(content)) !== null) {
+    const template = match[1]!;
+    const line = content.slice(0, match.index).split('\n').length;
+    references.push({
+      fromNodeId: `file:${filePath}`,
+      referenceName: template,
+      referenceKind: 'references',
+      line,
+      column: match[0].indexOf(template),
+      filePath,
+      language: 'php',
+    });
+  }
+  return { nodes, references };
+}
diff --git a/src/resolution/frameworks/symfony/yaml.ts b/src/resolution/frameworks/symfony/yaml.ts
new file mode 100644
index 0000000000..2e90b190c8
--- /dev/null
+++ b/src/resolution/frameworks/symfony/yaml.ts
@@ -0,0 +1,125 @@
+import { Node } from '../../../types';
+import { UnresolvedRef } from '../../types';
+
+export function extractYamlRoutes(
+  filePath: string,
+  content: string,
+  now: number
+): { nodes: Node[]; references: UnresolvedRef[] } {
+  const nodes: Node[] = [];
+  const references: UnresolvedRef[] = [];
+
+  // Skip YAML files without route- or service-specific keywords
+  if (!/^[\t ]*(?:controller|resource|services):/m.test(content)) return { nodes, references };
+
+  const lines = content.split('\n');
+  let currentRoute: { name: string; lineNum: number } | null = null;
+  let currentPathVal: string | null = null;
+  let currentController: string | null = null;
+  let currentMethods: string[] = [];
+  let currentPrefix: string | null = null;
+
+  const flushRoute = () => {
+    if (!currentRoute || !currentPathVal) return;
+    const effectivePath = currentPrefix ? currentPrefix + currentPathVal : currentPathVal;
+    const httpMethods = currentMethods.length > 0 ? currentMethods : ['ANY'];
+    for (const httpMethod of httpMethods) {
+      nodes.push({
+        id: `route:${filePath}:${currentRoute.lineNum}:${httpMethod}:${effectivePath}`,
+        kind: 'route',
+        name: `${httpMethod} ${effectivePath}`,
+        qualifiedName: `${filePath}::${currentRoute.name}`,
+        filePath,
+        startLine: currentRoute.lineNum,
+        endLine: currentRoute.lineNum,
+        startColumn: 0,
+        endColumn: 0,
+        language: 'yaml',
+        updatedAt: now,
+      });
+      if (currentController) {
+        references.push({
+          fromNodeId: `route:${filePath}:${currentRoute.lineNum}:${httpMethod}:${effectivePath}`,
+          referenceName: currentController,
+          referenceKind: 'references',
+          line: currentRoute.lineNum,
+          column: 0,
+          filePath,
+          language: 'yaml',
+        });
+      }
+    }
+  };
+
+  let inServicesBlock = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const indent = line.length - line.trimStart().length;
+    const keyValMatch = trimmed.match(/^([\w\-_.\\]+):\s*(.*)/);
+    if (!keyValMatch) continue;
+
+    const key = keyValMatch[1]!;
+    const val = keyValMatch[2]!.trim();
+
+    // Top-level key (column 0)
+    if (indent === 0) {
+      flushRoute();
+      currentRoute = null;
+      currentPathVal = null;
+      currentController = null;
+      currentMethods = [];
+      currentPrefix = null;
+      inServicesBlock = key === 'services';
+
+      if (!val || val.startsWith('#')) {
+        currentRoute = { name: key, lineNum: i + 1 };
+      } else if (!inServicesBlock && key !== 'services') {
+        currentRoute = { name: key, lineNum: i + 1 };
+        currentPathVal = val.replace(/^['"]|['"]$/g, '');
+      }
+      continue;
+    }
+
+    // Sub-key of current route
+    if (currentRoute && !inServicesBlock) {
+      if (key === 'path') {
+        const subVal = val.replace(/^['"]|['"]$/g, '').replace(/\s+#.*$/, '');
+        if (subVal) currentPathVal = subVal;
+      } else if (key === 'controller') {
+        const subVal = val.replace(/^['"]|['"]$/g, '').replace(/\s+#.*$/, '');
+        if (subVal) currentController = subVal;
+      } else if (key === 'methods') {
+        const m = val.match(/\[([^\]]*)\]/);
+        if (m) {
+          currentMethods = m[1]!.split(',').map(s => s.trim().replace(/['"]/g, '').toUpperCase()).filter(Boolean);
+        }
+      } else if (key === 'prefix') {
+        const subVal = val.replace(/^['"]|['"]$/g, '').replace(/\s+#.*$/, '');
+        if (subVal) currentPrefix = subVal;
+      }
+    }
+
+    // Service definitions under `services:`
+    if (inServicesBlock && indent > 0) {
+      const svcMatch = trimmed.match(/^([\w\\_.]+):\s*/);
+      if (svcMatch && svcMatch[1]!.includes('\\') && indent >= 2) {
+        references.push({
+          fromNodeId: `file:${filePath}`,
+          referenceName: svcMatch[1]!,
+          referenceKind: 'references',
+          line: i + 1,
+          column: 0,
+          filePath,
+          language: 'yaml',
+        });
+      }
+    }
+  }
+  flushRoute();
+
+  return { nodes, references };
+}
diff --git a/src/resolution/strip-comments.ts b/src/resolution/strip-comments.ts
index cead14864f..a4c6493dd9 100644
--- a/src/resolution/strip-comments.ts
+++ b/src/resolution/strip-comments.ts
@@ -289,8 +289,8 @@ function stripPhp(src: string): string {
       continue;
     }
 
-    // # line comment (PHP supports both)
-    if (c === '#') {
+    // # line comment (PHP supports both; NOT #[ which is a PHP 8 attribute)
+    if (c === '#' && c2 !== '[') {
       const start = i;
       while (i < n && src[i] !== '\n') i++;
       blankRange(out, start, i, src);