[ata-sesli]

Summary

Implements #110. Every index, full or incremental, now goes through the parallel extract/resolve path, whatever its file count or worker count. The sequential passes are deleted, and the parallel resolver gained the results that only the sequential one used to produce.

Stacked on #117. This PR's base is simplify/zova-ops-table. Review and merge #116 and #117 first; GitHub then retargets this PR to main.

Problem

Indexing had two implementations:

• Sequential. pass_definitions.c, pass_calls.c, pass_usages.c, pass_semantic.c and cbm_pipeline_pass_lsp_cross. It ran for repositories with 50 files or fewer, for CBM_WORKERS=1, and for incremental runs touching 50 files or fewer.
• Parallel. pass_parallel.c. It ran for everything else.

Each resolver rule had to be written twice, and "keep in sync" comments asked for that by hand. The two copies had drifted. The same project could get different edges depending on how many files it had or how many workers ran it.

Change

Three commits.

1. fix(pipeline): give the parallel resolver what only the sequential one had

I forced the parallel path for every index and ran the full suite. These were the only failures, and this commit fixes them in pass_parallel.c:

• Interface bases. A class base that resolves to an Interface becomes IMPLEMENTS, not INHERITS.
• FastAPI Depends(fn). It becomes a CALLS edge (strategy: fastapi_depends).
• Local fetch. A call to the project's own fetch is no longer turned into HTTP_CALLS by the arg-URL heuristic (#856).
• Cross-file LSP gate. The gate counted confidence-0 lsp_unresolved rows, so files whose only call was unresolved skipped cross-file LSP. It also ignored callable-reference candidates. It now counts only the rows the CALLS join uses, and also runs when reference candidates outnumber reference rows.

2. refactor(pipeline): run the parallel path for every index

Pipeline routing:

• Full index. pipeline.c always runs run_parallel_pipeline. run_sequential_pipeline and MIN_FILES_FOR_PARALLEL are gone.
• Incremental index. pipeline_incremental.c always extracts and resolves changed files in parallel.
• Callers of changed files. These are re-resolved through a new cbm_parallel_resolve_calls in pass_parallel.c, which uses the same resolve_file_calls as a full index.

Deleted:

• pass_definitions.c and pass_usages.c.
• cbm_pipeline_pass_lsp_cross.
• The sequential half of pass_semantic.c. The Go implicit-interface check remains in that file.
• cbm_pkgmap_build_from_repo / cbm_pkgmap_build_from_files.
• The sequential result cache.

Moved and kept:

• pass_calls.c is now service_bindings.c. It keeps only the two helpers the parallel resolver calls: cbm_pipeline_http_client_call_url (#1916) and cbm_pipeline_external_import_service.
• pass_k8s.c always extracts kustomize and manifest files itself; it no longer reads them from the deleted cache.

CBM_WORKERS=0 already meant one worker. The comment and docs/CONFIGURATION.md no longer say it selects a sequential path.

Tests:

• Parity tests in test_parallel.c. They compared the deleted passes against the parallel path. They now compare a 1-worker run against a 2-worker run.
• Removed test. pipeline_calls_args_overlong_argument_stops_cleanly tested a formatter that only existed in pass_calls.c; parallel_args_json_no_overflow covers the parallel one.
• Arg-URL control. The control in typed_http_no_url_twin_case was skipped for the small fixture because the sequential resolver lacked the heuristic. It now runs for both fixture sizes.

3. fix(pipeline): drop the self-loop of an unresolved route-suffix call

Small-repo parity found one more gap. An unresolved call whose name ends like a route method (request.headers.get('content-type'), unified().use(plugin)) with no route path goes through the callee_suffix fallback. That fallback passes the caller as the target, so its plain CALLS fall-through made a caller→caller self-loop. The sequential resolver never emitted it. Large repos on main already had these self-loops, because they took the parallel path.

New test: pipeline_unresolved_route_suffix_call_adds_no_self_loop. It fails without the fix.

Diff: 30 files, about 3,000 fewer lines.

Output compared with main

Measured with the CLI (index_repository into a fresh cache), main at 616926c vs this branch, macOS arm64. Counts are per node label and per edge type from get_graph_schema.

Repository	Files	Nodes	Edges
medium-cli (TypeScript)	27 indexed	identical (205)	identical (511)
mini-observer (C, Python)	19 indexed	identical (467)	identical (1,411)
this repository (snapshot of main)	686 indexed	identical (22,655)	153,511 → 153,534

The two small repositories took the sequential path on main. They give identical counts, both with the default worker count and with CBM_WORKERS=1.

The large-repository differences are expected:

• CALLS: 36,889 → 36,887. These are the two self-loops removed by commit 3 (httpGet and fetchChecksums in the Go installer).
  • One more edge keeps its endpoints but changes strategy from same_module to lsp_direct, because the cross-file LSP gate in commit 1 now runs for that file.
• SEMANTICALLY_RELATED: 1,940 → 1,965.
  • The changed pairs are almost all near-identical test functions (tests/test_c_lsp.c against other LSP test files) trading one nearest neighbour for another.
  • Semantic vectors are built partly from each function's CALLS neighbours, and CALLS is the only other edge type that changed. These flips most likely come from that change, but I did not isolate the cause with a separate build.
  • Both binaries are deterministic: three runs each gave identical counts.

The other commit 1 fixes add or retype edges only for code this repository does not have: Java/C#/TS interfaces, FastAPI, and a local fetch. On other projects, expect more IMPLEMENTS (fewer INHERITS), new fastapi_depends CALLS, more cross-file LSP CALLS / CALL_REFERENCE, and no HTTP_CALLS for calls to a project's own fetch.

Index time

Wall time of the cli index_repository process; 5 runs per small case, 3 for the large one; median shown.

Repository	Workers	main	this branch
medium-cli	default	0.474 s	0.368 s
medium-cli	1	0.582 s	0.464 s
mini-observer	default	0.687 s	0.463 s
mini-observer	1	0.893 s	0.895 s
this repository	default	17.40 s	17.85 s

Small repositories are as fast or faster on the parallel path. That includes one worker, which used to mean the sequential path.

The large repository is about 2.6% slower (0.45 s over 3 runs each). The likely cause is the wider cross-file LSP gate from commit 1. Peak RSS was 1.11–1.20 GB on main and 1.21–1.28 GB on this branch.

Verification

• Full test suite with CBM_TEST_TIERS=all (macOS arm64): 6,449 passed, 0 failed.
  • That is the 6,449 baseline, minus the deleted pass_calls formatter test, plus the new self-loop test.
  • The probes' UNEXPECTED PASS notes are identical to the base's.
• New test fails without its fix: pipeline_unresolved_route_suffix_call_adds_no_self_loop failed with ASSERT(!(self_loop)) before commit 3.
• Build sources: scripts/check-build-sources.sh passes after the build-list changes.
• Format and lint: clang-format-diff (clang-format 22.1.8) is clean on the changed lines; git diff --check and tests/test_github_workflows.sh pass.
  • Exception: service_bindings.c is the renamed pass_calls.c, and one signature carried over unchanged from main is wrapped differently from clang-format's output. I left it as on main.

Not done

• Many test comments and names still talk about "sequential" and "parallel" routing and MIN_FILES_FOR_PARALLEL. Examples: the _sequential variants in test_pipeline.c, and the probe files test_edge_types_probe.c, test_convergence_probe.c and test_lang_contract.c.
  • Those tests still pass and still test something useful: a small fixture against a padded one, or one worker against several. Renaming them and rewriting their comments is mechanical and would roughly double this diff, so I left it for a follow-up.