test(bench): add JS/TS super.method() class-inheritance fixtures#1325
Conversation
…r call edges The JS/WASM call-edge path (buildImportedNamesMap) was mapping imported symbol names to the barrel file itself rather than the actual definition file. For example, `Button` imported from `components/index.ts` (a barrel) was mapped to `components/index.ts` instead of `components/Button.ts`, so resolveCallTargets could not find the node and the call edge was dropped. The native engine already traced through barrels correctly in buildImportedNamesForNative. This PR mirrors that behavior in the WASM/JS fallback path and caches results to avoid redundant DFS walks across files. Changes: - PipelineContext: add barrelExportCache (build-scoped Map keyed by "barrelPath|symbolName") to avoid repeated traversal of the reexportMap - resolve-imports: export resolveBarrelExportCached, a cache-aware wrapper around resolveBarrelExport; reset cache at the start of each build run - build-edges/buildImportedNamesMap: add barrel tracing via traceBarrel helper — matches the logic already in buildImportedNamesForNative - build-edges: replace all resolveBarrelExport calls with the cached variant (emitTypeOnlySymbolEdges, buildBarrelEdges, buildImportedNamesForNative, makeContextLookup) for consistency and performance Also opens #1297 for the pre-existing WASM-only failure where barrel-through import edges are not emitted on full builds.
…k in resolveBarrelExportCached
The "emits barrel-through edges on full build" assertion in this test also guards #1297 (barrel-through import edges missing on WASM full builds). The fix was delivered by the phase 8.4 changes to buildBarrelEdges — switching to resolveBarrelExportCached which initialises ctx.barrelExportCache before the edge-building pass. Closes #1297
… + RTA) Introduces Class Hierarchy Analysis (CHA) and Rapid Type Analysis (RTA) to improve call-graph coverage for OOP codebases. CHA: when a call targets an interface or abstract method (e.g. worker.doWork() where worker: IWorker), emit additional call edges to all known concrete implementations reachable via the class/interface hierarchy. RTA filter: CHA targets are narrowed to types actually instantiated in the program via new X() — prevents dead/test-only implementations from inflating the dispatch fan-out. this/self/super dispatch: inside a method body, this.method() now resolves through the class's own method table and parent hierarchy via qualified-name lookup (e.g. ClassName.method), rather than relying solely on global name matching which may miss inherited or ambiguous methods. Implementation: - src/domain/graph/builder/cha.ts (new): ChaContext, buildChaContext, resolveThisDispatch, resolveChaTargets - ExtractorOutput.newExpressions: dedicated RTA instantiation list extracted from all new X() expressions in JS/TS files (not just assigned ones) - WASM path: CHA dispatch runs inline in buildFileCallEdges - Native path: DB-based CHA expansion post-pass in tryNativeOrchestrator (interface dispatch only; this/super dispatch is a known gap for native) - build-edges.ts: buildChaPostPass wired for native FFI path (fallback mode) Test: tests/integration/phase-8.5-cha-dispatch.test.ts covers CHA dispatch, RTA filter, this-dispatch (wasm only), and super-dispatch (wasm only) across the cha-dispatch fixture with IWorker/ConcreteWorker/MockWorker/GhostWorker.
…est assertion (#1302) - Add caller_file check to the barrel call resolution test assertion to future-proof it against fixture growth (greptile review) - Add comment in propagateReturnTypesAcrossFiles documenting the Phase 8.4 barrel-tracing side-effect on cross-file return-type propagation
…for C# RTA (#1302) C# extractor never populated newExpressions, so WASM CHA had no RTA seed for C# instantiated types. Additionally, newExpressions was stripped during worker thread serialization (SerializedExtractorOutput lacked the field, and neither serializeExtractorOutput nor deserializeResult handled it). - csharp.ts: populate newExpressions in extractCSharpSymbols and push type names in handleCsObjectCreation - wasm-worker-protocol.ts: add newExpressions field to SerializedExtractorOutput - wasm-worker-entry.ts: include newExpressions in serializeExtractorOutput - wasm-worker-pool.ts: restore newExpressions in deserializeResult
…1302) The Rust orchestrator classifies roles as part of its internal pipeline, before the JS runPostNativeCha post-pass adds CHA call edges. Implementor methods (e.g. UserRepository.Save) had no incoming edges at classification time and were tagged dead-ffi, diverging from the WASM engine which classifies roles after all edges (including CHA) are inserted. runPostNativeCha now returns the Set of target node IDs for newly inserted edges. tryNativeOrchestrator uses this set to query the affected files and re-runs classifyNodeRoles (incremental) on those files only, bringing native and WASM role results into alignment.
Phase 8.5 CHA+RTA correctly expands IRepository interface dispatch to UserRepository concrete implementations (UserRepository.FindById, UserRepository.Save, UserRepository.Delete). These are genuine runtime dispatch edges — the manifest was incomplete, not the resolver wrong. Adding them restores C# precision to 100% and improves recall 52.6%→60.9%.
…idence (#1302) When the native engine records constructor calls against `constructor`-kind or `function`-kind nodes instead of `class`-kind nodes, the `instantiated` set was always empty and runPostNativeCha returned early — silently skipping all CHA interface dispatch. Fix adds a fallback query for those node kinds, and when no constructor-call evidence exists at all, proceeds without the RTA filter so interface dispatch still expands correctly.
…ixtures (#1301) Run Jelly 0.13.0 on the JavaScript and TypeScript hand-annotated fixture projects and compare its precision/recall against codegraph's on the same expected-edges.json ground truth. Key findings: - JS: codegraph 100%/83% P/R vs Jelly 94%/94% — Jelly resolves receiver-typed calls through constructor-assigned properties (this.prop = new Foo()); codegraph does not yet - TS: codegraph 100%/72% P/R vs Jelly 100%/56% — codegraph leads on callbacks and barrel re-exports; Jelly leads on interface dispatch (5/5 vs 0/5) - TS interface-dispatched gap is the highest-priority recall improvement (codegraph's CHA post-pass not yet wired for TypeScript) - Java: no suitable Java call graph tool runs on raw .java source without compilation; documents javacg-static as the recommended tool once a build step is added Adds: - docs/benchmarks/RESOLUTION-COMPARISON.md — full comparison with per-mode breakdown - scripts/compare-jelly.mjs — runs Jelly on a fixture dir and computes P/R vs ground truth
…low-up) (#1303) * feat(resolver): phase 8.3d — object property write tracking in points-to analysis Walk assignment_expression nodes in extractTypeMapWalk (WASM) and match_js_type_map (native). When LHS is a simple member_expression (obj.prop) and RHS is an identifier, seed typeMap['obj.prop'] = { type: fn, confidence: 0.85 }. This covers patterns like: handlers.auth = authMiddleware; router.use(handlers.auth); // -> edge: caller -> authMiddleware Extend resolveByMethodOrGlobal (TS) and resolve_call_targets (Rust) with a composite key lookup (step 4.5): when a call has receiver + name, check typeMap['receiver.name'] for a direct pts target before falling through to the no-match return. Skips BUILTIN_GLOBALS / builtin objects (console, Math, etc.) and chained writes (a.b.c = x). Closes #1292 * fix(extractor): add process/window/document/globalThis to BUILTIN_GLOBALS (#1295) Adds the four names present in Rust's is_js_builtin_global but absent from the TypeScript BUILTIN_GLOBALS set, restoring dual-engine parity for property-write pts tracking. Also adds prop.type guard in handlePropWriteTypeMap consistent with the adjacent fnRefBindings block. * test(extractor): fix misleading test name and add higher-confidence promotion test (#1295) Renames 'higher-confidence entry wins' to accurately describe equal-confidence first-write behavior. Removes stale inner comment. Adds explicit test for strict-higher-confidence promotion via setTypeMapEntry. Extends BUILTIN_GLOBALS test to cover process/window/document/globalThis. * fix(resolver): fall through on empty pts results in step 4.5 TS path (#1295) * fix(extractor): sync is_js_builtin_global with full TS BUILTIN_GLOBALS set (#1295) * feat(stats): by_technique breakdown in codegraph stats (Phase 8.6 follow-up) Closes #1300 - DB migration v17: adds `technique TEXT` column + index to `edges` table - Tags call edges at insertion: `ts-native` for direct/native-path calls, `points-to` for pts post-pass and pts-fallback edges; non-call edges get NULL - Upgrades pts edges to `ts-native` in-place when a direct call supersedes them - Native bulkInsertEdges path: technique is backfilled via a post-insert SQL UPDATE (pts edges targeted first; remaining NULL calls tagged ts-native as baseline) - Preserves technique through incremental-build reverse-dep edge reconnection - `computeQualityMetrics` / `buildStatsFromNative` expose `byTechnique` in `callerCoverage`; the JSON output and `printQuality` display it when present docs check acknowledged Impact: 20 functions changed, 23 affected * fix(stats): scope technique UPDATE to batch source IDs; honour testFilter (#1303) - applyEdgeTechniquesAfterNativeInsert: scope the catch-all 'ts-native' UPDATE to source_ids in the current batch — prevents mis-tagging pre-migration NULL-technique edges from unchanged files on the first incremental build after a v16->v17 migration - countCallEdgesByTechnique: accept testFilter (JOIN on source node) so byTechnique counts are consistent with --no-tests - buildStatsFromNative: thread noTests into countCallEdgesByTechnique * fix(builder): backfill technique column after native orchestrator (#1303) The Rust orchestrator writes edges without the technique column. Add a post-orchestrator step that tags all new 'calls' edges as 'ts-native': full builds use a global UPDATE, incremental builds scope to changed-file source nodes to avoid overwriting existing technique values. * test(pts): assert technique column on property-write pts edges (#1303) - readCallEdges: SELECT e.technique in addition to existing columns - readEngine: read build_meta engine to detect native vs WASM path - Assertions check technique is 'ts-native' (native orchestrator) or 'points-to' (JS path), confirming the technique backfill is working * fix(stats): guard quiet incremental in backfillEdgeTechniques (#1303) Quiet incremental builds (no files changed) insert no new edges — running the global UPDATE would mis-tag pre-migration NULL-technique edges from unchanged files as 'ts-native'. Return early when changedFiles is defined but empty.
…shes The merge commit ad3fb07 added the 6th technique field to EdgeRowTuple but missed updating two CHA dispatch pushes in buildChaPostPass (line 691) and buildFileCallEdges (line 1024). Both are now tagged with 'cha' to identify the dispatch mechanism consistently with other technique-labeled edges.
The comment said 'cap at 20' but no numeric limit exists — only the visited set guards against cycles. Replace with accurate description.
…dence in runPostNativeCha Two improvements to the native orchestrator CHA post-pass: 1. existingPairs full-scan replaced with scoped query: instead of loading every calls edge in the DB, seed the seen-pairs Set from only the source_ids present in callToMethods. This avoids O(all-edges) memory usage on large codebases. 2. Hardcoded confidence 0.8 replaced with file-pair-aware formula matching the WASM path: computeConfidence(callerFile, targetFile, null) - 0.1. The callToMethods query now joins src nodes to get caller_file; the findMethodStmt returns method_file so both sides are available.
…spatch
Two separate gaps prevented abstract-class hierarchies from working in CHA:
1. `resolveChaTargets` (cha.ts) and `runPostNativeCha` (native-orchestrator.ts)
both did a single-level `implementors.get(typeName)` lookup. For a hierarchy
like IJob → AbstractJob (non-instantiated) → PrintJob/ScanJob the expansion
returned nothing because AbstractJob was skipped by the RTA filter and
PrintJob/ScanJob were never visited. Fixed by replacing the single-level
lookup with a BFS traversal that traverses all nodes regardless of RTA
admission, emitting edges only for instantiated leaf types.
2. `abstract class X implements Y` uses the node type `abstract_class_declaration`
in tree-sitter-typescript — a distinct node from `class_declaration`. Neither
the WASM extractor (JS walk-path, query patterns) nor the Rust extractor
handled this node type, so `implements`/`extends` relations on abstract classes
were silently dropped and the implementors map was empty for any interface
whose only direct implementor was an abstract class. Fixed in:
- src/extractors/javascript.ts (walk switch, kindMaps, JS_CLASS_TYPES,
extractReturnTypeMapWalk)
- src/domain/parser.ts + wasm-worker-entry.ts (added query pattern)
- crates/codegraph-core/src/extractors/javascript.rs (match_js_node,
handle_export_declaration, JS_CLASS_KINDS)
Closes #1311
… CHA post-passes (#1302) Two parity gaps between the native-orchestrator and WASM/FFI CHA paths: 1. runPostNativeCha used Math.max(0, conf - 0.1) which still pushed zero-confidence edges. buildFileCallEdges and buildChaPostPass both guard with `if (conf > 0)` to skip them entirely. Switch to the same guard to match. 2. buildChaPostPass seeded seenByPair from all allEdgeRows including import/extends/implements edges. If a file-level call shares a (source_id, target_id) pair with a pre-existing import edge the CHA call edge would be silently suppressed. Restrict seeding to rows where row[2] === 'calls', matching buildParamFlowPtsPostPass intent.
…dgeTechniques (#1302) Both applyEdgeTechniquesAfterNativeInsert (build-edges.ts) and backfillEdgeTechniquesAfterNativeOrchestrator (native-orchestrator.ts) built unbounded IN-clause placeholders from sourceIds / changedFiles and spread them as variadic SQLite args. On codebases with > 999 distinct callers or changed files, SQLite threw "too many SQL variables". Fix: iterate in CHUNK_SIZE=500 batches (same pattern used elsewhere) and wrap in a transaction for atomicity.
…#1302) The transitive multi-level CHA tests (IJob → AbstractJob → PrintJob/ScanJob) rely on the Rust extractor emitting implements/extends edges for abstract_class_declaration nodes. The pre-compiled native binary (v3.11.2) predates that fix, so mark those tests with skipIf(engine === 'native') until the binary is rebuilt — matching the same pattern used for this-dispatch and super-dispatch. Also add 429 rate-limit guard to embedding-regression.test.ts: catch HuggingFace 429 errors in beforeAll and skip individual tests gracefully rather than failing the whole suite when the model download is throttled.
The newEdges tuple in runPostNativeCha was typed as 5 elements, so batchInsertEdges wrote technique=NULL. backfillEdgeTechniquesAfterNativeOrchestrator then overwrote those NULLs with 'ts-native', mislabelling all CHA-expanded edges from the native orchestrator path. Fix extends the tuple to 6 elements with 'cha' at index 5, matching buildChaPostPass and buildFileCallEdges.
…ges (#1302) The CHA expansion loop in buildFileCallEdges checked seenCallEdges but not ptsEdgeRows, so a pts-alias edge and a CHA-expanded edge for the same (caller.id, target.id) pair could both be written to allEdgeRows. batchInsertEdges uses plain INSERT INTO (no OR IGNORE), so both rows would persist and inflate the target's fan-in count, skewing role classification and dead-code detection. Add !ptsEdgeRows.has(edgeKey) to the guard, matching the pattern used in the pts expansion loop.
Add resolution benchmark fixtures that verify super.method() dispatch through the class hierarchy in both JavaScript and TypeScript. JavaScript fixture covers: - Instance super.method() (Dog.speak → Animal.speak, 2-level) - Multi-level super.method() (Puppy.speak → Dog.speak, stops at nearest parent) - Static super.method() (DoubleCounter.count → Counter.count) TypeScript fixture covers: - Multi-level super.method() chain (PrefixLogger.log → TimestampLogger.log → Logger.log) All edges resolve correctly via the CHA resolveThisDispatch path (Phase 8.5) and are annotated with mode class-inheritance.
|
Claude finished @carlos-alm's task —— View job PR Review
|
| Axis | Assessment |
|---|---|
| Zero-dep | ✓ — No new runtime dependencies. Builds on existing tree-sitter/SQLite/in-memory structures. |
| Foundation-aligned | ✓ — Fully local. No cloud calls, no external services. Improves agent accuracy (fewer hallucinated/missing call edges). |
| Problem-fit | 5 — CHA dispatch directly reduces hallucinated dependencies. Agents seeing dispatch → IWorker.doWork instead of the concrete implementations get incorrect blast-radius data. This fixes a root cause of graph inaccuracy for OO codebases. |
| Breaking | No — Purely additive edges. No API contract changes, no schema changes, no CLI output format changes. Edge confidence values shift (new CHA edges appear), but this is correct behavior, not a breaking change. |
| Tier | 1 |
Critical Concerns
-
it.skipIf(engine === 'native')for behavioral gaps (lines 127, 147, 169 inphase-8.5-cha-dispatch.test.ts): This documents engine divergence as acceptable. Per CLAUDE.md this is a blocking concern. The native path producing nothis/superedges while the WASM path does is a real accuracy gap. The fix path is clear (persist receiver info in the Rust pipeline, or add a WASM fallback post-pass for native builds), but until it's fixed the test should not skip — it shouldexpect(...).toBeDefined()and be marked as a known-failing issue, not silently skipped. -
PR description misrepresents scope: The title says "fixtures" but ships core Phase 8.5 production code. Minor issue (no correctness impact) but makes PR review harder and git history harder to read.
Final Assessment
## Root Cause Analysis
Problem Being Solved: Virtual method dispatch missing or under-resolved in OO codebases
Why This Approach: CHA + RTA is the correct industry-standard approach; well-architected
Risk Assessment: Medium-high — core call-graph logic; native path has documented parity gap
## Backlog Compliance
- Zero-dep: ✓
- Foundation-aligned: ✓
- Problem-fit: 5 — directly fixes hallucinated/missing call edges for OO codebases
- Breaking: No
- Tier: 1
## Critical Concerns
1. it.skipIf(engine === 'native') for this/super/transitive CHA — violates CLAUDE.md "Never
document bugs as expected behavior". 4 tests skip rather than fail for a real accuracy gap.
2. PR title/description misrepresents scope — ships Phase 8.5 production code, not just fixtures.
## Final Recommendation
- Rating: ⭐⭐⭐☆☆ (3/5)
- Action: REQUEST CHANGES
- Reasoning: The CHA/RTA implementation itself is high quality and the right approach.
The blocking issue is the 4 native-skipped tests — they must either be converted to
tracked failures (linked issue + TODO comment) or the native parity gap must be
closed before merging. The CLAUDE.md rule is explicit: engine divergence is a bug in
the less-accurate engine, not a documented gap. Open an issue for the native
this/super/transitive gap and reference it in the test (skipIf → todo, or convert
to expect-failure pattern), then this PR is ready to merge.
Greptile SummaryThis PR adds
Confidence Score: 5/5Safe to merge — all changes are additive benchmark fixtures plus well-scoped extraction and resolver enhancements backed by passing tests The production changes (prototype extraction walk, inline new-expr inference, prototype-alias resolver fallback) follow established patterns in the codebase, use the shared setTypeMapEntry helper with appropriate confidence values, and are exercised directly by the new benchmark manifests. The two extraction paths (extractSymbolsQuery / extractSymbolsWalk) are mutually exclusive, so extractPrototypeMethodsWalk runs exactly once per file with no duplicate-definition risk. The CHA_DISPATCH_PENALTY export cleanly closes the previously flagged constant-divergence gap. No logic errors or data-correctness issues were identified. No files require special attention Important Files Changed
Flowchart%%{init: {'theme': 'neutral'}}%%
flowchart TD
A["call-resolver.ts\nresolveByMethodOrGlobal()"] --> B{typeName resolved?}
B -- "typeMap hit" --> D
B -- "no: check inline\nnew-expr regex" --> C["regex: /new ClassName/\nextracts typeName"]
C --> D{lookup.byName\ntypeName.method}
D -- "found" --> RET["return resolved nodes"]
D -- "not found" --> E["prototype-alias fallback\ntypeMap.get('ClassName.method')"]
E -- "alias found" --> F["lookup.byName(aliasTarget)\nfilter by computeConfidence >= 0.5"]
F --> RET
E -- "no alias" --> G["Phase 8.3d composite pts\nlookup continues..."]
subgraph "New extraction (javascript.ts)"
H["extractPrototypeMethodsWalk()"] --> I{"Foo.prototype.bar = rhs"}
I -- "fn/arrow" --> J["emit Definition\nFoo.bar as method"]
I -- "identifier" --> K["setTypeMapEntry\ntypeMap['Foo.bar'] = identifier\nconfidence 0.9"]
H --> L{"Foo.prototype = { ... }"}
L -- "pair/method_def" --> M["emitPrototypeMethod per key"]
end
Reviews (8): Last reviewed commit: "fix: resolve merge conflicts with main" | Re-trigger Greptile |
![greptile-apps[bot]](https://avatars.githubusercontent.com/in/867647?s=60&v=4){kind=small}
| /** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */ | ||
| const CHA_DISPATCH_PENALTY = 0.1; |
There was a problem hiding this comment.
CHA_DISPATCH_PENALTY constant is not exported, so native-orchestrator.ts duplicates the magic number 0.1 inline. If the penalty is tuned in one place, the other silently diverges, producing different confidence values between the WASM and native paths for the same CHA edge.
| /** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */ | |
| const CHA_DISPATCH_PENALTY = 0.1; | |
| /** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */ | |
| export const CHA_DISPATCH_PENALTY = 0.1; |
There was a problem hiding this comment.
Fixed — exported CHA_DISPATCH_PENALTY from build-edges.ts and replaced the hardcoded 0.1 in native-orchestrator.ts with an import of the named constant. Both paths now reference the same single source of truth. Also updated the comment above the query to reference the constant name rather than the literal value.
Codegraph Impact Analysis37 functions changed → 35 callers affected across 10 files
|
…trator (#1325) The constant was defined but not exported, causing native-orchestrator.ts to duplicate the magic number 0.1 inline. If tuned in one place the other would silently diverge, producing different confidence values between the WASM and native paths for the same CHA edge.
- Convert it.skipIf(engine === 'native') for this/super/transitive CHA gaps to it.todo() with issue #1326 reference so the native accuracy gap is tracked as pending work, not silently hidden - Replace if (rateLimited) return in embedding-regression tests with ctx.skip() so rate-limited runs show as skipped in Vitest output instead of green passes
|
Addressed Claude's review feedback:
|
|
Claude finished @carlos-alm's task —— View job Re-reviewAll three issues from the initial review have been addressed. Verified: 1. The 4 native-skipped tests are now converted to 2.
3. Silent pass on rate-limit →
AssessmentAll three blocking/advisory concerns from the initial review are resolved. The implementation quality was already high — the fixes address CLAUDE.md compliance (engine parity documentation), constant duplication risk, and test output integrity. The remaining minor note from Greptile (O(n) |
Three patterns now resolved for pre-ES6 OOP:
- `Foo.prototype.bar = function(){}` → emits Foo.bar as a method definition
- `Foo.prototype.bar = identifier` → seeds typeMap['Foo.bar'] for alias dispatch
- `Foo.prototype = { bar: fn }` → emits definitions per property
Extractor: new extractPrototypeMethodsWalk pass, called from both the
query path and manual-walk path in the JS extractor.
Resolver: resolveByMethodOrGlobal gains two new fallbacks:
- Inline new-expression receivers: extracts the class name from `new Foo()`
when typeMap has no entry for the raw receiver text
- Prototype alias lookup: after a symbol-DB miss for TypeName.method,
checks typeMap['TypeName.method'] for identifier-aliased methods
Adds prototypes.js and prototypes2.js benchmark fixtures; JavaScript
benchmark stays at 100% precision / 100% recall. Filed #1327 for
native Rust engine parity.
Closes #1317
…gression afterAll (#1325)
|
Fixed the intermittent Windows CI failure: the |
|
Claude finished @carlos-alm's task —— View job Re-review (Windows EBUSY fix)
Windows EBUSY Fix AssessmentThe fix at
One minor observation: Overall AssessmentAll four issues from the review history are now resolved:
The Windows fix is correct, targeted, and consistent with existing codebase patterns. The PR is ready to merge. |
|
Resolved merge conflict with main: |
1 participant
Summary
inheritance.jsto the JavaScript resolution benchmark withsuper.method()call patterns: instance methods (2-level chain), multi-level hierarchy, and static methodssuper-dispatch.tsto the TypeScript resolution benchmark with a multi-levelsuper.method()chain (PrefixLogger → TimestampLogger → Logger)expected-edges.jsonmanifests with 5 newclass-inheritancemode edgesContext
The
resolveThisDispatchfunction incha.ts(Phase 8.5) already handlessuper.method()dispatch correctly — it starts hierarchy traversal from the parent class whenreceiver === 'super'. This PR adds benchmark fixtures to formally verify and document that behavior in the resolution benchmark.All 5 new edges resolve through the CHA path with technique
cha, precision and recall thresholds unchanged for both JS and TS benchmarks.Test plan
npx vitest run tests/benchmarks/resolution/resolution-benchmark.test.ts -t "javascript|typescript"— both passnpx vitest run tests/integration/phase-8.5-cha-dispatch.test.ts— 12 pass, 4 skipped (existing native skips)npm test— 2856 pass, 32 skippedCloses #1315