fix(perf): pass symbolsOnly through parseFilesWasmInline (#1489)

* chore: gitignore napi-generated artifacts in crates/codegraph-core

* chore(tests): remove unused biome suppression in visitor.test.ts

* fix(titan-run): sync --start-from enum and phase-timestamp list with actual phases

* fix(hooks): track Bash file modifications via before/after git status diff

Adds snapshot-pre-bash.sh (PreToolUse Bash) + track-bash-writes.sh
(PostToolUse Bash): the pre-hook captures git status --porcelain to a
per-worktree temp file before each Bash call; the post-hook diffs the
before/after state and appends newly modified or created files to
.claude/session-edits.log.

This closes the gap where files written by sed -i, printf redirects,
tee, heredocs, or build tools (Cargo.lock, lockfiles) were never
recorded, causing guard-git.sh to emit false-positive BLOCKED errors.

Closes #1457

* chore(native): remove dead code (unused var, method, variant, fields)

- clojure.rs: annotate lifetime-anchor assignment to silence false-positive
- cfg.rs: remove never-called start_line_of method
- complexity.rs: remove never-constructed NotHandled variant; convert
  irrefutable if-let patterns to plain let destructures
- dataflow.rs: remove never-read callee fields from CallReturn/Destructured
- incremental.rs: remove never-read lang field from CacheEntry

cargo check and cargo clippy both clean after these changes.

* refactor(native): extract emit_pts_alias_edges params into PtsAliasCtx struct

* fix(wasm): sort call targets by confidence before emit to match native engine

* fix(bench): add 2 warmup runs and raise INCREMENTAL_RUNS to 5 for incremental tiers

* ci(bench): add per-PR perf canary for extractor/graph/native changes

Adds .github/workflows/perf-canary.yml — a path-filtered workflow that
fires on PRs touching src/extractors/, src/domain/graph/, or crates/**
and runs only the incremental-benchmark suite (full build + no-op +
1-file rebuild, both engines). Catches the class of regressions that
accumulated invisibly across the Phase 8.x PRs and were only detected
at v3.12.0 publish time.

The regression guard gains BENCH_CANARY=1 mode: raises thresholds to
50%/100%/150% (standard/noisy/WASM) and skips the build, query, and
resolution suites — only incremental checks run. This absorbs shared-
runner timing variance while still blocking catastrophic regressions
(+98% full build, +1827% 1-file rebuild from v3.12.0).

Closes #1433

* fix(perf): plumb symbolsOnly through parseFilesWasmInline to skip analysis visitors

* fix(perf): add parser.ts to canary paths and free WASM tree on symbolsOnly inline path

Guard the inline-path optimization against regressions by adding
src/domain/parser.ts to the perf-canary paths filter — without it the
canary silently skips exactly the file this PR modifies.

Also free the WASM-backed tree when symbolsOnly=true in parseFilesWasmInline.
The tree was being parsed and then discarded without an explicit .delete() call,
leaking WASM linear memory on every incremental rebuild that triggers the inline
path.  The deletion is guarded by a typeof check, matching the pattern used by
the extractor-error path at line 1078.

Author: carlos-alm

.github/workflows/perf-canary.yml

@@ -19,6 +19,7 @@ on:
     paths:
       - "src/extractors/**"
       - "src/domain/graph/**"
+      - "src/domain/parser.ts"
       - "crates/**"
       - "scripts/benchmark.ts"
       - "scripts/incremental-benchmark.ts"

src/domain/parser.ts

@@ -1198,11 +1198,16 @@ const INLINE_BACKFILL_THRESHOLD = 16;
  *
  * Returns symbols with `_tree` set so `runAnalyses` can run AST/CFG/dataflow
  * visitors via the unified walker (mirrors how WASM-engine results behaved
- * before the worker pool was introduced).
+ * before the worker pool was introduced), unless `symbolsOnly` is true — in
+ * that case `_tree` is not set, skipping all analysis visitor walks. Use
+ * `symbolsOnly` when only definitions/calls/typeMap are needed (e.g. the
+ * this/super dispatch post-pass) to avoid the analysis overhead on the inline
+ * path, matching the optimization already applied to the worker-pool path.
  */
 async function parseFilesWasmInline(
   filePaths: string[],
   rootDir: string,
+  symbolsOnly = false,
 ): Promise<Map<string, ExtractorOutput>> {
   const result = new Map<string, ExtractorOutput>();
   if (filePaths.length === 0) return result;
@@ -1220,7 +1225,18 @@ async function parseFilesWasmInline(
     if (!extracted) continue;
     const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
     const symbols = extracted.symbols as ExtractorOutput & { _tree?: unknown; _langId?: string };
-    symbols._tree = extracted.tree;
+    // When symbolsOnly=true, skip setting _tree so runAnalyses does not run
+    // AST/complexity/CFG/dataflow visitor walks — only definitions/calls/typeMap
+    // are needed by callers like the this/super dispatch post-pass.
+    if (!symbolsOnly) {
+      symbols._tree = extracted.tree;
+    } else if (typeof (extracted.tree as any)?.delete === 'function') {
+      // Free the WASM-backed tree immediately — web-tree-sitter trees are backed
+      // by WASM linear memory and require explicit disposal.  When symbolsOnly is
+      // true the tree is never stored anywhere, so we must delete it here to
+      // avoid leaking WASM heap on every incremental rebuild.
+      (extracted.tree as any).delete();
+    }
     symbols._langId = extracted.langId;
     result.set(relPath, symbols);
   }
@@ -1246,7 +1262,7 @@ export async function parseFilesWasmForBackfill(
   opts: { symbolsOnly?: boolean } = {},
 ): Promise<Map<string, ExtractorOutput>> {
   if (filePaths.length <= INLINE_BACKFILL_THRESHOLD) {
-    return parseFilesWasmInline(filePaths, rootDir);
+    return parseFilesWasmInline(filePaths, rootDir, opts.symbolsOnly);
   }
   return parseFilesWasm(filePaths, rootDir, opts.symbolsOnly ? EXTRACT_ONLY : FULL_ANALYSIS);
 }