Merge remote-tracking branch 'origin/main' into pr-179-merge

feat(python): index module-level singleton instances as CodeElement nodes
- Add definition.instance query to PYTHON_QUERIES, anchored to module scope with call on right-hand side - Add definition.instance to DEFINITION_CAPTURE_KEYS and label maps in both sequential (parsing-processor.ts) and worker (parse-worker.ts) paths - Compose with #137: instances are now linkable targets for File->Symbol IMPORTS edges created by symbol-level import resolution
2026-03-09 17:30:55 +00:00 · 2026-03-05 17:18:12 -08:00
740 changed files with 3689 additions and 34207 deletions
@@ -22,7 +22,7 @@ Run from the project root. This parses all source files, builds the knowledge gr
 | `--force`      | Force full re-index even if up to date                           |
 | `--embeddings` | Enable embedding generation for semantic search (off by default) |

-**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated.
+**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale.

 ### status — Check index freshness

@@ -12,29 +12,29 @@ on:
 jobs:
  # ── Integration test matrix ─────────────────────────────────────────
  # Each test-group runs on a SEPARATE runner per OS, giving full process
-  # isolation for the LadybugDB native C++ addon.
+  # isolation for the KuzuDB native C++ addon.
  # 3 OS x 4 groups = 12 parallel jobs.
  #
  # Groups:
-  #   lbug-db    — 7 files using withTestLbugDB / lbug-adapter (native addon)
+  #   kuzu-db    — 7 files using withTestKuzuDB / kuzu-adapter (native addon)
  #                Each file runs as its own `vitest run` invocation for full
-  #                process isolation. LadybugDB's native N-API addon registers
+  #                process isolation. KuzuDB's native N-API addon registers
  #                persistent handles that prevent fork workers from exiting
  #                on Linux, and its C++ destructors segfault during
  #                process.exit(). Running each file in its own process lets
  #                the OS reclaim all resources cleanly.
-  #   pipeline   — 12 files: ingestion pipeline + csv + 9 resolver tests
-  #   e2e        — 2 files: child-process only (spawnSync), no in-process lbug
-  #   standalone — 4 files: pure logic, no lbug, no child processes
+  #   pipeline   — 3 files: ingestion pipeline + csv, each creates own temp DB
+  #   e2e        — 2 files: child-process only (spawnSync), no in-process kuzu
+  #   standalone — 4 files: pure logic, no kuzu, no child processes
  test-matrix:
    name: integration (${{ matrix.os }} / ${{ matrix.test-group }})
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
-        test-group: [lbug-db, pipeline, e2e, standalone]
+        test-group: [kuzu-db, pipeline, e2e, standalone]
        include:
-          - test-group: lbug-db
+          - test-group: kuzu-db
            # Marker — actual files are listed in the run step below
            test-glob: ''
          - test-group: pipeline
@@ -42,22 +42,10 @@ jobs:
              test/integration/pipeline.test.ts
              test/integration/csv-pipeline.test.ts
              test/integration/parsing.test.ts
-              test/integration/resolvers/typescript.test.ts
-              test/integration/resolvers/csharp.test.ts
-              test/integration/resolvers/cpp.test.ts
-              test/integration/resolvers/java.test.ts
-              test/integration/resolvers/python.test.ts
-              test/integration/resolvers/rust.test.ts
-              test/integration/resolvers/go.test.ts
-              test/integration/resolvers/kotlin.test.ts
-              test/integration/resolvers/php.test.ts
-              test/integration/resolvers/ruby.test.ts
-              test/integration/resolvers/swift.test.ts
          - test-group: e2e
            test-glob: >-
              test/integration/cli-e2e.test.ts
              test/integration/hooks-e2e.test.ts
-              test/integration/skills-e2e.test.ts
          - test-group: standalone
            test-glob: >-
              test/integration/filesystem-walker.test.ts
@@ -65,25 +53,25 @@ jobs:
              test/integration/tree-sitter-languages.test.ts
              test/integration/worker-pool.test.ts
    runs-on: ${{ matrix.os }}
-    timeout-minutes: 25
+    timeout-minutes: 15
    steps:
      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
      - uses: ./.github/actions/setup-gitnexus
        with:
          build: 'true'

-      # lbug-db: run each file in its own vitest process for full isolation.
-      # LadybugDB's native addon hangs fork workers on Linux — process isolation
+      # kuzu-db: run each file in its own vitest process for full isolation.
+      # KuzuDB's native addon hangs fork workers on Linux — process isolation
      # is the only reliable fix boundary.
-      - name: Run integration tests — lbug-db (process-isolated)
-        if: matrix.test-group == 'lbug-db'
+      - name: Run integration tests — kuzu-db (process-isolated)
+        if: matrix.test-group == 'kuzu-db'
        working-directory: gitnexus
        shell: bash
        run: |
          set -e
          files=(
-            test/integration/lbug-core-adapter.test.ts
-            test/integration/lbug-pool.test.ts
+            test/integration/kuzu-core-adapter.test.ts
+            test/integration/kuzu-pool.test.ts
            test/integration/local-backend.test.ts
            test/integration/local-backend-calltool.test.ts
            test/integration/search-core.test.ts
@@ -101,9 +89,9 @@ jobs:
          done
          exit $exit_code

-      # Non-lbug groups: run all files in a single vitest invocation
+      # Non-kuzu groups: run all files in a single vitest invocation
      - name: Run integration tests — ${{ matrix.test-group }}
-        if: matrix.test-group != 'lbug-db'
+        if: matrix.test-group != 'kuzu-db'
        shell: bash
        env:
          TEST_GLOB: ${{ matrix.test-glob }}
@@ -111,9 +99,9 @@ jobs:
        working-directory: gitnexus

  # ── Coverage collection (ubuntu only) ─────────────────────────────────
-  # Runs non-lbug integration tests with coverage enabled so the PR report
+  # Runs non-kuzu integration tests with coverage enabled so the PR report
  # can merge integration + unit coverage for a combined view.
-  # lbug-db tests are excluded because each file must run in its own vitest
+  # kuzu-db tests are excluded because each file must run in its own vitest
  # process (native addon isolation) which prevents single-run coverage merge.
  coverage:
    name: integration (ubuntu / coverage)
@@ -152,17 +140,6 @@ jobs:
          test/integration/enrichment.test.ts
          test/integration/tree-sitter-languages.test.ts
          test/integration/worker-pool.test.ts
-          test/integration/resolvers/typescript.test.ts
-          test/integration/resolvers/csharp.test.ts
-          test/integration/resolvers/cpp.test.ts
-          test/integration/resolvers/java.test.ts
-          test/integration/resolvers/python.test.ts
-          test/integration/resolvers/rust.test.ts
-          test/integration/resolvers/go.test.ts
-          test/integration/resolvers/kotlin.test.ts
-          test/integration/resolvers/php.test.ts
-          test/integration/resolvers/ruby.test.ts
-          test/integration/resolvers/swift.test.ts

      - name: Upload integration coverage
        if: always()
@@ -119,66 +119,6 @@ jobs:
          sparse-checkout: gitnexus/vitest.config.ts
          sparse-checkout-cone-mode: false

-      # ── Fetch base branch coverage for delta reporting ───────────
-      - name: Fetch base branch coverage
-        if: steps.meta.outputs.skip != 'true'
-        id: base-coverage
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
-        with:
-          script: |
-            const fs = require('fs');
-            const path = require('path');
-
-            // Find the latest successful CI run on main
-            const runs = await github.rest.actions.listWorkflowRuns({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              workflow_id: 'ci.yml',
-              branch: 'main',
-              status: 'success',
-              per_page: 1,
-            });
-
-            if (runs.data.workflow_runs.length === 0) {
-              core.setOutput('found', 'false');
-              core.info('No successful main branch CI runs found');
-              return;
-            }
-
-            const mainRunId = runs.data.workflow_runs[0].id;
-            const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              run_id: mainRunId,
-            });
-
-            const testReports = artifacts.data.artifacts.find(a => a.name === 'test-reports');
-            if (!testReports) {
-              core.setOutput('found', 'false');
-              core.info('No test-reports artifact on main branch');
-              return;
-            }
-
-            const zip = await github.rest.actions.downloadArtifact({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              artifact_id: testReports.id,
-              archive_format: 'zip',
-            });
-
-            const dest = path.join(process.env.RUNNER_TEMP, 'base-coverage');
-            fs.mkdirSync(dest, { recursive: true });
-            fs.writeFileSync(path.join(dest, 'base.zip'), Buffer.from(zip.data));
-            core.setOutput('found', 'true');
-            core.setOutput('dir', dest);
-
-      - name: Extract base coverage
-        if: steps.meta.outputs.skip != 'true' && steps.base-coverage.outputs.found == 'true'
-        shell: bash
-        run: |
-          cd "${{ steps.base-coverage.outputs.dir }}"
-          unzip -o base.zip -d base
-
      # ── Merge coverage from unit + integration ─────────────────────
      - name: Setup Node.js
        if: steps.meta.outputs.skip != 'true'
@@ -243,14 +183,13 @@ jobs:
          UNIT: ${{ steps.meta.outputs.unit }}
          INTEG: ${{ steps.meta.outputs.integration }}
          HAS_MERGED: ${{ steps.coverage.outputs.has_merged }}
-          BASE_FOUND: ${{ steps.base-coverage.outputs.found }}
-          BASE_DIR: ${{ steps.base-coverage.outputs.dir }}
          RUN_URL: ${{ github.event.workflow_run.html_url }}
        run: |
          DIR="$RUNNER_TEMP/artifacts"
          MERGED_DIR="$RUNNER_TEMP/merged-coverage"

          # ── Helper: read coverage summary into prefixed vars ──
+          # Uses printf -v for safe variable assignment (no eval).
          read_cov() {
            local prefix=$1 file=$2
            if [ -n "$file" ] && [ -f "$file" ]; then
@@ -285,7 +224,7 @@ jobs:
            fi
          }

-          # ── Read all coverage reports ──
+          # ── Read all three coverage reports ──
          UNIT_SUMMARY=$(find "$DIR/test-reports" -name "coverage-summary.json" -type f 2>/dev/null | head -1)
          INTEG_SUMMARY=$(find "$DIR/integration-reports" -name "coverage-summary.json" -type f 2>/dev/null | head -1)
          MERGED_SUMMARY="$MERGED_DIR/coverage-summary.json"
@@ -296,14 +235,7 @@ jobs:
          HAS_INTEG=$?
          read_cov "M" "$MERGED_SUMMARY"

-          # ── Read base branch coverage (main) ──
-          BASE_SUMMARY=""
-          if [ "$BASE_FOUND" = "true" ] && [ -n "$BASE_DIR" ]; then
-            BASE_SUMMARY=$(find "$BASE_DIR/base" -name "coverage-summary.json" -type f 2>/dev/null | head -1)
-          fi
-          read_cov "B" "$BASE_SUMMARY"
-
-          # ── Locate test results ──
+          # ── Locate test results (unit) ──
          RESULTS_FILE=$(find "$DIR/test-reports" -name "test-results.json" -type f 2>/dev/null | head -1)
          INTEG_RESULTS=$(find "$DIR/integration-reports" -name "integration-results.json" -type f 2>/dev/null | head -1)

@@ -335,6 +267,17 @@ jobs:
          FAILED=$((U_FAILED + I_FAILED))
          SKIPPED=$((U_SKIPPED + I_SKIPPED))
          SUITES=$((U_SUITES + I_SUITES))
+          DURATION=$((U_DURATION + I_DURATION))
+
+          # ── Coverage thresholds (read from vitest.config.ts) ──
+          if [ -f gitnexus/vitest.config.ts ]; then
+            THRESH_STMTS=$(grep -oP 'statements:\s*\K[0-9]+' gitnexus/vitest.config.ts || echo 0)
+            THRESH_BRANCH=$(grep -oP 'branches:\s*\K[0-9]+' gitnexus/vitest.config.ts || echo 0)
+            THRESH_FUNCS=$(grep -oP 'functions:\s*\K[0-9]+' gitnexus/vitest.config.ts || echo 0)
+            THRESH_LINES=$(grep -oP 'lines:\s*\K[0-9]+' gitnexus/vitest.config.ts || echo 0)
+          else
+            THRESH_STMTS=0; THRESH_BRANCH=0; THRESH_FUNCS=0; THRESH_LINES=0
+          fi

          # ── Status helpers ──
          status_icon() {
@@ -346,22 +289,8 @@ jobs:
            esac
          }

-          cov_delta() {
-            local pct=$1 base=$2
-            if [ "$pct" = "N/A" ] || [ "$base" = "N/A" ]; then echo "—"; return; fi
-            local diff
-            diff=$(awk "BEGIN { printf \"%.1f\", $pct - $base }")
-            if [ "$(awk "BEGIN { print ($pct > $base) ? 1 : 0 }")" = "1" ]; then
-              echo "📈 +${diff}"
-            elif [ "$(awk "BEGIN { print ($pct < $base) ? 1 : 0 }")" = "1" ]; then
-              echo "📉 ${diff}"
-            else
-              echo "＝ ${diff}"
-            fi
-          }
-
          cov_bar() {
-            local pct=$1 base=$2
+            local pct=$1 thresh=$2
            if [ "$pct" = "N/A" ]; then echo "—"; return; fi
            local filled
            filled=$(awk "BEGIN { printf \"%d\", $pct / 5 }")
@@ -371,8 +300,7 @@ jobs:
            local bar=""
            for ((i=0; i<filled; i++)); do bar+="█"; done
            for ((i=0; i<empty; i++)); do bar+="░"; done
-            # Green if >= base (or base unavailable), red if dropped
-            if [ "$base" = "N/A" ] || [ "$(awk "BEGIN { print ($pct >= $base) ? 1 : 0 }")" = "1" ]; then
+            if [ "$(awk "BEGIN { print ($pct >= $thresh) ? 1 : 0 }")" = "1" ]; then
              echo "🟢 ${bar}"
            else
              echo "🔴 ${bar}"
@@ -405,50 +333,18 @@ jobs:
            if [ "$TOTAL" -gt 0 ] 2>/dev/null; then
              echo "### Test Results"
              echo ""
-              echo "| Suite | Tests | Passed | Failed | Skipped | Duration |"
-              echo "|-------|-------|--------|--------|---------|----------|"
-              if [ "$U_TOTAL" -gt 0 ] 2>/dev/null; then
-                echo "| Unit | ${U_TOTAL} | ${U_PASSED} | ${U_FAILED} | ${U_SKIPPED} | ${U_DURATION}s |"
-              fi
-              if [ "$I_TOTAL" -gt 0 ] 2>/dev/null; then
-                echo "| Integration | ${I_TOTAL} | ${I_PASSED} | ${I_FAILED} | ${I_SKIPPED} | ${I_DURATION}s |"
-              fi
-              echo "| **Total** | **${TOTAL}** | **${PASSED}** | **${FAILED}** | **${SKIPPED}** | **$((U_DURATION + I_DURATION))s** |"
-              echo ""
-
              if [ "$FAILED" = "0" ]; then
-                echo "✅ All **${PASSED}** tests passed"
+                echo "✅ **${PASSED}** passed"
              else
                echo "❌ **${FAILED}** failed / **${PASSED}** passed"
              fi
              if [ "$SKIPPED" != "0" ]; then
-                echo ""
-                echo "<details>"
-                echo "<summary>${SKIPPED} test(s) skipped — expand for details</summary>"
-                echo ""
-                # Extract skipped test names from integration results
-                if [ -n "$INTEG_RESULTS" ] && [ "$I_SKIPPED" -gt 0 ] 2>/dev/null; then
-                  echo "**Integration:**"
-                  jq -r '
-                    .testResults[]
-                    | .assertionResults[]?
-                    | select(.status == "pending" or .status == "skipped")
-                    | "- \(.ancestorTitles | join(" > ")) > \(.title)"
-                  ' "$INTEG_RESULTS" 2>/dev/null || echo "- _(unable to parse skipped test details)_"
-                fi
-                # Extract skipped test names from unit results
-                if [ -n "$RESULTS_FILE" ] && [ "$U_SKIPPED" -gt 0 ] 2>/dev/null; then
-                  echo ""
-                  echo "**Unit:**"
-                  jq -r '
-                    .testResults[]
-                    | .assertionResults[]?
-                    | select(.status == "pending" or .status == "skipped")
-                    | "- \(.ancestorTitles | join(" > ")) > \(.title)"
-                  ' "$RESULTS_FILE" 2>/dev/null || echo "- _(unable to parse skipped test details)_"
-                fi
-                echo ""
-                echo "</details>"
+                echo " · ${SKIPPED} skipped"
+              fi
+              echo " · ${SUITES} suites · ${TOTAL} total"
+              echo " · ⏱️ ${DURATION}s"
+              if [ "$I_TOTAL" -gt 0 ] 2>/dev/null; then
+                echo " · 📊 ${U_TOTAL} unit + ${I_TOTAL} integration"
              fi
              echo ""
            fi
@@ -457,15 +353,15 @@ jobs:
            cov_table() {
              local label=$1 s=$2 b=$3 f=$4 l=$5 sc=$6 bc=$7 fc=$8 lc=$9
              shift 9
-              local bs=$1 bb=$2 bf=$3 bl=$4
+              local ts=$1 tb=$2 tf=$3 tl=$4
              echo "#### ${label}"
              echo ""
-              echo "| Metric | Coverage | Covered | Base | Delta | Status |"
-              echo "|--------|----------|---------|------|-------|--------|"
-              echo "| Statements | **${s}%** | ${sc} | ${bs}% | $(cov_delta "$s" "$bs") | $(cov_bar "$s" "$bs") |"
-              echo "| Branches | **${b}%** | ${bc} | ${bb}% | $(cov_delta "$b" "$bb") | $(cov_bar "$b" "$bb") |"
-              echo "| Functions | **${f}%** | ${fc} | ${bf}% | $(cov_delta "$f" "$bf") | $(cov_bar "$f" "$bf") |"
-              echo "| Lines | **${l}%** | ${lc} | ${bl}% | $(cov_delta "$l" "$bl") | $(cov_bar "$l" "$bl") |"
+              echo "| Metric | Coverage | Covered | Threshold | Status |"
+              echo "|--------|----------|---------|-----------|--------|"
+              echo "| Statements | **${s}%** | ${sc} | ${ts}% | $(cov_bar "$s" "$ts") |"
+              echo "| Branches | **${b}%** | ${bc} | ${tb}% | $(cov_bar "$b" "$tb") |"
+              echo "| Functions | **${f}%** | ${fc} | ${tf}% | $(cov_bar "$f" "$tf") |"
+              echo "| Lines | **${l}%** | ${lc} | ${tl}% | $(cov_bar "$l" "$tl") |"
              echo ""
            }

@@ -475,7 +371,7 @@ jobs:
              cov_table "Combined (Unit + Integration)" \
                "$M_STMTS" "$M_BRANCH" "$M_FUNCS" "$M_LINES" \
                "$M_STMTS_COV" "$M_BRANCH_COV" "$M_FUNCS_COV" "$M_LINES_COV" \
-                "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
+                "$THRESH_STMTS" "$THRESH_BRANCH" "$THRESH_FUNCS" "$THRESH_LINES"

              echo "<details>"
              echo "<summary>Coverage breakdown by test suite</summary>"
@@ -484,23 +380,37 @@ jobs:
                cov_table "Unit Tests" \
                  "$U_STMTS" "$U_BRANCH" "$U_FUNCS" "$U_LINES" \
                  "$U_STMTS_COV" "$U_BRANCH_COV" "$U_FUNCS_COV" "$U_LINES_COV" \
-                  "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
+                  "$THRESH_STMTS" "$THRESH_BRANCH" "$THRESH_FUNCS" "$THRESH_LINES"
              fi
              if [ "$I_STMTS" != "N/A" ]; then
                cov_table "Integration Tests" \
                  "$I_STMTS" "$I_BRANCH" "$I_FUNCS" "$I_LINES" \
                  "$I_STMTS_COV" "$I_BRANCH_COV" "$I_FUNCS_COV" "$I_LINES_COV" \
-                  "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
+                  "$THRESH_STMTS" "$THRESH_BRANCH" "$THRESH_FUNCS" "$THRESH_LINES"
              fi
              echo "</details>"
              echo ""
+              echo "<details>"
+              echo "<summary>Coverage thresholds are auto-ratcheted — they only go up</summary>"
+              echo ""
+              echo "Vitest \`thresholds.autoUpdate\` bumps the floor whenever local coverage exceeds it."
+              echo "CI enforces the current thresholds; developers commit the ratcheted values."
+              echo "</details>"
+              echo ""
            elif [ "$U_STMTS" != "N/A" ]; then
              echo "### Code Coverage (Unit only)"
              echo ""
              cov_table "Unit Tests" \
                "$U_STMTS" "$U_BRANCH" "$U_FUNCS" "$U_LINES" \
                "$U_STMTS_COV" "$U_BRANCH_COV" "$U_FUNCS_COV" "$U_LINES_COV" \
-                "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
+                "$THRESH_STMTS" "$THRESH_BRANCH" "$THRESH_FUNCS" "$THRESH_LINES"
+              echo "<details>"
+              echo "<summary>Coverage thresholds are auto-ratcheted — they only go up</summary>"
+              echo ""
+              echo "Vitest \`thresholds.autoUpdate\` bumps the floor whenever local coverage exceeds it."
+              echo "CI enforces the current thresholds; developers commit the ratcheted values."
+              echo "</details>"
+              echo ""
            else
              echo "### Code Coverage"
              echo ""
@@ -48,9 +48,6 @@ coverage/
 # Claude Code worktrees
 .claude/worktrees/

-# Claude code skills
-.claude/skills/generated/
-
 # Assets (screenshots, images)
 assets/

@@ -62,9 +59,4 @@ docs/plans/

 gitnexus/test/fixtures/mini-repo/*.md
 gitnexus/test/fixtures/mini-repo/.claude
-gitnexus/test/fixtures/mini-repo/.gitignore
-
-# Ignore csharp generated obj and bin folders
-gitnexus/test/fixtures/lang-resolution/**/obj
-gitnexus/test/fixtures/lang-resolution/**/bin
-GitNexus.sln
+gitnexus/test/fixtures/mini-repo/.gitignore
@@ -1,7 +1,7 @@
 <!-- gitnexus:start -->
 # GitNexus — Code Intelligence

-This project is indexed by GitNexus as **GitNexus** (1999 symbols, 4681 relationships, 149 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **GitNexus** (1650 symbols, 4291 relationships, 125 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.

 > If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.

@@ -69,33 +69,10 @@ Before completing any code modification task, verify:
 3. `gitnexus_detect_changes()` confirms changes match expected scope
 4. All d=1 (WILL BREAK) dependents were updated

-## Keeping the Index Fresh
-
-After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
-
-```bash
-npx gitnexus analyze
-```
-
-If the index previously included embeddings, preserve them by adding `--embeddings`:
-
-```bash
-npx gitnexus analyze --embeddings
-```
-
-To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.**
-
-> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`.
-
 ## CLI

-| Task | Read this skill file |
-|------|---------------------|
-| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
-| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
-| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
-| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
-| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
-| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
+- Re-index: `npx gitnexus analyze`
+- Check freshness: `npx gitnexus status`
+- Generate docs: `npx gitnexus wiki`

 <!-- gitnexus:end -->
@@ -2,50 +2,6 @@

 All notable changes to GitNexus will be documented in this file.

-## [Unreleased]
-
-### Changed
- Migrated from KuzuDB to LadybugDB v0.15 (`@ladybugdb/core`, `@ladybugdb/wasm-core`)
- Renamed all internal paths from `kuzu` to `lbug` (storage: `.gitnexus/kuzu` → `.gitnexus/lbug`)
- Added automatic cleanup of stale KuzuDB index files
- LadybugDB v0.15 requires explicit VECTOR extension loading for semantic search
-
-## [1.4.0] - 2026-03-13
-
-### Added
-
- **Language-aware symbol resolution engine** with 3-tier resolver: exact FQN → scope-walk → guarded fuzzy fallback that refuses ambiguous matches (#238) — @magyargergo
- **Method Resolution Order (MRO)** with 5 language-specific strategies: C++ leftmost-base, C#/Java class-over-interface, Python C3 linearization, Rust qualified syntax, default BFS (#238) — @magyargergo
- **Constructor & struct literal resolution** across all languages — `new Foo()`, `User{...}`, C# primary constructors, target-typed new (#238) — @magyargergo
- **Receiver-constrained resolution** using per-file TypeEnv — disambiguates `user.save()` vs `repo.save()` via `ownerId` matching (#238) — @magyargergo
- **Heritage & ownership edges** — HAS_METHOD, OVERRIDES, Go struct embedding, Swift extension heritage, method signatures (`parameterCount`, `returnType`) (#238) — @magyargergo
- **Language-specific resolver directory** (`resolvers/`) — extracted JVM, Go, C#, PHP, Rust resolvers from monolithic import-processor (#238) — @magyargergo
- **Type extractor directory** (`type-extractors/`) — per-language type binding extraction with `Record<SupportedLanguages, Handler>` + `satisfies` dispatch (#238) — @magyargergo
- **Export detection dispatch table** — compile-time exhaustive `Record` + `satisfies` pattern replacing switch/if chains (#238) — @magyargergo
- **Language config module** (`language-config.ts`) — centralized tsconfig, go.mod, composer.json, .csproj, Swift package config loaders (#238) — @magyargergo
- **Optional skill generation** via `npx gitnexus analyze --skills` — generates AI agent skills from KuzuDB knowledge graph (#171) — @zander-raycraft
- **First-class C# support** — sibling-based modifier scanning, record/delegate/property/field/event declaration types (#163, #170, #178 via #237) — @Alice523, @benny-yamagata, @jnMetaCode
- **C/C++ support fixes** — `.h` → C++ mapping, static-linkage export detection, qualified/parenthesized declarators, 48 entry point patterns (#163, #227 via #237) — @Alice523, @bitgineer
- **Rust support fixes** — sibling-based `visibility_modifier` scanning for `pub` detection (#227 via #237) — @bitgineer
- **Adaptive tree-sitter buffer sizing** — `Math.min(Math.max(contentLength * 2, 512KB), 32MB)` (#216 via #237) — @JasonOA888
- **Call expression matching** in tree-sitter queries (#234 via #237) — @ex-nihilo-jg
- **DeepSeek model configurations** (#217) — @JasonOA888
- 282+ new unit tests, 178 integration resolver tests across 9 languages, 53 test files, 1146 total tests passing
-
-### Fixed
-
- Skip unavailable native Swift parsers in sequential ingestion (#188) — @Gujiassh
- Heritage heuristic language-gated — no longer applies class/interface rules to wrong languages (#238) — @magyargergo
- C# `base_list` distinguishes EXTENDS vs IMPLEMENTS via symbol table + `I[A-Z]` heuristic (#238) — @magyargergo
- Go `qualified_type` (`models.User`) correctly unwrapped in TypeEnv (#238) — @magyargergo
- Global tier no longer blocks resolution when kind/arity filtering can narrow to 1 candidate (#238) — @magyargergo
-
-### Changed
-
- `import-processor.ts` reduced from 1412 → 711 lines (50% reduction) via resolver and config extraction (#238) — @magyargergo
- `type-env.ts` reduced from 635 → ~125 lines via type-extractor extraction (#238) — @magyargergo
- CI/CD workflows hardened with security fixes and fork PR support (#222, #225) — @magyargergo
-
 ## [1.3.11] - 2026-03-08

 ### Security
@@ -1,7 +1,7 @@
 <!-- gitnexus:start -->
 # GitNexus — Code Intelligence

-This project is indexed by GitNexus as **GitNexus** (1999 symbols, 4681 relationships, 149 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **GitNexus** (1650 symbols, 4291 relationships, 125 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.

 > If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.

@@ -69,33 +69,10 @@ Before completing any code modification task, verify:
 3. `gitnexus_detect_changes()` confirms changes match expected scope
 4. All d=1 (WILL BREAK) dependents were updated

-## Keeping the Index Fresh
-
-After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
-
-```bash
-npx gitnexus analyze
-```
-
-If the index previously included embeddings, preserve them by adding `--embeddings`:
-
-```bash
-npx gitnexus analyze --embeddings
-```
-
-To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.**
-
-> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`.
-
 ## CLI

-| Task | Read this skill file |
-|------|---------------------|
-| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
-| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
-| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
-| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
-| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
-| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
+- Re-index: `npx gitnexus analyze`
+- Check freshness: `npx gitnexus status`
+- Generate docs: `npx gitnexus wiki`

 <!-- gitnexus:end -->
@@ -51,7 +51,7 @@ https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72
 | **For**     | Daily development with Cursor, Claude Code, Windsurf, OpenCode | Quick exploration, demos, one-off analysis                   |
 | **Scale**   | Full repos, any size                                           | Limited by browser memory (~5k files), or unlimited via backend mode |
 | **Install** | `npm install -g gitnexus`                                    | No install —[gitnexus.vercel.app](https://gitnexus.vercel.app) |
-| **Storage** | LadybugDB native (fast, persistent)                               | LadybugDB WASM (in-memory, per session)                         |
+| **Storage** | KuzuDB native (fast, persistent)                               | KuzuDB WASM (in-memory, per session)                         |
 | **Parsing** | Tree-sitter native bindings                                    | Tree-sitter WASM                                             |
 | **Privacy** | Everything local, no network                                   | Everything in-browser, no server                             |

@@ -135,10 +135,7 @@ claude mcp add gitnexus -- npx -y gitnexus@latest mcp
 gitnexus setup                    # Configure MCP for your editors (one-time)
 gitnexus analyze [path]           # Index a repository (or update stale index)
 gitnexus analyze --force          # Force full re-index
-gitnexus analyze --skills         # Generate repo-specific skill files from detected communities
 gitnexus analyze --skip-embeddings  # Skip embedding generation (faster)
-gitnexus analyze --embeddings     # Enable embedding generation (slower, better search)
-gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI connection
 gitnexus list                    # List all indexed repositories
@@ -192,10 +189,6 @@ gitnexus wiki --base-url <url>   # Wiki with custom LLM API base URL
 - **Impact Analysis** — Analyze blast radius before changes
 - **Refactoring** — Plan safe refactors using dependency mapping

-**Repo-specific skills** generated with `--skills`:
-
-When you run `gitnexus analyze --skills`, GitNexus detects the functional areas of your codebase (via Leiden community detection) and generates a `SKILL.md` file for each one under `.claude/skills/generated/`. Each skill describes a module's key files, entry points, execution flows, and cross-area connections — so your AI agent gets targeted context for the exact area of code you're working in. Skills are regenerated on each `--skills` run to stay current with the codebase.
-
 ---

 ## Multi-Repo MCP Architecture
@@ -224,8 +217,8 @@ flowchart TD
        Server["server.ts"]
        Backend["LocalBackend"]
        Pool["Connection Pool"]
-        ConnA["LadybugDB conn A"]
-        ConnB["LadybugDB conn B"]
+        ConnA["KuzuDB conn A"]
+        ConnB["KuzuDB conn B"]
    end

    Setup -->|"writes global MCP config"| CursorConfig["~/.cursor/mcp.json"]
@@ -242,7 +235,7 @@ flowchart TD
    ConnB -->|"queries"| RepoB
 ```

-**How it works:** Each `gitnexus analyze` stores the index in `.gitnexus/` inside the repo (portable, gitignored) and registers a pointer in `~/.gitnexus/registry.json`. When an AI agent starts, the MCP server reads the registry and can serve any indexed repo. LadybugDB connections are opened lazily on first query and evicted after 5 minutes of inactivity (max 5 concurrent). If only one repo is indexed, the `repo` parameter is optional on all tools — agents don't need to change anything.
+**How it works:** Each `gitnexus analyze` stores the index in `.gitnexus/` inside the repo (portable, gitignored) and registers a pointer in `~/.gitnexus/registry.json`. When an AI agent starts, the MCP server reads the registry and can serve any indexed repo. KuzuDB connections are opened lazily on first query and evicted after 5 minutes of inactivity (max 5 concurrent). If only one repo is indexed, the `repo` parameter is optional on all tools — agents don't need to change anything.

 ---

@@ -263,7 +256,7 @@ npm install
 npm run dev
 ```

-The web UI uses the same indexing pipeline as the CLI but runs entirely in WebAssembly (Tree-sitter WASM, LadybugDB WASM, in-browser embeddings). It's great for quick exploration but limited by browser memory for larger repos.
+The web UI uses the same indexing pipeline as the CLI but runs entirely in WebAssembly (Tree-sitter WASM, KuzuDB WASM, in-browser embeddings). It's great for quick exploration but limited by browser memory for larger repos.

 **Local Backend Mode:** Run `gitnexus serve` and open the web UI locally — it auto-detects the server and shows all your indexed repos, with full AI chat support. No need to re-upload or re-index. The agent's tools (Cypher queries, search, code navigation) route through the backend HTTP API automatically.

@@ -320,30 +313,14 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas

 1. **Structure** — Walks the file tree and maps folder/file relationships
 2. **Parsing** — Extracts functions, classes, methods, and interfaces using Tree-sitter ASTs
-3. **Resolution** — Resolves imports, function calls, heritage, constructor inference, and `self`/`this` receiver types across files with language-aware logic
+3. **Resolution** — Resolves imports and function calls across files with language-aware logic
 4. **Clustering** — Groups related symbols into functional communities
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval

 ### Supported Languages

-| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points |
-|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------|
-| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
-| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ |
-| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
-| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-
-**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
+TypeScript, JavaScript, Python, Java, Kotlin, C, C++, C#, Go, Rust, PHP, Swift

 ---

@@ -482,7 +459,7 @@ The wiki generator reads the indexed graph structure, groups files into modules
 | ------------------------- | ------------------------------------- | --------------------------------------- |
 | **Runtime**         | Node.js (native)                      | Browser (WASM)                          |
 | **Parsing**         | Tree-sitter native bindings           | Tree-sitter WASM                        |
-| **Database**        | LadybugDB native                         | LadybugDB WASM                             |
+| **Database**        | KuzuDB native                         | KuzuDB WASM                             |
 | **Embeddings**      | HuggingFace transformers.js (GPU/CPU) | transformers.js (WebGPU/WASM)           |
 | **Search**          | BM25 + semantic + RRF                 | BM25 + semantic + RRF                   |
 | **Agent Interface** | MCP (stdio)                           | LangChain ReAct agent                   |
@@ -503,10 +480,9 @@ The wiki generator reads the indexed graph structure, groups files into modules

 ### Recently Completed

- [X] Constructor-Inferred Type Resolution, `self`/`this` Receiver Mapping
 - [X] Wiki Generation, Multi-File Rename, Git-Diff Impact Analysis
 - [X] Process-Grouped Search, 360-Degree Context, Claude Code Hooks
- [X] Multi-Repo MCP, Zero-Config Setup, 13 Language Support
+- [X] Multi-Repo MCP, Zero-Config Setup, 11 Language Support
 - [X] Community Detection, Process Detection, Confidence Scoring
 - [X] Hybrid Search, Vector Index

@@ -523,7 +499,7 @@ The wiki generator reads the indexed graph structure, groups files into modules
 ## Acknowledgments

 - [Tree-sitter](https://tree-sitter.github.io/) — AST parsing
- [LadybugDB](https://ladybugdb.com/) — Embedded graph database with vector support (formerly KuzuDB)
+- [KuzuDB](https://kuzudb.com/) — Embedded graph database with vector support
 - [Sigma.js](https://www.sigmajs.org/) — WebGL graph rendering
 - [transformers.js](https://huggingface.co/docs/transformers.js) — Browser ML
 - [Graphology](https://graphology.github.io/) — Graph data structures
@@ -148,7 +148,7 @@ Each mode has a `system_{mode}.jinja` + `instance_{mode}.jinja` pair. The agent

 1. Docker container starts with SWE-bench instance (repo at specific commit)
 2. **GitNexus setup**: Node.js + gitnexus installed, `gitnexus analyze` runs (or restores from cache)
-3. **Eval-server starts**: `gitnexus eval-server` daemon (persistent HTTP server, keeps LadybugDB warm)
+3. **Eval-server starts**: `gitnexus eval-server` daemon (persistent HTTP server, keeps KuzuDB warm)
 4. **Standalone tool scripts installed** in `/usr/local/bin/` — works with `subprocess.run` (no `.bashrc` needed)
 5. Agent runs with the configured model + system prompt + GitNexus tools
 6. Agent's patch is extracted as a git diff
@@ -167,7 +167,7 @@ Each tool script in `/usr/local/bin/` is standalone — no sourcing, no env inhe
 ### Eval-server

 The eval-server is a lightweight HTTP daemon that:
- Keeps LadybugDB warm in memory (no cold start per tool call)
+- Keeps KuzuDB warm in memory (no cold start per tool call)
 - Returns LLM-friendly text (not raw JSON — saves tokens)
 - Includes next-step hints to guide tool chaining (query → context → impact → fix)
 - Auto-shuts down after idle timeout
@@ -1,13 +0,0 @@
-model: deepseek-ai/deepseek-chat
-provider: openrouter
-cost:
-  input: 0.14  # per 1M tokens
-  output: 0.28  # per 1M tokens
-  
-# Native DeepSeek API (direct)
-api_key: null
-base_url: null
-
-# For OpenRouter, uncomment below and comment out direct config above
-# api_key: \${OPENROUTER_API_KEY}
-# base_url: https://openrouter.ai/api/v1
@@ -1,15 +0,0 @@
-model: deepseek-ai/DeepSeek-V3
-provider: openrouter
-cost:
-  input: 0.27  # per 1M tokens
-  output: 1.10  # per 1M tokens
-  
-# Native DeepSeek API (direct)
-# Get your API key at: https://platform.deepseek.com/
-# Or use OpenRouter with: OPENROUTER_API_KEY
-api_key: null
-base_url: null
-
-# For OpenRouter, uncomment below and comment out direct config above
-# api_key: \${OPENROUTER_API_KEY}
-# base_url: https://openrouter.ai/api/v1
@@ -160,7 +160,7 @@ function handlePreToolUse(input) {
 * PostToolUse handler — detect index staleness after git mutations.
 *
 * Instead of spawning a full `gitnexus analyze` synchronously (which blocks
- * the agent for up to 120s and risks LadybugDB corruption on timeout), we do a
+ * the agent for up to 120s and risks KuzuDB corruption on timeout), we do a
 * lightweight staleness check: compare `git rev-parse HEAD` against the
 * lastCommit stored in `.gitnexus/meta.json`. If they differ, notify the
 * agent so it can decide when to reindex.
@@ -10,7 +10,6 @@
      "dependencies": {
        "@huggingface/transformers": "^3.0.0",
        "@isomorphic-git/lightning-fs": "^4.6.2",
-        "@ladybugdb/wasm-core": "^0.15.1",
        "@langchain/anthropic": "^1.3.10",
        "@langchain/core": "^1.1.15",
        "@langchain/google-genai": "^2.1.10",
@@ -31,6 +30,7 @@
        "graphology-utils": "^2.3.0",
        "isomorphic-git": "^1.36.1",
        "jszip": "^3.10.1",
+        "kuzu-wasm": "^0.11.1",
        "langchain": "^1.2.10",
        "lru-cache": "^11.2.4",
        "lucide-react": "^0.562.0",
@@ -1643,30 +1643,6 @@
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
-    "node_modules/@ladybugdb/wasm-core": {
-      "version": "0.15.1",
-      "resolved": "https://registry.npmjs.org/@ladybugdb/wasm-core/-/wasm-core-0.15.1.tgz",
-      "integrity": "sha512-dHEq8inJQBkHnJrqZMKGdltSfeSv9OHECkzWQixqDLApXXGlbJ5Ugq5rRfk2PLJuZ74LVHT0cZvcn4JLmsnAIA==",
-      "license": "MIT",
-      "dependencies": {
-        "threads": "^1.7.0",
-        "tiny-worker": "^2.3.0",
-        "uuid": "^11.0.3"
-      }
-    },
-    "node_modules/@ladybugdb/wasm-core/node_modules/uuid": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
-      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
-      "funding": [
-        "https://github.com/sponsors/broofa",
-        "https://github.com/sponsors/ctavan"
-      ],
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/esm/bin/uuid"
-      }
-    },
    "node_modules/@langchain/anthropic": {
      "version": "1.3.10",
      "resolved": "https://registry.npmjs.org/@langchain/anthropic/-/anthropic-1.3.10.tgz",
@@ -6218,6 +6194,31 @@
      "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz",
      "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="
    },
+    "node_modules/kuzu-wasm": {
+      "version": "0.11.3",
+      "resolved": "https://registry.npmjs.org/kuzu-wasm/-/kuzu-wasm-0.11.3.tgz",
+      "integrity": "sha512-+bLOqXgYZJJ2dHJG1y9LTLyb9ZB73eLxErRZahZz2rPokfIdyLaktTJFzJH7wX39hgyukKn8QxeRNobH6gl27g==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "license": "MIT",
+      "dependencies": {
+        "threads": "^1.7.0",
+        "tiny-worker": "^2.3.0",
+        "uuid": "^11.0.3"
+      }
+    },
+    "node_modules/kuzu-wasm/node_modules/uuid": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
+      "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/esm/bin/uuid"
+      }
+    },
    "node_modules/langchain": {
      "version": "1.2.10",
      "resolved": "https://registry.npmjs.org/langchain/-/langchain-1.2.10.tgz",
@@ -33,7 +33,7 @@
    "graphology-layout-noverlap": "^0.4.2",
    "isomorphic-git": "^1.36.1",
    "jszip": "^3.10.1",
-    "@ladybugdb/wasm-core": "^0.15.1",
+    "kuzu-wasm": "^0.11.1",
    "langchain": "^1.2.10",
    "lru-cache": "^11.2.4",
    "lucide-react": "^0.562.0",
@@ -5,42 +5,6 @@ import { vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism';
 import { useAppState } from '../hooks/useAppState';
 import { NODE_COLORS } from '../lib/constants';

-/** Map file extension to Prism syntax highlighter language identifier */
-const getSyntaxLanguage = (filePath: string | undefined): string => {
-  if (!filePath) return 'text';
-  const ext = filePath.split('.').pop()?.toLowerCase();
-  switch (ext) {
-    case 'js': case 'jsx': case 'mjs': case 'cjs': return 'javascript';
-    case 'ts': case 'tsx': case 'mts': case 'cts': return 'typescript';
-    case 'py': case 'pyw': return 'python';
-    case 'rb': case 'rake': case 'gemspec': return 'ruby';
-    case 'java': return 'java';
-    case 'go': return 'go';
-    case 'rs': return 'rust';
-    case 'c': case 'h': return 'c';
-    case 'cpp': case 'cc': case 'cxx': case 'hpp': case 'hxx': case 'hh': return 'cpp';
-    case 'cs': return 'csharp';
-    case 'php': return 'php';
-    case 'kt': case 'kts': return 'kotlin';
-    case 'swift': return 'swift';
-    case 'json': return 'json';
-    case 'yaml': case 'yml': return 'yaml';
-    case 'md': case 'mdx': return 'markdown';
-    case 'html': case 'htm': case 'erb': return 'markup';
-    case 'css': case 'scss': case 'sass': return 'css';
-    case 'sh': case 'bash': case 'zsh': return 'bash';
-    case 'sql': return 'sql';
-    case 'xml': return 'xml';
-    default: break;
-  }
-  // Handle extensionless Ruby files
-  const basename = filePath.split('/').pop() || '';
-  if (['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile'].includes(basename)) return 'ruby';
-  if (['Makefile'].includes(basename)) return 'makefile';
-  if (['Dockerfile'].includes(basename)) return 'docker';
-  return 'text';
-};
-
 // Match the code theme used elsewhere in the app
 const customTheme = {
  ...vscDarkPlus,
@@ -303,7 +267,12 @@ export const CodeReferencesPanel = ({ onFocusNode }: CodeReferencesPanelProps) =
            <div className="flex-1 min-h-0 overflow-auto scrollbar-thin">
              {selectedFileContent ? (
                <SyntaxHighlighter
-                  language={getSyntaxLanguage(selectedFilePath)}
+                  language={
+                    selectedFilePath?.endsWith('.py') ? 'python' :
+                    selectedFilePath?.endsWith('.js') || selectedFilePath?.endsWith('.jsx') ? 'javascript' :
+                    selectedFilePath?.endsWith('.ts') || selectedFilePath?.endsWith('.tsx') ? 'typescript' :
+                    'text'
+                  }
                  style={customTheme as any}
                  showLineNumbers
                  startingLineNumber={1}
@@ -370,7 +339,11 @@ export const CodeReferencesPanel = ({ onFocusNode }: CodeReferencesPanelProps) =
          const hasRange = typeof ref.startLine === 'number';
          const startDisplay = hasRange ? (ref.startLine ?? 0) + 1 : undefined;
          const endDisplay = hasRange ? (ref.endLine ?? ref.startLine ?? 0) + 1 : undefined;
-          const language = getSyntaxLanguage(ref.filePath);
+          const language =
+            ref.filePath.endsWith('.py') ? 'python' :
+            ref.filePath.endsWith('.js') || ref.filePath.endsWith('.jsx') ? 'javascript' :
+            ref.filePath.endsWith('.ts') || ref.filePath.endsWith('.tsx') ? 'typescript' :
+            'text';

          const isGlowing = glowRefId === ref.id;

@@ -83,7 +83,7 @@ export const EmbeddingStatus = () => {
            <button
              onClick={handleTestArrayParams}
              className="flex items-center gap-1 px-2 py-1.5 bg-surface border border-border-subtle rounded-lg text-xs text-text-muted hover:bg-hover hover:text-text-secondary transition-all"
-              title="Test if LadybugDB supports array params"
+              title="Test if KuzuDB supports array params"
            >
              <FlaskConical className="w-3 h-3" />
              {testResult || 'Test'}
@@ -9,6 +9,6 @@ export enum SupportedLanguages {
    Go = 'go',
    Rust = 'rust',
    PHP = 'php',
-    Ruby = 'ruby',
+    // Ruby = 'ruby',
    Swift = 'swift',
 }
@@ -275,7 +275,7 @@ export const embedBatch = async (texts: string[]): Promise<Float32Array[]> => {
 };

 /**
- * Convert Float32Array to regular number array (for LadybugDB storage)
+ * Convert Float32Array to regular number array (for KuzuDB storage)
 */
 export const embeddingToArray = (embedding: Float32Array): number[] => {
  return Array.from(embedding);
@@ -2,10 +2,10 @@
 * Embedding Pipeline Module
 * 
 * Orchestrates the background embedding process:
- * 1. Query embeddable nodes from LadybugDB
+ * 1. Query embeddable nodes from KuzuDB
 * 2. Generate text representations
 * 3. Batch embed using transformers.js
- * 4. Update LadybugDB with embeddings
+ * 4. Update KuzuDB with embeddings
 * 5. Create vector index for semantic search
 */

@@ -27,7 +27,7 @@ import {
 export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void;

 /**
- * Query all embeddable nodes from LadybugDB
+ * Query all embeddable nodes from KuzuDB
 * Uses table-specific queries (File has different schema than code elements)
 */
 const queryEmbeddableNodes = async (
@@ -102,23 +102,9 @@ const batchInsertEmbeddings = async (
 * Create the vector index for semantic search
 * Now indexes the separate CodeEmbedding table
 */
-let vectorExtensionLoaded = false;
-
 const createVectorIndex = async (
  executeQuery: (cypher: string) => Promise<any[]>
 ): Promise<void> => {
-  // LadybugDB v0.15+ requires explicit VECTOR extension loading (once per session)
-  if (!vectorExtensionLoaded) {
-    try {
-      await executeQuery('INSTALL VECTOR');
-      await executeQuery('LOAD EXTENSION VECTOR');
-      vectorExtensionLoaded = true;
-    } catch {
-      // Extension may already be loaded — CREATE_VECTOR_INDEX will fail clearly if not
-      vectorExtensionLoaded = true;
-    }
-  }
-
  const cypher = `
    CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
  `;
@@ -136,7 +122,7 @@ const createVectorIndex = async (
 /**
 * Run the embedding pipeline
 * 
- * @param executeQuery - Function to execute Cypher queries against LadybugDB
+ * @param executeQuery - Function to execute Cypher queries against KuzuDB
 * @param executeWithReusedStatement - Function to execute with reused prepared statement
 * @param onProgress - Callback for progress updates
 * @param config - Optional configuration override
@@ -220,7 +206,7 @@ export const runEmbeddingPipeline = async (
      // Embed the batch
      const embeddings = await embedBatch(texts);

-      // Update LadybugDB with embeddings
+      // Update KuzuDB with embeddings
      const updates = batch.map((node, i) => ({
        id: node.id,
        embedding: embeddingToArray(embeddings[i]),
@@ -327,64 +313,51 @@ export const semanticSearch = async (
    return [];
  }

-  // Group results by label for batched metadata queries
-  const byLabel = new Map<string, Array<{ nodeId: string; distance: number }>>();
+  // Get metadata for each result by querying each node table
+  const results: SemanticSearchResult[] = [];
+  
  for (const embRow of embResults) {
    const nodeId = embRow.nodeId ?? embRow[0];
    const distance = embRow.distance ?? embRow[1];
+    
+    // Extract label from node ID (format: Label:path:name)
    const labelEndIdx = nodeId.indexOf(':');
    const label = labelEndIdx > 0 ? nodeId.substring(0, labelEndIdx) : 'Unknown';
-    if (!byLabel.has(label)) byLabel.set(label, []);
-    byLabel.get(label)!.push({ nodeId, distance });
-  }
-
-  // Batch-fetch metadata per label
-  const results: SemanticSearchResult[] = [];
-
-  for (const [label, items] of byLabel) {
-    const idList = items.map(i => `'${i.nodeId.replace(/'/g, "''")}'`).join(', ');
+    
+    // Query the specific table for this node
+    // File nodes don't have startLine/endLine
    try {
      let nodeQuery: string;
      if (label === 'File') {
        nodeQuery = `
-          MATCH (n:File) WHERE n.id IN [${idList}]
-          RETURN n.id AS id, n.name AS name, n.filePath AS filePath
+          MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath
        `;
      } else {
        nodeQuery = `
-          MATCH (n:${label}) WHERE n.id IN [${idList}]
-          RETURN n.id AS id, n.name AS name, n.filePath AS filePath,
+          MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath, 
                 n.startLine AS startLine, n.endLine AS endLine
        `;
      }
      const nodeRows = await executeQuery(nodeQuery);
-      const rowMap = new Map<string, any>();
-      for (const row of nodeRows) {
-        const id = row.id ?? row[0];
-        rowMap.set(id, row);
-      }
-      for (const item of items) {
-        const nodeRow = rowMap.get(item.nodeId);
-        if (nodeRow) {
-          results.push({
-            nodeId: item.nodeId,
-            name: nodeRow.name ?? nodeRow[1] ?? '',
-            label,
-            filePath: nodeRow.filePath ?? nodeRow[2] ?? '',
-            distance: item.distance,
-            startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[3]) : undefined,
-            endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[4]) : undefined,
-          });
-        }
+      if (nodeRows.length > 0) {
+        const nodeRow = nodeRows[0];
+        results.push({
+          nodeId,
+          name: nodeRow.name ?? nodeRow[0] ?? '',
+          label,
+          filePath: nodeRow.filePath ?? nodeRow[1] ?? '',
+          distance,
+          startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[2]) : undefined,
+          endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[3]) : undefined,
+        });
      }
    } catch {
      // Table might not exist, skip
    }
  }

-  // Re-sort by distance since batch queries may have mixed order
-  results.sort((a, b) => a.distance - b.distance);
-
  return results;
 };

@@ -92,7 +92,7 @@ export interface SemanticSearchResult {
 }

 /**
- * Node data for embedding (minimal structure from LadybugDB query)
+ * Node data for embedding (minimal structure from KuzuDB query)
 */
 export interface EmbeddableNode {
  id: string;
@@ -54,7 +54,6 @@ export type RelationshipType =
  | 'DECORATES'
  | 'IMPLEMENTS'
  | 'EXTENDS'
-  | 'HAS_METHOD'
  | 'MEMBER_OF'
  | 'STEP_IN_PROCESS'

@@ -6,7 +6,6 @@ import { loadParser, loadLanguage } from '../tree-sitter/parser-loader';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries';
 import { generateId } from '../../lib/utils';
 import { getLanguageFromFilename } from './utils';
-import { callRouters } from './call-routing';

 /**
 * Node types that represent function/method definitions across languages.
@@ -36,9 +35,6 @@ const FUNCTION_NODE_TYPES = new Set([
  // Rust
  'function_item',
  'impl_item', // Methods inside impl blocks
-  // Ruby
-  'method',           // def foo
-  'singleton_method', // def self.foo
 ]);

 /**
@@ -96,18 +92,6 @@ const findEnclosingFunction = (
                         current.children?.find((c: any) => c.type === 'identifier');
        funcName = nameNode?.text;
        label = 'Method'; // Treat constructors as methods for process detection
-      } else if (current.type === 'method') {
-        // Ruby instance method: def foo
-        const nameNode = current.childForFieldName?.('name') ||
-                         current.children?.find((c: any) => c.type === 'identifier');
-        funcName = nameNode?.text;
-        label = 'Method';
-      } else if (current.type === 'singleton_method') {
-        // Ruby class method: def self.foo
-        const nameNode = current.childForFieldName?.('name') ||
-                         current.children?.find((c: any) => c.type === 'identifier');
-        funcName = nameNode?.text;
-        label = 'Method';
      } else if (current.type === 'arrow_function' || current.type === 'function_expression') {
        // Arrow/expression: const foo = () => {} - check parent variable declarator
        const parent = current.parent;
@@ -142,47 +126,6 @@ const findEnclosingFunction = (
  return null; // Top-level call (not inside any function)
 };

-/** AST node types that represent a class-like container */
-const CLASS_CONTAINER_TYPES = new Set([
-  'class_declaration', 'abstract_class_declaration',
-  'interface_declaration', 'struct_declaration', 'record_declaration',
-  'class_specifier', 'struct_specifier',
-  'impl_item', 'trait_item',
-  'class_definition',
-  'trait_declaration',
-  'protocol_declaration',
-  'class', 'module', // Ruby
-]);
-
-const CONTAINER_TYPE_TO_LABEL: Record<string, string> = {
-  class_declaration: 'Class', abstract_class_declaration: 'Class',
-  interface_declaration: 'Interface',
-  struct_declaration: 'Struct', struct_specifier: 'Struct',
-  class_specifier: 'Class', class_definition: 'Class',
-  impl_item: 'Impl', trait_item: 'Trait', trait_declaration: 'Trait',
-  record_declaration: 'Record', protocol_declaration: 'Interface',
-  class: 'Class', module: 'Module',
-};
-
-/** Walk up AST to find enclosing class/struct/interface, return its generateId or null. */
-const findEnclosingClassId = (node: any, filePath: string): string | null => {
-  let current = node.parent;
-  while (current) {
-    if (CLASS_CONTAINER_TYPES.has(current.type)) {
-      const nameNode = current.childForFieldName?.('name')
-        ?? current.children?.find((c: any) =>
-          c.type === 'type_identifier' || c.type === 'identifier' || c.type === 'name' || c.type === 'constant'
-        );
-      if (nameNode) {
-        const label = CONTAINER_TYPE_TO_LABEL[current.type] || 'Class';
-        return generateId(label, `${filePath}:${nameNode.text}`);
-      }
-    }
-    current = current.parent;
-  }
-  return null;
-};
-
 export const processCalls = async (
  graph: KnowledgeGraph,
  files: { path: string; content: string }[],
@@ -228,8 +171,6 @@ export const processCalls = async (
      continue;
    }

-    const callRouter = callRouters[language];
-
    // 3. Process each call match
    matches.forEach(match => {
      const captureMap: Record<string, any> = {};
@@ -243,68 +184,6 @@ export const processCalls = async (

      const calledName = nameNode.text;

-      // Dispatch: route language-specific calls (heritage, properties, imports)
-      const routed = callRouter(calledName, captureMap['call']);
-      if (routed) {
-        switch (routed.kind) {
-          case 'skip':
-          case 'import': // handled by import-processor
-            return;
-
-          case 'heritage':
-            for (const item of routed.items) {
-              const childId = symbolTable.lookupExact(file.path, item.enclosingClass) ||
-                              symbolTable.lookupFuzzy(item.enclosingClass)[0]?.nodeId ||
-                              generateId('Class', `${file.path}:${item.enclosingClass}`);
-              const parentId = symbolTable.lookupFuzzy(item.mixinName)[0]?.nodeId ||
-                               generateId('Module', `${item.mixinName}`);
-              if (childId && parentId) {
-                const relId = generateId('IMPLEMENTS', `${childId}->${parentId}:${item.heritageKind}`);
-                graph.addRelationship({
-                  id: relId, sourceId: childId, targetId: parentId,
-                  type: 'IMPLEMENTS', confidence: 1.0, reason: item.heritageKind,
-                });
-              }
-            }
-            return;
-
-          case 'properties': {
-            const fileId = generateId('File', file.path);
-            const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
-            for (const item of routed.items) {
-              const nodeId = generateId('Property', `${file.path}:${item.propName}`);
-              graph.addNode({
-                id: nodeId,
-                label: 'Property' as any, // TODO: add 'Property' to graph node label union
-                properties: {
-                  name: item.propName, filePath: file.path,
-                  startLine: item.startLine, endLine: item.endLine,
-                  language, isExported: true,
-                  description: item.accessorType,
-                },
-              });
-              symbolTable.add(file.path, item.propName, nodeId, 'Property');
-              const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-              graph.addRelationship({
-                id: relId, sourceId: fileId, targetId: nodeId,
-                type: 'DEFINES', confidence: 1.0, reason: '',
-              });
-              if (propEnclosingClassId) {
-                graph.addRelationship({
-                  id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
-                  sourceId: propEnclosingClassId, targetId: nodeId,
-                  type: 'HAS_METHOD', confidence: 1.0, reason: '',
-                });
-              }
-            }
-            return;
-          }
-
-          case 'call':
-            break; // fall through to normal call processing below
-        }
-      }
-
      // Skip common built-ins and noise
      if (isBuiltInOrNoise(calledName)) return;

@@ -321,10 +200,10 @@ export const processCalls = async (
      // 5. Find the enclosing function (caller)
      const callNode = captureMap['call'];
      const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable);
-
+      
      // Use enclosing function as source, fallback to file for top-level calls
      const sourceId = enclosingFuncId || generateId('File', file.path);
-
+      
      const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);

      graph.addRelationship({
@@ -832,72 +711,37 @@ const resolveCallTarget = (
 * Filter out common built-in functions and noise
 * that shouldn't be tracked as calls
 */
-/** Pre-built set (module-level singleton) to avoid re-creating per call */
-const BUILT_IN_NAMES = new Set([
-  // JavaScript/TypeScript built-ins
-  'console', 'log', 'warn', 'error', 'info', 'debug',
-  'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
-  'parseInt', 'parseFloat', 'isNaN', 'isFinite',
-  'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
-  'JSON', 'parse', 'stringify',
-  'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
-  'Map', 'Set', 'WeakMap', 'WeakSet',
-  'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
-  'Math', 'Date', 'RegExp', 'Error',
-  'require', 'import', 'export',
-  'fetch', 'Response', 'Request',
-  // React hooks and common functions
-  'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
-  'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
-  'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
-  // Common array/object methods
-  'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
-  'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
-  'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
-  'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
-  'hasOwnProperty', 'toString', 'valueOf',
-  // Python built-ins
-  'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
-  'open', 'read', 'write', 'close', 'append', 'extend', 'update',
-  'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
-  'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
-  // C/C++ standard library and common kernel helpers
-  'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
-  'scanf', 'fscanf', 'sscanf',
-  'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
-  'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
-  'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
-  'sizeof', 'offsetof', 'typeof',
-  'assert', 'abort', 'exit', '_exit',
-  'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
-  // Linux kernel common macros/helpers (not real call targets)
-  'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
-  'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
-  'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
-  'min', 'max', 'clamp', 'abs', 'swap',
-  'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
-  'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
-  'GFP_KERNEL', 'GFP_ATOMIC',
-  'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
-  'mutex_lock', 'mutex_unlock', 'mutex_init',
-  'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
-  'get', 'put',
-  // Ruby built-ins and Kernel methods
-  'puts', 'print', 'p', 'pp', 'warn', 'raise', 'fail',
-  'require', 'require_relative', 'load', 'autoload',
-  'include', 'extend', 'prepend',
-  'attr_accessor', 'attr_reader', 'attr_writer',
-  'public', 'private', 'protected', 'module_function',
-  'lambda', 'proc', 'block_given?',
-  'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?',
-  'freeze', 'frozen?', 'dup', 'clone', 'tap', 'then', 'yield_self',
-  // Ruby enumerables
-  'each', 'map', 'select', 'reject', 'find', 'detect', 'collect',
-  'inject', 'reduce', 'flat_map', 'each_with_object', 'each_with_index',
-  'any?', 'all?', 'none?', 'count', 'first', 'last',
-  'sort', 'sort_by', 'min', 'max', 'min_by', 'max_by',
-  'group_by', 'partition', 'zip', 'compact', 'flatten', 'uniq',
-]);
+const isBuiltInOrNoise = (name: string): boolean => {
+  const builtIns = new Set([
+    // JavaScript/TypeScript built-ins
+    'console', 'log', 'warn', 'error', 'info', 'debug',
+    'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+    'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+    'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+    'JSON', 'parse', 'stringify',
+    'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+    'Map', 'Set', 'WeakMap', 'WeakSet',
+    'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
+    'Math', 'Date', 'RegExp', 'Error',
+    'require', 'import', 'export',
+    'fetch', 'Response', 'Request',
+    // React hooks and common functions
+    'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
+    'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+    'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
+    // Common array/object methods
+    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
+    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
+    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
+    'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
+    'hasOwnProperty', 'toString', 'valueOf',
+    // Python built-ins
+    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
+    'open', 'read', 'write', 'close', 'append', 'extend', 'update',
+    'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
+    'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
+  ]);

-const isBuiltInOrNoise = (name: string): boolean => BUILT_IN_NAMES.has(name);
+  return builtIns.has(name);
+};

@@ -1,148 +0,0 @@
-/**
- * Shared Ruby call routing logic.
- *
- * Ruby expresses imports, heritage (mixins), and property definitions as
- * method calls rather than syntax-level constructs. This module provides a
- * routing function used by the CLI call-processor, CLI parse-worker, and
- * the web call-processor so that the classification logic lives in one place.
- *
- * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
- * two packages have separate build targets (Node native vs WASM/browser).
- * Keep both copies in sync until a shared package is introduced.
- */
-
-import { SupportedLanguages } from '../../config/supported-languages';
-
-// ── Call routing dispatch table ─────────────────────────────────────────────
-
-/** null = this call was not routed; fall through to default call handling */
-export type CallRoutingResult = RubyCallRouting | null;
-
-export type CallRouter = (
-  calledName: string,
-  callNode: any,
-) => CallRoutingResult;
-
-/** No-op router: returns null for every call (passthrough to normal processing) */
-const noRouting: CallRouter = () => null;
-
-/** Per-language call routing. noRouting = no special routing (normal call processing) */
-export const callRouters: Record<SupportedLanguages, CallRouter> = {
-  [SupportedLanguages.JavaScript]: noRouting,
-  [SupportedLanguages.TypeScript]: noRouting,
-  [SupportedLanguages.Python]: noRouting,
-  [SupportedLanguages.Java]: noRouting,
-  [SupportedLanguages.Go]: noRouting,
-  [SupportedLanguages.Rust]: noRouting,
-  [SupportedLanguages.CSharp]: noRouting,
-  [SupportedLanguages.PHP]: noRouting,
-  [SupportedLanguages.Swift]: noRouting,
-  [SupportedLanguages.CPlusPlus]: noRouting,
-  [SupportedLanguages.C]: noRouting,
-  [SupportedLanguages.Ruby]: routeRubyCall,
-};
-
-// ── Result types ────────────────────────────────────────────────────────────
-
-export type RubyCallRouting =
-  | { kind: 'import'; importPath: string; isRelative: boolean }
-  | { kind: 'heritage'; items: RubyHeritageItem[] }
-  | { kind: 'properties'; items: RubyPropertyItem[] }
-  | { kind: 'call' }
-  | { kind: 'skip' };
-
-export interface RubyHeritageItem {
-  enclosingClass: string;
-  mixinName: string;
-  heritageKind: 'include' | 'extend' | 'prepend';
-}
-
-export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer';
-
-export interface RubyPropertyItem {
-  propName: string;
-  accessorType: RubyAccessorType;
-  startLine: number;
-  endLine: number;
-}
-
-// ── Pre-allocated singletons for common return values ────────────────────────
-const CALL_RESULT: RubyCallRouting = { kind: 'call' };
-const SKIP_RESULT: RubyCallRouting = { kind: 'skip' };
-
-/** Max depth for parent-walking loops to prevent pathological AST traversals */
-const MAX_PARENT_DEPTH = 50;
-
-// ── Routing function ────────────────────────────────────────────────────────
-
-/**
- * Classify a Ruby call node and extract its semantic payload.
- *
- * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
- * @param callNode   - The tree-sitter `call` AST node
- * @returns A discriminated union describing the call's semantic role
- */
-export function routeRubyCall(calledName: string, callNode: any): RubyCallRouting {
-  // ── require / require_relative → import ─────────────────────────────────
-  if (calledName === 'require' || calledName === 'require_relative') {
-    const argList = callNode.childForFieldName?.('arguments');
-    const stringNode = argList?.children?.find((c: any) => c.type === 'string');
-    const contentNode = stringNode?.children?.find((c: any) => c.type === 'string_content');
-    if (!contentNode) return SKIP_RESULT;
-
-    let importPath: string = contentNode.text;
-    // Validate: reject null bytes, control chars, excessively long paths
-    if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) {
-      return SKIP_RESULT;
-    }
-    const isRelative = calledName === 'require_relative';
-    if (isRelative && !importPath.startsWith('.')) {
-      importPath = './' + importPath;
-    }
-    return { kind: 'import', importPath, isRelative };
-  }
-
-  // ── include / extend / prepend → heritage (mixin) ──────────────────────
-  if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
-    let enclosingClass: string | null = null;
-    let current = callNode.parent;
-    let depth = 0;
-    while (current && ++depth <= MAX_PARENT_DEPTH) {
-      if (current.type === 'class' || current.type === 'module') {
-        const nameNode = current.childForFieldName?.('name');
-        if (nameNode) { enclosingClass = nameNode.text; break; }
-      }
-      current = current.parent;
-    }
-    if (!enclosingClass) return SKIP_RESULT;
-
-    const items: RubyHeritageItem[] = [];
-    const argList = callNode.childForFieldName?.('arguments');
-    for (const arg of (argList?.children ?? [])) {
-      if (arg.type === 'constant' || arg.type === 'scope_resolution') {
-        items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName as 'include' | 'extend' | 'prepend' });
-      }
-    }
-    return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
-  }
-
-  // ── attr_accessor / attr_reader / attr_writer → property definitions ───
-  if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
-    const items: RubyPropertyItem[] = [];
-    const argList = callNode.childForFieldName?.('arguments');
-    for (const arg of (argList?.children ?? [])) {
-      if (arg.type === 'simple_symbol') {
-        items.push({
-          propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text,
-          accessorType: calledName as RubyAccessorType,
-          startLine: arg.startPosition.row,
-          endLine: arg.endPosition.row,
-        });
-      }
-    }
-    return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT;
-  }
-
-  // ── Everything else → regular call ─────────────────────────────────────
-  return CALL_RESULT;
-}
@@ -330,20 +330,25 @@ const calculateCohesion = (memberIds: string[], graph: Graph): number => {

  const memberSet = new Set(memberIds);
  let internalEdges = 0;
-  let totalEdges = 0;
-
-  // Count internal vs total edges for community members
+  
+  // Count edges within the community
  memberIds.forEach(nodeId => {
    if (graph.hasNode(nodeId)) {
      graph.forEachNeighbor(nodeId, neighbor => {
-        totalEdges++;
        if (memberSet.has(neighbor)) {
          internalEdges++;
        }
      });
    }
  });
-
-  if (totalEdges === 0) return 1.0;
-  return Math.min(1.0, internalEdges / totalEdges);
+  
+  // Each edge is counted twice (once from each end), so divide by 2
+  internalEdges = internalEdges / 2;
+  
+  // Maximum possible internal edges for n nodes: n*(n-1)/2
+  const maxPossibleEdges = (memberIds.length * (memberIds.length - 1)) / 2;
+  
+  if (maxPossibleEdges === 0) return 1.0;
+  
+  return Math.min(1.0, internalEdges / maxPossibleEdges);
 };
@@ -13,7 +13,7 @@
 import { detectFrameworkFromPath } from './framework-detection';

 // ============================================================================
-// NAME PATTERNS - All 11 supported languages
+// NAME PATTERNS - All 9 supported languages
 // ============================================================================

 /**
@@ -143,13 +143,6 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
    /^save$/,                 // Repository::save()
    /^delete$/,               // Repository::delete()
  ],
-
-  // Ruby
-  'ruby': [
-    /^call$/,                 // Service objects (MyService.call)
-    /^perform$/,              // Background jobs (Sidekiq, ActiveJob)
-    /^execute$/,              // Command pattern
-  ],
 };

 // ============================================================================
@@ -309,12 +302,7 @@ export function isTestFile(filePath: string): boolean {
    p.endsWith('test.php') ||
    p.endsWith('spec.php') ||
    p.includes('/tests/feature/') ||
-    p.includes('/tests/unit/') ||
-    // Ruby test patterns
-    p.endsWith('_spec.rb') ||
-    p.endsWith('_test.rb') ||
-    p.includes('/spec/') ||
-    p.includes('/test/fixtures/')
+    p.includes('/tests/unit/')
  );
 }

@@ -257,17 +257,6 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null
    return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
  }

-  // ========== RUBY ==========
-
-  // Ruby: bin/ or exe/ (CLI entry points)
-  if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) {
-    return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' };
-  }
-
-  // Ruby: Rakefile or *.rake (task definitions)
-  if (p.endsWith('/rakefile') || p.endsWith('.rake')) {
-    return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' };
-  }
  // ========== SWIFT / iOS ==========

  // iOS App entry points (highest priority)
@@ -4,7 +4,6 @@ import { loadParser, loadLanguage } from '../tree-sitter/parser-loader';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries';
 import { generateId } from '../../lib/utils';
 import { getLanguageFromFilename } from './utils';
-import { callRouters } from './call-routing';

 // Type: Map<FilePath, Set<ResolvedFilePath>>
 // Stores all files that a given file imports from
@@ -54,9 +53,7 @@ const resolveImportPath = (
    // Go
    '.go',
    // Rust
-    '.rs', '/mod.rs',
-    // Ruby
-    '.rb', '.rake',
+    '.rs', '/mod.rs'
  ];
  
  if (importPath.startsWith('.')) {
@@ -223,35 +220,6 @@ export const processImports = async (
          importMap.get(file.path)!.add(resolvedPath);
        }
      }
-
-      // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
-      if (captureMap['call']) {
-        const callNameNode = captureMap['call.name'];
-        if (callNameNode) {
-          const callRouter = callRouters[language];
-          const routed = callRouter(callNameNode.text, captureMap['call']);
-          if (routed && routed.kind === 'import') {
-            totalImportsFound++;
-            const resolvedPath = resolveImportPath(
-              file.path, routed.importPath, allFilePaths, allFileList, resolveCache
-            );
-            if (resolvedPath) {
-              const sourceId = generateId('File', file.path);
-              const targetId = generateId('File', resolvedPath);
-              const relId = generateId('IMPORTS', `${file.path}->${resolvedPath}`);
-              totalImportsResolved++;
-              graph.addRelationship({
-                id: relId, sourceId, targetId,
-                type: 'IMPORTS', confidence: 1.0, reason: '',
-              });
-              if (!importMap.has(file.path)) {
-                importMap.set(file.path, new Set());
-              }
-              importMap.get(file.path)!.add(resolvedPath);
-            }
-          }
-        }
-      }
    });

    // If re-parsed just for this, delete the tree to save memory
@@ -14,7 +14,7 @@ export type FileProgressCallback = (current: number, total: number, filePath: st

 /**
 * Check if a symbol (function, class, etc.) is exported/public
- * Handles all 11 supported languages with explicit logic
+ * Handles all 9 supported languages with explicit logic
 * 
 * @param node - The AST node for the symbol name
 * @param name - The symbol name
@@ -104,11 +104,7 @@ const isNodeExported = (node: any, name: string, language: string): boolean => {
    case 'c':
    case 'cpp':
      return false;
-
-    // Ruby: All top-level definitions are public by default
-    case 'ruby':
-      return true;
-
+    
    default:
      return false;
  }
@@ -396,40 +396,6 @@ export const PHP_QUERIES = `
      [(name) (qualified_name)] @heritage.trait))) @heritage
 `;

-// Ruby queries - works with tree-sitter-ruby
-// NOTE: Ruby uses `call` for require, include, extend, prepend, attr_* etc.
-// These are all captured as @call and routed in JS post-processing:
-//   - require/require_relative → import extraction
-//   - include/extend/prepend → heritage (mixin) extraction
-//   - attr_accessor/attr_reader/attr_writer → property definition extraction
-//   - everything else → regular call extraction
-export const RUBY_QUERIES = `
-; ── Modules ──────────────────────────────────────────────────────────────────
-(module
-  name: (constant) @name) @definition.module
-
-; ── Classes ──────────────────────────────────────────────────────────────────
-(class
-  name: (constant) @name) @definition.class
-
-; ── Instance methods ─────────────────────────────────────────────────────────
-(method
-  name: (identifier) @name) @definition.method
-
-; ── Singleton (class-level) methods ──────────────────────────────────────────
-(singleton_method
-  name: (identifier) @name) @definition.function
-
-; ── All calls (require, include, attr_*, and regular calls routed in JS) ─────
-(call
-  method: (identifier) @call.name) @call
-
-; ── Heritage: class < SuperClass ─────────────────────────────────────────────
-(class
-  name: (constant) @heritage.class
-  superclass: (superclass
-    (constant) @heritage.extends)) @heritage`;
-    
 // Swift queries - works with tree-sitter-swift
 export const SWIFT_QUERIES = `
 ; Classes
@@ -494,7 +460,6 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = {
  [SupportedLanguages.CSharp]: CSHARP_QUERIES,
  [SupportedLanguages.Rust]: RUST_QUERIES,
  [SupportedLanguages.PHP]: PHP_QUERIES,
-  [SupportedLanguages.Ruby]: RUBY_QUERIES,
  [SupportedLanguages.Swift]: SWIFT_QUERIES,
 };
 
@@ -1,8 +1,5 @@
 import { SupportedLanguages } from '../../config/supported-languages';

-/** Ruby extensionless filenames recognised as Ruby source */
-const RUBY_EXTENSIONLESS_FILES = new Set(['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile']);
-
 /**
 * Map file extension to SupportedLanguage enum
 */
@@ -34,15 +31,6 @@ export const getLanguageFromFilename = (filename: string): SupportedLanguages |
      filename.endsWith('.php5') || filename.endsWith('.php8')) {
    return SupportedLanguages.PHP;
  }
-  // Ruby (extensions)
-  if (filename.endsWith('.rb') || filename.endsWith('.rake') || filename.endsWith('.gemspec')) {
-    return SupportedLanguages.Ruby;
-  }
-  // Ruby (extensionless files)
-  const basename = filename.split('/').pop() || filename;
-  if (RUBY_EXTENSIONLESS_FILES.has(basename)) {
-    return SupportedLanguages.Ruby;
-  }
  // Swift
  if (filename.endsWith('.swift')) return SupportedLanguages.Swift;
  return null;
@@ -1,5 +1,5 @@
 /**
- * CSV Generator for LadybugDB Hybrid Schema
+ * CSV Generator for KuzuDB Hybrid Schema
 * 
 * Generates separate CSV files for each node table and one relation CSV.
 * This enables efficient bulk loading via COPY FROM for hybrid schema.
@@ -18,10 +18,10 @@ import { NODE_TABLES, NodeTableName } from './schema';
 // ============================================================================

 /**
- * Sanitize string to ensure valid UTF-8 and safe CSV content for LadybugDB
+ * Sanitize string to ensure valid UTF-8 and safe CSV content for KuzuDB
 * Removes or replaces invalid characters that would break CSV parsing.
 * 
- * Critical: LadybugDB's CSV parser can misinterpret \r\n inside quoted fields.
+ * Critical: KuzuDB's CSV parser can misinterpret \r\n inside quoted fields.
 * We normalize all line endings to \n only.
 */
 const sanitizeUTF8 = (str: string): string => {
@@ -213,7 +213,7 @@ const generateCommunityCSV = (nodes: GraphNode[]): string => {
  for (const node of nodes) {
    if (node.label !== 'Community') continue;
    
-    // Handle keywords array - convert to LadybugDB array format
+    // Handle keywords array - convert to KuzuDB array format
    const keywords = (node.properties as any).keywords || [];
    const keywordsStr = `[${keywords.map((k: string) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
    
@@ -221,7 +221,7 @@ const generateCommunityCSV = (nodes: GraphNode[]): string => {
      escapeCSVField(node.id),
      escapeCSVField(node.properties.name || ''),  // label is stored in name
      escapeCSVField(node.properties.heuristicLabel || ''),
-      keywordsStr,  // Array format for LadybugDB
+      keywordsStr,  // Array format for KuzuDB
      escapeCSVField((node.properties as any).description || ''),
      escapeCSVField((node.properties as any).enrichedBy || 'heuristic'),
      escapeCSVNumber(node.properties.cohesion, 0),
@@ -1,51 +1,51 @@
 /**
- * LadybugDB Adapter
- *
- * Manages the LadybugDB WASM instance for client-side graph database operations.
+ * KuzuDB Adapter
+ * 
+ * Manages the KuzuDB WASM instance for client-side graph database operations.
 * Uses the "Snapshot / Bulk Load" pattern with COPY FROM for performance.
- *
+ * 
 * Multi-table schema: separate tables for File, Function, Class, etc.
 */

 import { KnowledgeGraph } from '../graph/types';
-import {
-  NODE_TABLES,
+import { 
+  NODE_TABLES, 
  REL_TABLE_NAME,
-  SCHEMA_QUERIES,
+  SCHEMA_QUERIES, 
  EMBEDDING_TABLE_NAME,
  NodeTableName,
 } from './schema';
 import { generateAllCSVs } from './csv-generator';

 // Holds the reference to the dynamically loaded module
-let lbug: any = null;
+let kuzu: any = null;
 let db: any = null;
 let conn: any = null;

 /**
- * Initialize LadybugDB WASM module and create in-memory database
+ * Initialize KuzuDB WASM module and create in-memory database
 */
-export const initLbug = async () => {
-  if (conn) return { db, conn, lbug };
+export const initKuzu = async () => {
+  if (conn) return { db, conn, kuzu };

  try {
-    if (import.meta.env.DEV) console.log('🚀 Initializing LadybugDB...');
+    if (import.meta.env.DEV) console.log('🚀 Initializing KuzuDB...');

    // 1. Dynamic Import (Fixes the "not a function" bundler issue)
-    const lbugModule = await import('@ladybugdb/wasm-core');
-
+    const kuzuModule = await import('kuzu-wasm');
+    
    // 2. Handle Vite/Webpack "default" wrapping
-    lbug = lbugModule.default || lbugModule;
+    kuzu = kuzuModule.default || kuzuModule;

    // 3. Initialize WASM
-    await lbug.init();
-
-    // 4. Create Database with 512MB buffer manager
+    await kuzu.init();
+    
+    // 4. Create Database with 512MB buffer pool
    const BUFFER_POOL_SIZE = 512 * 1024 * 1024; // 512MB
-    db = new lbug.Database(':memory:', BUFFER_POOL_SIZE);
-    conn = new lbug.Connection(db);
-
-    if (import.meta.env.DEV) console.log('✅ LadybugDB WASM Initialized');
+    db = new kuzu.Database(':memory:', BUFFER_POOL_SIZE);
+    conn = new kuzu.Connection(db);
+    
+    if (import.meta.env.DEV) console.log('✅ KuzuDB WASM Initialized');

    // 5. Initialize Schema (all node tables, then rel tables, then embedding table)
    for (const schemaQuery of SCHEMA_QUERIES) {
@@ -58,60 +58,60 @@ export const initLbug = async () => {
        }
      }
    }
+    
+    if (import.meta.env.DEV) console.log('✅ KuzuDB Multi-Table Schema Created');

-    if (import.meta.env.DEV) console.log('✅ LadybugDB Multi-Table Schema Created');
-
-    return { db, conn, lbug };
+    return { db, conn, kuzu };
  } catch (error) {
-    if (import.meta.env.DEV) console.error('❌ LadybugDB Initialization Failed:', error);
+    if (import.meta.env.DEV) console.error('❌ KuzuDB Initialization Failed:', error);
    throw error;
  }
 };

 /**
- * Load a KnowledgeGraph into LadybugDB using COPY FROM (bulk load)
+ * Load a KnowledgeGraph into KuzuDB using COPY FROM (bulk load)
 * Uses batched CSV writes and COPY statements for optimal performance
 */
-export const loadGraphToLbug = async (
-  graph: KnowledgeGraph,
+export const loadGraphToKuzu = async (
+  graph: KnowledgeGraph, 
  fileContents: Map<string, string>
 ) => {
-  const { conn, lbug } = await initLbug();
-
+  const { conn, kuzu } = await initKuzu();
+  
  try {
-    if (import.meta.env.DEV) console.log(`LadybugDB: Generating CSVs for ${graph.nodeCount} nodes...`);
-
+    if (import.meta.env.DEV) console.log(`KuzuDB: Generating CSVs for ${graph.nodeCount} nodes...`);
+    
    // 1. Generate all CSVs (per-table)
    const csvData = generateAllCSVs(graph, fileContents);
-
-    const fs = lbug.FS;
-
+    
+    const fs = kuzu.FS;
+    
    // 2. Write all node CSVs to virtual filesystem
    const nodeFiles: Array<{ table: NodeTableName; path: string }> = [];
    for (const [tableName, csv] of csvData.nodes.entries()) {
      // Skip empty CSVs (only header row)
      if (csv.split('\n').length <= 1) continue;
-
+      
      const path = `/${tableName.toLowerCase()}.csv`;
      try { await fs.unlink(path); } catch {}
      await fs.writeFile(path, csv);
      nodeFiles.push({ table: tableName, path });
    }
-
+    
    // 3. Parse relation CSV and prepare for INSERT (COPY FROM doesn't work with multi-pair tables)
    const relLines = csvData.relCSV.split('\n').slice(1).filter(line => line.trim());
    const relCount = relLines.length;
-
+    
    if (import.meta.env.DEV) {
-      console.log(`LadybugDB: Wrote ${nodeFiles.length} node CSVs, ${relCount} relations to insert`);
+      console.log(`KuzuDB: Wrote ${nodeFiles.length} node CSVs, ${relCount} relations to insert`);
    }
-
+    
    // 4. COPY all node tables (must complete before rels due to FK constraints)
    for (const { table, path } of nodeFiles) {
      const copyQuery = getCopyQuery(table, path);
      await conn.query(copyQuery);
    }
-
+    
    // 5. INSERT relations one by one (COPY doesn't work with multi-pair REL tables)
    // Build a set of valid table names for fast lookup
    const validTables = new Set<string>(NODE_TABLES as readonly string[]);
@@ -135,13 +135,13 @@ export const loadGraphToLbug = async (
        // Format: "from","to","type",confidence,"reason",step
        const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)",([0-9-]+)/);
        if (!match) continue;
-
+        
        const [, fromId, toId, relType, confidenceStr, reason, stepStr] = match;

        const fromLabel = getNodeLabel(fromId);
        const toLabel = getNodeLabel(toId);

-        // Skip relationships where either node's label doesn't have a table in LadybugDB
+        // Skip relationships where either node's label doesn't have a table in KuzuDB
        // Querying a non-existent table causes a fatal native crash
        if (!validTables.has(fromLabel) || !validTables.has(toLabel)) {
          skippedRels++;
@@ -150,7 +150,7 @@ export const loadGraphToLbug = async (

        const confidence = parseFloat(confidenceStr) || 1.0;
        const step = parseInt(stepStr) || 0;
-
+        
        const insertQuery = `
          MATCH (a:${escapeLabel(fromLabel)} {id: '${fromId.replace(/'/g, "''")}'}),
                (b:${escapeLabel(toLabel)} {id: '${toId.replace(/'/g, "''")}'})
@@ -167,39 +167,38 @@ export const loadGraphToLbug = async (
          const toLabel = getNodeLabel(toId);
          const key = `${relType}:${fromLabel}->` + toLabel;
          skippedRelStats.set(key, (skippedRelStats.get(key) || 0) + 1);
-
+          
          if (import.meta.env.DEV) {
            console.warn(`⚠️ Skipped: ${key} | "${fromId}" → "${toId}" | ${err instanceof Error ? err.message : String(err)}`);
          }
        }
      }
    }
-
+    
    if (import.meta.env.DEV) {
-      console.log(`LadybugDB: Inserted ${insertedRels}/${relCount} relations`);
+      console.log(`KuzuDB: Inserted ${insertedRels}/${relCount} relations`);
      if (skippedRels > 0) {
        const topSkipped = Array.from(skippedRelStats.entries())
          .sort((a, b) => b[1] - a[1])
          .slice(0, 10);
-        console.warn(`LadybugDB: Skipped ${skippedRels}/${relCount} relations (top by kind/pair):`, topSkipped);
+        console.warn(`KuzuDB: Skipped ${skippedRels}/${relCount} relations (top by kind/pair):`, topSkipped);
      }
    }
-
+    
    // 6. Verify results
    let totalNodes = 0;
    for (const tableName of NODE_TABLES) {
      try {
        const countRes = await conn.query(`MATCH (n:${tableName}) RETURN count(n) AS cnt`);
-        const countRows = await countRes.getAll();
-        const countRow = countRows[0];
+        const countRow = await countRes.getNext();
        const count = countRow ? (countRow.cnt ?? countRow[0] ?? 0) : 0;
        totalNodes += Number(count);
      } catch {
        // Table might be empty, skip
      }
    }
-
-    if (import.meta.env.DEV) console.log(`✅ LadybugDB Bulk Load Complete. Total nodes: ${totalNodes}, edges: ${insertedRels}`);
+    
+    if (import.meta.env.DEV) console.log(`✅ KuzuDB Bulk Load Complete. Total nodes: ${totalNodes}, edges: ${insertedRels}`);

    // 7. Cleanup CSV files
    for (const { path } of nodeFiles) {
@@ -209,12 +208,12 @@ export const loadGraphToLbug = async (
    return { success: true, count: totalNodes };

  } catch (error) {
-    if (import.meta.env.DEV) console.error('❌ LadybugDB Bulk Load Failed:', error);
+    if (import.meta.env.DEV) console.error('❌ KuzuDB Bulk Load Failed:', error);
    return { success: false, count: 0 };
  }
 };

-// LadybugDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes).
+// KuzuDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes).
 // Source code content is full of backslashes which confuse the auto-detection.
 // We MUST explicitly set ESCAPE='"' and disable auto_detect.
 const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
@@ -230,9 +229,6 @@ const escapeTableName = (table: string): string => {
  return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;
 };

-/** Tables with isExported column (TypeScript/JS-native types) */
-const TABLES_WITH_EXPORTED = new Set<string>(['Function', 'Class', 'Interface', 'Method', 'CodeElement']);
-
 /**
 * Get the COPY query for a node table with correct column mapping
 */
@@ -250,12 +246,8 @@ const getCopyQuery = (table: NodeTableName, path: string): string => {
  if (table === 'Process') {
    return `COPY ${t}(id, label, heuristicLabel, processType, stepCount, communities, entryPointId, terminalId) FROM "${path}" ${COPY_CSV_OPTS}`;
  }
-  // TypeScript/JS code element tables have isExported; multi-language tables do not
-  if (TABLES_WITH_EXPORTED.has(table)) {
-    return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content) FROM "${path}" ${COPY_CSV_OPTS}`;
-  }
-  // Multi-language tables (Struct, Impl, Trait, Macro, etc.)
-  return `COPY ${t}(id, name, filePath, startLine, endLine, content) FROM "${path}" ${COPY_CSV_OPTS}`;
+  // Code element tables (Function, Class, Interface, Method, CodeElement, and multi-language)
+  return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content) FROM "${path}" ${COPY_CSV_OPTS}`;
 };

 /**
@@ -264,12 +256,12 @@ const getCopyQuery = (table: NodeTableName, path: string): string => {
 */
 export const executeQuery = async (cypher: string): Promise<any[]> => {
  if (!conn) {
-    await initLbug();
+    await initKuzu();
  }
-
+  
  try {
    const result = await conn.query(cypher);
-
+    
    // Extract column names from RETURN clause
    const returnMatch = cypher.match(/RETURN\s+(.+?)(?:\s+ORDER|\s+LIMIT|\s+SKIP|\s*$)/is);
    let columnNames: string[] = [];
@@ -292,11 +284,12 @@ export const executeQuery = async (cypher: string): Promise<any[]> => {
        return col.replace(/[^a-zA-Z0-9_]/g, '_');
      });
    }
-
+    
    // Collect all rows
-    const allRows = await result.getAll();
    const rows: any[] = [];
-    for (const row of allRows) {
+    while (await result.hasNext()) {
+      const row = await result.getNext();
+      
      // Convert tuple to named object if we have column names and row is array
      if (Array.isArray(row) && columnNames.length === row.length) {
        const namedRow: Record<string, any> = {};
@@ -309,7 +302,7 @@ export const executeQuery = async (cypher: string): Promise<any[]> => {
        rows.push(row);
      }
    }
-
+    
    return rows;
  } catch (error) {
    if (import.meta.env.DEV) console.error('Query execution failed:', error);
@@ -320,7 +313,7 @@ export const executeQuery = async (cypher: string): Promise<any[]> => {
 /**
 * Get database statistics
 */
-export const getLbugStats = async (): Promise<{ nodes: number; edges: number }> => {
+export const getKuzuStats = async (): Promise<{ nodes: number; edges: number }> => {
  if (!conn) {
    return { nodes: 0, edges: 0 };
  }
@@ -331,45 +324,43 @@ export const getLbugStats = async (): Promise<{ nodes: number; edges: number }>
    for (const tableName of NODE_TABLES) {
      try {
        const nodeResult = await conn.query(`MATCH (n:${tableName}) RETURN count(n) AS cnt`);
-        const nodeRows = await nodeResult.getAll();
-        const nodeRow = nodeRows[0];
+        const nodeRow = await nodeResult.getNext();
        totalNodes += Number(nodeRow?.cnt ?? nodeRow?.[0] ?? 0);
      } catch {
        // Table might not exist or be empty
      }
    }
-
+    
    // Count edges from single relation table
    let totalEdges = 0;
    try {
      const edgeResult = await conn.query(`MATCH ()-[r:${REL_TABLE_NAME}]->() RETURN count(r) AS cnt`);
-      const edgeRows = await edgeResult.getAll();
-      const edgeRow = edgeRows[0];
+      const edgeRow = await edgeResult.getNext();
      totalEdges = Number(edgeRow?.cnt ?? edgeRow?.[0] ?? 0);
    } catch {
      // Table might not exist or be empty
    }
-
+    
    return { nodes: totalNodes, edges: totalEdges };
  } catch (error) {
    if (import.meta.env.DEV) {
-      console.warn('Failed to get LadybugDB stats:', error);
+      console.warn('Failed to get Kuzu stats:', error);
    }
    return { nodes: 0, edges: 0 };
  }
 };

 /**
- * Check if LadybugDB is initialized and has data
+ * Check if KuzuDB is initialized and has data
 */
-export const isLbugReady = (): boolean => {
+export const isKuzuReady = (): boolean => {
  return conn !== null && db !== null;
 };

 /**
 * Close the database connection (cleanup)
 */
-export const closeLbug = async (): Promise<void> => {
+export const closeKuzu = async (): Promise<void> => {
  if (conn) {
    try {
      await conn.close();
@@ -382,7 +373,7 @@ export const closeLbug = async (): Promise<void> => {
    } catch {}
    db = null;
  }
-  lbug = null;
+  kuzu = null;
 };

 /**
@@ -396,20 +387,24 @@ export const executePrepared = async (
  params: Record<string, any>
 ): Promise<any[]> => {
  if (!conn) {
-    await initLbug();
+    await initKuzu();
  }
-
+  
  try {
    const stmt = await conn.prepare(cypher);
    if (!stmt.isSuccess()) {
      const errMsg = await stmt.getErrorMessage();
      throw new Error(`Prepare failed: ${errMsg}`);
    }
-
+    
    const result = await conn.execute(stmt, params);
-
-    const rows = await result.getAll();
-
+    
+    const rows: any[] = [];
+    while (await result.hasNext()) {
+      const row = await result.getNext();
+      rows.push(row);
+    }
+    
    await stmt.close();
    return rows;
  } catch (error) {
@@ -426,22 +421,22 @@ export const executeWithReusedStatement = async (
  paramsList: Array<Record<string, any>>
 ): Promise<void> => {
  if (!conn) {
-    await initLbug();
+    await initKuzu();
  }
-
+  
  if (paramsList.length === 0) return;
-
+  
  const SUB_BATCH_SIZE = 4;
-
+  
  for (let i = 0; i < paramsList.length; i += SUB_BATCH_SIZE) {
    const subBatch = paramsList.slice(i, i + SUB_BATCH_SIZE);
-
+    
    const stmt = await conn.prepare(cypher);
    if (!stmt.isSuccess()) {
      const errMsg = await stmt.getErrorMessage();
      throw new Error(`Prepare failed: ${errMsg}`);
    }
-
+    
    try {
      for (const params of subBatch) {
        await conn.execute(stmt, params);
@@ -449,7 +444,7 @@ export const executeWithReusedStatement = async (
    } finally {
      await stmt.close();
    }
-
+    
    if (i + SUB_BATCH_SIZE < paramsList.length) {
      await new Promise(r => setTimeout(r, 0));
    }
@@ -461,67 +456,65 @@ export const executeWithReusedStatement = async (
 */
 export const testArrayParams = async (): Promise<{ success: boolean; error?: string }> => {
  if (!conn) {
-    await initLbug();
+    await initKuzu();
  }
-
+  
  try {
    const testEmbedding = new Array(384).fill(0).map((_, i) => i / 384);
-
+    
    // Get any node ID to test with (try File first, then others)
    let testNodeId: string | null = null;
    for (const tableName of NODE_TABLES) {
      try {
        const nodeResult = await conn.query(`MATCH (n:${tableName}) RETURN n.id AS id LIMIT 1`);
-        const nodeRows = await nodeResult.getAll();
-        const nodeRow = nodeRows[0];
+        const nodeRow = await nodeResult.getNext();
        if (nodeRow) {
          testNodeId = nodeRow.id ?? nodeRow[0];
          break;
        }
      } catch {}
    }
-
+    
    if (!testNodeId) {
      return { success: false, error: 'No nodes found to test with' };
    }
-
+    
    if (import.meta.env.DEV) {
      console.log('🧪 Testing array params with node:', testNodeId);
    }
-
+    
    // First create an embedding entry
    const createQuery = `CREATE (e:${EMBEDDING_TABLE_NAME} {nodeId: $nodeId, embedding: $embedding})`;
    const stmt = await conn.prepare(createQuery);
-
+    
    if (!stmt.isSuccess()) {
      const errMsg = await stmt.getErrorMessage();
      return { success: false, error: `Prepare failed: ${errMsg}` };
    }
-
+    
    await conn.execute(stmt, {
      nodeId: testNodeId,
      embedding: testEmbedding,
    });
-
+    
    await stmt.close();
-
+    
    // Verify it was stored
    const verifyResult = await conn.query(
      `MATCH (e:${EMBEDDING_TABLE_NAME} {nodeId: '${testNodeId}'}) RETURN e.embedding AS emb`
    );
-    const verifyRows = await verifyResult.getAll();
-    const verifyRow = verifyRows[0];
+    const verifyRow = await verifyResult.getNext();
    const storedEmb = verifyRow?.emb ?? verifyRow?.[0];
-
+    
    if (storedEmb && Array.isArray(storedEmb) && storedEmb.length === 384) {
      if (import.meta.env.DEV) {
        console.log('✅ Array params WORK! Stored embedding length:', storedEmb.length);
      }
      return { success: true };
    } else {
-      return {
-        success: false,
-        error: `Embedding not stored correctly. Got: ${typeof storedEmb}, length: ${storedEmb?.length}`
+      return { 
+        success: false, 
+        error: `Embedding not stored correctly. Got: ${typeof storedEmb}, length: ${storedEmb?.length}` 
      };
    }
  } catch (error) {
@@ -1,5 +1,5 @@
 /**
- * LadybugDB Schema Definitions
+ * KuzuDB Schema Definitions
 * 
 * Hybrid Schema:
 * - Separate node tables for each code element type (File, Function, Class, etc.)
@@ -17,7 +17,7 @@ import { z } from 'zod';
 import { WebGPUNotAvailableError, embedText, embeddingToArray, initEmbedder, isEmbedderReady } from '../embeddings/embedder';

 /**
- * Tool factory - creates tools bound to the LadybugDB query functions
+ * Tool factory - creates tools bound to the KuzuDB query functions
 */
 export const createGraphRAGTools = (
  executeQuery: (cypher: string) => Promise<any[]>,
@@ -975,7 +975,7 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
      // For code elements (Function, Class, etc.), use the direct id
      const isFileTarget = targetType === 'File';
      
-      // Query each depth level separately (LadybugDB doesn't support list comprehensions on paths)
+      // Query each depth level separately (KuzuDB doesn't support list comprehensions on paths)
      // For depth 1: direct connections only
      // For depth 2+: chain multiple single-hop queries
      const depthQueries: Promise<any[]>[] = [];
@@ -224,7 +224,7 @@ export interface AgentStep {
 * Graph schema information for LLM context
 */
 export const GRAPH_SCHEMA_DESCRIPTION = `
-LADYBUG GRAPH DATABASE SCHEMA (Multi-Table):
+KUZU GRAPH DATABASE SCHEMA (Multi-Table):

 NODE TABLES:
 1. File - Source files
@@ -40,7 +40,6 @@ const getWasmPath = (language: SupportedLanguages, filePath?: string): string =>
        [SupportedLanguages.Go]: '/wasm/go/tree-sitter-go.wasm',
        [SupportedLanguages.Rust]: '/wasm/rust/tree-sitter-rust.wasm',
        [SupportedLanguages.PHP]: '/wasm/php/tree-sitter-php.wasm',
-        [SupportedLanguages.Ruby]: '/wasm/ruby/tree-sitter-ruby.wasm',
        [SupportedLanguages.Swift]: '/wasm/swift/tree-sitter-swift.wasm',
    };
    
@@ -1,35 +1,28 @@
-declare module '@ladybugdb/wasm-core' {
+declare module 'kuzu-wasm' {
  export function init(): Promise<void>;
  export class Database {
-    constructor(path: string, bufferPoolSize?: number);
+    constructor(path: string);
    close(): Promise<void>;
  }
  export class Connection {
    constructor(db: Database);
    query(cypher: string): Promise<QueryResult>;
-    prepare(cypher: string): Promise<PreparedStatement>;
-    execute(stmt: PreparedStatement, params?: Record<string, any>): Promise<QueryResult>;
    close(): Promise<void>;
  }
  export interface QueryResult {
-    getAll(): Promise<any[]>;
    hasNext(): Promise<boolean>;
    getNext(): Promise<any>;
  }
-  export interface PreparedStatement {
-    isSuccess(): boolean;
-    getErrorMessage(): Promise<string>;
-    close(): Promise<void>;
-  }
  export const FS: {
    writeFile(path: string, data: string): Promise<void>;
    unlink(path: string): Promise<void>;
  };
-  const lbug: {
+  const kuzu: {
    init: typeof init;
    Database: typeof Database;
    Connection: typeof Connection;
    FS: typeof FS;
  };
-  export default lbug;
+  export default kuzu;
 }
+
@@ -26,13 +26,13 @@ import {
  type HybridSearchResult,
 } from '../core/search';

-// Lazy import for LadybugDB to avoid breaking worker if SharedArrayBuffer unavailable
-let lbugAdapter: typeof import('../core/lbug/lbug-adapter') | null = null;
-const getLbugAdapter = async () => {
-  if (!lbugAdapter) {
-    lbugAdapter = await import('../core/lbug/lbug-adapter');
+// Lazy import for Kuzu to avoid breaking worker if SharedArrayBuffer unavailable
+let kuzuAdapter: typeof import('../core/kuzu/kuzu-adapter') | null = null;
+const getKuzuAdapter = async () => {
+  if (!kuzuAdapter) {
+    kuzuAdapter = await import('../core/kuzu/kuzu-adapter');
  }
-  return lbugAdapter;
+  return kuzuAdapter;
 };

 // Embedding state
@@ -172,52 +172,52 @@ const workerApi = {
      console.log(`🔍 BM25 index built: ${bm25DocCount} documents`);
    }
    
-    // Load graph into LadybugDB for querying (optional - gracefully degrades)
+    // Load graph into KuzuDB for querying (optional - gracefully degrades)
    try {
      onProgress({
        phase: 'complete',
        percent: 98,
-        message: 'Loading into LadybugDB...',
+        message: 'Loading into KuzuDB...',
        stats: {
          filesProcessed: result.graph.nodeCount,
          totalFiles: result.graph.nodeCount,
          nodesCreated: result.graph.nodeCount,
        },
      });
-
-      const lbug = await getLbugAdapter();
-      await lbug.loadGraphToLbug(result.graph, result.fileContents);
-
+      
+      const kuzu = await getKuzuAdapter();
+      await kuzu.loadGraphToKuzu(result.graph, result.fileContents);
+      
      if (import.meta.env.DEV) {
-        const stats = await lbug.getLbugStats();
-        console.log('LadybugDB loaded:', stats);
+        const stats = await kuzu.getKuzuStats();
+        console.log('KuzuDB loaded:', stats);
        console.log('📁 Stored', storedFileContents.size, 'files for grep/read tools');
      }
    } catch {
-      // LadybugDB is optional - silently continue without it
+      // KuzuDB is optional - silently continue without it
    }
-
+    
    // Store clustering config for background enrichment (runs after graph loads)
    if (clusteringConfig) {
      pendingEnrichmentConfig = clusteringConfig;
      console.log('📋 Clustering config saved for background enrichment');
    }
-
+    
    // Convert to serializable format for transfer back to main thread
    return serializePipelineResult(result);
  },

  /**
-   * Execute a Cypher query against the LadybugDB database
+   * Execute a Cypher query against the KuzuDB database
   * @param cypher - The Cypher query string
   * @returns Query results as an array of objects
   */
  async runQuery(cypher: string): Promise<any[]> {
-    const lbug = await getLbugAdapter();
-    if (!lbug.isLbugReady()) {
+    const kuzu = await getKuzuAdapter();
+    if (!kuzu.isKuzuReady()) {
      throw new Error('Database not ready. Please load a repository first.');
    }
-    return lbug.executeQuery(cypher);
+    return kuzu.executeQuery(cypher);
  },

  /**
@@ -225,8 +225,8 @@ const workerApi = {
   */
  async isReady(): Promise<boolean> {
    try {
-      const lbug = await getLbugAdapter();
-      return lbug.isLbugReady();
+      const kuzu = await getKuzuAdapter();
+      return kuzu.isKuzuReady();
    } catch {
      return false;
    }
@@ -237,8 +237,8 @@ const workerApi = {
   */
  async getStats(): Promise<{ nodes: number; edges: number }> {
    try {
-      const lbug = await getLbugAdapter();
-      return lbug.getLbugStats();
+      const kuzu = await getKuzuAdapter();
+      return kuzu.getKuzuStats();
    } catch {
      return { nodes: 0, edges: 0 };
    }
@@ -276,29 +276,29 @@ const workerApi = {
      console.log(`🔍 BM25 index built: ${bm25DocCount} documents`);
    }
    
-    // Load graph into LadybugDB for querying (optional - gracefully degrades)
+    // Load graph into KuzuDB for querying (optional - gracefully degrades)
    try {
      onProgress({
        phase: 'complete',
        percent: 98,
-        message: 'Loading into LadybugDB...',
+        message: 'Loading into KuzuDB...',
        stats: {
          filesProcessed: result.graph.nodeCount,
          totalFiles: result.graph.nodeCount,
          nodesCreated: result.graph.nodeCount,
        },
      });
-
-      const lbug = await getLbugAdapter();
-      await lbug.loadGraphToLbug(result.graph, result.fileContents);
-
+      
+      const kuzu = await getKuzuAdapter();
+      await kuzu.loadGraphToKuzu(result.graph, result.fileContents);
+      
      if (import.meta.env.DEV) {
-        const stats = await lbug.getLbugStats();
-        console.log('LadybugDB loaded:', stats);
+        const stats = await kuzu.getKuzuStats();
+        console.log('KuzuDB loaded:', stats);
        console.log('📁 Stored', storedFileContents.size, 'files for grep/read tools');
      }
    } catch {
-      // LadybugDB is optional - silently continue without it
+      // KuzuDB is optional - silently continue without it
    }
    
    // Store clustering config for background enrichment (runs after graph loads)
@@ -325,8 +325,8 @@ const workerApi = {
    onProgress: (progress: EmbeddingProgress) => void,
    forceDevice?: 'webgpu' | 'wasm'
  ): Promise<void> {
-    const lbug = await getLbugAdapter();
-    if (!lbug.isLbugReady()) {
+    const kuzu = await getKuzuAdapter();
+    if (!kuzu.isKuzuReady()) {
      throw new Error('Database not ready. Please load a repository first.');
    }

@@ -343,8 +343,8 @@ const workerApi = {
    };

    await runEmbeddingPipeline(
-      lbug.executeQuery,
-      lbug.executeWithReusedStatement,
+      kuzu.executeQuery, 
+      kuzu.executeWithReusedStatement, 
      progressCallback,
      forceDevice ? { device: forceDevice } : {}
    );
@@ -400,15 +400,15 @@ const workerApi = {
    k: number = 10,
    maxDistance: number = 0.5
  ): Promise<SemanticSearchResult[]> {
-    const lbug = await getLbugAdapter();
-    if (!lbug.isLbugReady()) {
+    const kuzu = await getKuzuAdapter();
+    if (!kuzu.isKuzuReady()) {
      throw new Error('Database not ready. Please load a repository first.');
    }
    if (!isEmbeddingComplete) {
      throw new Error('Embeddings not ready. Please wait for embedding pipeline to complete.');
    }

-    return doSemanticSearch(lbug.executeQuery, query, k, maxDistance);
+    return doSemanticSearch(kuzu.executeQuery, query, k, maxDistance);
  },

  /**
@@ -424,15 +424,15 @@ const workerApi = {
    k: number = 5,
    hops: number = 2
  ): Promise<any[]> {
-    const lbug = await getLbugAdapter();
-    if (!lbug.isLbugReady()) {
+    const kuzu = await getKuzuAdapter();
+    if (!kuzu.isKuzuReady()) {
      throw new Error('Database not ready. Please load a repository first.');
    }
    if (!isEmbeddingComplete) {
      throw new Error('Embeddings not ready. Please wait for embedding pipeline to complete.');
    }

-    return doSemanticSearchWithContext(lbug.executeQuery, query, k, hops);
+    return doSemanticSearchWithContext(kuzu.executeQuery, query, k, hops);
  },

  /**
@@ -458,9 +458,9 @@ const workerApi = {
    let semanticResults: SemanticSearchResult[] = [];
    if (isEmbeddingComplete) {
      try {
-        const lbug = await getLbugAdapter();
-        if (lbug.isLbugReady()) {
-          semanticResults = await doSemanticSearch(lbug.executeQuery, query, k * 3, 0.5);
+        const kuzu = await getKuzuAdapter();
+        if (kuzu.isKuzuReady()) {
+          semanticResults = await doSemanticSearch(kuzu.executeQuery, query, k * 3, 0.5);
        }
      } catch {
        // Semantic search failed, continue with BM25 only
@@ -516,15 +516,15 @@ const workerApi = {
  },

  /**
-   * Test if LadybugDB supports array parameters in prepared statements
+   * Test if KuzuDB supports array parameters in prepared statements
   * This is a diagnostic function
   */
  async testArrayParams(): Promise<{ success: boolean; error?: string }> {
-    const lbug = await getLbugAdapter();
-    if (!lbug.isLbugReady()) {
+    const kuzu = await getKuzuAdapter();
+    if (!kuzu.isKuzuReady()) {
      return { success: false, error: 'Database not ready' };
    }
-    return lbug.testArrayParams();
+    return kuzu.testArrayParams();
  },

  // ============================================================
@@ -539,8 +539,8 @@ const workerApi = {
   */
  async initializeAgent(config: ProviderConfig, projectName?: string): Promise<{ success: boolean; error?: string }> {
    try {
-      const lbug = await getLbugAdapter();
-      if (!lbug.isLbugReady()) {
+      const kuzu = await getKuzuAdapter();
+      if (!kuzu.isKuzuReady()) {
        return { success: false, error: 'Database not ready. Please load a repository first.' };
      }

@@ -549,31 +549,31 @@ const workerApi = {
        if (!isEmbeddingComplete) {
          throw new Error('Embeddings not ready');
        }
-        return doSemanticSearch(lbug.executeQuery, query, k, maxDistance);
+        return doSemanticSearch(kuzu.executeQuery, query, k, maxDistance);
      };

      const semanticSearchWithContextWrapper = async (query: string, k?: number, hops?: number) => {
        if (!isEmbeddingComplete) {
          throw new Error('Embeddings not ready');
        }
-        return doSemanticSearchWithContext(lbug.executeQuery, query, k, hops);
+        return doSemanticSearchWithContext(kuzu.executeQuery, query, k, hops);
      };

      // Hybrid search wrapper - combines BM25 + semantic
      const hybridSearchWrapper = async (query: string, k?: number) => {
        // Get BM25 results (always available after ingestion)
        const bm25Results = searchBM25(query, (k ?? 10) * 3);
-
+        
        // Get semantic results if embeddings are ready
        let semanticResults: any[] = [];
        if (isEmbeddingComplete) {
          try {
-            semanticResults = await doSemanticSearch(lbug.executeQuery, query, (k ?? 10) * 3, 0.5);
+            semanticResults = await doSemanticSearch(kuzu.executeQuery, query, (k ?? 10) * 3, 0.5);
          } catch {
            // Semantic search failed, continue with BM25 only
          }
        }
-
+        
        // Merge with RRF
        return mergeWithRRF(bm25Results, semanticResults, k ?? 10);
      };
@@ -586,7 +586,7 @@ const workerApi = {
      
      let codebaseContext;
      try {
-        codebaseContext = await buildCodebaseContext(lbug.executeQuery, resolvedProjectName);
+        codebaseContext = await buildCodebaseContext(kuzu.executeQuery, resolvedProjectName);
        if (import.meta.env.DEV) {
          console.log('📊 Codebase context built:', {
            files: codebaseContext.stats.fileCount,
@@ -600,7 +600,7 @@ const workerApi = {

      currentAgent = createGraphRAGAgent(
        config,
-        lbug.executeQuery,
+        kuzu.executeQuery,
        semanticSearchWrapper,
        semanticSearchWithContextWrapper,
        hybridSearchWrapper,
@@ -627,7 +627,7 @@ const workerApi = {

  /**
   * Initialize the Graph RAG agent in backend mode (HTTP-backed tools).
-   * Uses HTTP wrappers instead of local LadybugDB for all tool queries.
+   * Uses HTTP wrappers instead of local KuzuDB for all tool queries.
   * @param config - Provider configuration for the LLM
   * @param backendUrl - Base URL of the gitnexus serve backend
   * @param repoName - Repository name on the backend
@@ -848,9 +848,9 @@ const workerApi = {
      }
    });

-    // Update LadybugDB with new data
+    // Update KuzuDB with new data
    try {
-      const lbug = await getLbugAdapter();
+      const kuzu = await getKuzuAdapter();
        
      onProgress(enrichments.size, enrichments.size); // Done
      
@@ -872,11 +872,11 @@ const workerApi = {
               c.enrichedBy = "llm"
         `;
         
-         await lbug.executeQuery(query);
+         await kuzu.executeQuery(query);
      }
-
+      
    } catch (err) {
-      console.error('Failed to update LadybugDB with enrichment:', err);
+      console.error('Failed to update KuzuDB with enrichment:', err);
    }
    
    // Convert Map to Record for serialization
@@ -12,11 +12,11 @@ export default defineConfig({
    tailwindcss(),
    wasm(),
    topLevelAwait(),
-    // Copy lbug-wasm worker file to assets folder for production
+    // Copy kuzu-wasm worker file to assets folder for production
    viteStaticCopy({
      targets: [
        {
-          src: 'node_modules/@ladybugdb/wasm-core/lbug_wasm_worker.js',
+          src: 'node_modules/kuzu-wasm/kuzu_wasm_worker.js',
          dest: 'assets'
        }
      ]
@@ -35,12 +35,12 @@ export default defineConfig({
  define: {
    global: 'globalThis',
  },
-  // Optimize deps - exclude lbug-wasm from pre-bundling (it has WASM files)
+  // Optimize deps - exclude kuzu-wasm from pre-bundling (it has WASM files)
  optimizeDeps: {
-    exclude: ['@ladybugdb/wasm-core'],
+    exclude: ['kuzu-wasm'],
    include: ['buffer'],
  },
-  // Required for LadybugDB WASM (SharedArrayBuffer needs Cross-Origin Isolation)
+  // Required for KuzuDB WASM (SharedArrayBuffer needs Cross-Origin Isolation)
  server: {
    headers: {
      'Cross-Origin-Opener-Policy': 'same-origin',
@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "mcp__plugin_claude-mem_mcp-search__get_observations"
-    ]
-  }
-}
@@ -1,9 +0,0 @@
-FROM node:22-bookworm
-WORKDIR /app
-RUN apt-get update && apt-get install -y python3 make g++ && rm -rf /var/lib/apt/lists/*
-COPY . .
-RUN npm ci --ignore-scripts \
-    && node scripts/patch-tree-sitter-swift.cjs \
-    && (npm rebuild 2>&1 || true) \
-    && cd node_modules/tree-sitter-kotlin && npx --yes node-gyp rebuild 2>&1
-CMD ["npx", "vitest", "run", "test/integration", "--reporter=verbose"]
@@ -96,7 +96,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval

-The result is a **LadybugDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
+The result is a **KuzuDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.

 ## MCP Tools

@@ -139,8 +139,7 @@ Your AI agent gets these tools automatically:
 gitnexus setup                    # Configure MCP for your editors (one-time)
 gitnexus analyze [path]           # Index a repository (or update stale index)
 gitnexus analyze --force          # Force full re-index
-gitnexus analyze --embeddings     # Enable embedding generation (slower, better search)
-gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
+gitnexus analyze --skip-embeddings  # Skip embedding generation (faster)
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
 gitnexus list                    # List all indexed repositories
@@ -157,27 +156,7 @@ GitNexus supports indexing multiple repositories. Each `gitnexus analyze` regist

 ## Supported Languages

-TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby
-
-### Language Feature Matrix
-
-| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points |
-|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------|
-| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
-| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ |
-| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
-| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
-
-**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Swift

 ## Agent Skills

@@ -1,17 +1,16 @@
 {
  "name": "gitnexus",
-  "version": "1.4.0",
+  "version": "1.3.11",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "gitnexus",
-      "version": "1.4.0",
+      "version": "1.3.11",
      "hasInstallScript": true,
      "license": "PolyForm-Noncommercial-1.0.0",
      "dependencies": {
        "@huggingface/transformers": "^3.0.0",
-        "@ladybugdb/core": "^0.15.1",
        "@modelcontextprotocol/sdk": "^1.0.0",
        "cli-progress": "^3.12.0",
        "commander": "^12.0.0",
@@ -21,7 +20,7 @@
        "graphology": "^0.25.4",
        "graphology-indices": "^0.17.0",
        "graphology-utils": "^2.3.0",
-        "ignore": "^7.0.5",
+        "kuzu": "^0.11.3",
        "lru-cache": "^11.0.0",
        "mnemonist": "^0.39.0",
        "pandemonium": "^2.4.0",
@@ -32,9 +31,9 @@
        "tree-sitter-go": "^0.21.0",
        "tree-sitter-java": "^0.21.0",
        "tree-sitter-javascript": "^0.21.0",
+        "tree-sitter-kotlin": "^0.3.8",
        "tree-sitter-php": "^0.23.12",
        "tree-sitter-python": "^0.21.0",
-        "tree-sitter-ruby": "^0.23.1",
        "tree-sitter-rust": "^0.21.0",
        "tree-sitter-typescript": "^0.21.0",
        "uuid": "^13.0.0"
@@ -57,7 +56,6 @@
        "node": ">=18.0.0"
      },
      "optionalDependencies": {
-        "tree-sitter-kotlin": "^0.3.8",
        "tree-sitter-swift": "^0.6.0"
      }
    },
@@ -1149,133 +1147,6 @@
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
-    "node_modules/@ladybugdb/core": {
-      "version": "0.15.1",
-      "resolved": "https://registry.npmjs.org/@ladybugdb/core/-/core-0.15.1.tgz",
-      "integrity": "sha512-a+jhzIlS2+57Y2YWXlta7Dq5A3577dQ8YO7DzPCFZxozeiGIZn0K9v0ROO+ws4PW9BwuQYI5BXQxTEtaa1Otlg==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "dependencies": {
-        "cmake-js": "^8.0.0",
-        "node-addon-api": "^6.0.0"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/chownr": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
-      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/cmake-js": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/cmake-js/-/cmake-js-8.0.0.tgz",
-      "integrity": "sha512-YbUP88RDwCvoQkZhRtGURYm9RIpWdtvZuhT87fKNoLjk8kIFIFeARpKfuZQGdwfH99GZpUmqSfcDrK62X7lTgg==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.3",
-        "fs-extra": "^11.3.3",
-        "node-api-headers": "^1.8.0",
-        "rc": "1.2.8",
-        "semver": "^7.7.3",
-        "tar": "^7.5.6",
-        "url-join": "^4.0.1",
-        "which": "^6.0.0",
-        "yargs": "^17.7.2"
-      },
-      "bin": {
-        "cmake-js": "bin/cmake-js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/isexe": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
-      "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/minizlib": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
-      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
-      "license": "MIT",
-      "dependencies": {
-        "minipass": "^7.1.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/@ladybugdb/core/node_modules/tar": {
-      "version": "7.5.11",
-      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.11.tgz",
-      "integrity": "sha512-ChjMH33/KetonMTAtpYdgUFr0tbz69Fp2v7zWxQfYZX4g5ZN2nOBXm1R2xyA+lMIKrLKIoKAwFj93jE/avX9cQ==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/fs-minipass": "^4.0.0",
-        "chownr": "^3.0.0",
-        "minipass": "^7.1.2",
-        "minizlib": "^3.1.0",
-        "yallist": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/which": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
-      "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^4.0.0"
-      },
-      "bin": {
-        "node-which": "bin/which.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@ladybugdb/core/node_modules/yallist": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
-      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
    "node_modules/@modelcontextprotocol/sdk": {
      "version": "1.25.3",
      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.25.3.tgz",
@@ -2402,6 +2273,26 @@
        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
      }
    },
+    "node_modules/aproba": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
+      "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==",
+      "license": "ISC"
+    },
+    "node_modules/are-we-there-yet": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz",
+      "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+      }
+    },
    "node_modules/array-flatten": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
@@ -2430,6 +2321,23 @@
        "js-tokens": "^10.0.0"
      }
    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.4.tgz",
+      "integrity": "sha512-1wVkUaAO6WyaYtCkcYCOx12ZgpGf9Zif+qXa4n+oYzK558YryKqiL6UWwd5DqiH3VRW0GYhTZQ/vlgJrCoNQlg==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
    "node_modules/body-parser": {
      "version": "1.20.4",
      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz",
@@ -2524,6 +2432,15 @@
        "node": ">=18"
      }
    },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
    "node_modules/cli-progress": {
      "version": "3.12.0",
      "resolved": "https://registry.npmjs.org/cli-progress/-/cli-progress-3.12.0.tgz",
@@ -2664,6 +2581,55 @@
        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
      }
    },
+    "node_modules/cmake-js": {
+      "version": "7.4.0",
+      "resolved": "https://registry.npmjs.org/cmake-js/-/cmake-js-7.4.0.tgz",
+      "integrity": "sha512-Lw0JxEHrmk+qNj1n9W9d4IvkDdYTBn7l2BW6XmtLj7WPpIo2shvxUy+YokfjMxAAOELNonQwX3stkPhM5xSC2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "axios": "^1.6.5",
+        "debug": "^4",
+        "fs-extra": "^11.2.0",
+        "memory-stream": "^1.0.0",
+        "node-api-headers": "^1.1.0",
+        "npmlog": "^6.0.2",
+        "rc": "^1.2.7",
+        "semver": "^7.5.4",
+        "tar": "^6.2.0",
+        "url-join": "^4.0.1",
+        "which": "^2.0.2",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "cmake-js": "bin/cmake-js"
+      },
+      "engines": {
+        "node": ">= 14.15.0"
+      }
+    },
+    "node_modules/cmake-js/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/cmake-js/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
    "node_modules/color-convert": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2682,6 +2648,27 @@
      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
      "license": "MIT"
    },
+    "node_modules/color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "license": "ISC",
+      "bin": {
+        "color-support": "bin.js"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
    "node_modules/commander": {
      "version": "12.1.0",
      "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz",
@@ -2691,6 +2678,12 @@
        "node": ">=18"
      }
    },
+    "node_modules/console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+      "license": "ISC"
+    },
    "node_modules/content-disposition": {
      "version": "0.5.4",
      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
@@ -2810,6 +2803,21 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+      "license": "MIT"
+    },
    "node_modules/depd": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
@@ -2922,6 +2930,21 @@
        "node": ">= 0.4"
      }
    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
    "node_modules/es6-error": {
      "version": "4.1.1",
      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
@@ -3181,6 +3204,26 @@
      "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==",
      "license": "Apache-2.0"
    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
    "node_modules/foreground-child": {
      "version": "3.3.1",
      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
@@ -3197,6 +3240,22 @@
        "url": "https://github.com/sponsors/isaacs"
      }
    },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
    "node_modules/forwarded": {
      "version": "0.2.0",
      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -3229,6 +3288,30 @@
        "node": ">=14.14"
      }
    },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/fsevents": {
      "version": "2.3.3",
      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -3253,6 +3336,73 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/gauge": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz",
+      "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.3",
+        "console-control-strings": "^1.1.0",
+        "has-unicode": "^2.0.1",
+        "signal-exit": "^3.0.7",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.5"
+      },
+      "engines": {
+        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+      }
+    },
+    "node_modules/gauge/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/gauge/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/gauge/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/gauge/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/gauge/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/get-caller-file": {
      "version": "2.0.5",
      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
@@ -3468,6 +3618,27 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+      "license": "ISC"
+    },
    "node_modules/hasown": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
@@ -3529,15 +3700,6 @@
        "node": ">=0.10.0"
      }
    },
-    "node_modules/ignore": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
-      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
    "node_modules/inherits": {
      "version": "2.0.4",
      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
@@ -3680,6 +3842,18 @@
        "graceful-fs": "^4.1.6"
      }
    },
+    "node_modules/kuzu": {
+      "version": "0.11.3",
+      "resolved": "https://registry.npmjs.org/kuzu/-/kuzu-0.11.3.tgz",
+      "integrity": "sha512-4+hD3Y+YMV3e0uiqTv1/GUal47D04l8qluw1WFWg8Nx3k7rLsHG1Pmq9WHIOlf1742svxQvTYQiuY6oS1qxAZA==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "cmake-js": "^7.3.0",
+        "node-addon-api": "^6.0.0"
+      }
+    },
    "node_modules/long": {
      "version": "5.3.2",
      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
@@ -3763,6 +3937,15 @@
        "node": ">= 0.6"
      }
    },
+    "node_modules/memory-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/memory-stream/-/memory-stream-1.0.0.tgz",
+      "integrity": "sha512-Wm13VcsPIMdG96dzILfij09PvuS3APtcKNh7M28FsCA/w6+1mjR7hhPmfFNoilX9xU7wTdhsH5lJAm6XNzdtww==",
+      "license": "MIT",
+      "dependencies": {
+        "readable-stream": "^3.4.0"
+      }
+    },
    "node_modules/merge-descriptors": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
@@ -3847,6 +4030,43 @@
        "node": ">=16 || 14 >=14.17"
      }
    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
    "node_modules/mnemonist": {
      "version": "0.39.8",
      "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.39.8.tgz",
@@ -3913,6 +4133,22 @@
        "node-gyp-build-test": "build-test.js"
      }
    },
+    "node_modules/npmlog": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz",
+      "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "are-we-there-yet": "^3.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^4.0.3",
+        "set-blocking": "^2.0.0"
+      },
+      "engines": {
+        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+      }
+    },
    "node_modules/object-assign": {
      "version": "4.1.1",
      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -4233,6 +4469,12 @@
        "node": ">= 0.10"
      }
    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
    "node_modules/qs": {
      "version": "6.14.1",
      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
@@ -4303,6 +4545,20 @@
        "rc": "cli.js"
      }
    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
    "node_modules/require-directory": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
@@ -4546,6 +4802,12 @@
        "node": ">= 0.8.0"
      }
    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
    "node_modules/setprototypeof": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
@@ -4747,6 +5009,15 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
    "node_modules/string-width": {
      "version": "5.1.2",
      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
@@ -4865,6 +5136,33 @@
        "node": ">=8"
      }
    },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exhorbitant rates) by contacting i@izs.me",
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar/node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/tinybench": {
      "version": "2.9.0",
      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -5117,7 +5415,6 @@
      "integrity": "sha512-A4obq6bjzmYrA+F0JLLoheFPcofFkctNaZSpnDd+GPn1SfVZLY4/GG4C0cYVBTOShuPBGGAOPLM1JWLZQV4m1g==",
      "hasInstallScript": true,
      "license": "MIT",
-      "optional": true,
      "dependencies": {
        "node-addon-api": "^7.1.0",
        "node-gyp-build": "^4.8.0"
@@ -5135,8 +5432,7 @@
      "version": "7.1.1",
      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz",
      "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==",
-      "license": "MIT",
-      "optional": true
+      "license": "MIT"
    },
    "node_modules/tree-sitter-php": {
      "version": "0.23.12",
@@ -5191,34 +5487,6 @@
      "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==",
      "license": "MIT"
    },
-    "node_modules/tree-sitter-ruby": {
-      "version": "0.23.1",
-      "resolved": "https://registry.npmjs.org/tree-sitter-ruby/-/tree-sitter-ruby-0.23.1.tgz",
-      "integrity": "sha512-d9/RXgWjR6HanN7wTYhS5bpBQLz1VkH048Vm3CodPGyJVnamXMGb8oEhDypVCBq4QnHui9sTXuJBBP3WtCw5RA==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "dependencies": {
-        "node-addon-api": "^8.2.2",
-        "node-gyp-build": "^4.8.2"
-      },
-      "peerDependencies": {
-        "tree-sitter": "^0.21.1"
-      },
-      "peerDependenciesMeta": {
-        "tree-sitter": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tree-sitter-ruby/node_modules/node-addon-api": {
-      "version": "8.6.0",
-      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.6.0.tgz",
-      "integrity": "sha512-gBVjCaqDlRUk0EwoPNKzIr9KkS9041G/q31IBShPs1Xz6UTA+EXdZADbzqAJQrpDRq71CIMnOP5VMut3SL0z5Q==",
-      "license": "MIT",
-      "engines": {
-        "node": "^18 || ^20 || >= 21"
-      }
-    },
    "node_modules/tree-sitter-rust": {
      "version": "0.21.0",
      "resolved": "https://registry.npmjs.org/tree-sitter-rust/-/tree-sitter-rust-0.21.0.tgz",
@@ -5409,6 +5677,12 @@
      "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==",
      "license": "MIT"
    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
    "node_modules/utils-merge": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
@@ -5625,6 +5899,56 @@
        "node": ">=8"
      }
    },
+    "node_modules/wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
+    "node_modules/wide-align/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wide-align/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/wide-align/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wide-align/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/wrap-ansi": {
      "version": "8.1.0",
      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
@@ -5731,6 +6055,12 @@
        "node": ">=10"
      }
    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    },
    "node_modules/yargs": {
      "version": "17.7.2",
      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
@@ -1,6 +1,6 @@
 {
  "name": "gitnexus",
-  "version": "1.4.0",
+  "version": "1.3.11",
  "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
  "author": "Abhigyan Patwari",
  "license": "PolyForm-Noncommercial-1.0.0",
@@ -49,7 +49,6 @@
  },
  "dependencies": {
    "@huggingface/transformers": "^3.0.0",
-    "@ladybugdb/core": "^0.15.1",
    "@modelcontextprotocol/sdk": "^1.0.0",
    "cli-progress": "^3.12.0",
    "commander": "^12.0.0",
@@ -59,7 +58,7 @@
    "graphology": "^0.25.4",
    "graphology-indices": "^0.17.0",
    "graphology-utils": "^2.3.0",
-    "ignore": "^7.0.5",
+    "kuzu": "^0.11.3",
    "lru-cache": "^11.0.0",
    "mnemonist": "^0.39.0",
    "pandemonium": "^2.4.0",
@@ -70,15 +69,14 @@
    "tree-sitter-go": "^0.21.0",
    "tree-sitter-java": "^0.21.0",
    "tree-sitter-javascript": "^0.21.0",
+    "tree-sitter-kotlin": "^0.3.8",
    "tree-sitter-php": "^0.23.12",
    "tree-sitter-python": "^0.21.0",
-    "tree-sitter-ruby": "^0.23.1",
    "tree-sitter-rust": "^0.21.0",
    "tree-sitter-typescript": "^0.21.0",
    "uuid": "^13.0.0"
  },
  "optionalDependencies": {
-    "tree-sitter-kotlin": "^0.3.8",
    "tree-sitter-swift": "^0.6.0"
  },
  "devDependencies": {
@@ -9,7 +9,6 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { type GeneratedSkillInfo } from './skill-gen.js';

 // ESM equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -38,22 +37,7 @@ const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->';
 * - Exact tool commands with parameters — vague directives get ignored
 * - Self-review checklist — forces model to verify its own work
 */
-function generateGitNexusContent(projectName: string, stats: RepoStats, generatedSkills?: GeneratedSkillInfo[]): string {
-  const generatedRows = (generatedSkills && generatedSkills.length > 0)
-    ? generatedSkills.map(s =>
-        `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |`
-      ).join('\n')
-    : '';
-
-  const skillsTable = `| Task | Read this skill file |
-|------|---------------------|
-| Understand architecture / "How does X work?" | \`.claude/skills/gitnexus/gitnexus-exploring/SKILL.md\` |
-| Blast radius / "What breaks if I change X?" | \`.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md\` |
-| Trace bugs / "Why is X failing?" | \`.claude/skills/gitnexus/gitnexus-debugging/SKILL.md\` |
-| Rename / extract / split / refactor | \`.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md\` |
-| Tools, resources, schema reference | \`.claude/skills/gitnexus/gitnexus-guide/SKILL.md\` |
-| Index, status, clean, wiki CLI commands | \`.claude/skills/gitnexus/gitnexus-cli/SKILL.md\` |${generatedRows ? '\n' + generatedRows : ''}`;
-
+function generateGitNexusContent(projectName: string, stats: RepoStats): string {
  return `${GITNEXUS_START_MARKER}
 # GitNexus — Code Intelligence

@@ -145,7 +129,9 @@ To check whether embeddings exist, inspect \`.gitnexus/meta.json\` — the \`sta

 ## CLI

-${skillsTable}
+- Re-index: \`npx gitnexus analyze\`
+- Check freshness: \`npx gitnexus status\`
+- Generate docs: \`npx gitnexus wiki\`

 ${GITNEXUS_END_MARKER}`;
 }
@@ -284,10 +270,9 @@ export async function generateAIContextFiles(
  repoPath: string,
  _storagePath: string,
  projectName: string,
-  stats: RepoStats,
-  generatedSkills?: GeneratedSkillInfo[]
+  stats: RepoStats
 ): Promise<{ files: string[] }> {
-  const content = generateGitNexusContent(projectName, stats, generatedSkills);
+  const content = generateGitNexusContent(projectName, stats);
  const createdFiles: string[] = [];

  // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.)
@@ -9,15 +9,14 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
+import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex, loadCachedEmbeddings } from '../core/kuzu/kuzu-adapter.js';
 // Embedding imports are lazy (dynamic import) so onnxruntime-node is never
 // loaded when embeddings are not requested. This avoids crashes on Node
 // versions whose ABI is not yet supported by the native binary (#89).
 // disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
-import { generateSkillFiles, type GeneratedSkillInfo } from './skill-gen.js';
 import fs from 'fs/promises';


@@ -46,8 +45,6 @@ function ensureHeap(): boolean {
 export interface AnalyzeOptions {
  force?: boolean;
  embeddings?: boolean;
-  skills?: boolean;
-  verbose?: boolean;
 }

 /** Threshold: auto-skip embeddings for repos with more nodes than this */
@@ -63,7 +60,7 @@ const PHASE_LABELS: Record<string, string> = {
  communities: 'Detecting communities',
  processes: 'Detecting processes',
  complete: 'Pipeline complete',
-  lbug: 'Loading into LadybugDB',
+  kuzu: 'Loading into KuzuDB',
  fts: 'Creating search indexes',
  embeddings: 'Generating embeddings',
  done: 'Done',
@@ -75,10 +72,6 @@ export const analyzeCommand = async (
 ) => {
  if (ensureHeap()) return;

-  if (options?.verbose) {
-    process.env.GITNEXUS_VERBOSE = '1';
-  }
-
  console.log('\n  GitNexus Analyzer\n');

  let repoPath: string;
@@ -100,19 +93,11 @@ export const analyzeCommand = async (
    return;
  }

-  const { storagePath, lbugPath } = getStoragePaths(repoPath);
-
-  // Clean up stale KuzuDB files from before the LadybugDB migration.
-  // If kuzu existed but lbug doesn't, we're doing a migration re-index — say so.
-  const kuzuResult = await cleanupOldKuzuFiles(storagePath);
-  if (kuzuResult.found && kuzuResult.needsReindex) {
-    console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
-  }
-
+  const { storagePath, kuzuPath } = getStoragePaths(repoPath);
  const currentCommit = getCurrentCommit(repoPath);
  const existingMeta = await loadMeta(storagePath);

-  if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) {
+  if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
    console.log('  Already up to date\n');
    return;
  }
@@ -138,7 +123,7 @@ export const analyzeCommand = async (
    aborted = true;
    bar.stop();
    console.log('\n  Interrupted — cleaning up...');
-    closeLbug().catch(() => {}).finally(() => process.exit(130));
+    closeKuzu().catch(() => {}).finally(() => process.exit(130));
  };
  process.on('SIGINT', sigintHandler);

@@ -188,13 +173,13 @@ export const analyzeCommand = async (
  if (options?.embeddings && existingMeta && !options?.force) {
    try {
      updateBar(0, 'Caching embeddings...');
-      await initLbug(lbugPath);
+      await initKuzu(kuzuPath);
      const cached = await loadCachedEmbeddings();
      cachedEmbeddingNodeIds = cached.embeddingNodeIds;
      cachedEmbeddings = cached.embeddings;
-      await closeLbug();
+      await closeKuzu();
    } catch {
-      try { await closeLbug(); } catch {}
+      try { await closeKuzu(); } catch {}
    }
  }

@@ -205,25 +190,25 @@ export const analyzeCommand = async (
    updateBar(scaled, phaseLabel);
  });

-  // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
-  updateBar(60, 'Loading into LadybugDB...');
+  // ── Phase 2: KuzuDB (60–85%) ──────────────────────────────────────
+  updateBar(60, 'Loading into KuzuDB...');

-  await closeLbug();
-  const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
-  for (const f of lbugFiles) {
+  await closeKuzu();
+  const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`];
+  for (const f of kuzuFiles) {
    try { await fs.rm(f, { recursive: true, force: true }); } catch {}
  }

-  const t0Lbug = Date.now();
-  await initLbug(lbugPath);
-  let lbugMsgCount = 0;
-  const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-    lbugMsgCount++;
-    const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
+  const t0Kuzu = Date.now();
+  await initKuzu(kuzuPath);
+  let kuzuMsgCount = 0;
+  const kuzuResult = await loadGraphToKuzu(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
+    kuzuMsgCount++;
+    const progress = Math.min(84, 60 + Math.round((kuzuMsgCount / (kuzuMsgCount + 10)) * 24));
    updateBar(progress, msg);
  });
-  const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
-  const lbugWarnings = lbugResult.warnings;
+  const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1);
+  const kuzuWarnings = kuzuResult.warnings;

  // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
  updateBar(85, 'Creating search indexes...');
@@ -257,7 +242,7 @@ export const analyzeCommand = async (
  }

  // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-  const stats = await getLbugStats();
+  const stats = await getKuzuStats();
  let embeddingTime = '0.0';
  let embeddingSkipped = true;
  let embeddingSkipReason = 'off (use --embeddings to enable)';
@@ -326,13 +311,6 @@ export const analyzeCommand = async (
    aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length;
  }

-  let generatedSkills: GeneratedSkillInfo[] = [];
-  if (options?.skills && pipelineResult.communityResult) {
-    updateBar(99, 'Generating skill files...');
-    const skillResult = await generateSkillFiles(repoPath, projectName, pipelineResult);
-    generatedSkills = skillResult.skills;
-  }
-
  const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
    files: pipelineResult.totalFileCount,
    nodes: stats.nodes,
@@ -340,9 +318,9 @@ export const analyzeCommand = async (
    communities: pipelineResult.communityResult?.stats.totalCommunities,
    clusters: aggregatedClusterCount,
    processes: pipelineResult.processResult?.stats.totalProcesses,
-  }, generatedSkills);
+  });

-  await closeLbug();
+  await closeKuzu();
  // Note: we intentionally do NOT call disposeEmbedder() here.
  // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
  // Since the process exits immediately after, Node.js reclaims everything.
@@ -363,7 +341,7 @@ export const analyzeCommand = async (
  const embeddingsCached = cachedEmbeddings.length > 0;
  console.log(`\n  Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`);
  console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
-  console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
+  console.log(`  KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
  console.log(`  ${repoPath}`);

  if (aiContext.files.length > 0) {
@@ -371,12 +349,12 @@ export const analyzeCommand = async (
  }

  // Show a quiet summary if some edge types needed fallback insertion
-  if (lbugWarnings.length > 0) {
-    const totalFallback = lbugWarnings.reduce((sum, w) => {
+  if (kuzuWarnings.length > 0) {
+    const totalFallback = kuzuWarnings.reduce((sum, w) => {
      const m = w.match(/\((\d+) edges\)/);
      return sum + (m ? parseInt(m[1]) : 0);
    }, 0);
-    console.log(`  Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`);
+    console.log(`  Note: ${totalFallback} edges across ${kuzuWarnings.length} types inserted via fallback (schema will be updated in next release)`);
  }

  try {
@@ -387,7 +365,7 @@ export const analyzeCommand = async (

  console.log('');

-  // LadybugDB's native module holds open handles that prevent Node from exiting.
+  // KuzuDB's native module holds open handles that prevent Node from exiting.
  // ONNX Runtime also registers native atexit hooks that segfault on some
  // platforms (#38, #40). Force-exit to ensure clean termination.
  process.exit(0);
@@ -23,7 +23,7 @@ export async function augmentCommand(pattern: string): Promise<void> {
    
    if (result) {
      // IMPORTANT: Write to stderr, NOT stdout.
-      // LadybugDB's native module captures stdout fd at OS level during init,
+      // KuzuDB's native module captures stdout fd at OS level during init,
      // which makes stdout permanently broken in subprocess contexts.
      // stderr is never captured, so it works reliably everywhere.
      // The hook reads from the subprocess's stderr.
@@ -1,7 +1,7 @@
 /**
 * Eval Server — Lightweight HTTP server for SWE-bench evaluation
 * 
- * Keeps LadybugDB warm in memory so tool calls from the agent are near-instant.
+ * Keeps KuzuDB warm in memory so tool calls from the agent are near-instant.
 * Designed to run inside Docker containers during SWE-bench evaluation.
 * 
 * KEY DESIGN: Returns LLM-friendly text, not raw JSON.
@@ -26,9 +26,7 @@ program
  .description('Index a repository (full analysis)')
  .option('-f, --force', 'Force full re-index even if up to date')
  .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
-  .option('--skills', 'Generate repo-specific skill files from detected communities')
-   .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
-   .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
+  .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));

 program
  .command('serve')
@@ -11,7 +11,7 @@ import { LocalBackend } from '../mcp/local/local-backend.js';

 export const mcpCommand = async () => {
  // Prevent unhandled errors from crashing the MCP server process.
-  // LadybugDB lock conflicts and transient errors should degrade gracefully.
+  // KuzuDB lock conflicts and transient errors should degrade gracefully.
  process.on('uncaughtException', (err) => {
    console.error(`GitNexus MCP: uncaught exception — ${err.message}`);
    // Process is in an undefined state after uncaughtException — exit after flushing
@@ -10,7 +10,6 @@ import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
-import { glob } from 'glob';
 import { getGlobalDir } from '../storage/repo-manager.js';

 const __filename = fileURLToPath(import.meta.url);
@@ -241,6 +240,8 @@ async function setupOpenCode(result: SetupResult): Promise<void> {

 // ─── Skill Installation ───────────────────────────────────────────

+const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impact-analysis', 'gitnexus-refactoring', 'gitnexus-guide', 'gitnexus-cli'];
+
 /**
 * Install GitNexus skills to a target directory.
 * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md
@@ -254,38 +255,25 @@ async function installSkillsTo(targetDir: string): Promise<string[]> {
  const installed: string[] = [];
  const skillsRoot = path.join(__dirname, '..', '..', 'skills');

-  let flatFiles: string[] = [];
-  let dirSkillFiles: string[] = [];
-  try {
-    [flatFiles, dirSkillFiles] = await Promise.all([
-      glob('*.md', { cwd: skillsRoot }),
-      glob('*/SKILL.md', { cwd: skillsRoot }),
-    ]);
-  } catch {
-    return [];
-  }
-
-  const skillSources = new Map<string, { isDirectory: boolean }>();
-
-  for (const relPath of dirSkillFiles) {
-    skillSources.set(path.dirname(relPath), { isDirectory: true });
-  }
-  for (const relPath of flatFiles) {
-    const skillName = path.basename(relPath, '.md');
-    if (!skillSources.has(skillName)) {
-      skillSources.set(skillName, { isDirectory: false });
-    }
-  }
-
-  for (const [skillName, source] of skillSources) {
+  for (const skillName of SKILL_NAMES) {
    const skillDir = path.join(targetDir, skillName);

    try {
-      if (source.isDirectory) {
-        const dirSource = path.join(skillsRoot, skillName);
+      // Try directory-based skill first (skills/{name}/SKILL.md)
+      const dirSource = path.join(skillsRoot, skillName);
+      const dirSkillFile = path.join(dirSource, 'SKILL.md');
+
+      let isDirectory = false;
+      try {
+        const stat = await fs.stat(dirSource);
+        isDirectory = stat.isDirectory();
+      } catch { /* not a directory */ }
+
+      if (isDirectory) {
        await copyDirRecursive(dirSource, skillDir);
        installed.push(skillName);
      } else {
+        // Fall back to flat file (skills/{name}.md)
        const flatSource = path.join(skillsRoot, `${skillName}.md`);
        const content = await fs.readFile(flatSource, 'utf-8');
        await fs.mkdir(skillDir, { recursive: true });
@@ -1,712 +0,0 @@
-/**
- * Skill File Generator
- *
- * Generates repo-specific SKILL.md files from detected Leiden communities.
- * Each significant community becomes a skill that describes a functional area
- * of the codebase, including key files, entry points, execution flows, and
- * cross-community connections.
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { PipelineResult } from '../types/pipeline.js';
-import { CommunityNode, CommunityMembership } from '../core/ingestion/community-processor.js';
-import { ProcessNode } from '../core/ingestion/process-processor.js';
-import { GraphNode, KnowledgeGraph } from '../core/graph/types.js';
-
-// ============================================================================
-// TYPES
-// ============================================================================
-
-export interface GeneratedSkillInfo {
-  name: string;
-  label: string;
-  symbolCount: number;
-  fileCount: number;
-}
-
-interface AggregatedCommunity {
-  label: string;
-  rawIds: string[];
-  symbolCount: number;
-  cohesion: number;
-}
-
-interface MemberSymbol {
-  id: string;
-  name: string;
-  label: string;
-  filePath: string;
-  startLine: number;
-  isExported: boolean;
-}
-
-interface FileInfo {
-  relativePath: string;
-  symbols: string[];
-}
-
-interface CrossConnection {
-  targetLabel: string;
-  count: number;
-}
-
-// ============================================================================
-// MAIN EXPORT
-// ============================================================================
-
-/**
- * @brief Generate repo-specific skill files from detected communities
- * @param {string} repoPath - Absolute path to the repository root
- * @param {string} projectName - Human-readable project name
- * @param {PipelineResult} pipelineResult - In-memory pipeline data with communities, processes, graph
- * @returns {Promise<{ skills: GeneratedSkillInfo[], outputPath: string }>} Generated skill metadata
- */
-export const generateSkillFiles = async (
-  repoPath: string,
-  projectName: string,
-  pipelineResult: PipelineResult
-): Promise<{ skills: GeneratedSkillInfo[]; outputPath: string }> => {
-  const { communityResult, processResult, graph } = pipelineResult;
-  const outputDir = path.join(repoPath, '.claude', 'skills', 'generated');
-
-  if (!communityResult || !communityResult.memberships.length) {
-    console.log('\n  Skills: no communities detected, skipping skill generation');
-    return { skills: [], outputPath: outputDir };
-  }
-
-  console.log('\n  Generating repo-specific skills...');
-
-  // Step 1: Build communities from memberships (not the filtered communities array).
-  // The community processor skips singletons from its communities array but memberships
-  // include ALL assignments. For repos with sparse CALLS edges, the communities array
-  // can be empty while memberships still has useful groupings.
-  const communities = communityResult.communities.length > 0
-    ? communityResult.communities
-    : buildCommunitiesFromMemberships(communityResult.memberships, graph, repoPath);
-
-  const aggregated = aggregateCommunities(communities);
-
-  // Step 2: Filter to significant communities
-  // Keep communities with >= 3 symbols after aggregation.
-  const significant = aggregated
-    .filter(c => c.symbolCount >= 3)
-    .sort((a, b) => b.symbolCount - a.symbolCount)
-    .slice(0, 20);
-
-  if (significant.length === 0) {
-    console.log('\n  Skills: no significant communities found (all below 3-symbol threshold)');
-    return { skills: [], outputPath: outputDir };
-  }
-
-  // Step 3: Build lookup maps
-  const membershipsByComm = buildMembershipMap(communityResult.memberships);
-  const nodeIdToCommunityLabel = buildNodeCommunityLabelMap(
-    communityResult.memberships,
-    communities
-  );
-
-  // Step 4: Clear and recreate output directory
-  try {
-    await fs.rm(outputDir, { recursive: true, force: true });
-  } catch { /* may not exist */ }
-  await fs.mkdir(outputDir, { recursive: true });
-
-  // Step 5: Generate skill files
-  const skills: GeneratedSkillInfo[] = [];
-  const usedNames = new Set<string>();
-
-  for (const community of significant) {
-    // Gather member symbols
-    const members = gatherMembers(community.rawIds, membershipsByComm, graph);
-    if (members.length === 0) continue;
-
-    // Gather file info
-    const files = gatherFiles(members, repoPath);
-
-    // Gather entry points
-    const entryPoints = gatherEntryPoints(members);
-
-    // Gather execution flows
-    const flows = gatherFlows(community.rawIds, processResult?.processes || []);
-
-    // Gather cross-community connections
-    const connections = gatherCrossConnections(
-      community.rawIds,
-      community.label,
-      membershipsByComm,
-      nodeIdToCommunityLabel,
-      graph
-    );
-
-    // Generate kebab name
-    const kebabName = toKebabName(community.label, usedNames);
-    usedNames.add(kebabName);
-
-    // Generate SKILL.md content
-    const content = renderSkillMarkdown(
-      community,
-      projectName,
-      members,
-      files,
-      entryPoints,
-      flows,
-      connections,
-      kebabName
-    );
-
-    // Write file
-    const skillDir = path.join(outputDir, kebabName);
-    await fs.mkdir(skillDir, { recursive: true });
-    await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
-
-    const info: GeneratedSkillInfo = {
-      name: kebabName,
-      label: community.label,
-      symbolCount: community.symbolCount,
-      fileCount: files.length,
-    };
-    skills.push(info);
-
-    console.log(`    \u2713 ${community.label} (${community.symbolCount} symbols, ${files.length} files)`);
-  }
-
-  console.log(`\n  ${skills.length} skills generated \u2192 .claude/skills/generated/`);
-
-  return { skills, outputPath: outputDir };
-};
-
-// ============================================================================
-// FALLBACK COMMUNITY BUILDER
-// ============================================================================
-
-/**
- * @brief Build CommunityNode-like objects from raw memberships when the community
- *        processor's communities array is empty (all singletons were filtered out)
- * @param {CommunityMembership[]} memberships - All node-to-community assignments
- * @param {KnowledgeGraph} graph - The knowledge graph for resolving node metadata
- * @param {string} repoPath - Repository root for path normalization
- * @returns {CommunityNode[]} Synthetic community nodes built from membership data
- */
-const buildCommunitiesFromMemberships = (
-  memberships: CommunityMembership[],
-  graph: KnowledgeGraph,
-  repoPath: string
-): CommunityNode[] => {
-  // Group memberships by communityId
-  const groups = new Map<string, string[]>();
-  for (const m of memberships) {
-    const arr = groups.get(m.communityId);
-    if (arr) {
-      arr.push(m.nodeId);
-    } else {
-      groups.set(m.communityId, [m.nodeId]);
-    }
-  }
-
-  const communities: CommunityNode[] = [];
-
-  for (const [commId, nodeIds] of groups) {
-    // Derive a heuristic label from the most common parent directory
-    const folderCounts = new Map<string, number>();
-    for (const nodeId of nodeIds) {
-      const node = graph.getNode(nodeId);
-      if (!node?.properties.filePath) continue;
-      const normalized = node.properties.filePath.replace(/\\/g, '/');
-      const parts = normalized.split('/').filter(Boolean);
-      if (parts.length >= 2) {
-        const folder = parts[parts.length - 2];
-        if (!['src', 'lib', 'core', 'utils', 'common', 'shared', 'helpers'].includes(folder.toLowerCase())) {
-          folderCounts.set(folder, (folderCounts.get(folder) || 0) + 1);
-        }
-      }
-    }
-
-    let bestFolder = '';
-    let bestCount = 0;
-    for (const [folder, count] of folderCounts) {
-      if (count > bestCount) {
-        bestCount = count;
-        bestFolder = folder;
-      }
-    }
-
-    const label = bestFolder
-      ? bestFolder.charAt(0).toUpperCase() + bestFolder.slice(1)
-      : `Cluster_${commId.replace('comm_', '')}`;
-
-    // Compute cohesion as internal-edge ratio (matches backend calculateCohesion).
-    // For each member node, count edges that stay inside the community vs total.
-    const nodeSet = new Set(nodeIds);
-    let internalEdges = 0;
-    let totalEdges = 0;
-    graph.forEachRelationship(rel => {
-      if (nodeSet.has(rel.sourceId)) {
-        totalEdges++;
-        if (nodeSet.has(rel.targetId)) internalEdges++;
-      }
-    });
-    const cohesion = totalEdges > 0 ? Math.min(1.0, internalEdges / totalEdges) : 1.0;
-
-    communities.push({
-      id: commId,
-      label,
-      heuristicLabel: label,
-      cohesion,
-      symbolCount: nodeIds.length,
-    });
-  }
-
-  return communities.sort((a, b) => b.symbolCount - a.symbolCount);
-};
-
-// ============================================================================
-// AGGREGATION
-// ============================================================================
-
-/**
- * @brief Aggregate raw Leiden communities by heuristicLabel
- * @param {CommunityNode[]} communities - Raw community nodes from Leiden detection
- * @returns {AggregatedCommunity[]} Aggregated communities grouped by label
- */
-const aggregateCommunities = (communities: CommunityNode[]): AggregatedCommunity[] => {
-  const groups = new Map<string, {
-    rawIds: string[];
-    totalSymbols: number;
-    weightedCohesion: number;
-  }>();
-
-  for (const c of communities) {
-    const label = c.heuristicLabel || c.label || 'Unknown';
-    const symbols = c.symbolCount || 0;
-    const cohesion = c.cohesion || 0;
-    const existing = groups.get(label);
-
-    if (!existing) {
-      groups.set(label, {
-        rawIds: [c.id],
-        totalSymbols: symbols,
-        weightedCohesion: cohesion * symbols,
-      });
-    } else {
-      existing.rawIds.push(c.id);
-      existing.totalSymbols += symbols;
-      existing.weightedCohesion += cohesion * symbols;
-    }
-  }
-
-  return Array.from(groups.entries()).map(([label, g]) => ({
-    label,
-    rawIds: g.rawIds,
-    symbolCount: g.totalSymbols,
-    cohesion: g.totalSymbols > 0 ? g.weightedCohesion / g.totalSymbols : 0,
-  }));
-};
-
-// ============================================================================
-// LOOKUP MAP BUILDERS
-// ============================================================================
-
-/**
- * @brief Build a map from communityId to member nodeIds
- * @param {CommunityMembership[]} memberships - All membership records
- * @returns {Map<string, string[]>} Map of communityId -> nodeId[]
- */
-const buildMembershipMap = (memberships: CommunityMembership[]): Map<string, string[]> => {
-  const map = new Map<string, string[]>();
-  for (const m of memberships) {
-    const arr = map.get(m.communityId);
-    if (arr) {
-      arr.push(m.nodeId);
-    } else {
-      map.set(m.communityId, [m.nodeId]);
-    }
-  }
-  return map;
-};
-
-/**
- * @brief Build a map from nodeId to aggregated community label
- * @param {CommunityMembership[]} memberships - All membership records
- * @param {CommunityNode[]} communities - Community nodes with labels
- * @returns {Map<string, string>} Map of nodeId -> community label
- */
-const buildNodeCommunityLabelMap = (
-  memberships: CommunityMembership[],
-  communities: CommunityNode[]
-): Map<string, string> => {
-  const commIdToLabel = new Map<string, string>();
-  for (const c of communities) {
-    commIdToLabel.set(c.id, c.heuristicLabel || c.label || 'Unknown');
-  }
-
-  const map = new Map<string, string>();
-  for (const m of memberships) {
-    const label = commIdToLabel.get(m.communityId);
-    if (label) {
-      map.set(m.nodeId, label);
-    }
-  }
-  return map;
-};
-
-// ============================================================================
-// DATA GATHERING
-// ============================================================================
-
-/**
- * @brief Gather member symbols for an aggregated community
- * @param {string[]} rawIds - Raw community IDs belonging to this aggregated community
- * @param {Map<string, string[]>} membershipsByComm - communityId -> nodeIds
- * @param {KnowledgeGraph} graph - The knowledge graph
- * @returns {MemberSymbol[]} Array of member symbol information
- */
-const gatherMembers = (
-  rawIds: string[],
-  membershipsByComm: Map<string, string[]>,
-  graph: KnowledgeGraph
-): MemberSymbol[] => {
-  const seen = new Set<string>();
-  const members: MemberSymbol[] = [];
-
-  for (const commId of rawIds) {
-    const nodeIds = membershipsByComm.get(commId) || [];
-    for (const nodeId of nodeIds) {
-      if (seen.has(nodeId)) continue;
-      seen.add(nodeId);
-
-      const node = graph.getNode(nodeId);
-      if (!node) continue;
-
-      members.push({
-        id: node.id,
-        name: node.properties.name,
-        label: node.label,
-        filePath: node.properties.filePath || '',
-        startLine: node.properties.startLine || 0,
-        isExported: node.properties.isExported === true,
-      });
-    }
-  }
-
-  return members;
-};
-
-/**
- * @brief Gather deduplicated file info with per-file symbol names
- * @param {MemberSymbol[]} members - Member symbols
- * @param {string} repoPath - Repository root for relative path computation
- * @returns {FileInfo[]} Sorted by symbol count descending
- */
-const gatherFiles = (members: MemberSymbol[], repoPath: string): FileInfo[] => {
-  const fileMap = new Map<string, string[]>();
-
-  for (const m of members) {
-    if (!m.filePath) continue;
-    const rel = toRelativePath(m.filePath, repoPath);
-    const arr = fileMap.get(rel);
-    if (arr) {
-      arr.push(m.name);
-    } else {
-      fileMap.set(rel, [m.name]);
-    }
-  }
-
-  return Array.from(fileMap.entries())
-    .map(([relativePath, symbols]) => ({ relativePath, symbols }))
-    .sort((a, b) => b.symbols.length - a.symbols.length);
-};
-
-/**
- * @brief Gather exported entry points prioritized by type
- * @param {MemberSymbol[]} members - Member symbols
- * @returns {MemberSymbol[]} Exported symbols sorted by type priority
- */
-const gatherEntryPoints = (members: MemberSymbol[]): MemberSymbol[] => {
-  const typePriority: Record<string, number> = {
-    Function: 0,
-    Class: 1,
-    Method: 2,
-    Interface: 3,
-  };
-
-  return members
-    .filter(m => m.isExported)
-    .sort((a, b) => {
-      const pa = typePriority[a.label] ?? 99;
-      const pb = typePriority[b.label] ?? 99;
-      return pa - pb;
-    });
-};
-
-/**
- * @brief Gather execution flows touching this community
- * @param {string[]} rawIds - Raw community IDs for this aggregated community
- * @param {ProcessNode[]} processes - All detected processes
- * @returns {ProcessNode[]} Processes whose communities intersect rawIds, sorted by stepCount
- */
-const gatherFlows = (rawIds: string[], processes: ProcessNode[]): ProcessNode[] => {
-  const rawIdSet = new Set(rawIds);
-
-  return processes
-    .filter(proc => proc.communities.some(cid => rawIdSet.has(cid)))
-    .sort((a, b) => b.stepCount - a.stepCount);
-};
-
-/**
- * @brief Gather cross-community call connections
- * @param {string[]} rawIds - Raw community IDs for this aggregated community
- * @param {string} ownLabel - This community's aggregated label
- * @param {Map<string, string[]>} membershipsByComm - communityId -> nodeIds
- * @param {Map<string, string>} nodeIdToCommunityLabel - nodeId -> community label
- * @param {KnowledgeGraph} graph - The knowledge graph
- * @returns {CrossConnection[]} Aggregated cross-community connections sorted by count
- */
-const gatherCrossConnections = (
-  rawIds: string[],
-  ownLabel: string,
-  membershipsByComm: Map<string, string[]>,
-  nodeIdToCommunityLabel: Map<string, string>,
-  graph: KnowledgeGraph
-): CrossConnection[] => {
-  // Collect all node IDs in this aggregated community
-  const ownNodeIds = new Set<string>();
-  for (const commId of rawIds) {
-    const nodeIds = membershipsByComm.get(commId) || [];
-    for (const nid of nodeIds) {
-      ownNodeIds.add(nid);
-    }
-  }
-
-  // Count outgoing CALLS to nodes in different communities
-  const targetCounts = new Map<string, number>();
-
-  graph.forEachRelationship(rel => {
-    if (rel.type !== 'CALLS') return;
-    if (!ownNodeIds.has(rel.sourceId)) return;
-    if (ownNodeIds.has(rel.targetId)) return; // same community
-
-    const targetLabel = nodeIdToCommunityLabel.get(rel.targetId);
-    if (!targetLabel || targetLabel === ownLabel) return;
-
-    targetCounts.set(targetLabel, (targetCounts.get(targetLabel) || 0) + 1);
-  });
-
-  return Array.from(targetCounts.entries())
-    .map(([targetLabel, count]) => ({ targetLabel, count }))
-    .sort((a, b) => b.count - a.count);
-};
-
-// ============================================================================
-// MARKDOWN RENDERING
-// ============================================================================
-
-/**
- * @brief Render SKILL.md content for a single community
- * @param {AggregatedCommunity} community - The aggregated community data
- * @param {string} projectName - Project name for the description
- * @param {MemberSymbol[]} members - All member symbols
- * @param {FileInfo[]} files - File info with symbol names
- * @param {MemberSymbol[]} entryPoints - Exported entry point symbols
- * @param {ProcessNode[]} flows - Execution flows touching this community
- * @param {CrossConnection[]} connections - Cross-community connections
- * @param {string} kebabName - Kebab-case name for the skill
- * @returns {string} Full SKILL.md content
- */
-const renderSkillMarkdown = (
-  community: AggregatedCommunity,
-  projectName: string,
-  members: MemberSymbol[],
-  files: FileInfo[],
-  entryPoints: MemberSymbol[],
-  flows: ProcessNode[],
-  connections: CrossConnection[],
-  kebabName: string
-): string => {
-  const cohesionPct = Math.round(community.cohesion * 100);
-
-  // Dominant directory: most common top-level directory
-  const dominantDir = getDominantDirectory(files);
-
-  // Top symbol names for "When to Use"
-  const topNames = entryPoints.slice(0, 3).map(e => e.name);
-  if (topNames.length === 0) {
-    // Fallback to any members
-    topNames.push(...members.slice(0, 3).map(m => m.name));
-  }
-
-  const lines: string[] = [];
-
-  // Frontmatter
-  lines.push('---');
-  lines.push(`name: ${kebabName}`);
-  lines.push(`description: "Skill for the ${community.label} area of ${projectName}. ${community.symbolCount} symbols across ${files.length} files."`);
-  lines.push('---');
-  lines.push('');
-
-  // Title
-  lines.push(`# ${community.label}`);
-  lines.push('');
-  lines.push(`${community.symbolCount} symbols | ${files.length} files | Cohesion: ${cohesionPct}%`);
-  lines.push('');
-
-  // When to Use
-  lines.push('## When to Use');
-  lines.push('');
-  if (dominantDir) {
-    lines.push(`- Working with code in \`${dominantDir}/\``);
-  }
-  if (topNames.length > 0) {
-    lines.push(`- Understanding how ${topNames.join(', ')} work`);
-  }
-  lines.push(`- Modifying ${community.label.toLowerCase()}-related functionality`);
-  lines.push('');
-
-  // Key Files (top 10)
-  lines.push('## Key Files');
-  lines.push('');
-  lines.push('| File | Symbols |');
-  lines.push('|------|---------|');
-  for (const f of files.slice(0, 10)) {
-    const symbolList = f.symbols.slice(0, 5).join(', ');
-    const suffix = f.symbols.length > 5 ? ` (+${f.symbols.length - 5})` : '';
-    lines.push(`| \`${f.relativePath}\` | ${symbolList}${suffix} |`);
-  }
-  lines.push('');
-
-  // Entry Points (top 5)
-  if (entryPoints.length > 0) {
-    lines.push('## Entry Points');
-    lines.push('');
-    lines.push('Start here when exploring this area:');
-    lines.push('');
-    for (const ep of entryPoints.slice(0, 5)) {
-      lines.push(`- **\`${ep.name}\`** (${ep.label}) \u2014 \`${ep.filePath}:${ep.startLine}\``);
-    }
-    lines.push('');
-  }
-
-  // Key Symbols (top 20, exported first, then by type)
-  lines.push('## Key Symbols');
-  lines.push('');
-  lines.push('| Symbol | Type | File | Line |');
-  lines.push('|--------|------|------|------|');
-  const sortedMembers = [...members].sort((a, b) => {
-    if (a.isExported !== b.isExported) return a.isExported ? -1 : 1;
-    return a.label.localeCompare(b.label);
-  });
-  for (const m of sortedMembers.slice(0, 20)) {
-    lines.push(`| \`${m.name}\` | ${m.label} | \`${m.filePath}\` | ${m.startLine} |`);
-  }
-  lines.push('');
-
-  // Execution Flows
-  if (flows.length > 0) {
-    lines.push('## Execution Flows');
-    lines.push('');
-    lines.push('| Flow | Type | Steps |');
-    lines.push('|------|------|-------|');
-    for (const f of flows.slice(0, 10)) {
-      lines.push(`| \`${f.heuristicLabel}\` | ${f.processType} | ${f.stepCount} |`);
-    }
-    lines.push('');
-  }
-
-  // Connected Areas
-  if (connections.length > 0) {
-    lines.push('## Connected Areas');
-    lines.push('');
-    lines.push('| Area | Connections |');
-    lines.push('|------|-------------|');
-    for (const c of connections.slice(0, 8)) {
-      lines.push(`| ${c.targetLabel} | ${c.count} calls |`);
-    }
-    lines.push('');
-  }
-
-  // How to Explore
-  const firstEntry = entryPoints.length > 0 ? entryPoints[0].name : (members.length > 0 ? members[0].name : community.label);
-  lines.push('## How to Explore');
-  lines.push('');
-  lines.push(`1. \`gitnexus_context({name: "${firstEntry}"})\` \u2014 see callers and callees`);
-  lines.push(`2. \`gitnexus_query({query: "${community.label.toLowerCase()}"})\` \u2014 find related execution flows`);
-  lines.push('3. Read key files listed above for implementation details');
-  lines.push('');
-
-  return lines.join('\n');
-};
-
-// ============================================================================
-// UTILITY HELPERS
-// ============================================================================
-
-/**
- * @brief Convert a community label to a kebab-case directory name
- * @param {string} label - The community label
- * @param {Set<string>} usedNames - Already-used names for collision detection
- * @returns {string} Unique kebab-case name capped at 50 characters
- */
-const toKebabName = (label: string, usedNames: Set<string>): string => {
-  let name = label
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 50);
-
-  if (!name) name = 'skill';
-
-  let candidate = name;
-  let counter = 2;
-  while (usedNames.has(candidate)) {
-    candidate = `${name}-${counter}`;
-    counter++;
-  }
-
-  return candidate;
-};
-
-/**
- * @brief Convert an absolute or repo-relative file path to a clean relative path
- * @param {string} filePath - The file path from the graph node
- * @param {string} repoPath - Repository root path
- * @returns {string} Relative path using forward slashes
- */
-const toRelativePath = (filePath: string, repoPath: string): string => {
-  // Normalize to forward slashes for cross-platform consistency
-  const normalizedFile = filePath.replace(/\\/g, '/');
-  const normalizedRepo = repoPath.replace(/\\/g, '/');
-
-  if (normalizedFile.startsWith(normalizedRepo)) {
-    return normalizedFile.slice(normalizedRepo.length).replace(/^\//, '');
-  }
-  // Already relative or different root
-  return normalizedFile.replace(/^\//, '');
-};
-
-/**
- * @brief Find the dominant (most common) top-level directory across files
- * @param {FileInfo[]} files - File info entries
- * @returns {string | null} Most common directory or null
- */
-const getDominantDirectory = (files: FileInfo[]): string | null => {
-  const dirCounts = new Map<string, number>();
-
-  for (const f of files) {
-    const parts = f.relativePath.split('/');
-    if (parts.length >= 2) {
-      const dir = parts[0];
-      dirCounts.set(dir, (dirCounts.get(dir) || 0) + f.symbols.length);
-    }
-  }
-
-  let best: string | null = null;
-  let bestCount = 0;
-  for (const [dir, count] of dirCounts) {
-    if (count > bestCount) {
-      bestCount = count;
-      best = dir;
-    }
-  }
-
-  return best;
-};
@@ -4,12 +4,12 @@
 * Shows the indexing status of the current repository.
 */

-import { findRepo, getStoragePaths, hasKuzuIndex } from '../storage/repo-manager.js';
-import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
+import { findRepo } from '../storage/repo-manager.js';
+import { getCurrentCommit, isGitRepo } from '../storage/git.js';

 export const statusCommand = async () => {
  const cwd = process.cwd();
-
+  
  if (!isGitRepo(cwd)) {
    console.log('Not a git repository.');
    return;
@@ -17,16 +17,8 @@ export const statusCommand = async () => {

  const repo = await findRepo(cwd);
  if (!repo) {
-    // Check if there's a stale KuzuDB index that needs migration
-    const repoRoot = getGitRoot(cwd) ?? cwd;
-    const { storagePath } = getStoragePaths(repoRoot);
-    if (await hasKuzuIndex(storagePath)) {
-      console.log('Repository has a stale KuzuDB index from a previous version.');
-      console.log('Run: gitnexus analyze   (rebuilds the index with LadybugDB)');
-    } else {
-      console.log('Repository not indexed.');
-      console.log('Run: gitnexus analyze');
-    }
+    console.log('Repository not indexed.');
+    console.log('Run: gitnexus analyze');
    return;
  }

@@ -10,7 +10,7 @@
 *   gitnexus impact --target "AuthService" --direction upstream
 *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
 * 
- * Note: Output goes to stderr because LadybugDB's native module captures stdout
+ * Note: Output goes to stderr because KuzuDB's native module captures stdout
 * at the OS level during init. This is consistent with augment.ts.
 */

@@ -31,7 +31,7 @@ async function getBackend(): Promise<LocalBackend> {

 function output(data: any): void {
  const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-  // stderr because LadybugDB captures stdout at OS level
+  // stderr because KuzuDB captures stdout at OS level
  process.stderr.write(text + '\n');
 }

@@ -101,7 +101,7 @@ export const wikiCommand = async (
  }

  // ── Check for existing index ────────────────────────────────────────
-  const { storagePath, lbugPath } = getStoragePaths(repoPath);
+  const { storagePath, kuzuPath } = getStoragePaths(repoPath);
  const meta = await loadMeta(storagePath);

  if (!meta) {
@@ -247,7 +247,7 @@ export const wikiCommand = async (
  const generator = new WikiGenerator(
    repoPath,
    storagePath,
-    lbugPath,
+    kuzuPath,
    llmConfig,
    wikiOptions,
    (phase, percent, detail) => {
@@ -1,36 +1,3 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-const _require = createRequire(import.meta.url);
-const ignore = _require('ignore');
-
-let userIgnore: ReturnType<typeof ignore> | null = null;
-let userIgnoreLoadedFor: string | null = null;
-
-/**
- * Load .gitnexusignore from repo root (lazy, cached per repo).
- * Uses the `ignore` npm package for full .gitignore glob spec compliance.
- * Re-loads when repoPath changes (multi-repo support).
- */
-export const loadUserIgnore = (repoPath: string): void => {
-  if (userIgnoreLoadedFor === repoPath) return;
-  userIgnoreLoadedFor = repoPath;
-  userIgnore = null;
-  const ignorePath = path.join(repoPath, '.gitnexusignore');
-  try {
-    const content = fs.readFileSync(ignorePath, 'utf-8');
-    userIgnore = ignore().add(content);
-  } catch {
-    // No .gitnexusignore file — that's fine
-  }
-};
-
-/** Reset cache (for tests). */
-export const resetUserIgnore = (): void => {
-  userIgnore = null;
-  userIgnoreLoadedFor = null;
-};
-
 const DEFAULT_IGNORE_LIST = new Set([
    // Version Control
    '.git',
@@ -267,11 +234,6 @@ export const shouldIgnorePath = (filePath: string): boolean => {
    return true;
  }

-  // Check user-defined .gitnexusignore patterns
-  if (userIgnore?.ignores(normalizedPath)) {
-    return true;
-  }
-
  return false;
 }

@@ -7,9 +7,9 @@ export enum SupportedLanguages {
    CPlusPlus = 'cpp',
    CSharp = 'csharp',
    Go = 'go',
-    Ruby = 'ruby',
    Rust = 'rust',
    PHP = 'php',
    Kotlin = 'kotlin',
+    // Ruby = 'ruby',
    Swift = 'swift',
 }
@@ -24,7 +24,7 @@ import { listRegisteredRepos } from '../../storage/repo-manager.js';
 async function findRepoForCwd(cwd: string): Promise<{
  name: string;
  storagePath: string;
-  lbugPath: string;
+  kuzuPath: string;
 } | null> {
  try {
    const entries = await listRegisteredRepos({ validate: true });
@@ -66,7 +66,7 @@ async function findRepoForCwd(cwd: string): Promise<{
    return {
      name: bestMatch.name,
      storagePath: bestMatch.storagePath,
-      lbugPath: path.join(bestMatch.storagePath, 'lbug'),
+      kuzuPath: path.join(bestMatch.storagePath, 'kuzu'),
    };
  } catch {
    return null;
@@ -92,19 +92,19 @@ export async function augment(pattern: string, cwd?: string): Promise<string> {
    const repo = await findRepoForCwd(workDir);
    if (!repo) return '';
    
-    // Lazy-load lbug adapter (skip unnecessary init)
-    const { initLbug, executeQuery, isLbugReady } = await import('../../mcp/core/lbug-adapter.js');
-    const { searchFTSFromLbug } = await import('../search/bm25-index.js');
-
+    // Lazy-load kuzu adapter (skip unnecessary init)
+    const { initKuzu, executeQuery, isKuzuReady } = await import('../../mcp/core/kuzu-adapter.js');
+    const { searchFTSFromKuzu } = await import('../search/bm25-index.js');
+    
    const repoId = repo.name.toLowerCase();
-
-    // Init LadybugDB if not already
-    if (!isLbugReady(repoId)) {
-      await initLbug(repoId, repo.lbugPath);
+    
+    // Init KuzuDB if not already
+    if (!isKuzuReady(repoId)) {
+      await initKuzu(repoId, repo.kuzuPath);
    }
-
+    
    // Step 1: BM25 search (fast, no embeddings)
-    const bm25Results = await searchFTSFromLbug(pattern, 10, repoId);
+    const bm25Results = await searchFTSFromKuzu(pattern, 10, repoId);
    
    if (bm25Results.length === 0) return '';
    
@@ -140,90 +140,8 @@ export async function augment(pattern: string, cwd?: string): Promise<string> {
    
    if (symbolMatches.length === 0) return '';
    
-    // Step 3: Batch-fetch callers/callees/processes/cohesion for top matches
-    // Uses batched WHERE n.id IN [...] queries instead of per-symbol queries
-    const uniqueSymbols = symbolMatches.slice(0, 5).filter((sym, i, arr) =>
-      arr.findIndex(s => s.nodeId === sym.nodeId) === i
-    );
-
-    if (uniqueSymbols.length === 0) return '';
-
-    const idList = uniqueSymbols.map(s => `'${s.nodeId.replace(/'/g, "''")}'`).join(', ');
-
-    // Batch fetch callers
-    const callersMap = new Map<string, string[]>();
-    try {
-      const rows = await executeQuery(repoId, `
-        MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS targetId, caller.name AS name
-        LIMIT 15
-      `);
-      for (const r of rows) {
-        const tid = r.targetId || r[0];
-        const name = r.name || r[1];
-        if (tid && name) {
-          if (!callersMap.has(tid)) callersMap.set(tid, []);
-          callersMap.get(tid)!.push(name);
-        }
-      }
-    } catch { /* skip */ }
-
-    // Batch fetch callees
-    const calleesMap = new Map<string, string[]>();
-    try {
-      const rows = await executeQuery(repoId, `
-        MATCH (n)-[:CodeRelation {type: 'CALLS'}]->(callee)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS sourceId, callee.name AS name
-        LIMIT 15
-      `);
-      for (const r of rows) {
-        const sid = r.sourceId || r[0];
-        const name = r.name || r[1];
-        if (sid && name) {
-          if (!calleesMap.has(sid)) calleesMap.set(sid, []);
-          calleesMap.get(sid)!.push(name);
-        }
-      }
-    } catch { /* skip */ }
-
-    // Batch fetch processes
-    const processesMap = new Map<string, string[]>();
-    try {
-      const rows = await executeQuery(repoId, `
-        MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS nodeId, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
-      `);
-      for (const r of rows) {
-        const nid = r.nodeId || r[0];
-        const label = r.label || r[1];
-        const step = r.step || r[2];
-        const stepCount = r.stepCount || r[3];
-        if (nid && label) {
-          if (!processesMap.has(nid)) processesMap.set(nid, []);
-          processesMap.get(nid)!.push(`${label} (step ${step}/${stepCount})`);
-        }
-      }
-    } catch { /* skip */ }
-
-    // Batch fetch cohesion
-    const cohesionMap = new Map<string, number>();
-    try {
-      const rows = await executeQuery(repoId, `
-        MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS nodeId, c.cohesion AS cohesion
-      `);
-      for (const r of rows) {
-        const nid = r.nodeId || r[0];
-        const coh = r.cohesion ?? r[1] ?? 0;
-        if (nid) cohesionMap.set(nid, coh);
-      }
-    } catch { /* skip */ }
-
-    // Assemble enriched results
+    // Step 3: For top matches, fetch callers/callees/processes
+    // Also get cluster cohesion internally for ranking
    const enriched: Array<{
      name: string;
      filePath: string;
@@ -232,15 +150,72 @@ export async function augment(pattern: string, cwd?: string): Promise<string> {
      processes: string[];
      cohesion: number;
    }> = [];
-
-    for (const sym of uniqueSymbols) {
+    
+    const seen = new Set<string>();
+    
+    for (const sym of symbolMatches.slice(0, 5)) {
+      if (seen.has(sym.nodeId)) continue;
+      seen.add(sym.nodeId);
+      
+      const escaped = sym.nodeId.replace(/'/g, "''");
+      
+      // Callers
+      let callers: string[] = [];
+      try {
+        const rows = await executeQuery(repoId, `
+          MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n {id: '${escaped}'})
+          RETURN caller.name AS name
+          LIMIT 3
+        `);
+        callers = rows.map((r: any) => r.name || r[0]).filter(Boolean);
+      } catch { /* skip */ }
+      
+      // Callees
+      let callees: string[] = [];
+      try {
+        const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'CALLS'}]->(callee)
+          RETURN callee.name AS name
+          LIMIT 3
+        `);
+        callees = rows.map((r: any) => r.name || r[0]).filter(Boolean);
+      } catch { /* skip */ }
+      
+      // Processes
+      let processes: string[] = [];
+      try {
+        const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+          RETURN p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
+        `);
+        processes = rows.map((r: any) => {
+          const label = r.label || r[0];
+          const step = r.step || r[1];
+          const stepCount = r.stepCount || r[2];
+          return `${label} (step ${step}/${stepCount})`;
+        }).filter(Boolean);
+      } catch { /* skip */ }
+      
+      // Cluster cohesion (internal ranking signal)
+      let cohesion = 0;
+      try {
+        const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
+          RETURN c.cohesion AS cohesion
+          LIMIT 1
+        `);
+        if (rows.length > 0) {
+          cohesion = (rows[0].cohesion ?? rows[0][0]) || 0;
+        }
+      } catch { /* skip */ }
+      
      enriched.push({
        name: sym.name,
        filePath: sym.filePath,
-        callers: (callersMap.get(sym.nodeId) || []).slice(0, 3),
-        callees: (calleesMap.get(sym.nodeId) || []).slice(0, 3),
-        processes: processesMap.get(sym.nodeId) || [],
-        cohesion: cohesionMap.get(sym.nodeId) || 0,
+        callers,
+        callees,
+        processes,
+        cohesion,
      });
    }
    
@@ -262,7 +262,7 @@ export const embedBatch = async (texts: string[]): Promise<Float32Array[]> => {
 };

 /**
- * Convert Float32Array to regular number array (for LadybugDB storage)
+ * Convert Float32Array to regular number array (for KuzuDB storage)
 */
 export const embeddingToArray = (embedding: Float32Array): number[] => {
  return Array.from(embedding);
@@ -2,10 +2,10 @@
 * Embedding Pipeline Module
 * 
 * Orchestrates the background embedding process:
- * 1. Query embeddable nodes from LadybugDB
+ * 1. Query embeddable nodes from KuzuDB
 * 2. Generate text representations
 * 3. Batch embed using transformers.js
- * 4. Update LadybugDB with embeddings
+ * 4. Update KuzuDB with embeddings
 * 5. Create vector index for semantic search
 */

@@ -29,7 +29,7 @@ const isDev = process.env.NODE_ENV === 'development';
 export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void;

 /**
- * Query all embeddable nodes from LadybugDB
+ * Query all embeddable nodes from KuzuDB
 * Uses table-specific queries (File has different schema than code elements)
 */
 const queryEmbeddableNodes = async (
@@ -104,23 +104,9 @@ const batchInsertEmbeddings = async (
 * Create the vector index for semantic search
 * Now indexes the separate CodeEmbedding table
 */
-let vectorExtensionLoaded = false;
-
 const createVectorIndex = async (
  executeQuery: (cypher: string) => Promise<any[]>
 ): Promise<void> => {
-  // LadybugDB v0.15+ requires explicit VECTOR extension loading (once per session)
-  if (!vectorExtensionLoaded) {
-    try {
-      await executeQuery('INSTALL VECTOR');
-      await executeQuery('LOAD EXTENSION VECTOR');
-      vectorExtensionLoaded = true;
-    } catch {
-      // Extension may already be loaded — CREATE_VECTOR_INDEX will fail clearly if not
-      vectorExtensionLoaded = true;
-    }
-  }
-
  const cypher = `
    CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
  `;
@@ -138,7 +124,7 @@ const createVectorIndex = async (
 /**
 * Run the embedding pipeline
 * 
- * @param executeQuery - Function to execute Cypher queries against LadybugDB
+ * @param executeQuery - Function to execute Cypher queries against KuzuDB
 * @param executeWithReusedStatement - Function to execute with reused prepared statement
 * @param onProgress - Callback for progress updates
 * @param config - Optional configuration override
@@ -233,7 +219,7 @@ export const runEmbeddingPipeline = async (
      // Embed the batch
      const embeddings = await embedBatch(texts);

-      // Update LadybugDB with embeddings
+      // Update KuzuDB with embeddings
      const updates = batch.map((node, i) => ({
        id: node.id,
        embedding: embeddingToArray(embeddings[i]),
@@ -340,64 +326,51 @@ export const semanticSearch = async (
    return [];
  }

-  // Group results by label for batched metadata queries
-  const byLabel = new Map<string, Array<{ nodeId: string; distance: number }>>();
+  // Get metadata for each result by querying each node table
+  const results: SemanticSearchResult[] = [];
+  
  for (const embRow of embResults) {
    const nodeId = embRow.nodeId ?? embRow[0];
    const distance = embRow.distance ?? embRow[1];
+    
+    // Extract label from node ID (format: Label:path:name)
    const labelEndIdx = nodeId.indexOf(':');
    const label = labelEndIdx > 0 ? nodeId.substring(0, labelEndIdx) : 'Unknown';
-    if (!byLabel.has(label)) byLabel.set(label, []);
-    byLabel.get(label)!.push({ nodeId, distance });
-  }
-
-  // Batch-fetch metadata per label
-  const results: SemanticSearchResult[] = [];
-
-  for (const [label, items] of byLabel) {
-    const idList = items.map(i => `'${i.nodeId.replace(/'/g, "''")}'`).join(', ');
+    
+    // Query the specific table for this node
+    // File nodes don't have startLine/endLine
    try {
      let nodeQuery: string;
      if (label === 'File') {
        nodeQuery = `
-          MATCH (n:File) WHERE n.id IN [${idList}]
-          RETURN n.id AS id, n.name AS name, n.filePath AS filePath
+          MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath
        `;
      } else {
        nodeQuery = `
-          MATCH (n:${label}) WHERE n.id IN [${idList}]
-          RETURN n.id AS id, n.name AS name, n.filePath AS filePath,
+          MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath, 
                 n.startLine AS startLine, n.endLine AS endLine
        `;
      }
      const nodeRows = await executeQuery(nodeQuery);
-      const rowMap = new Map<string, any>();
-      for (const row of nodeRows) {
-        const id = row.id ?? row[0];
-        rowMap.set(id, row);
-      }
-      for (const item of items) {
-        const nodeRow = rowMap.get(item.nodeId);
-        if (nodeRow) {
-          results.push({
-            nodeId: item.nodeId,
-            name: nodeRow.name ?? nodeRow[1] ?? '',
-            label,
-            filePath: nodeRow.filePath ?? nodeRow[2] ?? '',
-            distance: item.distance,
-            startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[3]) : undefined,
-            endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[4]) : undefined,
-          });
-        }
+      if (nodeRows.length > 0) {
+        const nodeRow = nodeRows[0];
+        results.push({
+          nodeId,
+          name: nodeRow.name ?? nodeRow[0] ?? '',
+          label,
+          filePath: nodeRow.filePath ?? nodeRow[1] ?? '',
+          distance,
+          startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[2]) : undefined,
+          endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[3]) : undefined,
+        });
      }
    } catch {
      // Table might not exist, skip
    }
  }

-  // Re-sort by distance since batch queries may have mixed order
-  results.sort((a, b) => a.distance - b.distance);
-
  return results;
 };

@@ -92,7 +92,7 @@ export interface SemanticSearchResult {
 }

 /**
- * Node data for embedding (minimal structure from LadybugDB query)
+ * Node data for embedding (minimal structure from KuzuDB query)
 */
 export interface EmbeddableNode {
  id: string;
@@ -35,14 +35,12 @@ export type NodeLabel =
  | 'Template';


-import { SupportedLanguages } from '../../config/supported-languages.js';
-
 export type NodeProperties = {
  name: string,
  filePath: string,
  startLine?: number,
  endLine?: number,
-  language?: SupportedLanguages,
+  language?: string,
  isExported?: boolean,
  // Optional AST-derived framework hint (e.g. @Controller, @GetMapping)
  astFrameworkMultiplier?: number,
@@ -63,23 +61,19 @@ export type NodeProperties = {
  // Entry point scoring (computed by process detection)
  entryPointScore?: number,
  entryPointReason?: string,
-  // Method signature (for MRO disambiguation)
-  parameterCount?: number,
-  returnType?: string,
 }

-export type RelationshipType =
-  | 'CONTAINS'
-  | 'CALLS'
-  | 'INHERITS'
-  | 'OVERRIDES'
+export type RelationshipType = 
+  | 'CONTAINS' 
+  | 'CALLS' 
+  | 'INHERITS' 
+  | 'OVERRIDES' 
  | 'IMPORTS'
  | 'USES'
  | 'DEFINES'
  | 'DECORATES'
  | 'IMPLEMENTS'
  | 'EXTENDS'
-  | 'HAS_METHOD'
  | 'MEMBER_OF'
  | 'STEP_IN_PROCESS'

@@ -1,29 +1,50 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import type { SymbolDefinition } from './symbol-table.js';
+import { SymbolTable } from './symbol-table.js';
+import { ImportMap } from './import-processor.js';
 import Parser from 'tree-sitter';
-import type { ResolutionContext } from './resolution-context.js';
-import { TIER_CONFIDENCE, type ResolutionTier } from './resolution-context.js';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import {
-  getLanguageFromFilename,
-  isVerboseIngestionEnabled,
-  yieldToEventLoop,
-  FUNCTION_NODE_TYPES,
-  extractFunctionName,
-  isBuiltInOrNoise,
-  countCallArguments,
-  inferCallForm,
-  extractReceiverName,
-  findEnclosingClassId,
-} from './utils.js';
-import { buildTypeEnv } from './type-env.js';
-import type { ConstructorBinding } from './type-env.js';
-import { getTreeSitterBufferSize } from './constants.js';
-import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
-import { callRouters } from './call-routing.js';
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+import type { ExtractedCall, ExtractedRoute } from './workers/parse-worker.js';
+
+/**
+ * Node types that represent function/method definitions across languages.
+ * Used to find the enclosing function for a call site.
+ */
+const FUNCTION_NODE_TYPES = new Set([
+  // TypeScript/JavaScript
+  'function_declaration',
+  'arrow_function',
+  'function_expression',
+  'method_definition',
+  'generator_function_declaration',
+  // Python
+  'function_definition',
+  // Common async variants
+  'async_function_declaration',
+  'async_arrow_function',
+  // Java
+  'method_declaration',
+  'constructor_declaration',
+  // C/C++
+  // 'function_definition' already included above
+  // Go
+  // 'method_declaration' already included from Java
+  // C#
+  'local_function_statement',
+  // Rust
+  'function_item',
+  'impl_item', // Methods inside impl blocks
+  // Kotlin (function_declaration already included above via JS/TS)
+  'anonymous_function',
+  'lambda_literal',
+  // PHP — no additional node types needed
+  // Swift
+  'init_declaration',
+  'deinit_declaration',
+]);

 /**
 * Walk up the AST from a node to find the enclosing function/method.
@@ -32,126 +53,134 @@ import { callRouters } from './call-routing.js';
 const findEnclosingFunction = (
  node: any,
  filePath: string,
-  ctx: ResolutionContext
+  symbolTable: SymbolTable
 ): string | null => {
  let current = node.parent;
-
+  
  while (current) {
    if (FUNCTION_NODE_TYPES.has(current.type)) {
-      const { funcName, label } = extractFunctionName(current);
-
-      if (funcName) {
-        const resolved = ctx.resolve(funcName, filePath);
-        if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
-          return resolved.candidates[0].nodeId;
-        }
-
-        return generateId(label, `${filePath}:${funcName}`);
+      // Found enclosing function - try to get its name
+      let funcName: string | null = null;
+      let label = 'Function';
+      
+      // Different node types have different name locations
+      // Swift init/deinit — handle before generic cases (more specific)
+      if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
+        const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
+        return generateId('Constructor', `${filePath}:${funcName}`);
      }
+
+      if (current.type === 'function_declaration' ||
+          current.type === 'function_definition' ||
+          current.type === 'async_function_declaration' ||
+          current.type === 'generator_function_declaration' ||
+          current.type === 'function_item') { // Rust function
+        // Named function: function foo() {}
+        const nameNode = current.childForFieldName?.('name') || 
+                         current.children?.find((c: any) => c.type === 'identifier' || c.type === 'property_identifier');
+        funcName = nameNode?.text;
+      } else if (current.type === 'impl_item') {
+        // Rust method inside impl block: wrapper around function_item or const_item
+        // We need to look inside for the function_item
+        const funcItem = current.children?.find((c: any) => c.type === 'function_item');
+        if (funcItem) {
+           const nameNode = funcItem.childForFieldName?.('name') || 
+                            funcItem.children?.find((c: any) => c.type === 'identifier');
+           funcName = nameNode?.text;
+           label = 'Method';
+        }
+      } else if (current.type === 'method_definition') {
+        // Method: foo() {} inside class (JS/TS)
+        const nameNode = current.childForFieldName?.('name') ||
+                         current.children?.find((c: any) => c.type === 'property_identifier');
+        funcName = nameNode?.text;
+        label = 'Method';
+      } else if (current.type === 'method_declaration') {
+        // Java method: public void foo() {}
+        const nameNode = current.childForFieldName?.('name') ||
+                         current.children?.find((c: any) => c.type === 'identifier');
+        funcName = nameNode?.text;
+        label = 'Method';
+      } else if (current.type === 'constructor_declaration') {
+        // Java constructor: public ClassName() {}
+        const nameNode = current.childForFieldName?.('name') ||
+                         current.children?.find((c: any) => c.type === 'identifier');
+        funcName = nameNode?.text;
+        label = 'Method'; // Treat constructors as methods for process detection
+      } else if (current.type === 'arrow_function' || current.type === 'function_expression') {
+        // Arrow/expression: const foo = () => {} - check parent variable declarator
+        const parent = current.parent;
+        if (parent?.type === 'variable_declarator') {
+          const nameNode = parent.childForFieldName?.('name') ||
+                           parent.children?.find((c: any) => c.type === 'identifier');
+          funcName = nameNode?.text;
+        }
+      }
+      
+      if (funcName) {
+        // Look up the function in symbol table to get its node ID
+        // Try exact match first
+        const nodeId = symbolTable.lookupExact(filePath, funcName);
+        if (nodeId) return nodeId;
+        
+        // Try construct ID manually if lookup fails (common for non-exported internal functions)
+        // Format should match what parsing-processor generates: "Function:path/to/file:funcName"
+        // Check if we already have a node with this ID in the symbol table to be safe
+        const generatedId = generateId(label, `${filePath}:${funcName}`);
+        
+        // Ideally we should verify this ID exists, but strictly speaking if we are inside it,
+        // it SHOULD exist. Returning it is better than falling back to File.
+        return generatedId;
+      }
+      
+      // Couldn't determine function name - try parent (might be nested)
    }
    current = current.parent;
  }
-
-  return null;
-};
-
-/**
- * Verify constructor bindings against SymbolTable and infer receiver types.
- * Shared between sequential (processCalls) and worker (processCallsFromExtracted) paths.
- */
-const verifyConstructorBindings = (
-  bindings: readonly ConstructorBinding[],
-  filePath: string,
-  ctx: ResolutionContext,
-  graph?: KnowledgeGraph,
-): Map<string, string> => {
-  const verified = new Map<string, string>();
-
-  for (const { scope, varName, calleeName, receiverClassName } of bindings) {
-    const tiered = ctx.resolve(calleeName, filePath);
-    const isClass = tiered?.candidates.some(def => def.type === 'Class') ?? false;
-
-    if (isClass) {
-      verified.set(receiverKey(extractFuncNameFromScope(scope), varName), calleeName);
-    } else {
-      let callableDefs = tiered?.candidates.filter(d =>
-        d.type === 'Function' || d.type === 'Method'
-      );
-
-      // When receiver class is known (e.g. $this->method() in PHP), narrow
-      // candidates to methods owned by that class to avoid false disambiguation failures.
-      if (callableDefs && callableDefs.length > 1 && receiverClassName) {
-        if (graph) {
-          // Worker path: use graph.getNode (fast, already in-memory)
-          const narrowed = callableDefs.filter(d => {
-            if (!d.ownerId) return false;
-            const owner = graph.getNode(d.ownerId);
-            return owner?.properties.name === receiverClassName;
-          });
-          if (narrowed.length > 0) callableDefs = narrowed;
-        } else {
-          // Sequential path: use ctx.resolve (no graph available)
-          const classResolved = ctx.resolve(receiverClassName, filePath);
-          if (classResolved && classResolved.candidates.length > 0) {
-            const classNodeIds = new Set(classResolved.candidates.map(c => c.nodeId));
-            const narrowed = callableDefs.filter(d =>
-              d.ownerId && classNodeIds.has(d.ownerId)
-            );
-            if (narrowed.length > 0) callableDefs = narrowed;
-          }
-        }
-      }
-
-      if (callableDefs && callableDefs.length === 1 && callableDefs[0].returnType) {
-        const typeName = extractReturnTypeName(callableDefs[0].returnType);
-        if (typeName) {
-          verified.set(receiverKey(extractFuncNameFromScope(scope), varName), typeName);
-        }
-      }
-    }
-  }
-
-  return verified;
+  
+  return null; // Top-level call (not inside any function)
 };

 export const processCalls = async (
  graph: KnowledgeGraph,
  files: { path: string; content: string }[],
  astCache: ASTCache,
-  ctx: ResolutionContext,
-  onProgress?: (current: number, total: number) => void,
-): Promise<ExtractedHeritage[]> => {
+  symbolTable: SymbolTable,
+  importMap: ImportMap,
+  onProgress?: (current: number, total: number) => void
+) => {
  const parser = await loadParser();
-  const collectedHeritage: ExtractedHeritage[] = [];
-  const logSkipped = isVerboseIngestionEnabled();
-  const skippedByLang = logSkipped ? new Map<string, number>() : null;

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    onProgress?.(i + 1, files.length);
    if (i % 20 === 0) await yieldToEventLoop();

+    // 1. Check language support first
    const language = getLanguageFromFilename(file.path);
    if (!language) continue;
-    if (!isLanguageAvailable(language)) {
-      if (skippedByLang) {
-        skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
-      }
-      continue;
-    }

    const queryStr = LANGUAGE_QUERIES[language];
    if (!queryStr) continue;

+    // 2. ALWAYS load the language before querying (parser is stateful)
    await loadLanguage(language, file.path);

+    // 3. Get AST (Try Cache First)
    let tree = astCache.get(file.path);
+    let wasReparsed = false;
+
    if (!tree) {
+      // Cache Miss: Re-parse
+      // Use larger bufferSize for files > 32KB
      try {
-        tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+        tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
      } catch (parseError) {
+        // Skip files that can't be parsed
        continue;
      }
+      wasReparsed = true;
+      // Cache re-parsed tree so heritage phase gets hits
      astCache.set(file.path, tree);
    }

@@ -166,20 +195,12 @@ export const processCalls = async (
      continue;
    }

-    const lang = getLanguageFromFilename(file.path);
-    const typeEnv = lang ? buildTypeEnv(tree, lang, ctx.symbols) : null;
-    const callRouter = callRouters[language];
-
-    const verifiedReceivers = typeEnv && typeEnv.constructorBindings.length > 0
-      ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx)
-      : new Map<string, string>();
-
-    ctx.enableCache(file.path);
-
+    // 3. Process each call match
    matches.forEach(match => {
      const captureMap: Record<string, any> = {};
      match.captures.forEach(c => captureMap[c.name] = c.node);

+      // Only process @call captures
      if (!captureMap['call']) return;

      const nameNode = captureMap['call.name'];
@@ -187,87 +208,26 @@ export const processCalls = async (

      const calledName = nameNode.text;

-      const routed = callRouter(calledName, captureMap['call']);
-      if (routed) {
-        switch (routed.kind) {
-          case 'skip':
-          case 'import':
-            return;
-
-          case 'heritage':
-            for (const item of routed.items) {
-              collectedHeritage.push({
-                filePath: file.path,
-                className: item.enclosingClass,
-                parentName: item.mixinName,
-                kind: item.heritageKind,
-              });
-            }
-            return;
-
-          case 'properties': {
-            const fileId = generateId('File', file.path);
-            const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
-            for (const item of routed.items) {
-              const nodeId = generateId('Property', `${file.path}:${item.propName}`);
-              graph.addNode({
-                id: nodeId,
-                label: 'Property' as any, // TODO: add 'Property' to graph node label union
-                properties: {
-                  name: item.propName, filePath: file.path,
-                  startLine: item.startLine, endLine: item.endLine,
-                  language, isExported: true,
-                  description: item.accessorType,
-                },
-              });
-              ctx.symbols.add(file.path, item.propName, nodeId, 'Property',
-                propEnclosingClassId ? { ownerId: propEnclosingClassId } : undefined);
-              const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-              graph.addRelationship({
-                id: relId, sourceId: fileId, targetId: nodeId,
-                type: 'DEFINES', confidence: 1.0, reason: '',
-              });
-              if (propEnclosingClassId) {
-                graph.addRelationship({
-                  id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
-                  sourceId: propEnclosingClassId, targetId: nodeId,
-                  type: 'HAS_METHOD', confidence: 1.0, reason: '',
-                });
-              }
-            }
-            return;
-          }
-
-          case 'call':
-            break;
-        }
-      }
-
+      // Skip common built-ins and noise
      if (isBuiltInOrNoise(calledName)) return;

-      const callNode = captureMap['call'];
-      const callForm = inferCallForm(callNode, nameNode);
-      const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
-      let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
-      // Fall back to verified constructor bindings for return type inference
-      if (!receiverTypeName && receiverName && verifiedReceivers.size > 0) {
-        const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
-        const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : '';
-        receiverTypeName = verifiedReceivers.get(receiverKey(funcName, receiverName))
-          ?? verifiedReceivers.get(receiverKey('', receiverName));
-      }
-
-      const resolved = resolveCallTarget({
+      // 4. Resolve the target using priority strategy (returns confidence)
+      const resolved = resolveCallTarget(
        calledName,
-        argCount: countCallArguments(callNode),
-        callForm,
-        receiverTypeName,
-      }, file.path, ctx);
+        file.path,
+        symbolTable,
+        importMap
+      );

      if (!resolved) return;

-      const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx);
+      // 5. Find the enclosing function (caller)
+      const callNode = captureMap['call'];
+      const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable);
+      
+      // Use enclosing function as source, fallback to file for top-level calls
      const sourceId = enclosingFuncId || generateId('File', file.path);
+      
      const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);

      graph.addRelationship({
@@ -280,18 +240,8 @@ export const processCalls = async (
      });
    });

-    ctx.clearCache();
+    // Tree is now owned by the LRU cache — no manual delete needed
  }
-
-  if (skippedByLang && skippedByLang.size > 0) {
-    for (const [lang, count] of skippedByLang.entries()) {
-      console.warn(
-        `[ingestion] Skipped ${count} ${lang} file(s) in call processing — ${lang} parser not available.`
-      );
-    }
-  }
-
-  return collectedHeritage;
 };

 /**
@@ -299,340 +249,209 @@ export const processCalls = async (
 */
 interface ResolveResult {
  nodeId: string;
-  confidence: number;
-  reason: string;
+  confidence: number;  // 0-1: how sure are we?
+  reason: string;      // 'import-resolved' | 'same-file' | 'fuzzy-global'
 }

-const CALLABLE_SYMBOL_TYPES = new Set([
-  'Function',
-  'Method',
-  'Constructor',
-  'Macro',
-  'Delegate',
-]);
-
-const CONSTRUCTOR_TARGET_TYPES = new Set(['Constructor', 'Class', 'Struct', 'Record']);
-
-const filterCallableCandidates = (
-  candidates: readonly SymbolDefinition[],
-  argCount?: number,
-  callForm?: 'free' | 'member' | 'constructor',
-): SymbolDefinition[] => {
-  let kindFiltered: SymbolDefinition[];
-
-  if (callForm === 'constructor') {
-    const constructors = candidates.filter(c => c.type === 'Constructor');
-    if (constructors.length > 0) {
-      kindFiltered = constructors;
-    } else {
-      const types = candidates.filter(c => CONSTRUCTOR_TARGET_TYPES.has(c.type));
-      kindFiltered = types.length > 0 ? types : candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
-    }
-  } else {
-    kindFiltered = candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
-  }
-
-  if (kindFiltered.length === 0) return [];
-  if (argCount === undefined) return kindFiltered;
-
-  const hasParameterMetadata = kindFiltered.some(candidate => candidate.parameterCount !== undefined);
-  if (!hasParameterMetadata) return kindFiltered;
-
-  return kindFiltered.filter(candidate =>
-    candidate.parameterCount === undefined || candidate.parameterCount === argCount
-  );
-};
-
-const toResolveResult = (
-  definition: SymbolDefinition,
-  tier: ResolutionTier,
-): ResolveResult => ({
-  nodeId: definition.nodeId,
-  confidence: TIER_CONFIDENCE[tier],
-  reason: tier === 'same-file' ? 'same-file' : tier === 'import-scoped' ? 'import-resolved' : 'global',
-});
-
 /**
 * Resolve a function call to its target node ID using priority strategy:
- * A. Narrow candidates by scope tier via ctx.resolve()
- * B. Filter to callable symbol kinds (constructor-aware when callForm is set)
- * C. Apply arity filtering when parameter metadata is available
- * D. Apply receiver-type filtering for member calls with typed receivers
- *
- * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
+ * A. Check imported files first (highest confidence)
+ * B. Check local file definitions
+ * C. Fuzzy global search (lowest confidence)
+ * 
+ * Returns confidence score so agents know what to trust.
 */
 const resolveCallTarget = (
-  call: Pick<ExtractedCall, 'calledName' | 'argCount' | 'callForm' | 'receiverTypeName'>,
+  calledName: string,
  currentFile: string,
-  ctx: ResolutionContext,
+  symbolTable: SymbolTable,
+  importMap: ImportMap
 ): ResolveResult | null => {
-  const tiered = ctx.resolve(call.calledName, currentFile);
-  if (!tiered) return null;
-
-  const filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
-
-  // D. Receiver-type filtering: for member calls with a known receiver type,
-  // resolve the type through the same tiered import infrastructure, then
-  // filter method candidates to the type's defining file. Fall back to
-  // fuzzy ownerId matching only when file-based narrowing is inconclusive.
-  //
-  // Applied regardless of candidate count — the sole same-file candidate may
-  // belong to the wrong class (e.g. super.save() should hit the parent's save,
-  // not the child's own save method in the same file).
-  if (call.callForm === 'member' && call.receiverTypeName) {
-    // D1. Resolve the receiver type
-    const typeResolved = ctx.resolve(call.receiverTypeName, currentFile);
-    if (typeResolved && typeResolved.candidates.length > 0) {
-      const typeNodeIds = new Set(typeResolved.candidates.map(d => d.nodeId));
-      const typeFiles = new Set(typeResolved.candidates.map(d => d.filePath));
-
-      // D2. Widen candidates: same-file tier may miss the parent's method when
-      //     it lives in another file. Query the symbol table directly for all
-      //     global methods with this name, then apply arity/kind filtering.
-      const methodPool = filteredCandidates.length <= 1
-        ? filterCallableCandidates(ctx.symbols.lookupFuzzy(call.calledName), call.argCount, call.callForm)
-        : filteredCandidates;
-
-      // D3. File-based: prefer candidates whose filePath matches the resolved type's file
-      const fileFiltered = methodPool.filter(c => typeFiles.has(c.filePath));
-      if (fileFiltered.length === 1) {
-        return toResolveResult(fileFiltered[0], tiered.tier);
-      }
-
-      // D4. ownerId fallback: narrow by ownerId matching the type's nodeId
-      const pool = fileFiltered.length > 0 ? fileFiltered : methodPool;
-      const ownerFiltered = pool.filter(c => c.ownerId && typeNodeIds.has(c.ownerId));
-      if (ownerFiltered.length === 1) {
-        return toResolveResult(ownerFiltered[0], tiered.tier);
-      }
-      if (fileFiltered.length > 1 || ownerFiltered.length > 1) return null;
-    }
+  // Strategy B first (cheapest — single map lookup): Check local file
+  const localNodeId = symbolTable.lookupExact(currentFile, calledName);
+  if (localNodeId) {
+    return { nodeId: localNodeId, confidence: 0.85, reason: 'same-file' };
  }

-  if (filteredCandidates.length !== 1) return null;
+  // Strategy A: Check if any definition of calledName is in an imported file
+  // Reversed: instead of iterating all imports and checking each, get all definitions
+  // and check if any is imported. O(definitions) instead of O(imports).
+  const allDefs = symbolTable.lookupFuzzy(calledName);
+  if (allDefs.length > 0) {
+    const importedFiles = importMap.get(currentFile);
+    if (importedFiles) {
+      for (const def of allDefs) {
+        if (importedFiles.has(def.filePath)) {
+          return { nodeId: def.nodeId, confidence: 0.9, reason: 'import-resolved' };
+        }
+      }
+    }

-  return toResolveResult(filteredCandidates[0], tiered.tier);
+    // Strategy C: Fuzzy global (no import match found)
+    const confidence = allDefs.length === 1 ? 0.5 : 0.3;
+    return { nodeId: allDefs[0].nodeId, confidence, reason: 'fuzzy-global' };
+  }
+
+  return null;
 };

-// ── Return type text helpers ─────────────────────────────────────────────
-// extractSimpleTypeName works on AST nodes; this operates on raw return-type
-// text already stored in SymbolDefinition (e.g. "User", "Promise<User>",
-// "User | null", "*User").  Extracts the base user-defined type name.
-
-/** Primitive / built-in types that should NOT produce a receiver binding. */
-const PRIMITIVE_TYPES = new Set([
-  'string', 'number', 'boolean', 'void', 'int', 'float', 'double', 'long',
-  'short', 'byte', 'char', 'bool', 'str', 'i8', 'i16', 'i32', 'i64',
-  'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'usize', 'isize',
-  'undefined', 'null', 'None', 'nil',
+/**
+ * Filter out common built-in functions and noise
+ * that shouldn't be tracked as calls
+ */
+/** Pre-built set (module-level singleton) to avoid re-creating per call */
+const BUILT_IN_NAMES = new Set([
+  // JavaScript/TypeScript built-ins
+  'console', 'log', 'warn', 'error', 'info', 'debug',
+  'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+  'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+  'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+  'JSON', 'parse', 'stringify',
+  'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+  'Map', 'Set', 'WeakMap', 'WeakSet',
+  'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
+  'Math', 'Date', 'RegExp', 'Error',
+  'require', 'import', 'export',
+  'fetch', 'Response', 'Request',
+  // React hooks and common functions
+  'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
+  'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+  'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
+  // Common array/object methods
+  'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
+  'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
+  'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
+  'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
+  'hasOwnProperty', 'toString', 'valueOf',
+  // Python built-ins
+  'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
+  'open', 'read', 'write', 'close', 'append', 'extend', 'update',
+  'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
+  'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
+  // Kotlin stdlib (IMPORTANT: keep in sync with parse-worker.ts BUILT_IN_NAMES)
+  'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
+  'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
+  'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
+  'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
+  'repeat', 'synchronized',
+  // Kotlin coroutine builders & scope functions
+  'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
+  'supervisorScope', 'delay',
+  // Kotlin Flow operators
+  'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
+  'buffer', 'conflate', 'distinctUntilChanged',
+  'flatMapLatest', 'flatMapMerge', 'combine',
+  'stateIn', 'shareIn', 'launchIn',
+  // Kotlin infix stdlib functions
+  'to', 'until', 'downTo', 'step',
+  // C/C++ standard library and common kernel helpers
+  'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
+  'scanf', 'fscanf', 'sscanf',
+  'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
+  'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
+  'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
+  'sizeof', 'offsetof', 'typeof',
+  'assert', 'abort', 'exit', '_exit',
+  'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
+  // Linux kernel common macros/helpers (not real call targets)
+  'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
+  'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
+  'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
+  'min', 'max', 'clamp', 'abs', 'swap',
+  'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
+  'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
+  'GFP_KERNEL', 'GFP_ATOMIC',
+  'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
+  'mutex_lock', 'mutex_unlock', 'mutex_init',
+  'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
+  'get', 'put',
+  // Swift/iOS built-ins and standard library
+  'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+  'assert', 'assertionFailure', 'NSLog',
+  'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
+  'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+  'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
+  'type', 'MemoryLayout',
+  // Swift collection/string methods (common noise)
+  'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
+  'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
+  'sorted', 'reversed', 'enumerated', 'joined', 'split',
+  'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+  'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
+  // UIKit/Foundation common methods (noise in call graph)
+  'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
+  'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
+  'addTarget', 'removeTarget', 'addGestureRecognizer',
+  'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
+  'NSLocalizedString', 'Bundle',
+  'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
+  'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
+  'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
+  'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
+  'performSegue', 'prepare',
+  // GCD / async
+  'DispatchQueue', 'async', 'sync', 'asyncAfter',
+  'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
+  // Combine
+  'sink', 'store', 'assign', 'receive', 'subscribe',
+  // Notification / KVO
+  'addObserver', 'removeObserver', 'post', 'NotificationCenter',
 ]);

-/**
- * Extract a simple type name from raw return-type text.
- * Handles common patterns:
- *   "User"                → "User"
- *   "Promise<User>"       → "User"   (unwrap wrapper generics)
- *   "Option<User>"        → "User"
- *   "Result<User, Error>" → "User"   (first type arg)
- *   "User | null"         → "User"   (strip nullable union)
- *   "User?"               → "User"   (strip nullable suffix)
- *   "*User"               → "User"   (Go pointer)
- *   "&User"               → "User"   (Rust reference)
- * Returns undefined for complex types or primitives.
- */
-const WRAPPER_GENERICS = new Set([
-  'Promise', 'Observable', 'Future', 'CompletableFuture', 'Task', 'ValueTask',  // async wrappers
-  'Option', 'Some', 'Optional', 'Maybe',                                         // nullable wrappers
-  'Result', 'Either',                                                             // result wrappers
-  // Rust smart pointers (Deref to inner type)
-  'Rc', 'Arc', 'Weak',                                                          // pointer types
-  'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard',                          // guard types
-  'Ref', 'RefMut',                                                               // RefCell guards
-  'Cow',                                                                         // copy-on-write
-  // Containers (List, Array, Vec, Set, etc.) are intentionally excluded —
-  // methods are called on the container, not the element type.
-  // Non-wrapper generics return the base type (e.g., List) via the else branch.
-]);
-
-/**
- * Extracts the first type argument from a comma-separated generic argument string,
- * respecting nested angle brackets. For example:
- *   "Result<User, Error>"  → "Result<User, Error>"  (no top-level comma)
- *   "User, Error"          → "User"
- *   "Map<K, V>, string"    → "Map<K, V>"
- */
-function extractFirstGenericArg(args: string): string {
-  let depth = 0;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '<') depth++;
-    else if (args[i] === '>') depth--;
-    else if (args[i] === ',' && depth === 0) return args.slice(0, i).trim();
-  }
-  return args.trim();
-}
-
-/**
- * Extract the first non-lifetime type argument from a generic argument string.
- * Skips Rust lifetime parameters (e.g., `'a`, `'_`) to find the actual type.
- *   "'_, User"       → "User"
- *   "'a, User"       → "User"
- *   "User, Error"    → "User"  (no lifetime — delegates to extractFirstGenericArg)
- */
-function extractFirstTypeArg(args: string): string {
-  let remaining = args;
-  while (remaining) {
-    const first = extractFirstGenericArg(remaining);
-    if (!first.startsWith("'")) return first;
-    // Skip past this lifetime arg + the comma separator
-    const commaIdx = remaining.indexOf(',', first.length);
-    if (commaIdx < 0) return first; // only lifetimes — fall through
-    remaining = remaining.slice(commaIdx + 1).trim();
-  }
-  return args.trim();
-}
-
-export const extractReturnTypeName = (raw: string): string | undefined => {
-  let text = raw.trim();
-  if (!text) return undefined;
-
-  // Strip pointer/reference prefixes: *User, &User, &mut User
-  text = text.replace(/^[&*]+\s*(mut\s+)?/, '');
-
-  // Strip nullable suffix: User?
-  text = text.replace(/\?$/, '');
-
-  // Handle union types: "User | null" → "User"
-  if (text.includes('|')) {
-    const parts = text.split('|').map(p => p.trim()).filter(p =>
-      p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil'
-    );
-    if (parts.length === 1) text = parts[0];
-    else return undefined; // genuine union — too complex
-  }
-
-  // Handle generics: Promise<User> → unwrap if wrapper, else take base
-  const genericMatch = text.match(/^(\w+)\s*<(.+)>$/);
-  if (genericMatch) {
-    const [, base, args] = genericMatch;
-    if (WRAPPER_GENERICS.has(base)) {
-      // Take the first non-lifetime type argument, using bracket-balanced splitting
-      // so that nested generics like Result<User, Error> are not split at the inner
-      // comma. Lifetime parameters (Rust 'a, '_) are skipped.
-      const firstArg = extractFirstTypeArg(args);
-      return extractReturnTypeName(firstArg);
-    }
-    // Non-wrapper generic: return the base type (e.g., Map<K,V> → Map)
-    return PRIMITIVE_TYPES.has(base.toLowerCase()) ? undefined : base;
-  }
-
-  // Bare wrapper type without generic argument (e.g. Task, Promise, Option)
-  // should not produce a binding — these are meaningless without a type parameter
-  if (WRAPPER_GENERICS.has(text)) return undefined;
-
-  // Handle qualified names: models.User → User, Models::User → User, \App\Models\User → User
-  if (text.includes('::') || text.includes('.') || text.includes('\\')) {
-    text = text.split(/::|[.\\]/).pop()!;
-  }
-
-  // Final check: skip primitives
-  if (PRIMITIVE_TYPES.has(text) || PRIMITIVE_TYPES.has(text.toLowerCase())) return undefined;
-
-  // Must start with uppercase (class/type convention) or be a valid identifier
-  if (!/^[A-Z_]\w*$/.test(text)) return undefined;
-
-  return text;
-};
-
-// ── Scope key helpers ────────────────────────────────────────────────────
-// Scope keys use the format "funcName@startIndex" (produced by type-env.ts).
-// Source IDs use "Label:filepath:funcName" (produced by parse-worker.ts).
-// NUL (\0) is used as a composite-key separator because it cannot appear
-// in source-code identifiers, preventing ambiguous concatenation.
-
-/** Extract the function name from a scope key ("funcName@startIndex" → "funcName"). */
-const extractFuncNameFromScope = (scope: string): string =>
-  scope.slice(0, scope.indexOf('@'));
-
-/** Extract the trailing function name from a sourceId ("Function:filepath:funcName" → "funcName"). */
-const extractFuncNameFromSourceId = (sourceId: string): string => {
-  const lastColon = sourceId.lastIndexOf(':');
-  return lastColon >= 0 ? sourceId.slice(lastColon + 1) : '';
-};
-
-/** Build a scope-aware composite key for receiver type lookup. */
-const receiverKey = (funcName: string, varName: string): string =>
-  `${funcName}\0${varName}`;
+const isBuiltInOrNoise = (name: string): boolean => BUILT_IN_NAMES.has(name);

 /**
 * Fast path: resolve pre-extracted call sites from workers.
 * No AST parsing — workers already extracted calledName + sourceId.
+ * This function only does symbol table lookups + graph mutations.
 */
 export const processCallsFromExtracted = async (
  graph: KnowledgeGraph,
  extractedCalls: ExtractedCall[],
-  ctx: ResolutionContext,
-  onProgress?: (current: number, total: number) => void,
-  constructorBindings?: FileConstructorBindings[],
+  symbolTable: SymbolTable,
+  importMap: ImportMap,
+  onProgress?: (current: number, total: number) => void
 ) => {
-  // Scope-aware receiver types: keyed by filePath → "funcName\0varName" → typeName.
-  // The scope dimension prevents collisions when two functions in the same file
-  // have same-named locals pointing to different constructor types.
-  const fileReceiverTypes = new Map<string, Map<string, string>>();
-  if (constructorBindings) {
-    for (const { filePath, bindings } of constructorBindings) {
-      const verified = verifyConstructorBindings(bindings, filePath, ctx, graph);
-      if (verified.size > 0) {
-        fileReceiverTypes.set(filePath, verified);
-      }
-    }
-  }
-
+  // Group by file for progress reporting
  const byFile = new Map<string, ExtractedCall[]>();
  for (const call of extractedCalls) {
    let list = byFile.get(call.filePath);
-    if (!list) { list = []; byFile.set(call.filePath, list); }
+    if (!list) {
+      list = [];
+      byFile.set(call.filePath, list);
+    }
    list.push(call);
  }

  const totalFiles = byFile.size;
  let filesProcessed = 0;

-  for (const [filePath, calls] of byFile) {
+  for (const [_filePath, calls] of byFile) {
    filesProcessed++;
    if (filesProcessed % 100 === 0) {
      onProgress?.(filesProcessed, totalFiles);
      await yieldToEventLoop();
    }

-    ctx.enableCache(filePath);
-    const receiverMap = fileReceiverTypes.get(filePath);
-
    for (const call of calls) {
-      let effectiveCall = call;
-      if (!call.receiverTypeName && call.receiverName && receiverMap) {
-        const callFuncName = extractFuncNameFromSourceId(call.sourceId);
-        const resolvedType = receiverMap.get(receiverKey(callFuncName, call.receiverName))
-          ?? receiverMap.get(receiverKey('', call.receiverName)); // fall back to file-level scope
-        if (resolvedType) {
-          effectiveCall = { ...call, receiverTypeName: resolvedType };
-        }
-      }
-
-      const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
+      const resolved = resolveCallTarget(
+        call.calledName,
+        call.filePath,
+        symbolTable,
+        importMap
+      );
      if (!resolved) continue;

-      const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
+      const relId = generateId('CALLS', `${call.sourceId}:${call.calledName}->${resolved.nodeId}`);
      graph.addRelationship({
        id: relId,
-        sourceId: effectiveCall.sourceId,
+        sourceId: call.sourceId,
        targetId: resolved.nodeId,
        type: 'CALLS',
        confidence: resolved.confidence,
        reason: resolved.reason,
      });
    }
-
-    ctx.clearCache();
  }

  onProgress?.(totalFiles, totalFiles);
@@ -644,8 +463,9 @@ export const processCallsFromExtracted = async (
 export const processRoutesFromExtracted = async (
  graph: KnowledgeGraph,
  extractedRoutes: ExtractedRoute[],
-  ctx: ResolutionContext,
-  onProgress?: (current: number, total: number) => void,
+  symbolTable: SymbolTable,
+  importMap: ImportMap,
+  onProgress?: (current: number, total: number) => void
 ) => {
  for (let i = 0; i < extractedRoutes.length; i++) {
    const route = extractedRoutes[i];
@@ -656,18 +476,31 @@ export const processRoutesFromExtracted = async (

    if (!route.controllerName || !route.methodName) continue;

-    const controllerResolved = ctx.resolve(route.controllerName, route.filePath);
-    if (!controllerResolved || controllerResolved.candidates.length === 0) continue;
-    if (controllerResolved.tier === 'global' && controllerResolved.candidates.length > 1) continue;
+    // Resolve controller class in symbol table
+    const controllerDefs = symbolTable.lookupFuzzy(route.controllerName);
+    if (controllerDefs.length === 0) continue;

-    const controllerDef = controllerResolved.candidates[0];
-    const confidence = TIER_CONFIDENCE[controllerResolved.tier];
+    // Prefer import-resolved match
+    const importedFiles = importMap.get(route.filePath);
+    let controllerDef = controllerDefs[0];
+    let confidence = controllerDefs.length === 1 ? 0.7 : 0.5;

-    const methodResolved = ctx.resolve(route.methodName, controllerDef.filePath);
-    const methodId = methodResolved?.tier === 'same-file' ? methodResolved.candidates[0]?.nodeId : undefined;
+    if (importedFiles) {
+      for (const def of controllerDefs) {
+        if (importedFiles.has(def.filePath)) {
+          controllerDef = def;
+          confidence = 0.9;
+          break;
+        }
+      }
+    }
+
+    // Find the method on the controller
+    const methodId = symbolTable.lookupExact(controllerDef.filePath, route.methodName);
    const sourceId = generateId('File', route.filePath);

    if (!methodId) {
+      // Construct method ID manually
      const guessedId = generateId('Method', `${controllerDef.filePath}:${route.methodName}`);
      const relId = generateId('CALLS', `${sourceId}:route->${guessedId}`);
      graph.addRelationship({
@@ -1,149 +0,0 @@
-/**
- * Shared Ruby call routing logic.
- *
- * Ruby expresses imports, heritage (mixins), and property definitions as
- * method calls rather than syntax-level constructs. This module provides a
- * routing function used by the CLI call-processor, CLI parse-worker, and
- * the web call-processor so that the classification logic lives in one place.
- *
- * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
- * two packages have separate build targets (Node native vs WASM/browser).
- * Keep both copies in sync until a shared package is introduced.
- */
-
-import { SupportedLanguages } from '../../config/supported-languages.js';
-
-// ── Call routing dispatch table ─────────────────────────────────────────────
-
-/** null = this call was not routed; fall through to default call handling */
-export type CallRoutingResult = RubyCallRouting | null;
-
-export type CallRouter = (
-  calledName: string,
-  callNode: any,
-) => CallRoutingResult;
-
-/** No-op router: returns null for every call (passthrough to normal processing) */
-const noRouting: CallRouter = () => null;
-
-/** Per-language call routing. noRouting = no special routing (normal call processing) */
-export const callRouters: Record<SupportedLanguages, CallRouter> = {
-  [SupportedLanguages.JavaScript]: noRouting,
-  [SupportedLanguages.TypeScript]: noRouting,
-  [SupportedLanguages.Python]: noRouting,
-  [SupportedLanguages.Java]: noRouting,
-  [SupportedLanguages.Kotlin]: noRouting,
-  [SupportedLanguages.Go]: noRouting,
-  [SupportedLanguages.Rust]: noRouting,
-  [SupportedLanguages.CSharp]: noRouting,
-  [SupportedLanguages.PHP]: noRouting,
-  [SupportedLanguages.Swift]: noRouting,
-  [SupportedLanguages.CPlusPlus]: noRouting,
-  [SupportedLanguages.C]: noRouting,
-  [SupportedLanguages.Ruby]: routeRubyCall,
-};
-
-// ── Result types ────────────────────────────────────────────────────────────
-
-export type RubyCallRouting =
-  | { kind: 'import'; importPath: string; isRelative: boolean }
-  | { kind: 'heritage'; items: RubyHeritageItem[] }
-  | { kind: 'properties'; items: RubyPropertyItem[] }
-  | { kind: 'call' }
-  | { kind: 'skip' };
-
-export interface RubyHeritageItem {
-  enclosingClass: string;
-  mixinName: string;
-  heritageKind: 'include' | 'extend' | 'prepend';
-}
-
-export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer';
-
-export interface RubyPropertyItem {
-  propName: string;
-  accessorType: RubyAccessorType;
-  startLine: number;
-  endLine: number;
-}
-
-// ── Pre-allocated singletons for common return values ────────────────────────
-const CALL_RESULT: RubyCallRouting = { kind: 'call' };
-const SKIP_RESULT: RubyCallRouting = { kind: 'skip' };
-
-/** Max depth for parent-walking loops to prevent pathological AST traversals */
-const MAX_PARENT_DEPTH = 50;
-
-// ── Routing function ────────────────────────────────────────────────────────
-
-/**
- * Classify a Ruby call node and extract its semantic payload.
- *
- * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
- * @param callNode   - The tree-sitter `call` AST node
- * @returns A discriminated union describing the call's semantic role
- */
-export function routeRubyCall(calledName: string, callNode: any): RubyCallRouting {
-  // ── require / require_relative → import ─────────────────────────────────
-  if (calledName === 'require' || calledName === 'require_relative') {
-    const argList = callNode.childForFieldName?.('arguments');
-    const stringNode = argList?.children?.find((c: any) => c.type === 'string');
-    const contentNode = stringNode?.children?.find((c: any) => c.type === 'string_content');
-    if (!contentNode) return SKIP_RESULT;
-
-    let importPath: string = contentNode.text;
-    // Validate: reject null bytes, control chars, excessively long paths
-    if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) {
-      return SKIP_RESULT;
-    }
-    const isRelative = calledName === 'require_relative';
-    if (isRelative && !importPath.startsWith('.')) {
-      importPath = './' + importPath;
-    }
-    return { kind: 'import', importPath, isRelative };
-  }
-
-  // ── include / extend / prepend → heritage (mixin) ──────────────────────
-  if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
-    let enclosingClass: string | null = null;
-    let current = callNode.parent;
-    let depth = 0;
-    while (current && ++depth <= MAX_PARENT_DEPTH) {
-      if (current.type === 'class' || current.type === 'module') {
-        const nameNode = current.childForFieldName?.('name');
-        if (nameNode) { enclosingClass = nameNode.text; break; }
-      }
-      current = current.parent;
-    }
-    if (!enclosingClass) return SKIP_RESULT;
-
-    const items: RubyHeritageItem[] = [];
-    const argList = callNode.childForFieldName?.('arguments');
-    for (const arg of (argList?.children ?? [])) {
-      if (arg.type === 'constant' || arg.type === 'scope_resolution') {
-        items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName as 'include' | 'extend' | 'prepend' });
-      }
-    }
-    return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
-  }
-
-  // ── attr_accessor / attr_reader / attr_writer → property definitions ───
-  if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
-    const items: RubyPropertyItem[] = [];
-    const argList = callNode.childForFieldName?.('arguments');
-    for (const arg of (argList?.children ?? [])) {
-      if (arg.type === 'simple_symbol') {
-        items.push({
-          propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text,
-          accessorType: calledName as RubyAccessorType,
-          startLine: arg.startPosition.row,
-          endLine: arg.endPosition.row,
-        });
-      }
-    }
-    return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT;
-  }
-
-  // ── Everything else → regular call ─────────────────────────────────────
-  return CALL_RESULT;
-}
@@ -1,19 +0,0 @@
-/**
- * Default minimum buffer size for tree-sitter parsing (512 KB).
- * tree-sitter requires bufferSize >= file size in bytes.
- */
-export const TREE_SITTER_BUFFER_SIZE = 512 * 1024;
-
-/**
- * Maximum buffer size cap (32 MB) to prevent OOM on huge files.
- * Also used as the file-size skip threshold — files larger than this are not parsed.
- */
-export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024;
-
-/**
- * Compute adaptive buffer size for tree-sitter parsing.
- * Uses 2× file size, clamped between 512 KB and 32 MB.
- * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
- */
-export const getTreeSitterBufferSize = (contentLength: number): number =>
-  Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);
@@ -11,10 +11,9 @@
 */

 import { detectFrameworkFromPath } from './framework-detection.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';

 // ============================================================================
-// NAME PATTERNS - All 11 supported languages
+// NAME PATTERNS - All 9 supported languages
 // ============================================================================

 /**
@@ -39,47 +38,39 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
  ],
  
  // JavaScript/TypeScript
-  [SupportedLanguages.JavaScript]: [
+  'javascript': [
    /^use[A-Z]/,              // React hooks (useEffect, etc.)
  ],
-  [SupportedLanguages.TypeScript]: [
+  'typescript': [
    /^use[A-Z]/,              // React hooks
  ],
-
+  
  // Python
-  [SupportedLanguages.Python]: [
+  'python': [
    /^app$/,                  // Flask/FastAPI app
    /^(get|post|put|delete|patch)_/i,  // REST conventions
    /^api_/,                  // API functions
    /^view_/,                 // Django views
  ],
-
+  
  // Java
-  [SupportedLanguages.Java]: [
+  'java': [
    /^do[A-Z]/,               // doGet, doPost (Servlets)
    /^create[A-Z]/,           // Factory patterns
    /^build[A-Z]/,            // Builder patterns
    /Service$/,               // UserService
  ],
-
+  
  // C#
-  [SupportedLanguages.CSharp]: [
-    /^(Get|Post|Put|Delete|Patch)/,  // ASP.NET action methods
-    /Action$/,                        // MVC actions
-    /^On[A-Z]/,                      // Event handlers / Blazor lifecycle
-    /Async$/,                        // Async entry points
-    /^Configure$/,                   // Startup.Configure
-    /^ConfigureServices$/,           // Startup.ConfigureServices
-    /^Handle$/,                      // MediatR / generic handler
-    /^Execute$/,                     // Command pattern
-    /^Invoke$/,                      // Middleware Invoke
-    /^Map[A-Z]/,                     // Minimal API MapGet, MapPost
-    /Service$/,                      // Service classes
-    /^Seed/,                         // Database seeding
+  'csharp': [
+    /^(Get|Post|Put|Delete)/,  // ASP.NET conventions
+    /Action$/,                 // MVC actions
+    /^On[A-Z]/,               // Event handlers
+    /Async$/,                 // Async entry points
  ],
  
  // Go
-  [SupportedLanguages.Go]: [
+  'go': [
    /Handler$/,               // http.Handler pattern
    /^Serve/,                 // ServeHTTP
    /^New[A-Z]/,              // Constructor pattern (returns new instance)
@@ -87,7 +78,7 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
  ],
  
  // Rust
-  [SupportedLanguages.Rust]: [
+  'rust': [
    /^(get|post|put|delete)_handler$/i,
    /^handle_/,               // handle_request
    /^new$/,                  // Constructor pattern
@@ -95,64 +86,25 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
    /^spawn/,                 // Async spawn
  ],
  
-  // C - explicit main() boost plus common C entry point conventions
-  [SupportedLanguages.C]: [
+  // C - explicit main() boost (critical for C programs)
+  'c': [
    /^main$/,                 // THE entry point
-    /^init_/,                 // init_server, init_client
-    /_init$/,                 // module_init, server_init
-    /^start_/,                // start_server
-    /_start$/,                // thread_start
-    /^run_/,                  // run_loop
-    /_run$/,                  // event_run
-    /^stop_/,                 // stop_server
-    /_stop$/,                 // service_stop
-    /^open_/,                 // open_connection
-    /_open$/,                 // file_open
-    /^close_/,                // close_connection
-    /_close$/,                // socket_close
-    /^create_/,               // create_session
-    /_create$/,               // object_create
-    /^destroy_/,              // destroy_session
-    /_destroy$/,              // object_destroy
-    /^handle_/,               // handle_request
-    /_handler$/,              // signal_handler
-    /_callback$/,             // event_callback
-    /^cmd_/,                  // tmux: cmd_new_window, cmd_attach_session
-    /^server_/,               // server_start, server_loop
-    /^client_/,               // client_connect
-    /^session_/,              // session_create
-    /^window_/,               // window_resize (tmux)
-    /^key_/,                  // key_press
-    /^input_/,                // input_parse
-    /^output_/,               // output_write
-    /^notify_/,               // notify_client
-    /^control_/,              // control_start
+    /^init_/,                 // Initialization functions
+    /^start_/,                // Start functions
+    /^run_/,                  // Run functions
  ],
-
-  // C++ - same as C plus OOP/template patterns
-  [SupportedLanguages.CPlusPlus]: [
+  
+  // C++ - same as C plus class patterns
+  'cpp': [
    /^main$/,                 // THE entry point
    /^init_/,
-    /_init$/,
    /^Create[A-Z]/,           // Factory patterns
-    /^create_/,
    /^Run$/,                  // Run methods
-    /^run$/,
    /^Start$/,                // Start methods
-    /^start$/,
-    /^handle_/,
-    /_handler$/,
-    /_callback$/,
-    /^OnEvent/,               // Event callbacks
-    /^on_/,
-    /::Run$/,                 // Class::Run
-    /::Start$/,               // Class::Start
-    /::Init$/,                // Class::Init
-    /::Execute$/,             // Class::Execute
  ],

  // Swift / iOS
-  [SupportedLanguages.Swift]: [
+  'swift': [
    /^viewDidLoad$/,                  // UIKit lifecycle
    /^viewWillAppear$/,               // UIKit lifecycle
    /^viewDidAppear$/,                // UIKit lifecycle
@@ -172,7 +124,7 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
  ],

  // PHP / Laravel
-  [SupportedLanguages.PHP]: [
+  'php': [
    /Controller$/,            // UserController (class name convention)
    /^handle$/,               // Job::handle(), Listener::handle()
    /^execute$/,              // Command::execute()
@@ -191,23 +143,8 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {
    /^save$/,                 // Repository::save()
    /^delete$/,               // Repository::delete()
  ],
-
-  // Ruby
-  [SupportedLanguages.Ruby]: [
-    /^call$/,                 // Service objects (MyService.call)
-    /^perform$/,              // Background jobs (Sidekiq, ActiveJob)
-    /^execute$/,              // Command pattern
-  ],
 };

-/** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
-const MERGED_ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {};
-const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
-for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
-  if (lang === '*') continue;
-  MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
-}
-
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -262,7 +199,7 @@ export interface EntryPointScoreResult {
 */
 export function calculateEntryPointScore(
  name: string,
-  language: SupportedLanguages,
+  language: string,
  isExported: boolean,
  callerCount: number,
  calleeCount: number,
@@ -295,7 +232,9 @@ export function calculateEntryPointScore(
    reasons.push('utility-pattern');
  } else {
    // Check positive patterns
-    const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
+    const universalPatterns = ENTRY_POINT_PATTERNS['*'] || [];
+    const langPatterns = ENTRY_POINT_PATTERNS[language] || [];
+    const allPatterns = [...universalPatterns, ...langPatterns];
    
    if (allPatterns.some(p => p.test(name))) {
      nameMultiplier = 1.5;  // Bonus for matching entry point pattern
@@ -357,23 +296,13 @@ export function isTestFile(filePath: string): boolean {
    p.endsWith('test.swift') ||
    p.includes('uitests/') ||
    // C# test patterns
-    p.endsWith('tests.cs') ||
-    p.endsWith('test.cs') ||
    p.includes('.tests/') ||
-    p.includes('.test/') ||
-    p.includes('.integrationtests/') ||
-    p.includes('.unittests/') ||
-    p.includes('/testproject/') ||
+    p.includes('tests.cs') ||
    // PHP/Laravel test patterns
    p.endsWith('test.php') ||
    p.endsWith('spec.php') ||
    p.includes('/tests/feature/') ||
-    p.includes('/tests/unit/') ||
-    // Ruby test patterns
-    p.endsWith('_spec.rb') ||
-    p.endsWith('_test.rb') ||
-    p.includes('/spec/') ||
-    p.includes('/test/fixtures/')
+    p.includes('/tests/unit/')
  );
 }

@@ -1,243 +0,0 @@
-/**
- * Export Detection
- *
- * Determines whether a symbol (function, class, etc.) is exported/public
- * in its language. This is a pure function — safe for use in worker threads.
- *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
- */
-
-import { findSiblingChild, SyntaxNode } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-
-/** Handler type: given a node and symbol name, return true if the symbol is exported/public. */
-type ExportChecker = (node: SyntaxNode, name: string) => boolean;
-
-// ============================================================================
-// Per-language export checkers
-// ============================================================================
-
-/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
-const tsExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    const type = current.type;
-    if (type === 'export_statement' ||
-        type === 'export_specifier' ||
-        (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) {
-      return true;
-    }
-    // Fallback: check if node text starts with 'export ' for edge cases
-    if (current.text?.startsWith('export ')) {
-      return true;
-    }
-    current = current.parent;
-  }
-  return false;
-};
-
-/** Python: public if no leading underscore (convention). */
-const pythonExportChecker: ExportChecker = (_node, name) => !name.startsWith('_');
-
-/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
-const javaExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (current.parent) {
-      const parent = current.parent;
-      for (let i = 0; i < parent.childCount; i++) {
-        const child = parent.child(i);
-        if (child?.type === 'modifiers' && child.text?.includes('public')) {
-          return true;
-        }
-      }
-      if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
-        if (parent.text?.trimStart().startsWith('public')) {
-          return true;
-        }
-      }
-    }
-    current = current.parent;
-  }
-  return false;
-};
-
-/** C# declaration node types for sibling modifier scanning. */
-const CSHARP_DECL_TYPES = new Set([
-  'method_declaration', 'local_function_statement', 'constructor_declaration',
-  'class_declaration', 'interface_declaration', 'struct_declaration',
-  'enum_declaration', 'record_declaration', 'record_struct_declaration',
-  'record_class_declaration', 'delegate_declaration',
-  'property_declaration', 'field_declaration', 'event_declaration',
-  'namespace_declaration', 'file_scoped_namespace_declaration',
-]);
-
-/**
- * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
- * Walk up to the declaration node, then scan its direct children.
- */
-const csharpExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (CSHARP_DECL_TYPES.has(current.type)) {
-      for (let i = 0; i < current.childCount; i++) {
-        const child = current.child(i);
-        if (child?.type === 'modifier' && child.text === 'public') return true;
-      }
-      return false;
-    }
-    current = current.parent;
-  }
-  return false;
-};
-
-/** Go: uppercase first letter = exported. */
-const goExportChecker: ExportChecker = (_node, name) => {
-  if (name.length === 0) return false;
-  const first = name[0];
-  return first === first.toUpperCase() && first !== first.toLowerCase();
-};
-
-/** Rust declaration node types for sibling visibility_modifier scanning. */
-const RUST_DECL_TYPES = new Set([
-  'function_item', 'struct_item', 'enum_item', 'trait_item', 'impl_item',
-  'union_item', 'type_item', 'const_item', 'static_item', 'mod_item',
-  'use_declaration', 'associated_type', 'function_signature_item',
-]);
-
-/**
- * Rust: visibility_modifier is a SIBLING of the name node within the declaration node
- * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
- * then scan its direct children.
- */
-const rustExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (RUST_DECL_TYPES.has(current.type)) {
-      for (let i = 0; i < current.childCount; i++) {
-        const child = current.child(i);
-        if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub')) return true;
-      }
-      return false;
-    }
-    current = current.parent;
-  }
-  return false;
-};
-
-/**
- * Kotlin: default visibility is public (unlike Java).
- * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
- */
-const kotlinExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (current.parent) {
-      const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
-      if (visMod) {
-        const text = visMod.text;
-        if (text === 'private' || text === 'internal' || text === 'protected') return false;
-        if (text === 'public') return true;
-      }
-    }
-    current = current.parent;
-  }
-  // No visibility modifier = public (Kotlin default)
-  return true;
-};
-
-/**
- * C/C++: functions without 'static' storage class have external linkage by default,
- * making them globally accessible (equivalent to exported). Only functions explicitly
- * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
- * (namespace { ... }) also give internal linkage.
- */
-const cCppExportChecker: ExportChecker = (node, _name) => {
-  let cur: SyntaxNode | null = node;
-  while (cur) {
-    if (cur.type === 'function_definition' || cur.type === 'declaration') {
-      // Check for 'static' storage class specifier as a direct child node.
-      // This avoids reading the full function text (which can be very large).
-      for (let i = 0; i < cur.childCount; i++) {
-        const child = cur.child(i);
-        if (child?.type === 'storage_class_specifier' && child.text === 'static') return false;
-      }
-    }
-    // C++ anonymous namespace: namespace_definition with no name child = internal linkage
-    if (cur.type === 'namespace_definition') {
-      const hasName = cur.childForFieldName?.('name');
-      if (!hasName) return false;
-    }
-    cur = cur.parent;
-  }
-  return true; // Top-level C/C++ functions default to external linkage
-};
-
-/** PHP: check for visibility modifier or top-level scope. */
-const phpExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (current.type === 'class_declaration' ||
-        current.type === 'interface_declaration' ||
-        current.type === 'trait_declaration' ||
-        current.type === 'enum_declaration') {
-      return true;
-    }
-    if (current.type === 'visibility_modifier') {
-      return current.text === 'public';
-    }
-    current = current.parent;
-  }
-  // Top-level functions are globally accessible
-  return true;
-};
-
-/** Swift: check for 'public' or 'open' access modifiers. */
-const swiftExportChecker: ExportChecker = (node, _name) => {
-  let current: SyntaxNode | null = node;
-  while (current) {
-    if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-      const text = current.text || '';
-      if (text.includes('public') || text.includes('open')) return true;
-    }
-    current = current.parent;
-  }
-  return false;
-};
-
-// ============================================================================
-// Exhaustive dispatch table — satisfies enforces all SupportedLanguages are covered
-// ============================================================================
-
-const exportCheckers = {
-  [SupportedLanguages.JavaScript]: tsExportChecker,
-  [SupportedLanguages.TypeScript]: tsExportChecker,
-  [SupportedLanguages.Python]: pythonExportChecker,
-  [SupportedLanguages.Java]: javaExportChecker,
-  [SupportedLanguages.CSharp]: csharpExportChecker,
-  [SupportedLanguages.Go]: goExportChecker,
-  [SupportedLanguages.Rust]: rustExportChecker,
-  [SupportedLanguages.Kotlin]: kotlinExportChecker,
-  [SupportedLanguages.C]: cCppExportChecker,
-  [SupportedLanguages.CPlusPlus]: cCppExportChecker,
-  [SupportedLanguages.PHP]: phpExportChecker,
-  [SupportedLanguages.Swift]: swiftExportChecker,
-  [SupportedLanguages.Ruby]: (_node, _name) => true,
-} satisfies Record<SupportedLanguages, ExportChecker>;
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-/**
- * Check if a tree-sitter node is exported/public in its language.
- * @param node - The tree-sitter AST node
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export const isNodeExported = (node: SyntaxNode, name: string, language: SupportedLanguages): boolean => {
-  const checker = exportCheckers[language];
-  if (!checker) return false;
-  return checker(node, name);
-};
@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { glob } from 'glob';
-import { shouldIgnorePath, loadUserIgnore } from '../../config/ignore-service.js';
+import { shouldIgnorePath } from '../../config/ignore-service.js';

 export interface FileEntry {
  path: string;
@@ -32,8 +32,6 @@ export const walkRepositoryPaths = async (
  repoPath: string,
  onProgress?: (current: number, total: number, filePath: string) => void
 ): Promise<ScannedFile[]> => {
-  loadUserIgnore(repoPath);
-
  const files = await glob('**/*', {
    cwd: repoPath,
    nodir: true,
@@ -183,35 +183,7 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null
  if (p.endsWith('controller.cs')) {
    return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller-file' };
  }
-
-  // ASP.NET Services
-  if ((p.includes('/services/') || p.includes('/service/')) && p.endsWith('.cs')) {
-    return { framework: 'aspnet', entryPointMultiplier: 1.8, reason: 'aspnet-service' };
-  }
-
-  // ASP.NET Middleware
-  if (p.includes('/middleware/') && p.endsWith('.cs')) {
-    return { framework: 'aspnet', entryPointMultiplier: 2.5, reason: 'aspnet-middleware' };
-  }
-
-  // SignalR Hubs
-  if (p.includes('/hubs/') && p.endsWith('.cs')) {
-    return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub' };
-  }
-  if (p.endsWith('hub.cs')) {
-    return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub-file' };
-  }
-
-  // Minimal API / Program.cs / Startup.cs
-  if (p.endsWith('/program.cs') || p.endsWith('/startup.cs')) {
-    return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-entry' };
-  }
-
-  // Background services / Hosted services
-  if ((p.includes('/backgroundservices/') || p.includes('/hostedservices/')) && p.endsWith('.cs')) {
-    return { framework: 'aspnet', entryPointMultiplier: 2.0, reason: 'aspnet-background-service' };
-  }
-
+  
  // Blazor pages
  if (p.includes('/pages/') && p.endsWith('.razor')) {
    return { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-page' };
@@ -330,18 +302,6 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null
    return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
  }

-  // ========== RUBY ==========
-
-  // Ruby: bin/ or exe/ (CLI entry points)
-  if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) {
-    return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' };
-  }
-
-  // Ruby: Rakefile or *.rake (task definitions)
-  if (p.endsWith('/rakefile') || p.endsWith('.rake')) {
-    return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' };
-  }
-  
  // ========== SWIFT / iOS ==========

  // iOS App entry points (highest priority)
@@ -425,11 +385,7 @@ export const FRAMEWORK_AST_PATTERNS = {
  'jaxrs': ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
  
  // C# attributes
-  'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[HttpPut]', '[HttpDelete]',
-             '[Route]', '[Authorize]', '[AllowAnonymous]'],
-  'signalr': ['[HubMethodName]', ': Hub', ': Hub<'],
-  'blazor': ['@page', '[Parameter]', '@inject'],
-  'efcore': ['DbContext', 'DbSet<', 'OnModelCreating'],
+  'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[Route]'],
  
  // Go patterns (function signatures)
  'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
@@ -449,8 +405,6 @@ export const FRAMEWORK_AST_PATTERNS = {
  'combine': ['sink', 'assign', 'Publisher', 'Subscriber'],
 };

-import { SupportedLanguages } from '../../config/supported-languages.js';
-
 interface AstFrameworkPatternConfig {
  framework: string;
  entryPointMultiplier: number;
@@ -459,33 +413,30 @@ interface AstFrameworkPatternConfig {
 }

 const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE: Record<string, AstFrameworkPatternConfig[]> = {
-  [SupportedLanguages.JavaScript]: [
+  javascript: [
    { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
  ],
-  [SupportedLanguages.TypeScript]: [
+  typescript: [
    { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
  ],
-  [SupportedLanguages.Python]: [
+  python: [
    { framework: 'fastapi', entryPointMultiplier: 3.0, reason: 'fastapi-decorator', patterns: FRAMEWORK_AST_PATTERNS.fastapi },
    { framework: 'flask', entryPointMultiplier: 2.8, reason: 'flask-decorator', patterns: FRAMEWORK_AST_PATTERNS.flask },
  ],
-  [SupportedLanguages.Java]: [
+  java: [
    { framework: 'spring', entryPointMultiplier: 3.2, reason: 'spring-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring },
    { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs },
  ],
-  [SupportedLanguages.Kotlin]: [
+  kotlin: [
    { framework: 'spring-kotlin', entryPointMultiplier: 3.2, reason: 'spring-kotlin-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring },
    { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs },
    { framework: 'ktor', entryPointMultiplier: 2.8, reason: 'ktor-routing', patterns: ['routing', 'embeddedServer', 'Application.module'] },
    { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-annotation', patterns: ['@AndroidEntryPoint', 'AppCompatActivity', 'Fragment('] },
  ],
-  [SupportedLanguages.CSharp]: [
+  csharp: [
    { framework: 'aspnet', entryPointMultiplier: 3.2, reason: 'aspnet-attribute', patterns: FRAMEWORK_AST_PATTERNS.aspnet },
-    { framework: 'signalr', entryPointMultiplier: 2.8, reason: 'signalr-attribute', patterns: FRAMEWORK_AST_PATTERNS.signalr },
-    { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-attribute', patterns: FRAMEWORK_AST_PATTERNS.blazor },
-    { framework: 'efcore', entryPointMultiplier: 2.0, reason: 'efcore-pattern', patterns: FRAMEWORK_AST_PATTERNS.efcore },
  ],
-  [SupportedLanguages.PHP]: [
+  php: [
    { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
  ],
 };
@@ -505,7 +456,7 @@ const AST_PATTERNS_LOWERED: Record<string, Array<{ framework: string; entryPoint
 * Note: callers should slice definitionText to ~300 chars since annotations appear at the start.
 */
 export function detectFrameworkFromAST(
-  language: SupportedLanguages,
+  language: string,
  definitionText: string
 ): FrameworkHint | null {
  if (!language || !definitionText) return null;
@@ -1,99 +1,29 @@
 /**
 * Heritage Processor
- *
+ * 
 * Extracts class inheritance relationships:
- * - EXTENDS: Class extends another Class (TS, JS, Python, C#, C++)
- * - IMPLEMENTS: Class implements an Interface (TS, C#, Java, Kotlin, PHP)
- *
- * Languages like C# use a single `base_list` for both class and interface parents.
- * We resolve the correct edge type by checking the symbol table: if the parent is
- * registered as an Interface, we emit IMPLEMENTS; otherwise EXTENDS. For unresolved
- * external symbols, the fallback heuristic is language-gated:
- *   - C# / Java: apply the `I[A-Z]` naming convention (e.g. IDisposable → IMPLEMENTS)
- *   - Swift: default to IMPLEMENTS (protocol conformance is more common than class inheritance)
- *   - All other languages: default to EXTENDS
+ * - EXTENDS: Class extends another Class (TS, JS, Python)
+ * - IMPLEMENTS: Class implements an Interface (TS only)
 */

 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
+import { SymbolTable } from './symbol-table.js';
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { getTreeSitterBufferSize } from './constants.js';
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
 import type { ExtractedHeritage } from './workers/parse-worker.js';
-import type { ResolutionContext } from './resolution-context.js';
-
-/** C#/Java convention: interfaces start with I followed by an uppercase letter */
-const INTERFACE_NAME_RE = /^I[A-Z]/;
-
-/**
- * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship.
- * Uses the symbol table first (authoritative — Tier 1); falls back to a language-gated
- * heuristic for external symbols not present in the graph:
- *   - C# / Java: `I[A-Z]` naming convention
- *   - Swift: default IMPLEMENTS (protocol conformance is the norm)
- *   - All others: default EXTENDS
- */
-const resolveExtendsType = (
-  parentName: string,
-  currentFilePath: string,
-  ctx: ResolutionContext,
-  language: SupportedLanguages,
-): { type: 'EXTENDS' | 'IMPLEMENTS'; idPrefix: string } => {
-  const resolved = ctx.resolve(parentName, currentFilePath);
-  if (resolved && resolved.candidates.length > 0) {
-    const isInterface = resolved.candidates[0].type === 'Interface';
-    return isInterface
-      ? { type: 'IMPLEMENTS', idPrefix: 'Interface' }
-      : { type: 'EXTENDS', idPrefix: 'Class' };
-  }
-  // Unresolved symbol — fall back to language-specific heuristic
-  if (language === SupportedLanguages.CSharp || language === SupportedLanguages.Java) {
-    if (INTERFACE_NAME_RE.test(parentName)) {
-      return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-    }
-  } else if (language === SupportedLanguages.Swift) {
-    // Protocol conformance is far more common than class inheritance in Swift
-    return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-  }
-  return { type: 'EXTENDS', idPrefix: 'Class' };
-};
-
-/**
- * Resolve a symbol ID for heritage, with fallback to generated ID.
- * Uses ctx.resolve() → pick first candidate's nodeId → generate synthetic ID.
- */
-const resolveHeritageId = (
-  name: string,
-  filePath: string,
-  ctx: ResolutionContext,
-  fallbackLabel: string,
-  fallbackKey?: string,
-): string => {
-  const resolved = ctx.resolve(name, filePath);
-  if (resolved && resolved.candidates.length > 0) {
-    // For global with multiple candidates, refuse (a wrong edge is worse than no edge)
-    if (resolved.tier === 'global' && resolved.candidates.length > 1) {
-      return generateId(fallbackLabel, fallbackKey ?? name);
-    }
-    return resolved.candidates[0].nodeId;
-  }
-  return generateId(fallbackLabel, fallbackKey ?? name);
-};

 export const processHeritage = async (
  graph: KnowledgeGraph,
  files: { path: string; content: string }[],
  astCache: ASTCache,
-  ctx: ResolutionContext,
-  onProgress?: (current: number, total: number) => void,
+  symbolTable: SymbolTable,
+  onProgress?: (current: number, total: number) => void
 ) => {
  const parser = await loadParser();
-  const logSkipped = isVerboseIngestionEnabled();
-  const skippedByLang = logSkipped ? new Map<string, number>() : null;

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
@@ -103,12 +33,6 @@ export const processHeritage = async (
    // 1. Check language support
    const language = getLanguageFromFilename(file.path);
    if (!language) continue;
-    if (!isLanguageAvailable(language)) {
-      if (skippedByLang) {
-        skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
-      }
-      continue;
-    }

    const queryStr = LANGUAGE_QUERIES[language];
    if (!queryStr) continue;
@@ -118,14 +42,17 @@ export const processHeritage = async (

    // 3. Get AST
    let tree = astCache.get(file.path);
+    let wasReparsed = false;
+
    if (!tree) {
      // Use larger bufferSize for files > 32KB
      try {
-        tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+        tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
      } catch (parseError) {
        // Skip files that can't be parsed
        continue;
      }
+      wasReparsed = true;
      // Cache re-parsed tree for potential future use
      astCache.set(file.path, tree);
    }
@@ -148,30 +75,27 @@ export const processHeritage = async (
        captureMap[c.name] = c.node;
      });

-      // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where
-      // the tree-sitter query can't distinguish classes from interfaces (C#, Java)
+      // EXTENDS: Class extends another Class
      if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
-        // Go struct embedding: skip named fields (only anonymous fields are embedded)
-        const extendsNode = captureMap['heritage.extends'];
-        const fieldDecl = extendsNode.parent;
-        if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name')) {
-          return; // Named field, not struct embedding
-        }
-
        const className = captureMap['heritage.class'].text;
        const parentClassName = captureMap['heritage.extends'].text;

-        const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, language);
-
-        const childId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-        const parentId = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
+        // Resolve both class IDs
+        const childId = symbolTable.lookupExact(file.path, className) ||
+                        symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                        generateId('Class', `${file.path}:${className}`);
+        
+        const parentId = symbolTable.lookupFuzzy(parentClassName)[0]?.nodeId ||
+                         generateId('Class', `${parentClassName}`);

        if (childId && parentId && childId !== parentId) {
+          const relId = generateId('EXTENDS', `${childId}->${parentId}`);
+          
          graph.addRelationship({
-            id: generateId(relType, `${childId}->${parentId}`),
+            id: relId,
            sourceId: childId,
            targetId: parentId,
-            type: relType,
+            type: 'EXTENDS',
            confidence: 1.0,
            reason: '',
          });
@@ -183,12 +107,19 @@ export const processHeritage = async (
        const className = captureMap['heritage.class'].text;
        const interfaceName = captureMap['heritage.implements'].text;

-        const classId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-        const interfaceId = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
+        // Resolve class and interface IDs
+        const classId = symbolTable.lookupExact(file.path, className) ||
+                        symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                        generateId('Class', `${file.path}:${className}`);
+        
+        const interfaceId = symbolTable.lookupFuzzy(interfaceName)[0]?.nodeId ||
+                            generateId('Interface', `${interfaceName}`);

        if (classId && interfaceId) {
+          const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`);
+          
          graph.addRelationship({
-            id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
+            id: relId,
            sourceId: classId,
            targetId: interfaceId,
            type: 'IMPLEMENTS',
@@ -203,12 +134,19 @@ export const processHeritage = async (
        const structName = captureMap['heritage.class'].text;
        const traitName = captureMap['heritage.trait'].text;

-        const structId = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`);
-        const traitId = resolveHeritageId(traitName, file.path, ctx, 'Trait');
+        // Resolve struct and trait IDs
+        const structId = symbolTable.lookupExact(file.path, structName) ||
+                         symbolTable.lookupFuzzy(structName)[0]?.nodeId ||
+                         generateId('Struct', `${file.path}:${structName}`);
+        
+        const traitId = symbolTable.lookupFuzzy(traitName)[0]?.nodeId ||
+                        generateId('Trait', `${traitName}`);

        if (structId && traitId) {
+          const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`);
+          
          graph.addRelationship({
-            id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
+            id: relId,
            sourceId: structId,
            targetId: traitId,
            type: 'IMPLEMENTS',
@@ -221,14 +159,6 @@ export const processHeritage = async (

    // Tree is now owned by the LRU cache — no manual delete needed
  }
-
-  if (skippedByLang && skippedByLang.size > 0) {
-    for (const [lang, count] of skippedByLang.entries()) {
-      console.warn(
-        `[ingestion] Skipped ${count} ${lang} file(s) in heritage processing — ${lang} parser not available.`
-      );
-    }
-  }
 };

 /**
@@ -238,8 +168,8 @@ export const processHeritage = async (
 export const processHeritageFromExtracted = async (
  graph: KnowledgeGraph,
  extractedHeritage: ExtractedHeritage[],
-  ctx: ResolutionContext,
-  onProgress?: (current: number, total: number) => void,
+  symbolTable: SymbolTable,
+  onProgress?: (current: number, total: number) => void
 ) => {
  const total = extractedHeritage.length;

@@ -252,26 +182,30 @@ export const processHeritageFromExtracted = async (
    const h = extractedHeritage[i];

    if (h.kind === 'extends') {
-      const fileLanguage = getLanguageFromFilename(h.filePath);
-      if (!fileLanguage) continue;
-      const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, ctx, fileLanguage);
+      const childId = symbolTable.lookupExact(h.filePath, h.className) ||
+                      symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                      generateId('Class', `${h.filePath}:${h.className}`);

-      const childId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
-      const parentId = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix);
+      const parentId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+                       generateId('Class', `${h.parentName}`);

      if (childId && parentId && childId !== parentId) {
        graph.addRelationship({
-          id: generateId(relType, `${childId}->${parentId}`),
+          id: generateId('EXTENDS', `${childId}->${parentId}`),
          sourceId: childId,
          targetId: parentId,
-          type: relType,
+          type: 'EXTENDS',
          confidence: 1.0,
          reason: '',
        });
      }
    } else if (h.kind === 'implements') {
-      const classId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
-      const interfaceId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Interface');
+      const classId = symbolTable.lookupExact(h.filePath, h.className) ||
+                      symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                      generateId('Class', `${h.filePath}:${h.className}`);
+
+      const interfaceId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+                          generateId('Interface', `${h.parentName}`);

      if (classId && interfaceId) {
        graph.addRelationship({
@@ -283,18 +217,22 @@ export const processHeritageFromExtracted = async (
          reason: '',
        });
      }
-    } else if (h.kind === 'trait-impl' || h.kind === 'include' || h.kind === 'extend' || h.kind === 'prepend') {
-      const structId = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`);
-      const traitId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
+    } else if (h.kind === 'trait-impl') {
+      const structId = symbolTable.lookupExact(h.filePath, h.className) ||
+                       symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                       generateId('Struct', `${h.filePath}:${h.className}`);
+
+      const traitId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+                      generateId('Trait', `${h.parentName}`);

      if (structId && traitId) {
        graph.addRelationship({
-          id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`),
+          id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
          sourceId: structId,
          targetId: traitId,
          type: 'IMPLEMENTS',
          confidence: 1.0,
-          reason: h.kind,
+          reason: 'trait-impl',
        });
      }
    }
@@ -1,215 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-const isDev = process.env.NODE_ENV === 'development';
-
-// ============================================================================
-// LANGUAGE-SPECIFIC CONFIG TYPES
-// ============================================================================
-
-/** TypeScript path alias config parsed from tsconfig.json */
-export interface TsconfigPaths {
-  /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
-  aliases: Map<string, string>;
-  /** Base URL for path resolution (relative to repo root) */
-  baseUrl: string;
-}
-
-/** Go module config parsed from go.mod */
-export interface GoModuleConfig {
-  /** Module path (e.g., "github.com/user/repo") */
-  modulePath: string;
-}
-
-/** PHP Composer PSR-4 autoload config */
-export interface ComposerConfig {
-  /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
-  psr4: Map<string, string>;
-}
-
-/** C# project config parsed from .csproj files */
-export interface CSharpProjectConfig {
-  /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
-  rootNamespace: string;
-  /** Directory containing the .csproj file */
-  projectDir: string;
-}
-
-/** Swift Package Manager module config */
-export interface SwiftPackageConfig {
-  /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
-  targets: Map<string, string>;
-}
-
-// ============================================================================
-// LANGUAGE-SPECIFIC CONFIG LOADERS
-// ============================================================================
-
-/**
- * Parse tsconfig.json to extract path aliases.
- * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
- */
-export async function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null> {
-  const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
-
-  for (const filename of candidates) {
-    try {
-      const tsconfigPath = path.join(repoRoot, filename);
-      const raw = await fs.readFile(tsconfigPath, 'utf-8');
-      // Strip JSON comments (// and /* */ style) for robustness
-      const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      const tsconfig = JSON.parse(stripped);
-      const compilerOptions = tsconfig.compilerOptions;
-      if (!compilerOptions?.paths) continue;
-
-      const baseUrl = compilerOptions.baseUrl || '.';
-      const aliases = new Map<string, string>();
-
-      for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
-        if (!Array.isArray(targets) || targets.length === 0) continue;
-        const target = targets[0] as string;
-
-        // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
-        const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
-        const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
-
-        aliases.set(aliasPrefix, targetPrefix);
-      }
-
-      if (aliases.size > 0) {
-        if (isDev) {
-          console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
-        }
-        return { aliases, baseUrl };
-      }
-    } catch {
-      // File doesn't exist or isn't valid JSON - try next
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse go.mod to extract module path.
- */
-export async function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null> {
-  try {
-    const goModPath = path.join(repoRoot, 'go.mod');
-    const content = await fs.readFile(goModPath, 'utf-8');
-    const match = content.match(/^module\s+(\S+)/m);
-    if (match) {
-      if (isDev) {
-        console.log(`📦 Loaded Go module path: ${match[1]}`);
-      }
-      return { modulePath: match[1] };
-    }
-  } catch {
-    // No go.mod
-  }
-  return null;
-}
-
-/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
-export async function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null> {
-  try {
-    const composerPath = path.join(repoRoot, 'composer.json');
-    const raw = await fs.readFile(composerPath, 'utf-8');
-    const composer = JSON.parse(raw);
-    const psr4Raw = composer.autoload?.['psr-4'] ?? {};
-    const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
-    const merged = { ...psr4Raw, ...psr4Dev };
-
-    const psr4 = new Map<string, string>();
-    for (const [ns, dir] of Object.entries(merged)) {
-      const nsNorm = (ns as string).replace(/\\+$/, '');
-      const dirNorm = (dir as string).replace(/\\/g, '/').replace(/\/+$/, '');
-      psr4.set(nsNorm, dirNorm);
-    }
-
-    if (isDev) {
-      console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
-    }
-    return { psr4 };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Parse .csproj files to extract RootNamespace.
- * Scans the repo root for .csproj files and returns configs for each.
- */
-export async function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]> {
-  const configs: CSharpProjectConfig[] = [];
-  // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning
-  const scanQueue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }];
-  const maxDepth = 5;
-  const maxDirs = 100;
-  let dirsScanned = 0;
-
-  while (scanQueue.length > 0 && dirsScanned < maxDirs) {
-    const { dir, depth } = scanQueue.shift()!;
-    dirsScanned++;
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && depth < maxDepth) {
-          // Skip common non-project directories
-          if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj') continue;
-          scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
-        }
-        if (entry.isFile() && entry.name.endsWith('.csproj')) {
-          try {
-            const csprojPath = path.join(dir, entry.name);
-            const content = await fs.readFile(csprojPath, 'utf-8');
-            const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
-            const rootNamespace = nsMatch
-              ? nsMatch[1].trim()
-              : entry.name.replace(/\.csproj$/, '');
-            const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
-            configs.push({ rootNamespace, projectDir });
-            if (isDev) {
-              console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
-            }
-          } catch {
-            // Can't read .csproj
-          }
-        }
-      }
-    } catch {
-      // Can't read directory
-    }
-  }
-  return configs;
-}
-
-export async function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null> {
-  // Swift imports are module-name based (e.g., `import SiuperModel`)
-  // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
-  // We scan for these directories to build a target map
-  const targets = new Map<string, string>();
-
-  const sourceDirs = ['Sources', 'Package/Sources', 'src'];
-  for (const sourceDir of sourceDirs) {
-    try {
-      const fullPath = path.join(repoRoot, sourceDir);
-      const entries = await fs.readdir(fullPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          targets.set(entry.name, sourceDir + '/' + entry.name);
-        }
-      }
-    } catch {
-      // Directory doesn't exist
-    }
-  }
-
-  if (targets.size > 0) {
-    if (isDev) {
-      console.log(`📦 Loaded ${targets.size} Swift package targets`);
-    }
-    return { targets };
-  }
-  return null;
-}
@@ -1,465 +0,0 @@
-/**
- * MRO (Method Resolution Order) Processor
- *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
- * each ancestor via HAS_METHOD edges, detects method-name collisions across
- * parents, and applies language-specific resolution rules to emit OVERRIDES edges.
- *
- * Language-specific rules:
- * - C++:       leftmost base class in declaration order wins
- * - C#/Java:   class method wins over interface default; multiple interface
- *              methods with same name are ambiguous (null resolution)
- * - Python:    C3 linearization determines MRO; first in linearized order wins
- * - Rust:      no auto-resolution — requires qualified syntax, resolvedTo = null
- * - Default:   single inheritance — first definition wins
- *
- * OVERRIDES edge direction: Class → Method (not Method → Method).
- * The source is the child class that inherits conflicting methods,
- * the target is the winning ancestor method node.
- * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
- */
-
-import { KnowledgeGraph, GraphRelationship } from '../graph/types.js';
-import { generateId } from '../../lib/utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-export interface MROEntry {
-  classId: string;
-  className: string;
-  language: SupportedLanguages;
-  mro: string[];               // linearized parent names
-  ambiguities: MethodAmbiguity[];
-}
-
-export interface MethodAmbiguity {
-  methodName: string;
-  definedIn: Array<{ classId: string; className: string; methodId: string }>;
-  resolvedTo: string | null;   // winning methodId or null if truly ambiguous
-  reason: string;
-}
-
-export interface MROResult {
-  entries: MROEntry[];
-  overrideEdges: number;
-  ambiguityCount: number;
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph. */
-function buildAdjacency(graph: KnowledgeGraph) {
-  // parentMap: childId → parentIds[] (in insertion / declaration order)
-  const parentMap = new Map<string, string[]>();
-  // methodMap: classId → methodIds[]
-  const methodMap = new Map<string, string[]>();
-  // Track which edge type each parent link came from
-  const parentEdgeType = new Map<string, Map<string, 'EXTENDS' | 'IMPLEMENTS'>>();
-
-  graph.forEachRelationship((rel) => {
-    if (rel.type === 'EXTENDS' || rel.type === 'IMPLEMENTS') {
-      let parents = parentMap.get(rel.sourceId);
-      if (!parents) {
-        parents = [];
-        parentMap.set(rel.sourceId, parents);
-      }
-      parents.push(rel.targetId);
-
-      let edgeTypes = parentEdgeType.get(rel.sourceId);
-      if (!edgeTypes) {
-        edgeTypes = new Map();
-        parentEdgeType.set(rel.sourceId, edgeTypes);
-      }
-      edgeTypes.set(rel.targetId, rel.type);
-    }
-
-    if (rel.type === 'HAS_METHOD') {
-      let methods = methodMap.get(rel.sourceId);
-      if (!methods) {
-        methods = [];
-        methodMap.set(rel.sourceId, methods);
-      }
-      methods.push(rel.targetId);
-    }
-  });
-
-  return { parentMap, methodMap, parentEdgeType };
-}
-
-/**
- * Gather all ancestor IDs in BFS / topological order.
- * Returns the linearized list of ancestor IDs (excluding the class itself).
- */
-function gatherAncestors(
-  classId: string,
-  parentMap: Map<string, string[]>,
-): string[] {
-  const visited = new Set<string>();
-  const order: string[] = [];
-  const queue: string[] = [...(parentMap.get(classId) ?? [])];
-
-  while (queue.length > 0) {
-    const id = queue.shift()!;
-    if (visited.has(id)) continue;
-    visited.add(id);
-    order.push(id);
-    const grandparents = parentMap.get(id);
-    if (grandparents) {
-      for (const gp of grandparents) {
-        if (!visited.has(gp)) queue.push(gp);
-      }
-    }
-  }
-
-  return order;
-}
-
-// ---------------------------------------------------------------------------
-// C3 linearization (Python MRO)
-// ---------------------------------------------------------------------------
-
-/**
- * Compute C3 linearization for a class given a parentMap.
- * Returns an array of ancestor IDs in C3 order (excluding the class itself),
- * or null if linearization fails (inconsistent or cyclic hierarchy).
- */
-function c3Linearize(
-  classId: string,
-  parentMap: Map<string, string[]>,
-  cache: Map<string, string[] | null>,
-  inProgress?: Set<string>,
-): string[] | null {
-  if (cache.has(classId)) return cache.get(classId)!;
-
-  // Cycle detection: if we're already computing this class, the hierarchy is cyclic
-  const visiting = inProgress ?? new Set<string>();
-  if (visiting.has(classId)) {
-    cache.set(classId, null);
-    return null;
-  }
-  visiting.add(classId);
-
-  const directParents = parentMap.get(classId);
-  if (!directParents || directParents.length === 0) {
-    visiting.delete(classId);
-    cache.set(classId, []);
-    return [];
-  }
-
-  // Compute linearization for each parent first
-  const parentLinearizations: string[][] = [];
-  for (const pid of directParents) {
-    const pLin = c3Linearize(pid, parentMap, cache, visiting);
-    if (pLin === null) {
-      visiting.delete(classId);
-      cache.set(classId, null);
-      return null;
-    }
-    parentLinearizations.push([pid, ...pLin]);
-  }
-
-  // Add the direct parents list as the final sequence
-  const sequences = [...parentLinearizations, [...directParents]];
-  const result: string[] = [];
-
-  while (sequences.some(s => s.length > 0)) {
-    // Find a good head: one that doesn't appear in the tail of any other sequence
-    let head: string | null = null;
-    for (const seq of sequences) {
-      if (seq.length === 0) continue;
-      const candidate = seq[0];
-      const inTail = sequences.some(
-        other => other.length > 1 && other.indexOf(candidate, 1) !== -1
-      );
-      if (!inTail) {
-        head = candidate;
-        break;
-      }
-    }
-
-    if (head === null) {
-      // Inconsistent hierarchy
-      visiting.delete(classId);
-      cache.set(classId, null);
-      return null;
-    }
-
-    result.push(head);
-
-    // Remove the chosen head from all sequences
-    for (const seq of sequences) {
-      if (seq.length > 0 && seq[0] === head) {
-        seq.shift();
-      }
-    }
-  }
-
-  visiting.delete(classId);
-  cache.set(classId, result);
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Language-specific resolution
-// ---------------------------------------------------------------------------
-
-type MethodDef = { classId: string; className: string; methodId: string };
-type Resolution = { resolvedTo: string | null; reason: string };
-
-/** Resolve by MRO order — first ancestor in linearized order wins. */
-function resolveByMroOrder(
-  methodName: string,
-  defs: MethodDef[],
-  mroOrder: string[],
-  reasonPrefix: string,
-): Resolution {
-  for (const ancestorId of mroOrder) {
-    const match = defs.find(d => d.classId === ancestorId);
-    if (match) {
-      return {
-        resolvedTo: match.methodId,
-        reason: `${reasonPrefix}: ${match.className}::${methodName}`,
-      };
-    }
-  }
-  return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
-}
-
-function resolveCsharpJava(
-  methodName: string,
-  defs: MethodDef[],
-  parentEdgeTypes: Map<string, 'EXTENDS' | 'IMPLEMENTS'> | undefined,
-): Resolution {
-  const classDefs: MethodDef[] = [];
-  const interfaceDefs: MethodDef[] = [];
-
-  for (const def of defs) {
-    const edgeType = parentEdgeTypes?.get(def.classId);
-    if (edgeType === 'IMPLEMENTS') {
-      interfaceDefs.push(def);
-    } else {
-      classDefs.push(def);
-    }
-  }
-
-  if (classDefs.length > 0) {
-    return {
-      resolvedTo: classDefs[0].methodId,
-      reason: `class method wins: ${classDefs[0].className}::${methodName}`,
-    };
-  }
-
-  if (interfaceDefs.length > 1) {
-    return {
-      resolvedTo: null,
-      reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
-    };
-  }
-
-  if (interfaceDefs.length === 1) {
-    return {
-      resolvedTo: interfaceDefs[0].methodId,
-      reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
-    };
-  }
-
-  return { resolvedTo: null, reason: 'no resolution found' };
-}
-
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-
-export function computeMRO(graph: KnowledgeGraph): MROResult {
-  const { parentMap, methodMap, parentEdgeType } = buildAdjacency(graph);
-  const c3Cache = new Map<string, string[] | null>();
-
-  const entries: MROEntry[] = [];
-  let overrideEdges = 0;
-  let ambiguityCount = 0;
-
-  // Process every class that has at least one parent
-  for (const [classId, directParents] of parentMap) {
-    if (directParents.length === 0) continue;
-
-    const classNode = graph.getNode(classId);
-    if (!classNode) continue;
-
-    const language = classNode.properties.language;
-    if (!language) continue;
-    const className = classNode.properties.name;
-
-    // Compute linearized MRO depending on language
-    let mroOrder: string[];
-    if (language === SupportedLanguages.Python) {
-      const c3Result = c3Linearize(classId, parentMap, c3Cache);
-      mroOrder = c3Result ?? gatherAncestors(classId, parentMap);
-    } else {
-      mroOrder = gatherAncestors(classId, parentMap);
-    }
-
-    // Get the parent names for the MRO entry
-    const mroNames: string[] = mroOrder
-      .map(id => graph.getNode(id)?.properties.name)
-      .filter((n): n is string => n !== undefined);
-
-    // Collect methods from all ancestors, grouped by method name
-    const methodsByName = new Map<string, MethodDef[]>();
-    for (const ancestorId of mroOrder) {
-      const ancestorNode = graph.getNode(ancestorId);
-      if (!ancestorNode) continue;
-
-      const methods = methodMap.get(ancestorId) ?? [];
-      for (const methodId of methods) {
-        const methodNode = graph.getNode(methodId);
-        if (!methodNode) continue;
-        // Properties don't participate in method resolution order
-        if (methodNode.label === 'Property') continue;
-
-        const methodName = methodNode.properties.name;
-        let defs = methodsByName.get(methodName);
-        if (!defs) {
-          defs = [];
-          methodsByName.set(methodName, defs);
-        }
-        // Avoid duplicates (same method seen via multiple paths)
-        if (!defs.some(d => d.methodId === methodId)) {
-          defs.push({
-            classId: ancestorId,
-            className: ancestorNode.properties.name,
-            methodId,
-          });
-        }
-      }
-    }
-
-    // Detect collisions: methods defined in 2+ different ancestors
-    const ambiguities: MethodAmbiguity[] = [];
-
-    // Compute transitive edge types once per class (only needed for C#/Java)
-    const needsEdgeTypes = language === SupportedLanguages.CSharp || language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin;
-    const classEdgeTypes = needsEdgeTypes
-      ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType)
-      : undefined;
-
-    for (const [methodName, defs] of methodsByName) {
-      if (defs.length < 2) continue;
-
-      // Own method shadows inherited — no ambiguity
-      const ownMethods = methodMap.get(classId) ?? [];
-      const ownDefinesIt = ownMethods.some(mid => {
-        const mn = graph.getNode(mid);
-        return mn?.properties.name === methodName;
-      });
-      if (ownDefinesIt) continue;
-
-      let resolution: Resolution;
-
-      switch (language) {
-        case SupportedLanguages.CPlusPlus:
-          resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base');
-          break;
-        case SupportedLanguages.CSharp:
-        case SupportedLanguages.Java:
-        case SupportedLanguages.Kotlin:
-          resolution = resolveCsharpJava(methodName, defs, classEdgeTypes);
-          break;
-        case SupportedLanguages.Python:
-          resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO');
-          break;
-        case SupportedLanguages.Rust:
-          resolution = {
-            resolvedTo: null,
-            reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
-          };
-          break;
-        default:
-          resolution = resolveByMroOrder(methodName, defs, mroOrder, 'first definition');
-          break;
-      }
-
-      const ambiguity: MethodAmbiguity = {
-        methodName,
-        definedIn: defs,
-        resolvedTo: resolution.resolvedTo,
-        reason: resolution.reason,
-      };
-      ambiguities.push(ambiguity);
-
-      if (resolution.resolvedTo === null) {
-        ambiguityCount++;
-      }
-
-      // Emit OVERRIDES edge if resolution found
-      if (resolution.resolvedTo !== null) {
-        graph.addRelationship({
-          id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`),
-          sourceId: classId,
-          targetId: resolution.resolvedTo,
-          type: 'OVERRIDES',
-          confidence: 1.0,
-          reason: resolution.reason,
-        });
-        overrideEdges++;
-      }
-    }
-
-    entries.push({
-      classId,
-      className,
-      language,
-      mro: mroNames,
-      ambiguities,
-    });
-  }
-
-  return { entries, overrideEdges, ambiguityCount };
-}
-
-/**
- * Build transitive edge types for a class using BFS from the class to all ancestors.
- *
- * Known limitation: BFS first-reach heuristic can misclassify an interface as
- * EXTENDS if it's reachable via a class chain before being seen via IMPLEMENTS.
- * E.g. if BaseClass also implements IFoo, IFoo may be classified as EXTENDS.
- * This affects C#/Java/Kotlin conflict resolution in rare diamond hierarchies.
- */
-function buildTransitiveEdgeTypes(
-  classId: string,
-  parentMap: Map<string, string[]>,
-  parentEdgeType: Map<string, Map<string, 'EXTENDS' | 'IMPLEMENTS'>>,
-): Map<string, 'EXTENDS' | 'IMPLEMENTS'> {
-  const result = new Map<string, 'EXTENDS' | 'IMPLEMENTS'>();
-  const directEdges = parentEdgeType.get(classId);
-  if (!directEdges) return result;
-
-  // BFS: propagate edge type from direct parents
-  const queue: Array<{ id: string; edgeType: 'EXTENDS' | 'IMPLEMENTS' }> = [];
-  const directParents = parentMap.get(classId) ?? [];
-
-  for (const pid of directParents) {
-    const et = directEdges.get(pid) ?? 'EXTENDS';
-    if (!result.has(pid)) {
-      result.set(pid, et);
-      queue.push({ id: pid, edgeType: et });
-    }
-  }
-
-  while (queue.length > 0) {
-    const { id, edgeType } = queue.shift()!;
-    const grandparents = parentMap.get(id) ?? [];
-    for (const gp of grandparents) {
-      if (!result.has(gp)) {
-        result.set(gp, edgeType);
-        queue.push({ id: gp, edgeType });
-      }
-    }
-  }
-
-  return result;
-}
@@ -1,384 +0,0 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
-import type { NamedImportMap } from './import-processor.js';
-
-/**
- * Walk a named-binding re-export chain through NamedImportMap.
- *
- * When file A imports { User } from B, and B re-exports { User } from C,
- * the NamedImportMap for A points to B, but B has no User definition.
- * This function follows the chain: A→B→C until a definition is found.
- *
- * Returns the definitions found at the end of the chain, or null if the
- * chain breaks (missing binding, circular reference, or depth exceeded).
- * Max depth 5 to prevent infinite loops.
- *
- * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the
- *               complete unfiltered result. Passing a file-filtered subset will cause
- *               silent misses at depth=0 for non-aliased bindings.
- */
-export function walkBindingChain(
-  name: string,
-  currentFilePath: string,
-  symbolTable: SymbolTable,
-  namedImportMap: NamedImportMap,
-  allDefs: SymbolDefinition[],
-): SymbolDefinition[] | null {
-  let lookupFile = currentFilePath;
-  let lookupName = name;
-  const visited = new Set<string>();
-
-  for (let depth = 0; depth < 5; depth++) {
-    const bindings = namedImportMap.get(lookupFile);
-    if (!bindings) return null;
-
-    const binding = bindings.get(lookupName);
-    if (!binding) return null;
-
-    const key = `${binding.sourcePath}:${binding.exportedName}`;
-    if (visited.has(key)) return null; // circular
-    visited.add(key);
-
-    const targetName = binding.exportedName;
-    const resolvedDefs = targetName !== lookupName || depth > 0
-      ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
-      : allDefs.filter(def => def.filePath === binding.sourcePath);
-
-    if (resolvedDefs.length > 0) return resolvedDefs;
-
-    // No definition in source file → follow re-export chain
-    lookupFile = binding.sourcePath;
-    lookupName = targetName;
-  }
-
-  return null;
-}
-
-/**
- * Extract named bindings from an import AST node.
- * Returns undefined if the import is not a named import (e.g., import * or default).
- *
- * TS: import { User, Repo as R } from './models'
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- *
- * Python: from models import User, Repo as R
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- */
-export function extractNamedBindings(
-  importNode: any,
-  language: SupportedLanguages,
-): { local: string; exported: string }[] | undefined {
-  if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
-    return extractTsNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.Python) {
-    return extractPythonNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.Kotlin) {
-    return extractKotlinNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.Rust) {
-    return extractRustNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.PHP) {
-    return extractPhpNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.CSharp) {
-    return extractCsharpNamedBindings(importNode);
-  }
-  if (language === SupportedLanguages.Java) {
-    return extractJavaNamedBindings(importNode);
-  }
-  return undefined;
-}
-
-export function extractTsNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // import_statement > import_clause > named_imports > import_specifier*
-  const importClause = findChild(importNode, 'import_clause');
-  if (importClause) {
-    const namedImports = findChild(importClause, 'named_imports');
-    if (!namedImports) return undefined; // default import, namespace import, or side-effect
-
-    const bindings: { local: string; exported: string }[] = [];
-    for (let i = 0; i < namedImports.namedChildCount; i++) {
-      const specifier = namedImports.namedChild(i);
-      if (specifier?.type !== 'import_specifier') continue;
-
-      const identifiers: string[] = [];
-      for (let j = 0; j < specifier.namedChildCount; j++) {
-        const child = specifier.namedChild(j);
-        if (child?.type === 'identifier') identifiers.push(child.text);
-      }
-
-      if (identifiers.length === 1) {
-        bindings.push({ local: identifiers[0], exported: identifiers[0] });
-      } else if (identifiers.length === 2) {
-        // import { Foo as Bar } → exported='Foo', local='Bar'
-        bindings.push({ local: identifiers[1], exported: identifiers[0] });
-      }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-  }
-
-  // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
-  const exportClause = findChild(importNode, 'export_clause');
-  if (exportClause) {
-    const bindings: { local: string; exported: string }[] = [];
-    for (let i = 0; i < exportClause.namedChildCount; i++) {
-      const specifier = exportClause.namedChild(i);
-      if (specifier?.type !== 'export_specifier') continue;
-
-      const identifiers: string[] = [];
-      for (let j = 0; j < specifier.namedChildCount; j++) {
-        const child = specifier.namedChild(j);
-        if (child?.type === 'identifier') identifiers.push(child.text);
-      }
-
-      if (identifiers.length === 1) {
-        // export { User } from './base' → re-exports User as User
-        bindings.push({ local: identifiers[0], exported: identifiers[0] });
-      } else if (identifiers.length === 2) {
-        // export { Repo as Repository } from './models' → name=Repo, alias=Repository
-        // For re-exports, the first id is the source name, second is what's exported
-        // When another file imports { Repository }, they get Repo from the source
-        bindings.push({ local: identifiers[1], exported: identifiers[0] });
-      }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-  }
-
-  return undefined;
-}
-
-export function extractPythonNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // Only from import_from_statement, not plain import_statement
-  if (importNode.type !== 'import_from_statement') return undefined;
-
-  const bindings: { local: string; exported: string }[] = [];
-  for (let i = 0; i < importNode.namedChildCount; i++) {
-    const child = importNode.namedChild(i);
-    if (!child) continue;
-
-    if (child.type === 'dotted_name') {
-      // Skip the module_name (first dotted_name is the source module)
-      const fieldName = importNode.childForFieldName?.('module_name');
-      if (fieldName && child.startIndex === fieldName.startIndex) continue;
-
-      // This is an imported name: from x import User
-      const name = child.text;
-      if (name) bindings.push({ local: name, exported: name });
-    }
-
-    if (child.type === 'aliased_import') {
-      // from x import Repo as R
-      const dottedName = findChild(child, 'dotted_name');
-      const aliasIdent = findChild(child, 'identifier');
-      if (dottedName && aliasIdent) {
-        bindings.push({ local: aliasIdent.text, exported: dottedName.text });
-      }
-    }
-  }
-
-  return bindings.length > 0 ? bindings : undefined;
-}
-
-export function extractKotlinNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // import_header > identifier + import_alias > simple_identifier
-  if (importNode.type !== 'import_header') return undefined;
-
-  const fullIdent = findChild(importNode, 'identifier');
-  if (!fullIdent) return undefined;
-
-  const fullText = fullIdent.text;
-  const exportedName = fullText.includes('.') ? fullText.split('.').pop()! : fullText;
-
-  const importAlias = findChild(importNode, 'import_alias');
-  if (importAlias) {
-    // Aliased: import com.example.User as U
-    const aliasIdent = findChild(importAlias, 'simple_identifier');
-    if (!aliasIdent) return undefined;
-    return [{ local: aliasIdent.text, exported: exportedName }];
-  }
-
-  // Non-aliased: import com.example.User → local="User", exported="User"
-  // Skip wildcard imports (ending in *)
-  if (fullText.endsWith('.*') || fullText.endsWith('*')) return undefined;
-  // Skip lowercase last segments — those are member/function imports (e.g.,
-  // import util.OneArg.writeAudit), not class imports. Multiple member imports
-  // with the same function name would collide in NamedImportMap, breaking
-  // arity-based disambiguation.
-  if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase()) return undefined;
-  return [{ local: exportedName, exported: exportedName }];
-}
-
-export function extractRustNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // use_declaration may contain use_as_clause at any depth
-  if (importNode.type !== 'use_declaration') return undefined;
-
-  const bindings: { local: string; exported: string }[] = [];
-  collectRustBindings(importNode, bindings);
-  return bindings.length > 0 ? bindings : undefined;
-}
-
-function collectRustBindings(node: any, bindings: { local: string; exported: string }[]): void {
-  if (node.type === 'use_as_clause') {
-    // First identifier = exported name, second identifier = local alias
-    const idents: string[] = [];
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child?.type === 'identifier') idents.push(child.text);
-      // For scoped_identifier, extract the last segment
-      if (child?.type === 'scoped_identifier') {
-        const nameNode = child.childForFieldName?.('name');
-        if (nameNode) idents.push(nameNode.text);
-      }
-    }
-    if (idents.length === 2) {
-      bindings.push({ local: idents[1], exported: idents[0] });
-    }
-    return;
-  }
-
-  // Terminal identifier in a use_list: use crate::models::{User, Repo}
-  if (node.type === 'identifier' && node.parent?.type === 'use_list') {
-    bindings.push({ local: node.text, exported: node.text });
-    return;
-  }
-
-  // Skip scoped_identifier that serves as path prefix in scoped_use_list
-  // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
-  if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
-    return; // path prefix — the use_list sibling handles the actual symbols
-  }
-
-  // Terminal scoped_identifier: use crate::models::User;
-  // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
-  if (node.type === 'scoped_identifier') {
-    let hasDeeper = false;
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
-        hasDeeper = true;
-        break;
-      }
-    }
-    if (!hasDeeper) {
-      const nameNode = node.childForFieldName?.('name');
-      if (nameNode) {
-        bindings.push({ local: nameNode.text, exported: nameNode.text });
-      }
-      return;
-    }
-  }
-
-  // Recurse into children
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectRustBindings(child, bindings);
-  }
-}
-
-export function extractPhpNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // namespace_use_declaration > namespace_use_clause* (flat)
-  // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
-  if (importNode.type !== 'namespace_use_declaration') return undefined;
-
-  const bindings: { local: string; exported: string }[] = [];
-
-  // Collect all clauses — from direct children AND from namespace_use_group
-  const clauses: any[] = [];
-  for (let i = 0; i < importNode.namedChildCount; i++) {
-    const child = importNode.namedChild(i);
-    if (child?.type === 'namespace_use_clause') {
-      clauses.push(child);
-    } else if (child?.type === 'namespace_use_group') {
-      for (let j = 0; j < child.namedChildCount; j++) {
-        const groupChild = child.namedChild(j);
-        if (groupChild?.type === 'namespace_use_clause') clauses.push(groupChild);
-      }
-    }
-  }
-
-  for (const clause of clauses) {
-    // Flat imports: qualified_name + name (alias)
-    let qualifiedName: any = null;
-    const names: any[] = [];
-    for (let j = 0; j < clause.namedChildCount; j++) {
-      const child = clause.namedChild(j);
-      if (child?.type === 'qualified_name') qualifiedName = child;
-      else if (child?.type === 'name') names.push(child);
-    }
-
-    if (qualifiedName && names.length > 0) {
-      // Flat aliased import: use App\Models\Repo as R;
-      const fullText = qualifiedName.text;
-      const exportedName = fullText.includes('\\') ? fullText.split('\\').pop()! : fullText;
-      bindings.push({ local: names[0].text, exported: exportedName });
-    } else if (qualifiedName && names.length === 0) {
-      // Flat non-aliased import: use App\Models\User;
-      const fullText = qualifiedName.text;
-      const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop()! : fullText;
-      bindings.push({ local: lastSegment, exported: lastSegment });
-    } else if (!qualifiedName && names.length >= 2) {
-      // Grouped aliased import: {Repo as R} — first name = exported, second = alias
-      bindings.push({ local: names[1].text, exported: names[0].text });
-    } else if (!qualifiedName && names.length === 1) {
-      // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
-      bindings.push({ local: names[0].text, exported: names[0].text });
-    }
-  }
-  return bindings.length > 0 ? bindings : undefined;
-}
-
-export function extractCsharpNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // using_directive with identifier (alias) + qualified_name (target)
-  if (importNode.type !== 'using_directive') return undefined;
-
-  let aliasIdent: any = null;
-  let qualifiedName: any = null;
-  for (let i = 0; i < importNode.namedChildCount; i++) {
-    const child = importNode.namedChild(i);
-    if (child?.type === 'identifier' && !aliasIdent) aliasIdent = child;
-    else if (child?.type === 'qualified_name') qualifiedName = child;
-  }
-
-  if (!aliasIdent || !qualifiedName) return undefined;
-
-  const fullText = qualifiedName.text;
-  const exportedName = fullText.includes('.') ? fullText.split('.').pop()! : fullText;
-
-  return [{ local: aliasIdent.text, exported: exportedName }];
-}
-
-export function extractJavaNamedBindings(importNode: any): { local: string; exported: string }[] | undefined {
-  // import_declaration > scoped_identifier "com.example.models.User"
-  // Wildcard imports (.*) don't produce named bindings
-  if (importNode.type !== 'import_declaration') return undefined;
-
-  // Check for asterisk (wildcard import) — skip those
-  for (let i = 0; i < importNode.childCount; i++) {
-    const child = importNode.child(i);
-    if (child?.type === 'asterisk') return undefined;
-  }
-
-  const scopedId = findChild(importNode, 'scoped_identifier');
-  if (!scopedId) return undefined;
-
-  const fullText = scopedId.text;
-  const lastDot = fullText.lastIndexOf('.');
-  if (lastDot === -1) return undefined;
-
-  const className = fullText.slice(lastDot + 1);
-  // Skip lowercase names — those are package imports, not class imports
-  if (className[0] && className[0] === className[0].toLowerCase()) return undefined;
-
-  return [{ local: className, exported: className }];
-}
-
-function findChild(node: any, type: string): any {
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type === type) return child;
-  }
-  return null;
-}
@@ -1,17 +1,14 @@
 import { KnowledgeGraph, GraphNode, GraphRelationship } from '../graph/types.js';
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { SymbolTable } from './symbol-table.js';
 import { ASTCache } from './ast-cache.js';
-import { getLanguageFromFilename, yieldToEventLoop, DEFINITION_CAPTURE_KEYS, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
-import { isNodeExported } from './export-detection.js';
+import { findSiblingChild, getLanguageFromFilename, yieldToEventLoop } from './utils.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
-import { typeConfigs } from './type-extractors/index.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ParseWorkerResult, ParseWorkerInput, ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+import type { ParseWorkerResult, ParseWorkerInput, ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute } from './workers/parse-worker.js';

 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;

@@ -20,12 +17,186 @@ export interface WorkerExtractedData {
  calls: ExtractedCall[];
  heritage: ExtractedHeritage[];
  routes: ExtractedRoute[];
-  constructorBindings: FileConstructorBindings[];
 }

-// isNodeExported imported from ./export-detection.js (shared module)
-// Re-export for backward compatibility with any external consumers
-export { isNodeExported } from './export-detection.js';
+const DEFINITION_CAPTURE_KEYS = [
+  'definition.function',
+  'definition.class',
+  'definition.interface',
+  'definition.method',
+  'definition.struct',
+  'definition.enum',
+  'definition.namespace',
+  'definition.module',
+  'definition.trait',
+  'definition.impl',
+  'definition.type',
+  'definition.const',
+  'definition.static',
+  'definition.typedef',
+  'definition.macro',
+  'definition.union',
+  'definition.property',
+  'definition.record',
+  'definition.delegate',
+  'definition.annotation',
+  'definition.constructor',
+  'definition.template',
+  'definition.instance',
+] as const;
+
+const getDefinitionNodeFromCaptures = (captureMap: Record<string, any>): any | null => {
+  for (const key of DEFINITION_CAPTURE_KEYS) {
+    if (captureMap[key]) return captureMap[key];
+  }
+  return null;
+};
+
+// ============================================================================
+// EXPORT DETECTION - Language-specific visibility detection
+// ============================================================================
+
+/**
+ * Check if a symbol (function, class, etc.) is exported/public
+ * Handles all 9 supported languages with explicit logic
+ *
+ * @param node - The AST node for the symbol name
+ * @param name - The symbol name
+ * @param language - The programming language
+ * @returns true if the symbol is exported/public
+ */
+export const isNodeExported = (node: any, name: string, language: string): boolean => {
+  let current = node;
+
+  switch (language) {
+    // JavaScript/TypeScript: Check for export keyword in ancestors
+    case 'javascript':
+    case 'typescript':
+      while (current) {
+        const type = current.type;
+        if (type === 'export_statement' ||
+            type === 'export_specifier' ||
+            type === 'lexical_declaration' && current.parent?.type === 'export_statement') {
+          return true;
+        }
+        // Also check if text starts with 'export '
+        if (current.text?.startsWith('export ')) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+
+    // Python: Public if no leading underscore (convention)
+    case 'python':
+      return !name.startsWith('_');
+
+    // Java: Check for 'public' modifier
+    // In tree-sitter Java, modifiers are siblings of the name node, not parents
+    case 'java':
+      while (current) {
+        // Check if this node or any sibling is a 'modifiers' node containing 'public'
+        if (current.parent) {
+          const parent = current.parent;
+          // Check all children of the parent for modifiers
+          for (let i = 0; i < parent.childCount; i++) {
+            const child = parent.child(i);
+            if (child?.type === 'modifiers' && child.text?.includes('public')) {
+              return true;
+            }
+          }
+          // Also check if the parent's text starts with 'public' (fallback)
+          if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
+            if (parent.text?.trimStart().startsWith('public')) {
+              return true;
+            }
+          }
+        }
+        current = current.parent;
+      }
+      return false;
+
+    // C#: Check for 'public' modifier in ancestors
+    case 'csharp':
+      while (current) {
+        if (current.type === 'modifier' || current.type === 'modifiers') {
+          if (current.text?.includes('public')) return true;
+        }
+        current = current.parent;
+      }
+      return false;
+
+    // Go: Uppercase first letter = exported
+    case 'go':
+      if (name.length === 0) return false;
+      const first = name[0];
+      // Must be uppercase letter (not a number or symbol)
+      return first === first.toUpperCase() && first !== first.toLowerCase();
+
+    // Rust: Check for 'pub' visibility modifier
+    case 'rust':
+      while (current) {
+        if (current.type === 'visibility_modifier') {
+          if (current.text?.includes('pub')) return true;
+        }
+        current = current.parent;
+      }
+      return false;
+
+    // Kotlin: Default visibility is public (unlike Java)
+    // visibility_modifier is inside modifiers, a sibling of the name node within the declaration
+    case 'kotlin':
+      while (current) {
+        if (current.parent) {
+          const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
+          if (visMod) {
+            const text = visMod.text;
+            if (text === 'private' || text === 'internal' || text === 'protected') return false;
+            if (text === 'public') return true;
+          }
+        }
+        current = current.parent;
+      }
+      // No visibility modifier = public (Kotlin default)
+      return true;
+
+    // C/C++: No native export concept at language level
+    // Entry points will be detected via name patterns (main, etc.)
+    case 'c':
+    case 'cpp':
+      return false;
+
+    // Swift: Check for 'public' or 'open' access modifiers
+    case 'swift':
+      while (current) {
+        if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
+          const text = current.text || '';
+          if (text.includes('public') || text.includes('open')) return true;
+        }
+        current = current.parent;
+      }
+      return false;
+
+    // PHP: Check for visibility modifier or top-level scope
+    case 'php':
+      while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'interface_declaration' ||
+            current.type === 'trait_declaration' ||
+            current.type === 'enum_declaration') {
+          return true;
+        }
+        if (current.type === 'visibility_modifier') {
+          return current.text === 'public';
+        }
+        current = current.parent;
+      }
+      return true; // Top-level functions are globally accessible
+
+    default:
+      return false;
+  }
+};

 // ============================================================================
 // Worker-based parallel parsing
@@ -46,7 +217,7 @@ const processParsingWithWorkers = async (
    if (lang) parseableFiles.push({ path: file.path, content: file.content });
  }

-  if (parseableFiles.length === 0) return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
+  if (parseableFiles.length === 0) return { imports: [], calls: [], heritage: [], routes: [] };

  const total = files.length;

@@ -63,7 +234,6 @@ const processParsingWithWorkers = async (
  const allCalls: ExtractedCall[] = [];
  const allHeritage: ExtractedHeritage[] = [];
  const allRoutes: ExtractedRoute[] = [];
-  const allConstructorBindings: FileConstructorBindings[] = [];
  for (const result of chunkResults) {
    for (const node of result.nodes) {
      graph.addNode({
@@ -78,39 +248,18 @@ const processParsingWithWorkers = async (
    }

    for (const sym of result.symbols) {
-      symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
-        parameterCount: sym.parameterCount,
-        returnType: sym.returnType,
-        ownerId: sym.ownerId,
-      });
+      symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type);
    }

    allImports.push(...result.imports);
    allCalls.push(...result.calls);
    allHeritage.push(...result.heritage);
    allRoutes.push(...result.routes);
-    allConstructorBindings.push(...result.constructorBindings);
-  }
-
-  // Merge and log skipped languages from workers
-  const skippedLanguages = new Map<string, number>();
-  for (const result of chunkResults) {
-    if (result.skippedLanguages) {
-      for (const [lang, count] of Object.entries(result.skippedLanguages)) {
-        skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count);
-      }
-    }
-  }
-  if (skippedLanguages.size > 0) {
-    const summary = Array.from(skippedLanguages.entries())
-      .map(([lang, count]) => `${lang}: ${count}`)
-      .join(', ');
-    console.warn(`  Skipped unsupported languages: ${summary}`);
  }

  // Final progress
  onFileProgress?.(total, total, 'done');
-  return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
+  return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes };
 };

 // ============================================================================
@@ -126,7 +275,6 @@ const processParsingSequential = async (
 ) => {
  const parser = await loadParser();
  const total = files.length;
-  const skippedLanguages = new Map<string, number>();

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
@@ -139,24 +287,18 @@ const processParsingSequential = async (

    if (!language) continue;

-    // Skip unsupported languages (e.g. Swift when tree-sitter-swift not installed)
-    if (!isLanguageAvailable(language)) {
-      skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
-      continue;
-    }
-
-    // Skip files larger than the max tree-sitter buffer (32 MB)
-    if (file.content.length > TREE_SITTER_MAX_BUFFER) continue;
+    // Skip very large files — they can crash tree-sitter or cause OOM
+    if (file.content.length > 512 * 1024) continue;

    try {
      await loadLanguage(language, file.path);
    } catch {
-      continue;  // parser unavailable — safety net
+      continue;  // parser unavailable — already warned in pipeline
    }

    let tree;
    try {
-      tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+      tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
    } catch (parseError) {
      console.warn(`Skipping unparseable file: ${file.path}`);
      continue;
@@ -224,29 +366,17 @@ const processParsingSequential = async (
      else if (captureMap['definition.annotation']) nodeLabel = 'Annotation';
      else if (captureMap['definition.constructor']) nodeLabel = 'Constructor';
      else if (captureMap['definition.template']) nodeLabel = 'Template';
+      else if (captureMap['definition.instance']) nodeLabel = 'CodeElement';

      const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
      const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
-      const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+      const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);

      const definitionNode = getDefinitionNodeFromCaptures(captureMap);
      const frameworkHint = definitionNode
        ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
        : null;

-      // Extract method signature for Method/Constructor nodes
-      const methodSig = (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor')
-        ? extractMethodSignature(definitionNode)
-        : undefined;
-
-      // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
-      if (methodSig && !methodSig.returnType && definitionNode) {
-        const tc = typeConfigs[language as keyof typeof typeConfigs];
-        if (tc?.extractReturnType) {
-          methodSig.returnType = tc.extractReturnType(definitionNode);
-        }
-      }
-
      const node: GraphNode = {
        id: nodeId,
        label: nodeLabel as any,
@@ -261,25 +391,12 @@ const processParsingSequential = async (
            astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
            astFrameworkReason: frameworkHint.reason,
          } : {}),
-          ...(methodSig ? {
-            parameterCount: methodSig.parameterCount,
-            returnType: methodSig.returnType,
-          } : {}),
        },
      };

      graph.addNode(node);

-      // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
-      // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
-      const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
-      const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
-
-      symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
-        parameterCount: methodSig?.parameterCount,
-        returnType: methodSig?.returnType,
-        ownerId: enclosingClassId ?? undefined,
-      });
+      symbolTable.add(file.path, nodeName, nodeId, nodeLabel);

      const fileId = generateId('File', file.path);

@@ -295,27 +412,8 @@ const processParsingSequential = async (
      };

      graph.addRelationship(relationship);
-
-      // ── HAS_METHOD: link method/constructor/property to enclosing class ──
-      if (enclosingClassId) {
-        graph.addRelationship({
-          id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
-          sourceId: enclosingClassId,
-          targetId: nodeId,
-          type: 'HAS_METHOD',
-          confidence: 1.0,
-          reason: '',
-        });
-      }
    });
  }
-
-  if (skippedLanguages.size > 0) {
-    const summary = Array.from(skippedLanguages.entries())
-      .map(([lang, count]) => `${lang}: ${count}`)
-      .join(', ');
-    console.warn(`  Skipped unsupported languages: ${summary}`);
-  }
 };

 // ============================================================================
@@ -1,17 +1,12 @@
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
 import { processParsing } from './parsing-processor.js';
-import {
-  processImports,
-  processImportsFromExtracted,
-  buildImportResolutionContext
-} from './import-processor.js';
+import { processImports, processImportsFromExtracted, createImportMap, buildImportResolutionContext } from './import-processor.js';
 import { processCalls, processCallsFromExtracted, processRoutesFromExtracted } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
-import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
-import { createResolutionContext } from './resolution-context.js';
+import { createSymbolTable } from './symbol-table.js';
 import { createASTCache } from './ast-cache.js';
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
 import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
@@ -38,13 +33,13 @@ export const runPipelineFromRepo = async (
  onProgress: (progress: PipelineProgress) => void
 ): Promise<PipelineResult> => {
  const graph = createKnowledgeGraph();
-  const ctx = createResolutionContext();
-  const symbolTable = ctx.symbols;
+  const symbolTable = createSymbolTable();
  let astCache = createASTCache(AST_CACHE_CAP);
+  const importMap = createImportMap();

  const cleanup = () => {
    astCache.clear();
-    ctx.clear();
+    symbolTable.clear();
  };

  try {
@@ -216,69 +211,23 @@ export const runPipelineFromRepo = async (
          workerPool,
        );

-        const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
-
        if (chunkWorkerData) {
          // Imports
-          await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {
-            onProgress({
-              phase: 'parsing',
-              percent: Math.round(chunkBasePercent),
-              message: `Resolving imports (chunk ${chunkIdx + 1}/${numChunks})...`,
-              detail: `${current}/${total} files`,
-              stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
-            });
-          }, repoPath, importCtx);
-          // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them)
-          // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps,
-          // and the single-threaded event loop prevents races between synchronous addRelationship calls.
-          await Promise.all([
-            processCallsFromExtracted(
-              graph,
-              chunkWorkerData.calls,
-              ctx,
-              (current, total) => {
-                onProgress({
-                  phase: 'parsing',
-                  percent: Math.round(chunkBasePercent),
-                  message: `Resolving calls (chunk ${chunkIdx + 1}/${numChunks})...`,
-                  detail: `${current}/${total} files`,
-                  stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
-                });
-              },
-              chunkWorkerData.constructorBindings,
-            ),
-            processHeritageFromExtracted(
-              graph,
-              chunkWorkerData.heritage,
-              ctx,
-              (current, total) => {
-                onProgress({
-                  phase: 'parsing',
-                  percent: Math.round(chunkBasePercent),
-                  message: `Resolving heritage (chunk ${chunkIdx + 1}/${numChunks})...`,
-                  detail: `${current}/${total} records`,
-                  stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
-                });
-              },
-            ),
-            processRoutesFromExtracted(
-              graph,
-              chunkWorkerData.routes ?? [],
-              ctx,
-              (current, total) => {
-                onProgress({
-                  phase: 'parsing',
-                  percent: Math.round(chunkBasePercent),
-                  message: `Resolving routes (chunk ${chunkIdx + 1}/${numChunks})...`,
-                  detail: `${current}/${total} routes`,
-                  stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
-                });
-              },
-            ),
-          ]);
+          await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx, symbolTable);
+          // Calls — resolve immediately, then free the array
+          if (chunkWorkerData.calls.length > 0) {
+            await processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap);
+          }
+          // Heritage — resolve immediately, then free
+          if (chunkWorkerData.heritage.length > 0) {
+            await processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable);
+          }
+          // Routes — resolve immediately (Laravel route→controller CALLS edges)
+          if (chunkWorkerData.routes && chunkWorkerData.routes.length > 0) {
+            await processRoutesFromExtracted(graph, chunkWorkerData.routes, symbolTable, importMap);
+          }
        } else {
-          await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
+          await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths, symbolTable);
          sequentialChunkPaths.push(chunkPaths);
        }

@@ -299,22 +248,11 @@ export const runPipelineFromRepo = async (
        .filter(p => chunkContents.has(p))
        .map(p => ({ path: p, content: chunkContents.get(p)! }));
      astCache = createASTCache(chunkFiles.length);
-      const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx);
-      await processHeritage(graph, chunkFiles, astCache, ctx);
-      if (rubyHeritage.length > 0) {
-        await processHeritageFromExtracted(graph, rubyHeritage, ctx);
-      }
+      await processCalls(graph, chunkFiles, astCache, symbolTable, importMap);
+      await processHeritage(graph, chunkFiles, astCache, symbolTable);
      astCache.clear();
    }

-    // Log resolution cache stats
-    if (isDev) {
-      const rcStats = ctx.getStats();
-      const total = rcStats.cacheHits + rcStats.cacheMisses;
-      const hitRate = total > 0 ? ((rcStats.cacheHits / total) * 100).toFixed(1) : '0';
-      console.log(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`);
-    }
-
    // Free import resolution context — suffix index + resolve cache no longer needed
    // (allPathObjects and importCtx hold ~94MB+ for large repos)
    allPathObjects.length = 0;
@@ -322,17 +260,12 @@ export const runPipelineFromRepo = async (
    (importCtx as any).suffixIndex = null;
    (importCtx as any).normalizedFileList = null;

-    // ── Phase 4.5: Method Resolution Order ──────────────────────────────
-    onProgress({
-      phase: 'parsing',
-      percent: 81,
-      message: 'Computing method resolution order...',
-      stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-    });
-
-    const mroResult = computeMRO(graph);
-    if (isDev && mroResult.entries.length > 0) {
-      console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`);
+    if (isDev) {
+      let importsCount = 0;
+      for (const r of graph.iterRelationships()) {
+        if (r.type === 'IMPORTS') importsCount++;
+      }
+      console.log(`📊 Pipeline: graph has ${importsCount} IMPORTS, ${graph.relationshipCount} total relationships`);
    }

    // ── Phase 5: Communities ───────────────────────────────────────────
@@ -13,7 +13,6 @@
 import { KnowledgeGraph, GraphNode, GraphRelationship, NodeLabel } from '../graph/types.js';
 import { CommunityMembership } from './community-processor.js';
 import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';

 const isDev = process.env.NODE_ENV === 'development';

@@ -288,7 +287,7 @@ const findEntryPoints = (
    // Calculate entry point score using new scoring system
    const { score: baseScore, reasons } = calculateEntryPointScore(
      node.properties.name,
-      node.properties.language ?? SupportedLanguages.JavaScript,
+      node.properties.language || 'javascript',
      node.properties.isExported ?? false,
      callers.length,
      callees.length,
@@ -1,192 +0,0 @@
-/**
- * Resolution Context
- *
- * Single implementation of tiered name resolution. Replaces the duplicated
- * tier-selection logic previously split between symbol-resolver.ts and
- * call-processor.ts.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactFull — authoritative)
- * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
- * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
- * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
- * 3. Global (all candidates — consumers must check candidate count)
- */
-
-import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
-import { createSymbolTable } from './symbol-table.js';
-import type { NamedImportBinding } from './import-processor.js';
-import { isFileInPackageDir } from './import-processor.js';
-import { walkBindingChain } from './named-binding-extraction.js';
-
-/** Resolution tier for tracking, logging, and test assertions. */
-export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
-
-/** Tier-selected candidates with metadata. */
-export interface TieredCandidates {
-  readonly candidates: readonly SymbolDefinition[];
-  readonly tier: ResolutionTier;
-}
-
-/** Confidence scores per resolution tier. */
-export const TIER_CONFIDENCE: Record<ResolutionTier, number> = {
-  'same-file': 0.95,
-  'import-scoped': 0.9,
-  'global': 0.5,
-};
-
-// --- Map types ---
-export type ImportMap = Map<string, Set<string>>;
-export type PackageMap = Map<string, Set<string>>;
-export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
-
-export interface ResolutionContext {
-  /**
-   * The only resolution API. Returns all candidates at the winning tier.
-   *
-   * Tier 3 ('global') returns ALL candidates regardless of count —
-   * consumers must check candidates.length and refuse ambiguous matches.
-   */
-  resolve(name: string, fromFile: string): TieredCandidates | null;
-
-  // --- Data access (for pipeline wiring, not resolution) ---
-  /** Symbol table — used by parsing-processor to populate symbols. */
-  readonly symbols: SymbolTable;
-  /** Raw maps — used by import-processor to populate import data. */
-  readonly importMap: ImportMap;
-  readonly packageMap: PackageMap;
-  readonly namedImportMap: NamedImportMap;
-
-  // --- Per-file cache lifecycle ---
-  enableCache(filePath: string): void;
-  clearCache(): void;
-
-  // --- Operational ---
-  getStats(): { fileCount: number; globalSymbolCount: number; cacheHits: number; cacheMisses: number };
-  clear(): void;
-}
-
-export const createResolutionContext = (): ResolutionContext => {
-  const symbols = createSymbolTable();
-  const importMap: ImportMap = new Map();
-  const packageMap: PackageMap = new Map();
-  const namedImportMap: NamedImportMap = new Map();
-
-  // Per-file cache state
-  let cacheFile: string | null = null;
-  let cache: Map<string, TieredCandidates | null> | null = null;
-  let cacheHits = 0;
-  let cacheMisses = 0;
-
-  // --- Core resolution (single implementation of tier logic) ---
-
-  const resolveUncached = (name: string, fromFile: string): TieredCandidates | null => {
-    // Tier 1: Same file — authoritative match
-    const localDef = symbols.lookupExactFull(fromFile, name);
-    if (localDef) {
-      return { candidates: [localDef], tier: 'same-file' };
-    }
-
-    // Get all global definitions for subsequent tiers
-    const allDefs = symbols.lookupFuzzy(name);
-
-    // Tier 2a-named: Check named bindings BEFORE empty-allDefs early return
-    // because aliased imports mean lookupFuzzy('U') returns empty but we
-    // can resolve via the exported name.
-    const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap, allDefs);
-    if (chainResult && chainResult.length > 0) {
-      return { candidates: chainResult, tier: 'import-scoped' };
-    }
-
-    if (allDefs.length === 0) return null;
-
-    // Tier 2a: Import-scoped — definition in a file imported by fromFile
-    const importedFiles = importMap.get(fromFile);
-    if (importedFiles) {
-      const importedDefs = allDefs.filter(def => importedFiles.has(def.filePath));
-      if (importedDefs.length > 0) {
-        return { candidates: importedDefs, tier: 'import-scoped' };
-      }
-    }
-
-    // Tier 2b: Package-scoped — definition in a package dir imported by fromFile
-    const importedPackages = packageMap.get(fromFile);
-    if (importedPackages) {
-      const packageDefs = allDefs.filter(def => {
-        for (const dirSuffix of importedPackages) {
-          if (isFileInPackageDir(def.filePath, dirSuffix)) return true;
-        }
-        return false;
-      });
-      if (packageDefs.length > 0) {
-        return { candidates: packageDefs, tier: 'import-scoped' };
-      }
-    }
-
-    // Tier 3: Global — pass all candidates through.
-    // Consumers must check candidate count and refuse ambiguous matches.
-    return { candidates: allDefs, tier: 'global' };
-  };
-
-  const resolve = (name: string, fromFile: string): TieredCandidates | null => {
-    // Check cache (only when enabled AND fromFile matches cached file)
-    if (cache && cacheFile === fromFile) {
-      if (cache.has(name)) {
-        cacheHits++;
-        return cache.get(name)!;
-      }
-      cacheMisses++;
-    }
-
-    const result = resolveUncached(name, fromFile);
-
-    // Store in cache if active and file matches
-    if (cache && cacheFile === fromFile) {
-      cache.set(name, result);
-    }
-
-    return result;
-  };
-
-  // --- Cache lifecycle ---
-
-  const enableCache = (filePath: string): void => {
-    cacheFile = filePath;
-    if (!cache) cache = new Map();
-    else cache.clear();
-  };
-
-  const clearCache = (): void => {
-    cacheFile = null;
-    // Reuse the Map instance — just clear entries to reduce GC pressure at scale.
-    cache?.clear();
-  };
-
-  const getStats = () => ({
-    ...symbols.getStats(),
-    cacheHits,
-    cacheMisses,
-  });
-
-  const clear = (): void => {
-    symbols.clear();
-    importMap.clear();
-    packageMap.clear();
-    namedImportMap.clear();
-    clearCache();
-    cacheHits = 0;
-    cacheMisses = 0;
-  };
-
-  return {
-    resolve,
-    symbols,
-    importMap,
-    packageMap,
-    namedImportMap,
-    enableCache,
-    clearCache,
-    getStats,
-    clear,
-  };
-};
@@ -1,128 +0,0 @@
-/**
- * C# namespace import resolution.
- * Handles using-directive resolution via .csproj root namespace stripping.
- */
-
-import type { SuffixIndex } from './utils.js';
-import { suffixResolve } from './utils.js';
-
-/** C# project config parsed from .csproj files */
-export interface CSharpProjectConfig {
-  /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
-  rootNamespace: string;
-  /** Directory containing the .csproj file */
-  projectDir: string;
-}
-
-/**
- * Resolve a C# using-directive import path to matching .cs files.
- * Tries single-file match first, then directory match for namespace imports.
- */
-export function resolveCSharpImport(
-  importPath: string,
-  csharpConfigs: CSharpProjectConfig[],
-  normalizedFileList: string[],
-  allFileList: string[],
-  index?: SuffixIndex,
-): string[] {
-  const namespacePath = importPath.replace(/\./g, '/');
-  const results: string[] = [];
-
-  for (const config of csharpConfigs) {
-    const nsPath = config.rootNamespace.replace(/\./g, '/');
-    let relative: string;
-    if (namespacePath.startsWith(nsPath + '/')) {
-      relative = namespacePath.slice(nsPath.length + 1);
-    } else if (namespacePath === nsPath) {
-      // The import IS the root namespace — resolve to all .cs files in project root
-      relative = '';
-    } else {
-      continue;
-    }
-
-    const dirPrefix = config.projectDir
-      ? (relative ? config.projectDir + '/' + relative : config.projectDir)
-      : relative;
-
-    // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs")
-    if (relative) {
-      const candidate = dirPrefix + '.cs';
-      if (index) {
-        const result = index.get(candidate) || index.getInsensitive(candidate);
-        if (result) return [result];
-      }
-      // Also try suffix match
-      const suffixResult = index?.get(relative + '.cs') || index?.getInsensitive(relative + '.cs');
-      if (suffixResult) return [suffixResult];
-    }
-
-    // 2. Try as directory: all .cs files directly inside (namespace import)
-    if (index) {
-      const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
-      for (const f of dirFiles) {
-        const normalized = f.replace(/\\/g, '/');
-        // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes
-        const prefixIdx = normalized.indexOf(dirPrefix + '/');
-        if (prefixIdx < 0) continue;
-        const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1);
-        if (!afterDir.includes('/')) {
-          results.push(f);
-        }
-      }
-      if (results.length > 0) return results;
-    }
-
-    // 3. Linear scan fallback for directory matching
-    if (results.length === 0) {
-      const dirTrail = dirPrefix + '/';
-      for (let i = 0; i < normalizedFileList.length; i++) {
-        const normalized = normalizedFileList[i];
-        if (!normalized.endsWith('.cs')) continue;
-        const prefixIdx = normalized.indexOf(dirTrail);
-        if (prefixIdx < 0) continue;
-        const afterDir = normalized.substring(prefixIdx + dirTrail.length);
-        if (!afterDir.includes('/')) {
-          results.push(allFileList[i]);
-        }
-      }
-      if (results.length > 0) return results;
-    }
-  }
-
-  // Fallback: suffix matching without namespace stripping (single file)
-  const pathParts = namespacePath.split('/').filter(Boolean);
-  const fallback = suffixResolve(pathParts, normalizedFileList, allFileList, index);
-  return fallback ? [fallback] : [];
-}
-
-/**
- * Compute the directory suffix for a C# namespace import (for PackageMap).
- * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
- */
-export function resolveCSharpNamespaceDir(
-  importPath: string,
-  csharpConfigs: CSharpProjectConfig[],
-): string | null {
-  const namespacePath = importPath.replace(/\./g, '/');
-
-  for (const config of csharpConfigs) {
-    const nsPath = config.rootNamespace.replace(/\./g, '/');
-    let relative: string;
-    if (namespacePath.startsWith(nsPath + '/')) {
-      relative = namespacePath.slice(nsPath.length + 1);
-    } else if (namespacePath === nsPath) {
-      relative = '';
-    } else {
-      continue;
-    }
-
-    const dirPrefix = config.projectDir
-      ? (relative ? config.projectDir + '/' + relative : config.projectDir)
-      : relative;
-
-    if (!dirPrefix) continue;
-    return '/' + dirPrefix + '/';
-  }
-
-  return null;
-}
@@ -1,58 +0,0 @@
-/**
- * Go package import resolution.
- * Handles Go module path-based package imports.
- */
-
-/** Go module config parsed from go.mod */
-export interface GoModuleConfig {
-  /** Module path (e.g., "github.com/user/repo") */
-  modulePath: string;
-}
-
-/**
- * Extract the package directory suffix from a Go import path.
- * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
- */
-export function resolveGoPackageDir(
-  importPath: string,
-  goModule: GoModuleConfig,
-): string | null {
-  if (!importPath.startsWith(goModule.modulePath)) return null;
-  const relativePkg = importPath.slice(goModule.modulePath.length + 1);
-  if (!relativePkg) return null;
-  return '/' + relativePkg + '/';
-}
-
-/**
- * Resolve a Go internal package import to all .go files in the package directory.
- * Returns an array of file paths.
- */
-export function resolveGoPackage(
-  importPath: string,
-  goModule: GoModuleConfig,
-  normalizedFileList: string[],
-  allFileList: string[],
-): string[] {
-  if (!importPath.startsWith(goModule.modulePath)) return [];
-
-  // Strip module path to get relative package path
-  const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth"
-  if (!relativePkg) return [];
-
-  const pkgSuffix = '/' + relativePkg + '/';
-  const matches: string[] = [];
-
-  for (let i = 0; i < normalizedFileList.length; i++) {
-    // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
-    const normalized = '/' + normalizedFileList[i];
-    // File must be directly in the package directory (not a subdirectory)
-    if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) {
-      const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
-      if (!afterPkg.includes('/')) {
-        matches.push(allFileList[i]);
-      }
-    }
-  }
-
-  return matches;
-}
@@ -1,25 +0,0 @@
-/**
- * Language-specific import resolvers.
- * Extracted from import-processor.ts for maintainability.
- */
-
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
-export type { SuffixIndex } from './utils.js';
-
-export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
-
-export { resolveGoPackageDir, resolveGoPackage } from './go.js';
-export type { GoModuleConfig } from './go.js';
-
-export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
-export type { CSharpProjectConfig } from './csharp.js';
-
-export { resolvePhpImport } from './php.js';
-export type { ComposerConfig } from './php.js';
-
-export { resolveRustImport, tryRustModulePath } from './rust.js';
-
-export { resolveRubyImport } from './ruby.js';
-
-export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';
-export type { TsconfigPaths } from './standard.js';
@@ -1,106 +0,0 @@
-/**
- * JVM import resolution (Java + Kotlin).
- * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
- */
-
-import type { SuffixIndex } from './utils.js';
-
-/** Kotlin file extensions for JVM resolver reuse */
-export const KOTLIN_EXTENSIONS: readonly string[] = ['.kt', '.kts'];
-
-/**
- * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
- * Pure function — returns a new string without mutating the input.
- */
-export const appendKotlinWildcard = (importPath: string, importNode: any): string => {
-  for (let i = 0; i < importNode.childCount; i++) {
-    if (importNode.child(i)?.type === 'wildcard_import') {
-      return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
-    }
-  }
-  return importPath;
-};
-
-/**
- * Resolve a JVM wildcard import (com.example.*) to all matching files.
- * Works for both Java (.java) and Kotlin (.kt, .kts).
- */
-export function resolveJvmWildcard(
-  importPath: string,
-  normalizedFileList: string[],
-  allFileList: string[],
-  extensions: readonly string[],
-  index?: SuffixIndex,
-): string[] {
-  // "com.example.util.*" -> "com/example/util"
-  const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
-
-  if (index) {
-    const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
-    // Filter to only direct children (no subdirectories)
-    const packageSuffix = '/' + packagePath + '/';
-    return candidates.filter(f => {
-      const normalized = f.replace(/\\/g, '/');
-      const idx = normalized.indexOf(packageSuffix);
-      if (idx < 0) return false;
-      const afterPkg = normalized.substring(idx + packageSuffix.length);
-      return !afterPkg.includes('/');
-    });
-  }
-
-  // Fallback: linear scan
-  const packageSuffix = '/' + packagePath + '/';
-  const matches: string[] = [];
-  for (let i = 0; i < normalizedFileList.length; i++) {
-    const normalized = normalizedFileList[i];
-    if (normalized.includes(packageSuffix) &&
-        extensions.some(ext => normalized.endsWith(ext))) {
-      const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length);
-      if (!afterPackage.includes('/')) {
-        matches.push(allFileList[i]);
-      }
-    }
-  }
-  return matches;
-}
-
-/**
- * Try to resolve a JVM member/static import by stripping the member name.
- * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
- * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
- */
-export function resolveJvmMemberImport(
-  importPath: string,
-  normalizedFileList: string[],
-  allFileList: string[],
-  extensions: readonly string[],
-  index?: SuffixIndex,
-): string | null {
-  // Member imports: com.example.Constants.VALUE or com.example.Constants.*
-  // The last segment is a member name if it starts with lowercase, is ALL_CAPS, or is a wildcard
-  const segments = importPath.split('.');
-  if (segments.length < 3) return null;
-
-  const lastSeg = segments[segments.length - 1];
-  if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) {
-    const classPath = segments.slice(0, -1).join('/');
-
-    for (const ext of extensions) {
-      const classSuffix = classPath + ext;
-      if (index) {
-        const result = index.get(classSuffix) || index.getInsensitive(classSuffix);
-        if (result) return result;
-      } else {
-        const fullSuffix = '/' + classSuffix;
-        for (let i = 0; i < normalizedFileList.length; i++) {
-          if (normalizedFileList[i].endsWith(fullSuffix) ||
-              normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) {
-            return allFileList[i];
-          }
-        }
-      }
-    }
-  }
-
-  return null;
-}
@@ -1,51 +0,0 @@
-/**
- * PHP PSR-4 import resolution.
- * Handles use-statement resolution via composer.json autoload mappings.
- */
-
-import type { SuffixIndex } from './utils.js';
-import { suffixResolve } from './utils.js';
-
-/** PHP Composer PSR-4 autoload config */
-export interface ComposerConfig {
-  /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
-  psr4: Map<string, string>;
-}
-
-/**
- * Resolve a PHP use-statement import path using PSR-4 mappings.
- * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
- */
-export function resolvePhpImport(
-  importPath: string,
-  composerConfig: ComposerConfig | null,
-  allFiles: Set<string>,
-  normalizedFileList: string[],
-  allFileList: string[],
-  index?: SuffixIndex,
-): string | null {
-  // Normalize: replace backslashes with forward slashes
-  const normalized = importPath.replace(/\\/g, '/');
-
-  // Try PSR-4 resolution if composer.json was found
-  if (composerConfig) {
-    // Sort namespaces by length descending (longest match wins)
-    const sorted = [...composerConfig.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
-    for (const [nsPrefix, dirPrefix] of sorted) {
-      const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
-      if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
-        const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
-        const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
-        if (allFiles.has(filePath)) return filePath;
-        if (index) {
-          const result = index.getInsensitive(filePath);
-          if (result) return result;
-        }
-      }
-    }
-  }
-
-  // Fallback: suffix matching (works without composer.json)
-  const pathParts = normalized.split('/').filter(Boolean);
-  return suffixResolve(pathParts, normalizedFileList, allFileList, index);
-}
@@ -1,23 +0,0 @@
-/**
- * Ruby require/require_relative import resolution.
- * Handles path resolution for Ruby's require and require_relative calls.
- */
-
-import type { SuffixIndex } from './utils.js';
-import { suffixResolve } from './utils.js';
-
-/**
- * Resolve a Ruby require/require_relative path to a matching .rb file.
- *
- * require_relative paths are pre-normalized to './' prefix by the caller.
- * require paths use suffix matching (gem-style paths like 'json', 'net/http').
- */
-export function resolveRubyImport(
-  importPath: string,
-  normalizedFileList: string[],
-  allFileList: string[],
-  index?: SuffixIndex,
-): string | null {
-  const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
-  return suffixResolve(pathParts, normalizedFileList, allFileList, index);
-}
@@ -1,82 +0,0 @@
-/**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
- */
-
-/**
- * Resolve Rust use-path to a file.
- * Handles crate::, super::, self:: prefixes and :: path separators.
- */
-export function resolveRustImport(
-  currentFile: string,
-  importPath: string,
-  allFiles: Set<string>,
-): string | null {
-  let rustPath: string;
-
-  if (importPath.startsWith('crate::')) {
-    // crate:: resolves from src/ directory (standard Rust layout)
-    rustPath = importPath.slice(7).replace(/::/g, '/');
-
-    // Try from src/ (standard layout)
-    const fromSrc = tryRustModulePath('src/' + rustPath, allFiles);
-    if (fromSrc) return fromSrc;
-
-    // Try from repo root (non-standard)
-    const fromRoot = tryRustModulePath(rustPath, allFiles);
-    if (fromRoot) return fromRoot;
-
-    return null;
-  }
-
-  if (importPath.startsWith('super::')) {
-    // super:: = parent directory of current file's module
-    const currentDir = currentFile.split('/').slice(0, -1);
-    currentDir.pop(); // Go up one level for super::
-    rustPath = importPath.slice(7).replace(/::/g, '/');
-    const fullPath = [...currentDir, rustPath].join('/');
-    return tryRustModulePath(fullPath, allFiles);
-  }
-
-  if (importPath.startsWith('self::')) {
-    // self:: = current module's directory
-    const currentDir = currentFile.split('/').slice(0, -1);
-    rustPath = importPath.slice(6).replace(/::/g, '/');
-    const fullPath = [...currentDir, rustPath].join('/');
-    return tryRustModulePath(fullPath, allFiles);
-  }
-
-  // Bare path without prefix (e.g., from a use in a nested module)
-  // Convert :: to / and try suffix matching
-  if (importPath.includes('::')) {
-    rustPath = importPath.replace(/::/g, '/');
-    return tryRustModulePath(rustPath, allFiles);
-  }
-
-  return null;
-}
-
-/**
- * Try to resolve a Rust module path to a file.
- * Tries: path.rs, path/mod.rs, and with the last segment stripped
- * (last segment might be a symbol name, not a module).
- */
-export function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null {
-  // Try direct: path.rs
-  if (allFiles.has(modulePath + '.rs')) return modulePath + '.rs';
-  // Try directory: path/mod.rs
-  if (allFiles.has(modulePath + '/mod.rs')) return modulePath + '/mod.rs';
-  // Try path/lib.rs (for crate root)
-  if (allFiles.has(modulePath + '/lib.rs')) return modulePath + '/lib.rs';
-
-  // The last segment might be a symbol (function, struct, etc.), not a module.
-  // Strip it and try again.
-  const lastSlash = modulePath.lastIndexOf('/');
-  if (lastSlash > 0) {
-    const parentPath = modulePath.substring(0, lastSlash);
-    if (allFiles.has(parentPath + '.rs')) return parentPath + '.rs';
-    if (allFiles.has(parentPath + '/mod.rs')) return parentPath + '/mod.rs';
-  }
-
-  return null;
-}
@@ -1,177 +0,0 @@
-/**
- * Standard import path resolution.
- * Handles relative imports, path alias rewriting, and generic suffix matching.
- * Used as the fallback when language-specific resolvers don't match.
- */
-
-import type { SuffixIndex } from './utils.js';
-import { tryResolveWithExtensions, suffixResolve } from './utils.js';
-import { resolveRustImport } from './rust.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-
-/** TypeScript path alias config parsed from tsconfig.json */
-export interface TsconfigPaths {
-  /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
-  aliases: Map<string, string>;
-  /** Base URL for path resolution (relative to repo root) */
-  baseUrl: string;
-}
-
-/** Max entries in the resolve cache. Beyond this, entries are evicted.
- *  100K entries ≈ 15MB — covers the most common import patterns. */
-export const RESOLVE_CACHE_CAP = 100_000;
-
-/**
- * Resolve an import path to a file path in the repository.
- *
- * Language-specific preprocessing is applied before the generic resolution:
- * - TypeScript/JavaScript: rewrites tsconfig path aliases
- * - Rust: converts crate::/super::/self:: to relative paths
- *
- * Java wildcards and Go package imports are handled separately in processImports
- * because they resolve to multiple files.
- */
-export const resolveImportPath = (
-  currentFile: string,
-  importPath: string,
-  allFiles: Set<string>,
-  allFileList: string[],
-  normalizedFileList: string[],
-  resolveCache: Map<string, string | null>,
-  language: SupportedLanguages,
-  tsconfigPaths: TsconfigPaths | null,
-  index?: SuffixIndex,
-): string | null => {
-  const cacheKey = `${currentFile}::${importPath}`;
-  if (resolveCache.has(cacheKey)) return resolveCache.get(cacheKey) ?? null;
-
-  const cache = (result: string | null): string | null => {
-    // Evict oldest 20% when cap is reached instead of clearing all
-    if (resolveCache.size >= RESOLVE_CACHE_CAP) {
-      const evictCount = Math.floor(RESOLVE_CACHE_CAP * 0.2);
-      const iter = resolveCache.keys();
-      for (let i = 0; i < evictCount; i++) {
-        const key = iter.next().value;
-        if (key !== undefined) resolveCache.delete(key);
-      }
-    }
-    resolveCache.set(cacheKey, result);
-    return result;
-  };
-
-  // ---- TypeScript/JavaScript: rewrite path aliases ----
-  if (
-    (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) &&
-    tsconfigPaths &&
-    !importPath.startsWith('.')
-  ) {
-    for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) {
-      if (importPath.startsWith(aliasPrefix)) {
-        const remainder = importPath.slice(aliasPrefix.length);
-        // Build the rewritten path relative to baseUrl
-        const rewritten = tsconfigPaths.baseUrl === '.'
-          ? targetPrefix + remainder
-          : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder;
-
-        // Try direct resolution from repo root
-        const resolved = tryResolveWithExtensions(rewritten, allFiles);
-        if (resolved) return cache(resolved);
-
-        // Try suffix matching as fallback
-        const parts = rewritten.split('/').filter(Boolean);
-        const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index);
-        if (suffixResult) return cache(suffixResult);
-      }
-    }
-  }
-
-  // ---- Rust: convert module path syntax to file paths ----
-  if (language === SupportedLanguages.Rust) {
-    // Handle grouped imports: use crate::module::{Foo, Bar, Baz}
-    // Extract the prefix path before ::{...} and resolve the module, not the symbols
-    let rustImportPath = importPath;
-    const braceIdx = importPath.indexOf('::{');
-    if (braceIdx !== -1) {
-      rustImportPath = importPath.substring(0, braceIdx);
-    } else if (importPath.startsWith('{') && importPath.endsWith('}')) {
-      // Top-level grouped imports: use {crate::a, crate::b}
-      // Iterate each part and return the first that resolves. This function returns a single
-      // string, so callers that need ALL edges must intercept before reaching here (see the
-      // Rust grouped-import blocks in processImports / processImportsBatch). This fallback
-      // handles any path that reaches resolveImportPath directly.
-      const inner = importPath.slice(1, -1);
-      const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
-      for (const part of parts) {
-        const partResult = resolveRustImport(currentFile, part, allFiles);
-        if (partResult) return cache(partResult);
-      }
-      return cache(null);
-    }
-
-    const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles);
-    if (rustResult) return cache(rustResult);
-    // Fall through to generic resolution if Rust-specific didn't match
-  }
-
-  // ---- Python relative imports (PEP 328): .module, ..module, ... ----
-  if (language === SupportedLanguages.Python && importPath.startsWith('.')) {
-    const dotMatch = importPath.match(/^(\.+)(.*)/);
-    if (dotMatch) {
-      const dotCount = dotMatch[1].length;
-      const modulePart = dotMatch[2]; // e.g., "models" from ".models"
-      const dirParts = currentFile.split('/').slice(0, -1); // remove filename
-
-      // Navigate up: 1 dot = same package, 2 dots = parent package, etc.
-      // First dot means "current package", each additional dot goes up one level
-      for (let i = 1; i < dotCount; i++) {
-        dirParts.pop();
-      }
-
-      if (modulePart) {
-        // from .models import User → resolve "models" relative to current package
-        const modulePath = modulePart.replace(/\./g, '/');
-        dirParts.push(...modulePath.split('/'));
-      }
-
-      const basePath = dirParts.join('/');
-      const resolved = tryResolveWithExtensions(basePath, allFiles);
-      return cache(resolved);
-    }
-  }
-
-  // ---- Generic relative import resolution (./ and ../) ----
-  const currentDir = currentFile.split('/').slice(0, -1);
-  const parts = importPath.split('/');
-
-  for (const part of parts) {
-    if (part === '.') continue;
-    if (part === '..') {
-      currentDir.pop();
-    } else {
-      currentDir.push(part);
-    }
-  }
-
-  const basePath = currentDir.join('/');
-
-  if (importPath.startsWith('.')) {
-    const resolved = tryResolveWithExtensions(basePath, allFiles);
-    return cache(resolved);
-  }
-
-  // ---- Generic package/absolute import resolution (suffix matching) ----
-  // Java wildcards are handled in processImports, not here
-  if (importPath.endsWith('.*')) {
-    return cache(null);
-  }
-
-  // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes
-  const isCpp = language === SupportedLanguages.C || language === SupportedLanguages.CPlusPlus;
-  const pathLike = importPath.includes('/') || isCpp
-    ? importPath
-    : importPath.replace(/\./g, '/');
-  const pathParts = pathLike.split('/').filter(Boolean);
-
-  const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
-  return cache(resolved);
-};
@@ -1,158 +0,0 @@
-/**
- * Shared utilities for import resolution.
- * Extracted from import-processor.ts to reduce file size.
- */
-
-/** All file extensions to try during resolution */
-export const EXTENSIONS = [
-  '',
-  // TypeScript/JavaScript
-  '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js',
-  // Python
-  '.py', '/__init__.py',
-  // Java
-  '.java',
-  // Kotlin
-  '.kt', '.kts',
-  // C/C++
-  '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh',
-  // C#
-  '.cs',
-  // Go
-  '.go',
-  // Rust
-  '.rs', '/mod.rs',
-  // PHP
-  '.php', '.phtml',
-  // Swift
-  '.swift',
-  // Ruby
-  '.rb',
-];
-
-/**
- * Try to match a path (with extensions) against the known file set.
- * Returns the matched file path or null.
- */
-export function tryResolveWithExtensions(
-  basePath: string,
-  allFiles: Set<string>,
-): string | null {
-  for (const ext of EXTENSIONS) {
-    const candidate = basePath + ext;
-    if (allFiles.has(candidate)) return candidate;
-  }
-  return null;
-}
-
-/**
- * Build a suffix index for O(1) endsWith lookups.
- * Maps every possible path suffix to its original file path.
- * e.g. for "src/com/example/Foo.java":
- *   "Foo.java" -> "src/com/example/Foo.java"
- *   "example/Foo.java" -> "src/com/example/Foo.java"
- *   "com/example/Foo.java" -> "src/com/example/Foo.java"
- *   etc.
- */
-export interface SuffixIndex {
-  /** Exact suffix lookup (case-sensitive) */
-  get(suffix: string): string | undefined;
-  /** Case-insensitive suffix lookup */
-  getInsensitive(suffix: string): string | undefined;
-  /** Get all files in a directory suffix */
-  getFilesInDir(dirSuffix: string, extension: string): string[];
-}
-
-export function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex {
-  // Map: normalized suffix -> original file path
-  const exactMap = new Map<string, string>();
-  // Map: lowercase suffix -> original file path
-  const lowerMap = new Map<string, string>();
-  // Map: directory suffix -> list of file paths in that directory
-  const dirMap = new Map<string, string[]>();
-
-  for (let i = 0; i < normalizedFileList.length; i++) {
-    const normalized = normalizedFileList[i];
-    const original = allFileList[i];
-    const parts = normalized.split('/');
-
-    // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"]
-    for (let j = parts.length - 1; j >= 0; j--) {
-      const suffix = parts.slice(j).join('/');
-      // Only store first match (longest path wins for ambiguous suffixes)
-      if (!exactMap.has(suffix)) {
-        exactMap.set(suffix, original);
-      }
-      const lower = suffix.toLowerCase();
-      if (!lowerMap.has(lower)) {
-        lowerMap.set(lower, original);
-      }
-    }
-
-    // Index directory membership
-    const lastSlash = normalized.lastIndexOf('/');
-    if (lastSlash >= 0) {
-      // Build all directory suffixes
-      const dirParts = parts.slice(0, -1);
-      const fileName = parts[parts.length - 1];
-      const ext = fileName.substring(fileName.lastIndexOf('.'));
-
-      for (let j = dirParts.length - 1; j >= 0; j--) {
-        const dirSuffix = dirParts.slice(j).join('/');
-        const key = `${dirSuffix}:${ext}`;
-        let list = dirMap.get(key);
-        if (!list) {
-          list = [];
-          dirMap.set(key, list);
-        }
-        list.push(original);
-      }
-    }
-  }
-
-  return {
-    get: (suffix: string) => exactMap.get(suffix),
-    getInsensitive: (suffix: string) => lowerMap.get(suffix.toLowerCase()),
-    getFilesInDir: (dirSuffix: string, extension: string) => {
-      return dirMap.get(`${dirSuffix}:${extension}`) || [];
-    },
-  };
-}
-
-/**
- * Suffix-based resolution using index. O(1) per lookup instead of O(files).
- */
-export function suffixResolve(
-  pathParts: string[],
-  normalizedFileList: string[],
-  allFileList: string[],
-  index?: SuffixIndex,
-): string | null {
-  if (index) {
-    for (let i = 0; i < pathParts.length; i++) {
-      const suffix = pathParts.slice(i).join('/');
-      for (const ext of EXTENSIONS) {
-        const suffixWithExt = suffix + ext;
-        const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt);
-        if (result) return result;
-      }
-    }
-    return null;
-  }
-
-  // Fallback: linear scan (for backward compatibility)
-  for (let i = 0; i < pathParts.length; i++) {
-    const suffix = pathParts.slice(i).join('/');
-    for (const ext of EXTENSIONS) {
-      const suffixWithExt = suffix + ext;
-      const suffixPattern = '/' + suffixWithExt;
-      const matchIdx = normalizedFileList.findIndex(filePath =>
-        filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase())
-      );
-      if (matchIdx !== -1) {
-        return allFileList[matchIdx];
-      }
-    }
-  }
-  return null;
-}
@@ -2,24 +2,13 @@ export interface SymbolDefinition {
  nodeId: string;
  filePath: string;
  type: string; // 'Function', 'Class', etc.
-  parameterCount?: number;
-  /** Raw return type text extracted from AST (e.g. 'User', 'Promise<User>') */
-  returnType?: string;
-  /** Links Method/Constructor to owning Class/Struct/Trait nodeId */
-  ownerId?: string;
 }

 export interface SymbolTable {
  /**
   * Register a new symbol definition
   */
-  add: (
-    filePath: string,
-    name: string,
-    nodeId: string,
-    type: string,
-    metadata?: { parameterCount?: number; returnType?: string; ownerId?: string }
-  ) => void;
+  add: (filePath: string, name: string, nodeId: string, type: string) => void;
  
  /**
   * High Confidence: Look for a symbol specifically inside a file
@@ -27,12 +16,6 @@ export interface SymbolTable {
   */
  lookupExact: (filePath: string, name: string) => string | undefined;
  
-  /**
-   * High Confidence: Look for a symbol in a specific file, returning full definition.
-   * Includes type information needed for heritage resolution (Class vs Interface).
-   */
-  lookupExactFull: (filePath: string, name: string) => SymbolDefinition | undefined;
-
  /**
   * Low Confidence: Look for a symbol anywhere in the project
   * Used when imports are missing or for framework magic
@@ -51,49 +34,32 @@ export interface SymbolTable {
 }

 export const createSymbolTable = (): SymbolTable => {
-  // 1. File-Specific Index — stores full SymbolDefinition for O(1) lookupExactFull
-  // Structure: FilePath -> (SymbolName -> SymbolDefinition)
-  const fileIndex = new Map<string, Map<string, SymbolDefinition>>();
+  // 1. File-Specific Index (The "Good" one)
+  // Structure: FilePath -> (SymbolName -> NodeID)
+  const fileIndex = new Map<string, Map<string, string>>();

  // 2. Global Reverse Index (The "Backup")
  // Structure: SymbolName -> [List of Definitions]
  const globalIndex = new Map<string, SymbolDefinition[]>();

-  const add = (
-    filePath: string,
-    name: string,
-    nodeId: string,
-    type: string,
-    metadata?: { parameterCount?: number; returnType?: string; ownerId?: string }
-  ) => {
-    const def: SymbolDefinition = {
-      nodeId,
-      filePath,
-      type,
-      ...(metadata?.parameterCount !== undefined ? { parameterCount: metadata.parameterCount } : {}),
-      ...(metadata?.returnType !== undefined ? { returnType: metadata.returnType } : {}),
-      ...(metadata?.ownerId !== undefined ? { ownerId: metadata.ownerId } : {}),
-    };
-
-    // A. Add to File Index (shared reference — zero additional memory)
+  const add = (filePath: string, name: string, nodeId: string, type: string) => {
+    // A. Add to File Index
    if (!fileIndex.has(filePath)) {
      fileIndex.set(filePath, new Map());
    }
-    fileIndex.get(filePath)!.set(name, def);
+    fileIndex.get(filePath)!.set(name, nodeId);

-    // B. Add to Global Index (same object reference)
+    // B. Add to Global Index
    if (!globalIndex.has(name)) {
      globalIndex.set(name, []);
    }
-    globalIndex.get(name)!.push(def);
+    globalIndex.get(name)!.push({ nodeId, filePath, type });
  };

  const lookupExact = (filePath: string, name: string): string | undefined => {
-    return fileIndex.get(filePath)?.get(name)?.nodeId;
-  };
-
-  const lookupExactFull = (filePath: string, name: string): SymbolDefinition | undefined => {
-    return fileIndex.get(filePath)?.get(name);
+    const fileSymbols = fileIndex.get(filePath);
+    if (!fileSymbols) return undefined;
+    return fileSymbols.get(name);
  };

  const lookupFuzzy = (name: string): SymbolDefinition[] => {
@@ -110,5 +76,5 @@ export const createSymbolTable = (): SymbolTable => {
    globalIndex.clear();
  };

-  return { add, lookupExact, lookupExactFull, lookupFuzzy, getStats, clear };
-};
+  return { add, lookupExact, lookupFuzzy, getStats, clear };
+};
@@ -47,10 +47,6 @@ export const TYPESCRIPT_QUERIES = `
 (import_statement
  source: (string) @import.source) @import

-; Re-export statements: export { X } from './y'
-(export_statement
-  source: (string) @import.source) @import
-
 (call_expression
  function: (identifier) @call.name) @call

@@ -58,10 +54,6 @@ export const TYPESCRIPT_QUERIES = `
  function: (member_expression
    property: (property_identifier) @call.name)) @call

-; Constructor calls: new Foo()
-(new_expression
-  constructor: (identifier) @call.name) @call
-
 ; Heritage queries - class extends
 (class_declaration
  name: (type_identifier) @heritage.class
@@ -77,7 +69,7 @@ export const TYPESCRIPT_QUERIES = `
      (type_identifier) @heritage.implements))) @heritage.impl
 `;

-// JavaScript queries - works with tree-sitter-javascript
+// JavaScript queries - works with tree-sitter-javascript  
 export const JAVASCRIPT_QUERIES = `
 (class_declaration
  name: (identifier) @name) @definition.class
@@ -113,10 +105,6 @@ export const JAVASCRIPT_QUERIES = `
 (import_statement
  source: (string) @import.source) @import

-; Re-export statements: export { X } from './y'
-(export_statement
-  source: (string) @import.source) @import
-
 (call_expression
  function: (identifier) @call.name) @call

@@ -124,10 +112,6 @@ export const JAVASCRIPT_QUERIES = `
  function: (member_expression
    property: (property_identifier) @call.name)) @call

-; Constructor calls: new Foo()
-(new_expression
-  constructor: (identifier) @call.name) @call
-
 ; Heritage queries - class extends (JavaScript uses different AST than TypeScript)
 ; In tree-sitter-javascript, class_heritage directly contains the parent identifier
 (class_declaration
@@ -150,9 +134,6 @@ export const PYTHON_QUERIES = `
 (import_from_statement
  module_name: (dotted_name) @import.source) @import

-(import_from_statement
-  module_name: (relative_import) @import.source) @import
-
 (call
  function: (identifier) @call.name) @call

@@ -160,6 +141,13 @@ export const PYTHON_QUERIES = `
  function: (attribute
    attribute: (identifier) @call.name)) @call

+; Module-level singleton instances: service = ServiceClass()
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @name
+      right: (call))) @definition.instance)
+
 ; Heritage queries - Python class inheritance
 (class_definition
  name: (identifier) @heritage.class
@@ -186,9 +174,6 @@ export const JAVA_QUERIES = `
 (method_invocation name: (identifier) @call.name) @call
 (method_invocation object: (_) name: (identifier) @call.name) @call

-; Constructor calls: new Foo()
-(object_creation_expression type: (type_identifier) @call.name) @call
-
 ; Heritage - extends class
 (class_declaration name: (identifier) @heritage.class
  (superclass (type_identifier) @heritage.extends)) @heritage
@@ -200,17 +185,10 @@ export const JAVA_QUERIES = `

 // C queries - works with tree-sitter-c
 export const C_QUERIES = `
-; Functions (direct declarator)
+; Functions
 (function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
 (declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function

-; Functions returning pointers (pointer_declarator wraps function_declarator)
-(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function
-(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function
-
-; Functions returning double pointers (nested pointer_declarator)
-(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function
-
 ; Structs, Unions, Enums, Typedefs
 (struct_specifier name: (type_identifier) @name) @definition.struct
 (union_specifier name: (type_identifier) @name) @definition.union
@@ -238,26 +216,15 @@ export const GO_QUERIES = `
 ; Types
 (type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct
 (type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface
+(type_declaration (type_spec name: (type_identifier) @name)) @definition.type

 ; Imports
 (import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import
 (import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import

-; Struct embedding (anonymous fields = inheritance)
-(type_declaration
-  (type_spec
-    name: (type_identifier) @heritage.class
-    type: (struct_type
-      (field_declaration_list
-        (field_declaration
-          type: (type_identifier) @heritage.extends))))) @definition.struct
-
 ; Calls
 (call_expression function: (identifier) @call.name) @call
 (call_expression function: (selector_expression field: (field_identifier) @call.name)) @call
-
-; Struct literal construction: User{Name: "Alice"}
-(composite_literal type: (type_identifier) @call.name) @call
 `;

 // C++ queries - works with tree-sitter-cpp
@@ -268,46 +235,10 @@ export const CPP_QUERIES = `
 (namespace_definition name: (namespace_identifier) @name) @definition.namespace
 (enum_specifier name: (type_identifier) @name) @definition.enum

-; Typedefs and unions (common in C-style headers and mixed C/C++ code)
-(type_definition declarator: (type_identifier) @name) @definition.typedef
-(union_specifier name: (type_identifier) @name) @definition.union
-
-; Macros
-(preproc_function_def name: (identifier) @name) @definition.macro
-(preproc_def name: (identifier) @name) @definition.macro
-
-; Functions & Methods (direct declarator)
+; Functions & Methods
 (function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
 (function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method

-; Functions/methods returning pointers (pointer_declarator wraps function_declarator)
-(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function
-(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method
-
-; Functions/methods returning double pointers (nested pointer_declarator)
-(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function
-(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method
-
-; Functions/methods returning references (reference_declarator wraps function_declarator)
-(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function
-(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method
-
-; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp)
-(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method
-
-; Function declarations / prototypes (common in headers)
-(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function
-(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function
-
-; Inline class method declarations (inside class body, no body: void Foo();)
-(field_declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.method
-
-; Inline class method definitions (inside class body, with body: void Foo() { ... })
-(field_declaration_list
-  (function_definition
-    declarator: (function_declarator
-      declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method)
-
 ; Templates
 (template_declaration (class_specifier name: (type_identifier) @name)) @definition.template
 (template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template
@@ -321,9 +252,6 @@ export const CPP_QUERIES = `
 (call_expression function: (qualified_identifier name: (identifier) @call.name)) @call
 (call_expression function: (template_function name: (identifier) @call.name)) @call

-; Constructor calls: new User()
-(new_expression type: (type_identifier) @call.name) @call
-
 ; Heritage
 (class_specifier name: (type_identifier) @heritage.class
  (base_class_clause (type_identifier) @heritage.extends)) @heritage
@@ -341,11 +269,9 @@ export const CSHARP_QUERIES = `
 (record_declaration name: (identifier) @name) @definition.record
 (delegate_declaration name: (identifier) @name) @definition.delegate

-; Namespaces (block form and C# 10+ file-scoped form)
+; Namespaces
 (namespace_declaration name: (identifier) @name) @definition.namespace
 (namespace_declaration name: (qualified_name) @name) @definition.namespace
-(file_scoped_namespace_declaration name: (identifier) @name) @definition.namespace
-(file_scoped_namespace_declaration name: (qualified_name) @name) @definition.namespace

 ; Methods & Properties
 (method_declaration name: (identifier) @name) @definition.method
@@ -353,10 +279,6 @@ export const CSHARP_QUERIES = `
 (constructor_declaration name: (identifier) @name) @definition.constructor
 (property_declaration name: (identifier) @name) @definition.property

-; Primary constructors (C# 12): class User(string name, int age) { }
-(class_declaration name: (identifier) @name (parameter_list) @definition.constructor)
-(record_declaration name: (identifier) @name (parameter_list) @definition.constructor)
-
 ; Using
 (using_directive (qualified_name) @import.source) @import
 (using_directive (identifier) @import.source) @import
@@ -365,24 +287,11 @@ export const CSHARP_QUERIES = `
 (invocation_expression function: (identifier) @call.name) @call
 (invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call

-; Null-conditional method calls: user?.Save()
-; Parses as: invocation_expression → conditional_access_expression → member_binding_expression → identifier
-(invocation_expression
-  function: (conditional_access_expression
-    (member_binding_expression
-      (identifier) @call.name))) @call
-
-; Constructor calls: new Foo() and new Foo { Props }
-(object_creation_expression type: (identifier) @call.name) @call
-
-; Target-typed new (C# 9): User u = new("x", 5)
-(variable_declaration type: (identifier) @call.name (variable_declarator (implicit_object_creation_expression) @call))
-
 ; Heritage
 (class_declaration name: (identifier) @heritage.class
-  (base_list (identifier) @heritage.extends)) @heritage
+  (base_list (simple_base_type (identifier) @heritage.extends))) @heritage
 (class_declaration name: (identifier) @heritage.class
-  (base_list (generic_name (identifier) @heritage.extends))) @heritage
+  (base_list (simple_base_type (generic_name (identifier) @heritage.extends)))) @heritage
 `;

 // Rust queries - works with tree-sitter-rust
@@ -392,8 +301,7 @@ export const RUST_QUERIES = `
 (struct_item name: (type_identifier) @name) @definition.struct
 (enum_item name: (type_identifier) @name) @definition.enum
 (trait_item name: (type_identifier) @name) @definition.trait
-(impl_item type: (type_identifier) @name !trait) @definition.impl
-(impl_item type: (generic_type type: (type_identifier) @name) !trait) @definition.impl
+(impl_item type: (type_identifier) @name) @definition.impl
 (mod_item name: (identifier) @name) @definition.module

 ; Type aliases, const, static, macros
@@ -411,14 +319,9 @@ export const RUST_QUERIES = `
 (call_expression function: (scoped_identifier name: (identifier) @call.name)) @call
 (call_expression function: (generic_function function: (identifier) @call.name)) @call

-; Struct literal construction: User { name: value }
-(struct_expression name: (type_identifier) @call.name) @call
-
-; Heritage (trait implementation) — all combinations of concrete/generic trait × concrete/generic type
+; Heritage (trait implementation)
 (impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage
 (impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage
-(impl_item trait: (type_identifier) @heritage.trait type: (generic_type type: (type_identifier) @heritage.class)) @heritage
-(impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (generic_type type: (type_identifier) @heritage.class)) @heritage
 `;

 // PHP queries - works with tree-sitter-php (php_only grammar)
@@ -480,9 +383,6 @@ export const PHP_QUERIES = `
 (scoped_call_expression
  name: (name) @call.name) @call

-; Constructor call: new User()
-(object_creation_expression (name) @call.name) @call
-
 ; ── Heritage: extends ────────────────────────────────────────────────────────
 (class_declaration
  name: (name) @heritage.class
@@ -503,51 +403,6 @@ export const PHP_QUERIES = `
      [(name) (qualified_name)] @heritage.trait))) @heritage
 `;

-// Ruby queries - works with tree-sitter-ruby
-// NOTE: Ruby uses `call` for require, include, extend, prepend, attr_* etc.
-// These are all captured as @call and routed in JS post-processing:
-//   - require/require_relative → import extraction
-//   - include/extend/prepend → heritage (mixin) extraction
-//   - attr_accessor/attr_reader/attr_writer → property definition extraction
-//   - everything else → regular call extraction
-export const RUBY_QUERIES = `
-; ── Modules ──────────────────────────────────────────────────────────────────
-(module
-  name: (constant) @name) @definition.module
-
-; ── Classes ──────────────────────────────────────────────────────────────────
-(class
-  name: (constant) @name) @definition.class
-
-; ── Instance methods ─────────────────────────────────────────────────────────
-(method
-  name: (identifier) @name) @definition.method
-
-; ── Singleton (class-level) methods ──────────────────────────────────────────
-(singleton_method
-  name: (identifier) @name) @definition.method
-
-; ── All calls (require, include, attr_*, and regular calls routed in JS) ─────
-(call
-  method: (identifier) @call.name) @call
-
-; ── Bare calls without parens (identifiers at statement level are method calls) ─
-; NOTE: This may over-capture variable reads as calls (e.g. 'result' at
-; statement level). Ruby's grammar makes bare identifiers ambiguous — they
-; could be local variables or zero-arity method calls. Post-processing via
-; isBuiltInOrNoise and symbol resolution filtering suppresses most false
-; positives, but a variable name that coincidentally matches a method name
-; elsewhere may produce a false CALLS edge.
-(body_statement
-  (identifier) @call.name @call)
-
-; ── Heritage: class < SuperClass ─────────────────────────────────────────────
-(class
-  name: (constant) @heritage.class
-  superclass: (superclass
-    (constant) @heritage.extends)) @heritage
-`;
-
 // Kotlin queries - works with tree-sitter-kotlin (fwcd/tree-sitter-kotlin)
 // Based on official tags.scm; functions use simple_identifier, classes use type_identifier
 export const KOTLIN_QUERIES = `
@@ -679,11 +534,6 @@ export const SWIFT_QUERIES = `
 ; Heritage - protocol inheritance
 (protocol_declaration name: (type_identifier) @heritage.class
  (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage
-
-; Heritage - extension protocol conformance (e.g. extension Foo: SomeProtocol)
-; Extensions wrap the name in user_type unlike class/struct/enum declarations
-(class_declaration "extension" name: (user_type (type_identifier) @heritage.class)
-  (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage
 `;

 export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = {
@@ -695,7 +545,6 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = {
  [SupportedLanguages.Go]: GO_QUERIES,
  [SupportedLanguages.CPlusPlus]: CPP_QUERIES,
  [SupportedLanguages.CSharp]: CSHARP_QUERIES,
-  [SupportedLanguages.Ruby]: RUBY_QUERIES,
  [SupportedLanguages.Rust]: RUST_QUERIES,
  [SupportedLanguages.PHP]: PHP_QUERIES,
  [SupportedLanguages.Kotlin]: KOTLIN_QUERIES,
@@ -1,381 +0,0 @@
-import type { SyntaxNode } from './utils.js';
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
-import type { ClassNameLookup } from './type-extractors/types.js';
-import { extractSimpleTypeName } from './type-extractors/shared.js';
-import type { SymbolTable } from './symbol-table.js';
-
-/**
- * Per-file scoped type environment: maps (scope, variableName) → typeName.
- * Scope-aware: variables inside functions are keyed by function name,
- * file-level variables use the '' (empty string) scope.
- *
- * Design constraints:
- * - Explicit-only: only type annotations, never inferred types
- * - Scope-aware: function-local variables don't collide across functions
- * - Conservative: complex/generic types extract the base name only
- * - Per-file: built once, used for receiver resolution, then discarded
- */
-export type TypeEnv = Map<string, Map<string, string>>;
-
-/** File-level scope key */
-const FILE_SCOPE = '';
-
-/** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */
-const findTypeIdentifierChild = (node: SyntaxNode): SyntaxNode | null => {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child && child.type === 'type_identifier') return child;
-  }
-  return null;
-};
-
-/**
- * Per-file type environment with receiver resolution.
- * Built once per file via `buildTypeEnv`, used for receiver-type filtering,
- * then discarded. Encapsulates scope-aware type lookup and self/this/super
- * AST resolution behind a single `.lookup()` method.
- */
-export interface TypeEnvironment {
-  /** Look up a variable's resolved type, with self/this/super AST resolution. */
-  lookup(varName: string, callNode: SyntaxNode): string | undefined;
-  /** Unverified cross-file constructor bindings for SymbolTable verification. */
-  readonly constructorBindings: readonly ConstructorBinding[];
-  /** Raw per-scope type bindings — for testing and debugging. */
-  readonly env: TypeEnv;
-}
-
-/** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */
-const lookupInEnv = (
-  env: TypeEnv,
-  varName: string,
-  callNode: SyntaxNode,
-): string | undefined => {
-  // Self/this receiver: resolve to enclosing class name via AST walk
-  if (varName === 'self' || varName === 'this' || varName === '$this') {
-    return findEnclosingClassName(callNode);
-  }
-
-  // Super/base/parent receiver: resolve to the parent class name via AST walk.
-  // Walks up to the enclosing class, then extracts the superclass from its heritage node.
-  if (varName === 'super' || varName === 'base' || varName === 'parent') {
-    return findEnclosingParentClassName(callNode);
-  }
-
-  // Determine the enclosing function scope for the call
-  const scopeKey = findEnclosingScopeKey(callNode);
-
-  // Try function-local scope first
-  if (scopeKey) {
-    const scopeEnv = env.get(scopeKey);
-    if (scopeEnv) {
-      const result = scopeEnv.get(varName);
-      if (result) return result;
-    }
-  }
-
-  // Fall back to file-level scope
-  const fileEnv = env.get(FILE_SCOPE);
-  return fileEnv?.get(varName);
-};
-
-
-/**
- * Walk up the AST from a node to find the enclosing class/module name.
- * Used to resolve `self`/`this` receivers to their containing type.
- */
-const findEnclosingClassName = (node: SyntaxNode): string | undefined => {
-  let current = node.parent;
-  while (current) {
-    if (CLASS_CONTAINER_TYPES.has(current.type)) {
-      const nameNode = current.childForFieldName('name')
-        ?? findTypeIdentifierChild(current);
-      if (nameNode) return nameNode.text;
-    }
-    current = current.parent;
-  }
-  return undefined;
-};
-
-/**
- * Walk up the AST to find the enclosing class, then extract its parent class name
- * from the heritage/superclass AST node. Used to resolve `super`/`base`/`parent`.
- *
- * Supported patterns per tree-sitter grammar:
- * - Java/Ruby: `superclass` field → type_identifier/constant
- * - Python: `superclasses` field → argument_list → first identifier
- * - TypeScript/JS: unnamed `class_heritage` child → `extends_clause` → identifier
- * - C#: unnamed `base_list` child → first identifier
- * - PHP: unnamed `base_clause` child → name
- * - Kotlin: unnamed `delegation_specifier` child → constructor_invocation → user_type → type_identifier
- * - C++: unnamed `base_class_clause` child → type_identifier
- * - Swift: unnamed `inheritance_specifier` child → user_type → type_identifier
- */
-const findEnclosingParentClassName = (node: SyntaxNode): string | undefined => {
-  let current = node.parent;
-  while (current) {
-    if (CLASS_CONTAINER_TYPES.has(current.type)) {
-      return extractParentClassFromNode(current);
-    }
-    current = current.parent;
-  }
-  return undefined;
-};
-
-/** Extract the parent/superclass name from a class declaration AST node. */
-const extractParentClassFromNode = (classNode: SyntaxNode): string | undefined => {
-  // 1. Named fields: Java (superclass), Ruby (superclass), Python (superclasses)
-  const superclassNode = classNode.childForFieldName('superclass');
-  if (superclassNode) {
-    // Java: superclass > type_identifier or generic_type, Ruby: superclass > constant
-    const inner = superclassNode.childForFieldName('type')
-      ?? superclassNode.firstNamedChild
-      ?? superclassNode;
-    return extractSimpleTypeName(inner) ?? inner.text;
-  }
-
-  const superclassesNode = classNode.childForFieldName('superclasses');
-  if (superclassesNode) {
-    // Python: argument_list with identifiers or attribute nodes (e.g. models.Model)
-    const first = superclassesNode.firstNamedChild;
-    if (first) return extractSimpleTypeName(first) ?? first.text;
-  }
-
-  // 2. Unnamed children: walk class node's children looking for heritage nodes
-  for (let i = 0; i < classNode.childCount; i++) {
-    const child = classNode.child(i);
-    if (!child) continue;
-
-    switch (child.type) {
-      // TypeScript: class_heritage > extends_clause > type_identifier
-      // JavaScript: class_heritage > identifier (no extends_clause wrapper)
-      case 'class_heritage': {
-        for (let j = 0; j < child.childCount; j++) {
-          const clause = child.child(j);
-          if (clause?.type === 'extends_clause') {
-            const typeNode = clause.firstNamedChild;
-            if (typeNode) return extractSimpleTypeName(typeNode) ?? typeNode.text;
-          }
-          // JS: direct identifier child (no extends_clause wrapper)
-          if (clause?.type === 'identifier' || clause?.type === 'type_identifier') {
-            return clause.text;
-          }
-        }
-        break;
-      }
-
-      // C#: base_list > identifier or generic_name > identifier
-      case 'base_list': {
-        const first = child.firstNamedChild;
-        if (first) {
-          // generic_name wraps the identifier: BaseClass<T>
-          if (first.type === 'generic_name') {
-            const inner = first.childForFieldName('name') ?? first.firstNamedChild;
-            if (inner) return inner.text;
-          }
-          return first.text;
-        }
-        break;
-      }
-
-      // PHP: base_clause > name
-      case 'base_clause': {
-        const name = child.firstNamedChild;
-        if (name) return name.text;
-        break;
-      }
-
-      // C++: base_class_clause > type_identifier (with optional access_specifier before it)
-      case 'base_class_clause': {
-        for (let j = 0; j < child.childCount; j++) {
-          const inner = child.child(j);
-          if (inner?.type === 'type_identifier') return inner.text;
-        }
-        break;
-      }
-
-      // Kotlin: delegation_specifier > constructor_invocation > user_type > type_identifier
-      case 'delegation_specifier': {
-        const delegate = child.firstNamedChild;
-        if (delegate?.type === 'constructor_invocation') {
-          const userType = delegate.firstNamedChild;
-          if (userType?.type === 'user_type') {
-            const typeId = userType.firstNamedChild;
-            if (typeId) return typeId.text;
-          }
-        }
-        // Also handle plain user_type (interface conformance without parentheses)
-        if (delegate?.type === 'user_type') {
-          const typeId = delegate.firstNamedChild;
-          if (typeId) return typeId.text;
-        }
-        break;
-      }
-
-      // Swift: inheritance_specifier > user_type > type_identifier
-      case 'inheritance_specifier': {
-        const userType = child.childForFieldName('inherits_from') ?? child.firstNamedChild;
-        if (userType?.type === 'user_type') {
-          const typeId = userType.firstNamedChild;
-          if (typeId) return typeId.text;
-        }
-        break;
-      }
-    }
-  }
-
-  return undefined;
-};
-
-/** Find the enclosing function name for scope lookup. */
-const findEnclosingScopeKey = (node: SyntaxNode): string | undefined => {
-  let current = node.parent;
-  while (current) {
-    if (FUNCTION_NODE_TYPES.has(current.type)) {
-      const { funcName } = extractFunctionName(current);
-      if (funcName) return `${funcName}@${current.startIndex}`;
-    }
-    current = current.parent;
-  }
-  return undefined;
-};
-
-/**
- * Create a lookup that checks both local AST class names AND the SymbolTable's
- * global index. This allows extractInitializer functions to distinguish
- * constructor calls from function calls (e.g. Kotlin `User()` vs `getUser()`)
- * using cross-file type information when available.
- *
- * Only `.has()` is exposed — the SymbolTable doesn't support iteration.
- * Results are memoized to avoid redundant lookupFuzzy scans across declarations.
- */
-const createClassNameLookup = (
-  localNames: Set<string>,
-  symbolTable?: SymbolTable,
-): ClassNameLookup => {
-  if (!symbolTable) return localNames;
-
-  const memo = new Map<string, boolean>();
-  return {
-    has(name: string): boolean {
-      if (localNames.has(name)) return true;
-      const cached = memo.get(name);
-      if (cached !== undefined) return cached;
-      const result = symbolTable.lookupFuzzy(name).some(def => def.type === 'Class');
-      memo.set(name, result);
-      return result;
-    },
-  };
-};
-
-/**
- * Build a TypeEnvironment from a tree-sitter AST for a given language.
- * Single-pass: collects class/struct names, type bindings, AND constructor
- * bindings that couldn't be resolved locally — all in one AST walk.
- *
- * When a symbolTable is provided (call-processor path), class names from across
- * the project are available for constructor inference in languages like Kotlin
- * where constructors are syntactically identical to function calls.
- */
-export const buildTypeEnv = (
-  tree: { rootNode: SyntaxNode },
-  language: SupportedLanguages,
-  symbolTable?: SymbolTable,
-): TypeEnvironment => {
-  const env: TypeEnv = new Map();
-  const localClassNames = new Set<string>();
-  const classNames = createClassNameLookup(localClassNames, symbolTable);
-  const config = typeConfigs[language];
-  const bindings: ConstructorBinding[] = [];
-
-  /**
-   * Try to extract a (variableName → typeName) binding from a single AST node.
-   *
-   * Resolution tiers (first match wins):
-   * - Tier 0: explicit type annotations via extractDeclaration
-   * - Tier 1: constructor-call inference via extractInitializer (fallback)
-   */
-  const extractTypeBinding = (node: SyntaxNode, scopeEnv: Map<string, string>): void => {
-    // This guard eliminates 90%+ of calls before any language dispatch.
-    if (TYPED_PARAMETER_TYPES.has(node.type)) {
-      config.extractParameter(node, scopeEnv);
-      return;
-    }
-    if (config.declarationNodeTypes.has(node.type)) {
-      config.extractDeclaration(node, scopeEnv);
-      // Tier 1: constructor-call inference as fallback.
-      // Always called when available — each language's extractInitializer
-      // internally skips declarators that already have explicit annotations,
-      // so this handles mixed cases like `const a: A = x, b = new B()`.
-      if (config.extractInitializer) {
-        config.extractInitializer(node, scopeEnv, classNames);
-      }
-    }
-  };
-
-  const walk = (node: SyntaxNode, currentScope: string): void => {
-    // Collect class/struct names as we encounter them (used by extractInitializer
-    // to distinguish constructor calls from function calls, e.g. C++ `User()` vs `getUser()`)
-    // Currently only C++ uses this locally; other languages rely on the SymbolTable path.
-    if (CLASS_CONTAINER_TYPES.has(node.type)) {
-      // Most languages use 'name' field; Kotlin uses a type_identifier child instead
-      const nameNode = node.childForFieldName('name')
-        ?? findTypeIdentifierChild(node);
-      if (nameNode) localClassNames.add(nameNode.text);
-    }
-
-    // Detect scope boundaries (function/method definitions)
-    let scope = currentScope;
-    if (FUNCTION_NODE_TYPES.has(node.type)) {
-      const { funcName } = extractFunctionName(node);
-      if (funcName) scope = `${funcName}@${node.startIndex}`;
-    }
-
-    // Get or create the sub-map for this scope
-    if (!env.has(scope)) env.set(scope, new Map());
-    const scopeEnv = env.get(scope)!;
-
-    extractTypeBinding(node, scopeEnv);
-
-    // Scan for constructor bindings that couldn't be resolved locally.
-    // Only collect if TypeEnv didn't already resolve this binding.
-    if (config.scanConstructorBinding) {
-      const result = config.scanConstructorBinding(node);
-      if (result && !scopeEnv.has(result.varName)) {
-        bindings.push({ scope, ...result });
-      }
-    }
-
-    // Recurse into children
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child) walk(child, scope);
-    }
-  };
-
-  walk(tree.rootNode, FILE_SCOPE);
-  return {
-    lookup: (varName, callNode) => lookupInEnv(env, varName, callNode),
-    constructorBindings: bindings,
-    env,
-  };
-};
-
-/**
- * Unverified constructor binding: a `val x = Callee()` pattern where we
- * couldn't confirm the callee is a class (because it's defined in another file).
- * The caller must verify `calleeName` against the SymbolTable before trusting.
- */
-export interface ConstructorBinding {
-  /** Function scope key (matches TypeEnv scope keys) */
-  scope: string;
-  /** Variable name that received the constructor result */
-  varName: string;
-  /** Name of the callee (potential class constructor) */
-  calleeName: string;
-  /** Enclosing class name when callee is a method on a known receiver (e.g. $this) */
-  receiverClassName?: string;
-}
-
-
@@ -1,169 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner } from './types.js';
-import { extractSimpleTypeName, extractVarName } from './shared.js';
-
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'declaration',
-  'for_range_loop',
-]);
-
-/** C++: Type x = ...; Type* x; Type& x; */
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return;
-  const typeName = extractSimpleTypeName(typeNode);
-  if (!typeName) return;
-
-  const declarator = node.childForFieldName('declarator');
-  if (!declarator) return;
-
-  // init_declarator: Type x = value
-  const nameNode = declarator.type === 'init_declarator'
-    ? declarator.childForFieldName('declarator')
-    : declarator;
-  if (!nameNode) return;
-
-  // Handle pointer/reference declarators
-  const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-    ? nameNode.firstNamedChild
-    : nameNode;
-  if (!finalName) return;
-
-  const varName = extractVarName(finalName);
-  if (varName) env.set(varName, typeName);
-};
-
-/** C++: auto x = new User(); auto x = User(); */
-const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => {
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return;
-
-  // Only handle auto/placeholder — typed declarations are handled by extractDeclaration
-  const typeText = typeNode.text;
-  if (
-    typeText !== 'auto' &&
-    typeText !== 'decltype(auto)' &&
-    typeNode.type !== 'placeholder_type_specifier'
-  ) return;
-
-  const declarator = node.childForFieldName('declarator');
-  if (!declarator) return;
-
-  // Must be an init_declarator (i.e., has an initializer value)
-  if (declarator.type !== 'init_declarator') return;
-
-  const value = declarator.childForFieldName('value');
-  if (!value) return;
-
-  // Resolve the variable name, unwrapping pointer/reference declarators
-  const nameNode = declarator.childForFieldName('declarator');
-  if (!nameNode) return;
-  const finalName =
-    nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-      ? nameNode.firstNamedChild
-      : nameNode;
-  if (!finalName) return;
-  const varName = extractVarName(finalName);
-  if (!varName) return;
-
-  // auto x = new User() — new_expression
-  if (value.type === 'new_expression') {
-    const ctorType = value.childForFieldName('type');
-    if (ctorType) {
-      const typeName = extractSimpleTypeName(ctorType);
-      if (typeName) env.set(varName, typeName);
-    }
-    return;
-  }
-
-  // auto x = User() — call_expression where function is a type name
-  // tree-sitter-cpp may parse the constructor name as type_identifier or identifier.
-  // For plain identifiers, verify against known class names from the file's AST
-  // to distinguish constructor calls (User()) from function calls (getUser()).
-  if (value.type === 'call_expression') {
-    const func = value.childForFieldName('function');
-    if (!func) return;
-    if (func.type === 'type_identifier') {
-      const typeName = func.text;
-      if (typeName) env.set(varName, typeName);
-    } else if (func.type === 'identifier') {
-      const text = func.text;
-      if (text && classNames.has(text)) env.set(varName, text);
-    }
-    return;
-  }
-
-  // auto x = User{} — compound_literal_expression (brace initialization)
-  // AST: compound_literal_expression > type_identifier + initializer_list
-  if (value.type === 'compound_literal_expression') {
-    const typeId = value.firstNamedChild;
-    const typeName = typeId ? extractSimpleTypeName(typeId) : undefined;
-    if (typeName) env.set(varName, typeName);
-  }
-};
-
-/** C/C++: parameter_declaration → type declarator */
-const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'parameter_declaration') {
-    typeNode = node.childForFieldName('type');
-    const declarator = node.childForFieldName('declarator');
-    if (declarator) {
-      nameNode = declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator'
-        ? declarator.firstNamedChild
-        : declarator;
-    }
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** C/C++: auto x = User() where function is an identifier (not type_identifier) */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'declaration') return undefined;
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return undefined;
-  const typeText = typeNode.text;
-  if (typeText !== 'auto' && typeText !== 'decltype(auto)' && typeNode.type !== 'placeholder_type_specifier') return undefined;
-  const declarator = node.childForFieldName('declarator');
-  if (!declarator || declarator.type !== 'init_declarator') return undefined;
-  const value = declarator.childForFieldName('value');
-  if (!value || value.type !== 'call_expression') return undefined;
-  const func = value.childForFieldName('function');
-  if (!func) return undefined;
-  if (func.type === 'qualified_identifier' || func.type === 'scoped_identifier') {
-    const last = func.lastNamedChild;
-    if (!last) return undefined;
-    const nameNode = declarator.childForFieldName('declarator');
-    if (!nameNode) return undefined;
-    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-      ? nameNode.firstNamedChild : nameNode;
-    if (!finalName) return undefined;
-    return { varName: finalName.text, calleeName: last.text };
-  }
-  if (func.type !== 'identifier') return undefined;
-  const nameNode = declarator.childForFieldName('declarator');
-  if (!nameNode) return undefined;
-  const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-    ? nameNode.firstNamedChild : nameNode;
-  if (!finalName) return undefined;
-  const varName = finalName.text;
-  if (!varName) return undefined;
-  return { varName, calleeName: func.text };
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  extractInitializer,
-  scanConstructorBinding,
-};
@@ -1,151 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { ConstructorBindingScanner, LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor } from './types.js';
-import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait } from './shared.js';
-
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'local_declaration_statement',
-  'variable_declaration',
-  'field_declaration',
-  'is_pattern_expression',
-]);
-
-/** C#: Type x = ...; var x = new Type(); obj is Type x */
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  // C# pattern matching: `obj is User user` → is_pattern_expression > declaration_pattern
-  if (node.type === 'is_pattern_expression') {
-    const pattern = node.childForFieldName('pattern');
-    if (pattern?.type === 'declaration_pattern') {
-      const typeNode = pattern.childForFieldName('type');
-      const nameNode = pattern.childForFieldName('name');
-      if (typeNode && nameNode) {
-        const typeName = extractSimpleTypeName(typeNode);
-        const varName = extractVarName(nameNode);
-        if (typeName && varName) env.set(varName, typeName);
-      }
-    }
-    return;
-  }
-
-  // C# tree-sitter: local_declaration_statement > variable_declaration > ...
-  // Recursively descend through wrapper nodes
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (!child) continue;
-    if (child.type === 'variable_declaration' || child.type === 'local_declaration_statement') {
-      extractDeclaration(child, env);
-      return;
-    }
-  }
-
-  // At variable_declaration level: first child is type, rest are variable_declarators
-  let typeNode: SyntaxNode | null = null;
-  const declarators: SyntaxNode[] = [];
-
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (!child) continue;
-
-    if (!typeNode && child.type !== 'variable_declarator' && child.type !== 'equals_value_clause') {
-      // First non-declarator child is the type (identifier, implicit_type, generic_name, etc.)
-      typeNode = child;
-    }
-    if (child.type === 'variable_declarator') {
-      declarators.push(child);
-    }
-  }
-
-  if (!typeNode || declarators.length === 0) return;
-
-  // Handle 'var x = new Foo()' — infer from object_creation_expression
-  let typeName: string | undefined;
-  if (typeNode.type === 'implicit_type' && typeNode.text === 'var') {
-    // Try to infer from initializer: var x = new Foo()
-    // tree-sitter-c-sharp may put object_creation_expression as direct child
-    // or inside equals_value_clause depending on grammar version
-    if (declarators.length === 1) {
-      const initializer = findChildByType(declarators[0], 'object_creation_expression')
-        ?? findChildByType(declarators[0], 'equals_value_clause')?.firstNamedChild;
-      if (initializer?.type === 'object_creation_expression') {
-        const ctorType = initializer.childForFieldName('type');
-        if (ctorType) typeName = extractSimpleTypeName(ctorType);
-      }
-    }
-  } else {
-    typeName = extractSimpleTypeName(typeNode);
-  }
-
-  if (!typeName) return;
-  for (const decl of declarators) {
-    const nameNode = decl.childForFieldName('name') ?? decl.firstNamedChild;
-    if (nameNode) {
-      const varName = extractVarName(nameNode);
-      if (varName) env.set(varName, typeName);
-    }
-  }
-};
-
-/** C#: parameter → type name */
-const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'parameter') {
-    typeNode = node.childForFieldName('type');
-    nameNode = node.childForFieldName('name');
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** C#: var x = SomeFactory(...) → bind x to SomeFactory (constructor-like call) */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'variable_declaration') return undefined;
-  // Find type and declarator children by iterating (C# grammar doesn't expose 'type' as a named field)
-  let typeNode: SyntaxNode | null = null;
-  let declarator: SyntaxNode | null = null;
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (!child) continue;
-    if (child.type === 'variable_declarator') { if (!declarator) declarator = child; }
-    else if (!typeNode) { typeNode = child; }
-  }
-  // Only handle implicit_type (var) — explicit types handled by extractDeclaration
-  if (!typeNode || typeNode.type !== 'implicit_type') return undefined;
-  if (!declarator) return undefined;
-  const nameNode = declarator.childForFieldName('name') ?? declarator.firstNamedChild;
-  if (!nameNode || nameNode.type !== 'identifier') return undefined;
-  // Find the initializer value: either inside equals_value_clause or as a direct child
-  // (tree-sitter-c-sharp puts invocation_expression directly inside variable_declarator)
-  let value: SyntaxNode | null = null;
-  for (let i = 0; i < declarator.namedChildCount; i++) {
-    const child = declarator.namedChild(i);
-    if (!child) continue;
-    if (child.type === 'equals_value_clause') { value = child.firstNamedChild; break; }
-    if (child.type === 'invocation_expression' || child.type === 'object_creation_expression' || child.type === 'await_expression') { value = child; break; }
-  }
-  if (!value) return undefined;
-  // Unwrap await: `var user = await svc.GetUserAsync()` → await_expression wraps invocation_expression
-  value = unwrapAwait(value);
-  if (!value) return undefined;
-  // Skip object_creation_expression (new User()) — handled by extractInitializer
-  if (value.type === 'object_creation_expression') return undefined;
-  if (value.type !== 'invocation_expression') return undefined;
-  const func = value.firstNamedChild;
-  if (!func) return undefined;
-  const calleeName = extractSimpleTypeName(func);
-  if (!calleeName) return undefined;
-  return { varName: nameNode.text, calleeName };
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  scanConstructorBinding,
-};
@@ -1,189 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { ConstructorBindingScanner, LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor } from './types.js';
-import { extractSimpleTypeName, extractVarName } from './shared.js';
-
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'var_declaration',
-  'var_spec',
-  'short_var_declaration',
-]);
-
-/** Go: var x Foo */
-const extractGoVarDeclaration = (node: SyntaxNode, env: Map<string, string>): void => {
-  // Go var_declaration contains var_spec children
-  if (node.type === 'var_declaration') {
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const spec = node.namedChild(i);
-      if (spec?.type === 'var_spec') extractGoVarDeclaration(spec, env);
-    }
-    return;
-  }
-
-  // var_spec: name type [= value]
-  const nameNode = node.childForFieldName('name');
-  const typeNode = node.childForFieldName('type');
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Go: x := Foo{...} — infer type from composite literal (handles multi-assignment) */
-const extractGoShortVarDeclaration = (node: SyntaxNode, env: Map<string, string>): void => {
-  const left = node.childForFieldName('left');
-  const right = node.childForFieldName('right');
-  if (!left || !right) return;
-
-  // Collect LHS names and RHS values (may be expression_lists for multi-assignment)
-  const lhsNodes: SyntaxNode[] = [];
-  const rhsNodes: SyntaxNode[] = [];
-
-  if (left.type === 'expression_list') {
-    for (let i = 0; i < left.namedChildCount; i++) {
-      const c = left.namedChild(i);
-      if (c) lhsNodes.push(c);
-    }
-  } else {
-    lhsNodes.push(left);
-  }
-
-  if (right.type === 'expression_list') {
-    for (let i = 0; i < right.namedChildCount; i++) {
-      const c = right.namedChild(i);
-      if (c) rhsNodes.push(c);
-    }
-  } else {
-    rhsNodes.push(right);
-  }
-
-  // Pair each LHS name with its corresponding RHS value
-  const count = Math.min(lhsNodes.length, rhsNodes.length);
-  for (let i = 0; i < count; i++) {
-    let valueNode = rhsNodes[i];
-    // Unwrap &User{} — unary_expression (address-of) wrapping composite_literal
-    if (valueNode.type === 'unary_expression' && valueNode.firstNamedChild?.type === 'composite_literal') {
-      valueNode = valueNode.firstNamedChild;
-    }
-    // Go built-in new(User) — call_expression with 'new' callee and type argument
-    // Go built-in make([]User, 0) / make(map[string]User) — extract element/value type
-    if (valueNode.type === 'call_expression') {
-      const funcNode = valueNode.childForFieldName('function');
-      if (funcNode?.text === 'new') {
-        const args = valueNode.childForFieldName('arguments');
-        if (args?.firstNamedChild) {
-          const typeName = extractSimpleTypeName(args.firstNamedChild);
-          const varName = extractVarName(lhsNodes[i]);
-          if (varName && typeName) env.set(varName, typeName);
-        }
-      } else if (funcNode?.text === 'make') {
-        const args = valueNode.childForFieldName('arguments');
-        const firstArg = args?.firstNamedChild;
-        if (firstArg) {
-          let innerType: SyntaxNode | null = null;
-          if (firstArg.type === 'slice_type') {
-            innerType = firstArg.childForFieldName('element');
-          } else if (firstArg.type === 'map_type') {
-            innerType = firstArg.childForFieldName('value');
-          }
-          if (innerType) {
-            const typeName = extractSimpleTypeName(innerType);
-            const varName = extractVarName(lhsNodes[i]);
-            if (varName && typeName) env.set(varName, typeName);
-          }
-        }
-      }
-      continue;
-    }
-    // Go type assertion: user := iface.(User) — type_assertion_expression with 'type' field
-    if (valueNode.type === 'type_assertion_expression') {
-      const typeNode = valueNode.childForFieldName('type');
-      if (typeNode) {
-        const typeName = extractSimpleTypeName(typeNode);
-        const varName = extractVarName(lhsNodes[i]);
-        if (varName && typeName) env.set(varName, typeName);
-      }
-      continue;
-    }
-    if (valueNode.type !== 'composite_literal') continue;
-    const typeNode = valueNode.childForFieldName('type');
-    if (!typeNode) continue;
-    const typeName = extractSimpleTypeName(typeNode);
-    if (!typeName) continue;
-    const varName = extractVarName(lhsNodes[i]);
-    if (varName) env.set(varName, typeName);
-  }
-};
-
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  if (node.type === 'var_declaration' || node.type === 'var_spec') {
-    extractGoVarDeclaration(node, env);
-  } else if (node.type === 'short_var_declaration') {
-    extractGoShortVarDeclaration(node, env);
-  }
-};
-
-/** Go: parameter → name type */
-const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'parameter') {
-    nameNode = node.childForFieldName('name');
-    typeNode = node.childForFieldName('type');
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Go: user := NewUser(...) — infer type from single-assignment call expression */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'short_var_declaration') return undefined;
-  const left = node.childForFieldName('left');
-  const right = node.childForFieldName('right');
-  if (!left || !right) return undefined;
-  const leftIds = left.type === 'expression_list' ? left.namedChildren : [left];
-  const rightExprs = right.type === 'expression_list' ? right.namedChildren : [right];
-
-  // Multi-return: user, err := NewUser() — bind first var when second is err/ok/_
-  if (leftIds.length === 2 && rightExprs.length === 1) {
-    const secondVar = leftIds[1];
-    const isErrorOrDiscard =
-      secondVar.text === '_' ||
-      secondVar.text === 'err' ||
-      secondVar.text === 'ok' ||
-      secondVar.text === 'error';
-    if (isErrorOrDiscard && leftIds[0].type === 'identifier') {
-      if (rightExprs[0].type !== 'call_expression') return undefined;
-      const func = rightExprs[0].childForFieldName('function');
-      if (!func) return undefined;
-      if (func.text === 'new' || func.text === 'make') return undefined;
-      const calleeName = extractSimpleTypeName(func);
-      if (!calleeName) return undefined;
-      return { varName: leftIds[0].text, calleeName };
-    }
-  }
-
-  // Single assignment only
-  if (leftIds.length !== 1 || leftIds[0].type !== 'identifier') return undefined;
-  if (rightExprs.length !== 1 || rightExprs[0].type !== 'call_expression') return undefined;
-  const func = rightExprs[0].childForFieldName('function');
-  if (!func) return undefined;
-  // Skip new() and make() — already handled by extractDeclaration
-  if (func.text === 'new' || func.text === 'make') return undefined;
-  const calleeName = extractSimpleTypeName(func);
-  if (!calleeName) return undefined;
-  return { varName: leftIds[0].text, calleeName };
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  scanConstructorBinding,
-};
@@ -1,44 +0,0 @@
-/**
- * Per-language type extraction configurations.
- * Assembled here into a dispatch map keyed by SupportedLanguages.
- */
-
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-import type { LanguageTypeConfig } from './types.js';
-
-import { typeConfig as typescriptConfig } from './typescript.js';
-import { javaTypeConfig, kotlinTypeConfig } from './jvm.js';
-import { typeConfig as csharpConfig } from './csharp.js';
-import { typeConfig as goConfig } from './go.js';
-import { typeConfig as rustConfig } from './rust.js';
-import { typeConfig as pythonConfig } from './python.js';
-import { typeConfig as swiftConfig } from './swift.js';
-import { typeConfig as cCppConfig } from './c-cpp.js';
-import { typeConfig as phpConfig } from './php.js';
-import { typeConfig as rubyConfig } from './ruby.js';
-
-export const typeConfigs = {
-  [SupportedLanguages.JavaScript]: typescriptConfig,
-  [SupportedLanguages.TypeScript]: typescriptConfig,
-  [SupportedLanguages.Java]: javaTypeConfig,
-  [SupportedLanguages.Kotlin]: kotlinTypeConfig,
-  [SupportedLanguages.CSharp]: csharpConfig,
-  [SupportedLanguages.Go]: goConfig,
-  [SupportedLanguages.Rust]: rustConfig,
-  [SupportedLanguages.Python]: pythonConfig,
-  [SupportedLanguages.Swift]: swiftConfig,
-  [SupportedLanguages.C]: cCppConfig,
-  [SupportedLanguages.CPlusPlus]: cCppConfig,
-  [SupportedLanguages.PHP]: phpConfig,
-  [SupportedLanguages.Ruby]: rubyConfig,
-} satisfies Record<SupportedLanguages, LanguageTypeConfig>;
-
-export type { LanguageTypeConfig, TypeBindingExtractor, ParameterExtractor, ConstructorBindingScanner } from './types.js';
-export { 
-  TYPED_PARAMETER_TYPES,
-  extractSimpleTypeName,
-  extractGenericTypeArgs,
-  extractVarName,
-  findChildByType,
-  extractRubyConstructorAssignment
-} from './shared.js';
@@ -1,224 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner } from './types.js';
-import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
-
-// ── Java ──────────────────────────────────────────────────────────────────
-
-const JAVA_DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'local_variable_declaration',
-  'field_declaration',
-]);
-
-/** Java: Type x = ...; Type x; */
-const extractJavaDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return;
-  const typeName = extractSimpleTypeName(typeNode);
-  if (!typeName || typeName === 'var') return; // skip Java 10 var — handled by extractInitializer
-
-  // Find variable_declarator children
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type !== 'variable_declarator') continue;
-    const nameNode = child.childForFieldName('name');
-    if (nameNode) {
-      const varName = extractVarName(nameNode);
-      if (varName) env.set(varName, typeName);
-    }
-  }
-};
-
-/** Java 10+: var x = new User() — infer type from object_creation_expression */
-const extractJavaInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, _classNames: ClassNameLookup): void => {
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type !== 'variable_declarator') continue;
-    const nameNode = child.childForFieldName('name');
-    const valueNode = child.childForFieldName('value');
-    if (!nameNode || !valueNode) continue;
-    // Skip declarators that already have a binding from extractDeclaration
-    const varName = extractVarName(nameNode);
-    if (!varName || env.has(varName)) continue;
-    if (valueNode.type !== 'object_creation_expression') continue;
-    const ctorType = valueNode.childForFieldName('type');
-    if (!ctorType) continue;
-    const typeName = extractSimpleTypeName(ctorType);
-    if (typeName) env.set(varName, typeName);
-  }
-};
-
-/** Java: formal_parameter → type name */
-const extractJavaParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'formal_parameter') {
-    typeNode = node.childForFieldName('type');
-    nameNode = node.childForFieldName('name');
-  } else {
-    // Generic fallback
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Java: var x = SomeFactory.create() — constructor binding for `var` with method_invocation */
-const scanJavaConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'local_variable_declaration') return undefined;
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return undefined;
-  if (typeNode.text !== 'var') return undefined;
-  const declarator = node.namedChildren.find((c: SyntaxNode) => c.type === 'variable_declarator');
-  if (!declarator) return undefined;
-  const nameNode = declarator.childForFieldName('name');
-  const value = declarator.childForFieldName('value');
-  if (!nameNode || !value) return undefined;
-  if (value.type === 'object_creation_expression') return undefined;
-  if (value.type !== 'method_invocation') return undefined;
-  const methodName = value.childForFieldName('name');
-  if (!methodName) return undefined;
-  return { varName: nameNode.text, calleeName: methodName.text };
-};
-
-export const javaTypeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: JAVA_DECLARATION_NODE_TYPES,
-  extractDeclaration: extractJavaDeclaration,
-  extractParameter: extractJavaParameter,
-  extractInitializer: extractJavaInitializer,
-  scanConstructorBinding: scanJavaConstructorBinding,
-};
-
-// ── Kotlin ────────────────────────────────────────────────────────────────
-
-const KOTLIN_DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'property_declaration',
-  'variable_declaration',
-]);
-
-/** Kotlin: val x: Foo = ... */
-const extractKotlinDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  if (node.type === 'property_declaration') {
-    // Kotlin property_declaration: name/type are inside a variable_declaration child
-    const varDecl = findChildByType(node, 'variable_declaration');
-    if (varDecl) {
-      const nameNode = findChildByType(varDecl, 'simple_identifier');
-      const typeNode = findChildByType(varDecl, 'user_type');
-      if (!nameNode || !typeNode) return;
-      const varName = extractVarName(nameNode);
-      const typeName = extractSimpleTypeName(typeNode);
-      if (varName && typeName) env.set(varName, typeName);
-      return;
-    }
-    // Fallback: try direct fields
-    const nameNode = node.childForFieldName('name')
-      ?? findChildByType(node, 'simple_identifier');
-    const typeNode = node.childForFieldName('type')
-      ?? findChildByType(node, 'user_type');
-    if (!nameNode || !typeNode) return;
-    const varName = extractVarName(nameNode);
-    const typeName = extractSimpleTypeName(typeNode);
-    if (varName && typeName) env.set(varName, typeName);
-  } else if (node.type === 'variable_declaration') {
-    // variable_declaration directly inside functions
-    const nameNode = findChildByType(node, 'simple_identifier');
-    const typeNode = findChildByType(node, 'user_type');
-    if (nameNode && typeNode) {
-      const varName = extractVarName(nameNode);
-      const typeName = extractSimpleTypeName(typeNode);
-      if (varName && typeName) env.set(varName, typeName);
-    }
-  }
-};
-
-/** Kotlin: formal_parameter → type name */
-const extractKotlinParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'formal_parameter') {
-    typeNode = node.childForFieldName('type');
-    nameNode = node.childForFieldName('name');
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Kotlin: val user = User() — infer type from call_expression when callee is a known class.
- *  Kotlin constructors are syntactically identical to function calls, so we verify
- *  against classNames (which may include cross-file SymbolTable lookups). */
-const extractKotlinInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => {
-  if (node.type !== 'property_declaration') return;
-  // Skip if there's an explicit type annotation — Tier 0 already handled it
-  const varDecl = findChildByType(node, 'variable_declaration');
-  if (varDecl && findChildByType(varDecl, 'user_type')) return;
-
-  // Get the initializer value — the call_expression after '='
-  const value = node.childForFieldName('value')
-    ?? findChildByType(node, 'call_expression');
-  if (!value || value.type !== 'call_expression') return;
-
-  // The callee is the first child of call_expression (simple_identifier for direct calls)
-  const callee = value.firstNamedChild;
-  if (!callee || callee.type !== 'simple_identifier') return;
-
-  const calleeName = callee.text;
-  if (!calleeName || !classNames.has(calleeName)) return;
-
-  // Extract the variable name from the variable_declaration inside property_declaration
-  const nameNode = varDecl
-    ? findChildByType(varDecl, 'simple_identifier')
-    : findChildByType(node, 'simple_identifier');
-  if (!nameNode) return;
-
-  const varName = extractVarName(nameNode);
-  if (varName) env.set(varName, calleeName);
-};
-
-/** Kotlin: val x = User(...) — constructor binding for property_declaration with call_expression */
-const scanKotlinConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'property_declaration') return undefined;
-  const varDecl = node.namedChildren.find(c => c.type === 'variable_declaration');
-  if (!varDecl) return undefined;
-  if (varDecl.namedChildren.some(c => c.type === 'user_type')) return undefined;
-  const callExpr = node.namedChildren.find(c => c.type === 'call_expression');
-  if (!callExpr) return undefined;
-  const callee = callExpr.firstNamedChild;
-  if (!callee) return undefined;
-
-  let calleeName: string | undefined;
-  if (callee.type === 'simple_identifier') {
-    calleeName = callee.text;
-  } else if (callee.type === 'navigation_expression') {
-    // Extract method name from qualified call: service.getUser() → getUser
-    const suffix = callee.lastNamedChild;
-    if (suffix?.type === 'navigation_suffix') {
-      const methodName = suffix.lastNamedChild;
-      if (methodName?.type === 'simple_identifier') {
-        calleeName = methodName.text;
-      }
-    }
-  }
-  if (!calleeName) return undefined;
-  const nameNode = varDecl.namedChildren.find(c => c.type === 'simple_identifier');
-  if (!nameNode) return undefined;
-  return { varName: nameNode.text, calleeName };
-};
-
-export const kotlinTypeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES,
-  extractDeclaration: extractKotlinDeclaration,
-  extractParameter: extractKotlinParameter,
-  extractInitializer: extractKotlinInitializer,
-  scanConstructorBinding: scanKotlinConstructorBinding,
-};
@@ -1,255 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ReturnTypeExtractor } from './types.js';
-import { extractSimpleTypeName, extractVarName, extractCalleeName } from './shared.js';
-
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'assignment_expression',   // For constructor inference: $x = new User()
-  'property_declaration',    // PHP 7.4+ typed properties: private UserRepo $repo;
-  'method_declaration',      // PHPDoc @param on class methods
-  'function_definition',     // PHPDoc @param on top-level functions
-]);
-
-/** Walk up the AST to find the enclosing class declaration. */
-const findEnclosingClass = (node: SyntaxNode): SyntaxNode | null => {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'class_declaration') return current;
-    current = current.parent;
-  }
-  return null;
-};
-
-/**
- * Resolve PHP self/static/parent to the actual class name.
- * - self/static → enclosing class name
- * - parent → superclass from base_clause
- */
-const resolvePhpKeyword = (keyword: string, node: SyntaxNode): string | undefined => {
-  if (keyword === 'self' || keyword === 'static') {
-    const cls = findEnclosingClass(node);
-    if (!cls) return undefined;
-    const nameNode = cls.childForFieldName('name');
-    return nameNode?.text;
-  }
-  if (keyword === 'parent') {
-    const cls = findEnclosingClass(node);
-    if (!cls) return undefined;
-    // base_clause contains the parent class name
-    for (let i = 0; i < cls.namedChildCount; i++) {
-      const child = cls.namedChild(i);
-      if (child?.type === 'base_clause') {
-        const parentName = child.firstNamedChild;
-        if (parentName) return extractSimpleTypeName(parentName);
-      }
-    }
-    return undefined;
-  }
-  return undefined;
-};
-
-const normalizePhpType = (raw: string): string | undefined => {
-  // Strip nullable prefix: ?User → User
-  let type = raw.startsWith('?') ? raw.slice(1) : raw;
-  // Strip array suffix: User[] → User
-  type = type.replace(/\[\]$/, '');
-  // Strip union with null/false/void: User|null → User
-  const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
-  if (parts.length !== 1) return undefined;
-  type = parts[0];
-  // Strip namespace: \App\Models\User → User
-  const segments = type.split('\\');
-  type = segments[segments.length - 1];
-  // Skip uninformative types
-  if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object') return undefined;
-  if (/^\w+$/.test(type)) return type;
-  return undefined;
-};
-
-/** Node types to skip when walking backwards to find doc-comments.
- *  PHP 8+ attributes (#[Route(...)]) appear as named siblings between PHPDoc and method. */
-const SKIP_NODE_TYPES: ReadonlySet<string> = new Set(['attribute_list', 'attribute']);
-
-/** Regex to extract PHPDoc @param annotations: `@param Type $name` (standard order) */
-const PHPDOC_PARAM_RE = /@param\s+(\S+)\s+\$(\w+)/g;
-/** Alternate PHPDoc order: `@param $name Type` (name first) */
-const PHPDOC_PARAM_ALT_RE = /@param\s+\$(\w+)\s+(\S+)/g;
-
-/**
- * Collect PHPDoc @param type bindings from comment nodes preceding a method/function.
- * Returns a map of paramName → typeName (without $ prefix).
- */
-const collectPhpDocParams = (methodNode: SyntaxNode): Map<string, string> => {
-  const commentTexts: string[] = [];
-  let sibling = methodNode.previousSibling;
-  while (sibling) {
-    if (sibling.type === 'comment') {
-      commentTexts.unshift(sibling.text);
-    } else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) {
-      break;
-    }
-    sibling = sibling.previousSibling;
-  }
-  if (commentTexts.length === 0) return new Map();
-
-  const params = new Map<string, string>();
-  const commentBlock = commentTexts.join('\n');
-  PHPDOC_PARAM_RE.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = PHPDOC_PARAM_RE.exec(commentBlock)) !== null) {
-    const typeName = normalizePhpType(match[1]);
-    const paramName = match[2]; // without $ prefix
-    if (typeName) {
-      // Store with $ prefix to match how PHP variables appear in the env
-      params.set('$' + paramName, typeName);
-    }
-  }
-
-  // Also check alternate PHPDoc order: @param $name Type
-  PHPDOC_PARAM_ALT_RE.lastIndex = 0;
-  while ((match = PHPDOC_PARAM_ALT_RE.exec(commentBlock)) !== null) {
-    const paramName = match[1];
-    if (params.has('$' + paramName)) continue; // standard format takes priority
-    const typeName = normalizePhpType(match[2]);
-    if (typeName) {
-      params.set('$' + paramName, typeName);
-    }
-  }
-  return params;
-};
-
-/**
- * PHP: typed class properties (PHP 7.4+): private UserRepo $repo;
- * Also: PHPDoc @param annotations on method/function definitions.
- */
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  // PHPDoc @param on methods/functions — pre-populate env with param types
-  if (node.type === 'method_declaration' || node.type === 'function_definition') {
-    const phpDocParams = collectPhpDocParams(node);
-    for (const [paramName, typeName] of phpDocParams) {
-      if (!env.has(paramName)) env.set(paramName, typeName);
-    }
-    return;
-  }
-
-  if (node.type !== 'property_declaration') return;
-
-  const typeNode = node.childForFieldName('type');
-  if (!typeNode) return;
-
-  const typeName = extractSimpleTypeName(typeNode);
-  if (!typeName) return;
-
-  // The variable name is inside property_element > variable_name
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type === 'property_element') {
-      const varNameNode = child.firstNamedChild; // variable_name
-      if (varNameNode) {
-        const varName = extractVarName(varNameNode);
-        if (varName) env.set(varName, typeName);
-      }
-      break;
-    }
-  }
-};
-
-/** PHP: $x = new User() — infer type from object_creation_expression */
-const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, _classNames: ClassNameLookup): void => {
-  if (node.type !== 'assignment_expression') return;
-  const left = node.childForFieldName('left');
-  const right = node.childForFieldName('right');
-  if (!left || !right) return;
-  if (right.type !== 'object_creation_expression') return;
-  // The class name is the first named child of object_creation_expression
-  // (tree-sitter-php uses 'name' or 'qualified_name' nodes here)
-  const ctorType = right.firstNamedChild;
-  if (!ctorType) return;
-  const typeName = extractSimpleTypeName(ctorType);
-  if (!typeName) return;
-  // Resolve PHP self/static/parent to actual class names
-  const resolvedType = (typeName === 'self' || typeName === 'static' || typeName === 'parent')
-    ? resolvePhpKeyword(typeName, node)
-    : typeName;
-  if (!resolvedType) return;
-  const varName = extractVarName(left);
-  if (varName) env.set(varName, resolvedType);
-};
-
-/** PHP: simple_parameter → type $name */
-const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'simple_parameter') {
-    typeNode = node.childForFieldName('type');
-    nameNode = node.childForFieldName('name');
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** PHP: $x = SomeFactory() or $x = $this->getUser() — bind variable to call return type */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  if (node.type !== 'assignment_expression') return undefined;
-  const left = node.childForFieldName('left');
-  const right = node.childForFieldName('right');
-  if (!left || !right) return undefined;
-  if (left.type !== 'variable_name') return undefined;
-  // Skip object_creation_expression (new User()) — handled by extractInitializer
-  if (right.type === 'object_creation_expression') return undefined;
-  // Handle both standalone function calls and method calls ($this->getUser())
-  if (right.type === 'function_call_expression') {
-    const calleeName = extractCalleeName(right);
-    if (!calleeName) return undefined;
-    return { varName: left.text, calleeName };
-  }
-  if (right.type === 'member_call_expression') {
-    const methodName = right.childForFieldName('name');
-    if (!methodName) return undefined;
-    // When receiver is $this/self/static, qualify with enclosing class for disambiguation
-    const receiver = right.childForFieldName('object');
-    const receiverText = receiver?.text;
-    let receiverClassName: string | undefined;
-    if (receiverText === '$this' || receiverText === 'self' || receiverText === 'static') {
-      const cls = findEnclosingClass(node);
-      const clsName = cls?.childForFieldName('name');
-      if (clsName) receiverClassName = clsName.text;
-    }
-    return { varName: left.text, calleeName: methodName.text, receiverClassName };
-  }
-  return undefined;
-};
-
-/** Regex to extract PHPDoc @return annotations: `@return User` */
-const PHPDOC_RETURN_RE = /@return\s+(\S+)/;
-
-/**
- * Extract return type from PHPDoc `@return Type` annotation preceding a method.
- * Walks backwards through preceding siblings looking for comment nodes.
- */
-const extractReturnType: ReturnTypeExtractor = (node) => {
-  let sibling = node.previousSibling;
-  while (sibling) {
-    if (sibling.type === 'comment') {
-      const match = PHPDOC_RETURN_RE.exec(sibling.text);
-      if (match) return normalizePhpType(match[1]);
-    } else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) break;
-    sibling = sibling.previousSibling;
-  }
-  return undefined;
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  extractInitializer,
-  scanConstructorBinding,
-  extractReturnType,
-};
@@ -1,111 +0,0 @@
-import type { SyntaxNode } from '../utils.js';
-import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner } from './types.js';
-import { extractSimpleTypeName, extractVarName } from './shared.js';
-
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'assignment',
-  'named_expression',
-]);
-
-/** Python: x: Foo = ... (PEP 484 annotations) */
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  // Python annotated assignment: left : type = value
-  // tree-sitter represents this differently based on grammar version
-  const left = node.childForFieldName('left');
-  const typeNode = node.childForFieldName('type');
-  if (!left || !typeNode) return;
-  const varName = extractVarName(left);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Python: parameter with type annotation */
-const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  let nameNode: SyntaxNode | null = null;
-  let typeNode: SyntaxNode | null = null;
-
-  if (node.type === 'parameter') {
-    nameNode = node.childForFieldName('name');
-    typeNode = node.childForFieldName('type');
-  } else {
-    nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-    typeNode = node.childForFieldName('type');
-  }
-
-  if (!nameNode || !typeNode) return;
-  const varName = extractVarName(nameNode);
-  const typeName = extractSimpleTypeName(typeNode);
-  if (varName && typeName) env.set(varName, typeName);
-};
-
-/** Python: user = User("alice") — infer type from call when callee is a known class.
- *  Python constructors are syntactically identical to function calls, so we verify
- *  against classNames (which may include cross-file SymbolTable lookups).
- *  Also handles walrus operator: if (user := User("alice")): */
-const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => {
-  let left: SyntaxNode | null;
-  let right: SyntaxNode | null;
-
-  if (node.type === 'named_expression') {
-    // Walrus operator: (user := User("alice"))
-    // tree-sitter-python: named_expression has 'name' and 'value' fields
-    left = node.childForFieldName('name');
-    right = node.childForFieldName('value');
-  } else if (node.type === 'assignment') {
-    left = node.childForFieldName('left');
-    right = node.childForFieldName('right');
-    // Skip if already has type annotation — extractDeclaration handled it
-    if (node.childForFieldName('type')) return;
-  } else {
-    return;
-  }
-
-  if (!left || !right) return;
-  const varName = extractVarName(left);
-  if (!varName || env.has(varName)) return;
-  if (right.type !== 'call') return;
-  const func = right.childForFieldName('function');
-  if (!func) return;
-  // Support both direct calls (User()) and qualified calls (models.User())
-  // tree-sitter-python: direct → identifier, qualified → attribute
-  const calleeName = extractSimpleTypeName(func);
-  if (!calleeName) return;
-  if (classNames.has(calleeName)) {
-    env.set(varName, calleeName);
-  }
-};
-
-/** Python: user = User("alice") — scan assignment/walrus for constructor-like calls.
- *  Returns {varName, calleeName} without checking classNames (caller validates). */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  let left: SyntaxNode | null;
-  let right: SyntaxNode | null;
-
-  if (node.type === 'named_expression') {
-    left = node.childForFieldName('name');
-    right = node.childForFieldName('value');
-  } else if (node.type === 'assignment') {
-    left = node.childForFieldName('left');
-    right = node.childForFieldName('right');
-    if (node.childForFieldName('type')) return undefined;
-  } else {
-    return undefined;
-  }
-
-  if (!left || !right) return undefined;
-  if (left.type !== 'identifier') return undefined;
-  if (right.type !== 'call') return undefined;
-  const func = right.childForFieldName('function');
-  if (!func) return undefined;
-  const calleeName = extractSimpleTypeName(func);
-  if (!calleeName) return undefined;
-  return { varName: left.text, calleeName };
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  extractInitializer,
-  scanConstructorBinding,
-};
@@ -1,271 +0,0 @@
-import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ReturnTypeExtractor } from './types.js';
-import { extractRubyConstructorAssignment, extractSimpleTypeName } from './shared.js';
-import { SyntaxNode } from '../utils.js';
-
-/**
- * Ruby type extractor — YARD annotation parsing.
- *
- * Ruby has no static type system, but the YARD documentation convention
- * provides de facto type annotations via comments:
- *
- *   # @param name [String] the user's name
- *   # @param repo [UserRepo] the repository
- *   # @return [User]
- *   def create(name, repo)
- *     repo.save
- *   end
- *
- * This extractor parses `@param name [Type]` patterns from comment nodes
- * preceding method definitions and binds parameter names to their types.
- *
- * Resolution tiers:
- * - Tier 0: YARD @param annotations (extractDeclaration pre-populates env)
- * - Tier 1: Constructor inference via `user = User.new` (handled by scanConstructorBinding in typeConfig)
- */
-
-/** Regex to extract @param annotations: `@param name [Type]` */
-const YARD_PARAM_RE = /@param\s+(\w+)\s+\[([^\]]+)\]/g;
-/** Alternate YARD order: `@param [Type] name` */
-const YARD_PARAM_ALT_RE = /@param\s+\[([^\]]+)\]\s+(\w+)/g;
-
-/** Regex to extract @return annotations: `@return [Type]` */
-const YARD_RETURN_RE = /@return\s+\[([^\]]+)\]/;
-
-/**
- * Extract the simple type name from a YARD type string.
- * Handles:
- * - Simple types: "String" → "String"
- * - Qualified types: "Models::User" → "User"
- * - Generic types: "Array<User>" → "Array"
- * - Nullable types: "String, nil" → "String"
- * - Union types: "String, Integer" → undefined (ambiguous)
- */
-const extractYardTypeName = (yardType: string): string | undefined => {
-  const trimmed = yardType.trim();
-
-  // Handle nullable: "Type, nil" or "nil, Type"
-  // Use bracket-balanced split to avoid breaking on commas inside generics like Hash<Symbol, User>
-  const parts: string[] = [];
-  let depth = 0, start = 0;
-  for (let i = 0; i < trimmed.length; i++) {
-    if (trimmed[i] === '<') depth++;
-    else if (trimmed[i] === '>') depth--;
-    else if (trimmed[i] === ',' && depth === 0) {
-      parts.push(trimmed.slice(start, i).trim());
-      start = i + 1;
-    }
-  }
-  parts.push(trimmed.slice(start).trim());
-  const filtered = parts.filter(p => p !== '' && p !== 'nil');
-  if (filtered.length !== 1) return undefined; // ambiguous union
-
-  const typePart = filtered[0];
-
-  // Handle qualified: "Models::User" → "User"
-  const segments = typePart.split('::');
-  const last = segments[segments.length - 1];
-
-  // Handle generic: "Array<User>" → "Array"
-  const genericMatch = last.match(/^(\w+)\s*[<{(]/);
-  if (genericMatch) return genericMatch[1];
-
-  // Simple identifier check
-  if (/^\w+$/.test(last)) return last;
-
-  return undefined;
-};
-
-/**
- * Collect YARD @param annotations from comment nodes preceding a method definition.
- * Returns a map of paramName → typeName.
- *
- * In tree-sitter-ruby, comments are sibling nodes that appear before the method node.
- * We walk backwards through preceding siblings collecting consecutive comment nodes.
- */
-const collectYardParams = (methodNode: SyntaxNode): Map<string, string> => {
-  const params = new Map<string, string>();
-
-  // In tree-sitter-ruby, YARD comments preceding a method inside a class body
-  // are placed as children of the `class` node, NOT as siblings of the `method`
-  // inside `body_statement`. The AST structure is:
-  //
-  //   class
-  //     constant = "ClassName"
-  //     comment = "# @param ..."     ← sibling of body_statement
-  //     comment = "# @param ..."     ← sibling of body_statement
-  //     body_statement
-  //       method                     ← method is here, no preceding siblings
-  //
-  // For top-level methods (outside classes), comments ARE direct siblings.
-  // We handle both by checking: if method has no preceding comment siblings,
-  // look at parent (body_statement) siblings instead.
-  const commentTexts: string[] = [];
-
-  const collectComments = (startNode: SyntaxNode): void => {
-    let sibling = startNode.previousSibling;
-    while (sibling) {
-      if (sibling.type === 'comment') {
-        commentTexts.unshift(sibling.text);
-      } else if (sibling.isNamed) {
-        break;
-      }
-      sibling = sibling.previousSibling;
-    }
-  };
-
-  // Try method's own siblings first (top-level methods)
-  collectComments(methodNode);
-
-  // If no comments found and parent is body_statement, check parent's siblings
-  if (commentTexts.length === 0 && methodNode.parent?.type === 'body_statement') {
-    collectComments(methodNode.parent);
-  }
-
-  // Parse all comment lines for @param annotations
-  const commentBlock = commentTexts.join('\n');
-  let match: RegExpExecArray | null;
-
-  // Reset regex state
-  YARD_PARAM_RE.lastIndex = 0;
-  while ((match = YARD_PARAM_RE.exec(commentBlock)) !== null) {
-    const paramName = match[1];
-    const rawType = match[2];
-    const typeName = extractYardTypeName(rawType);
-    if (typeName) {
-      params.set(paramName, typeName);
-    }
-  }
-
-  // Also check alternate YARD order: @param [Type] name
-  YARD_PARAM_ALT_RE.lastIndex = 0;
-  while ((match = YARD_PARAM_ALT_RE.exec(commentBlock)) !== null) {
-    const rawType = match[1];
-    const paramName = match[2];
-    if (params.has(paramName)) continue; // standard format takes priority
-    const typeName = extractYardTypeName(rawType);
-    if (typeName) {
-      params.set(paramName, typeName);
-    }
-  }
-
-  return params;
-};
-
-/**
- * Ruby node types that may carry type bindings.
- * - `method`/`singleton_method`: YARD @param annotations (via extractDeclaration)
- * - `assignment`: Constructor inference like `user = User.new` (via extractInitializer;
- *   extractDeclaration returns early for these nodes)
- */
-const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([
-  'method',
-  'singleton_method',
-  'assignment',
-]);
-
-/**
- * Extract YARD annotations from method definitions.
- * Pre-populates the scope env with parameter types before the
- * standard parameter walk (which won't find types since Ruby has none).
- */
-const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
-  if (node.type !== 'method' && node.type !== 'singleton_method') return;
-
-  const yardParams = collectYardParams(node);
-  if (yardParams.size === 0) return;
-
-  // Pre-populate env with YARD type bindings for each parameter
-  for (const [paramName, typeName] of yardParams) {
-    env.set(paramName, typeName);
-  }
-};
-
-/**
- * Ruby parameter extraction.
- * Ruby parameters (identifiers inside method_parameters) have no inline
- * type annotations. YARD types are already populated by extractDeclaration,
- * so this is a no-op — the bindings are already in the env.
- *
- * We still register this to maintain the LanguageTypeConfig contract.
- */
-const extractParameter: ParameterExtractor = (_node: SyntaxNode, _env: Map<string, string>): void => {
-  // Ruby parameters have no type annotations.
-  // YARD types are pre-populated by extractDeclaration.
-};
-
-/**
- * Ruby constructor inference: user = User.new or service = Models::User.new
- * Uses the shared extractRubyConstructorAssignment helper for AST matching,
- * then resolves against locally-known class names.
- */
-const extractInitializer: InitializerExtractor = (node, env, classNames): void => {
-  const result = extractRubyConstructorAssignment(node);
-  if (!result) return;
-  if (env.has(result.varName)) return;
-  if (classNames.has(result.calleeName)) {
-    env.set(result.varName, result.calleeName);
-  }
-};
-
-/**
- * Extract return type from YARD `@return [Type]` annotation preceding a method.
- * Reuses the same comment-walking strategy as collectYardParams: try direct
- * siblings first, fall back to parent (body_statement) siblings for class methods.
- */
-const extractReturnType: ReturnTypeExtractor = (node) => {
-  const search = (startNode: SyntaxNode): string | undefined => {
-    let sibling = startNode.previousSibling;
-    while (sibling) {
-      if (sibling.type === 'comment') {
-        const match = YARD_RETURN_RE.exec(sibling.text);
-        if (match) return extractYardTypeName(match[1]);
-      } else if (sibling.isNamed) {
-        break;
-      }
-      sibling = sibling.previousSibling;
-    }
-    return undefined;
-  };
-
-  const result = search(node);
-  if (result) return result;
-
-  if (node.parent?.type === 'body_statement') {
-    return search(node.parent);
-  }
-  return undefined;
-};
-
-/**
- * Ruby constructor binding scanner: captures both `user = User.new` and
- * plain call assignments like `user = get_user()`.
- * The `.new` pattern returns the class name directly; plain calls return the
- * callee name for return-type inference via SymbolTable lookup.
- */
-const scanConstructorBinding: ConstructorBindingScanner = (node) => {
-  // Try the .new pattern first (returns class name directly)
-  const newResult = extractRubyConstructorAssignment(node);
-  if (newResult) return newResult;
-
-  // Plain call assignment: user = get_user() / user = Models.create()
-  if (node.type !== 'assignment') return undefined;
-  const left = node.childForFieldName('left');
-  const right = node.childForFieldName('right');
-  if (!left || !right) return undefined;
-  if (left.type !== 'identifier' && left.type !== 'constant') return undefined;
-  if (right.type !== 'call') return undefined;
-  const method = right.childForFieldName('method');
-  if (!method) return undefined;
-  const calleeName = extractSimpleTypeName(method);
-  if (!calleeName) return undefined;
-  return { varName: left.text, calleeName };
-};
-
-export const typeConfig: LanguageTypeConfig = {
-  declarationNodeTypes: DECLARATION_NODE_TYPES,
-  extractDeclaration,
-  extractParameter,
-  extractInitializer,
-  scanConstructorBinding,
-  extractReturnType,
-};
--- a/Show More
+++ b/Show More