Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
wip: Smart CI narrows PR CI for real (pre-rebase checkpoint)
Martin Vogel7f6f56784066
diff --git a/.codebase-memory.json b/.codebase-memory.jsonindex 448c14f6f..80f8b521f 100644--- a/.codebase-memory.json+++ b/.codebase-memory.json@@ -14,12 +14,27 @@},{"id": "engine",- "paths": [".codebase-memory.json", "src/mcp/test_impact*", "src/store/store_impact.*"],+ "paths": [+ ".codebase-memory.json",+ "src/mcp/test_impact*",+ "src/store/store_impact.*",+ "scripts/test-impact/**",+ "scripts/ci/test-impact-*"+ ],"action": "run_all"},{"id": "build",- "paths": ["scripts/**", "test-infrastructure/**", "pkg/**"],+ "paths": [+ "scripts/build.sh",+ "scripts/env.sh",+ "scripts/test.sh",+ "scripts/run-tests-parallel.sh",+ "scripts/suite-failure-report.sh",+ "scripts/ci/verify-shard-union.sh",+ "scripts/embed-frontend.sh",+ "/.gitattributes"+ ],"action": "run_all"},{@@ -35,13 +50,31 @@},{"id": "contracts",- "paths": ["tests/**/*.{sh,py,json,txt}"],+ "paths": ["tests/**/*.{sh,py,json,txt,ps1}"],"action": "ignore"},{"id": "notices","paths": ["NOTICE*", "CHANGELOG*", "THIRD_PARTY*"],"action": "ignore"+ },+ {+ "id": "repo-data",+ "paths": [+ "scripts/**",+ "pkg/**",+ "test-infrastructure/**",+ "docs/**",+ "**/*.md",+ "graph-ui/**",+ "tools/**",+ "tests/fuzz/corpus/**",+ "/{.clang-format,.clang-tidy,.cppcheck,.gitignore,.gitleaksignore,DCO,Formula}",+ "/{flake.lock,flake.nix,glama.json,install.ps1,install.sh,server.json}"+ ],+ "action": "referencing_tests",+ "key": "path",+ "unreferenced": "ignore"}],"unmapped_files": "run_all",diff --git a/.github/workflows/_test.yml b/.github/workflows/_test.ymlindex 0a1f0c488..39baa516c 100644--- a/.github/workflows/_test.yml+++ b/.github/workflows/_test.yml@@ -25,7 +25,7 @@ on:type: stringdefault: alltest_selection:- description: 'PR test selection (smart CI): the artifact the select-tests job uploaded; the test-unix and test-windows legs run only its tests. Empty = every test (dry run, release, and any PR the selection does not narrow)'+ description: 'PR test selection (smart CI): the artifact the select-tests job uploaded; the Linux x86_64 test-unix leg runs only its tests, the arm64, macOS and Windows legs run every test. Empty = every test (dry run, release, and any PR the selection does not narrow)'type: stringdefault: ''@@ -222,7 +222,11 @@ jobs:ccache-test-${{ matrix.os }}-${{ matrix.cc }}-- name: Fetch the test selection- if: ${{ inputs.test_selection != '' }}+ # Only the Linux x86_64 leg narrows (user decision 2026-10-16): the+ # coverage that justifies an omission comes from the Linux x86_64+ # producer, so arm64, macOS and Windows code under #ifdef has static+ # evidence only and those legs run every test.+ if: ${{ inputs.test_selection != '' && runner.os == 'Linux' && runner.arch == 'X64' }}uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1with:name: ${{ inputs.test_selection }}@@ -234,7 +238,7 @@ jobs:CBM_TEST_SHARD: ${{ matrix.shard }}CBM_TEST_LEG: ${{ matrix.os }}-${{ matrix.cc }}CBM_SKIP_PERF: ${{ inputs.skip_perf && '1' || '' }}- CBM_TEST_SELECTION_DIR: ${{ inputs.test_selection != '' && format('{0}/test-selection', runner.temp) || '' }}+ CBM_TEST_SELECTION_DIR: ${{ inputs.test_selection != '' && runner.os == 'Linux' && runner.arch == 'X64' && format('{0}/test-selection', runner.temp) || '' }}CCACHE_DIR: ${{ github.workspace }}/.ccacheCCACHE_MAXSIZE: 1500M@@ -617,13 +621,6 @@ jobs:ccache-test-${{ matrix.os }}-${{ matrix.msystem }}-${{ github.ref }}-ccache-test-${{ matrix.os }}-${{ matrix.msystem }}-- - name: Fetch the test selection- if: ${{ inputs.test_selection != '' }}- uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1- with:- name: ${{ inputs.test_selection }}- path: ${{ runner.temp }}/test-selection-- name: Testshell: msys2 {0}# AddressSanitizer is unavailable on native ARM64 Windows (LLVM ships no@@ -651,7 +648,8 @@ jobs:CBM_TEST_SHARD: ${{ matrix.shard }}CBM_TEST_LEG: ${{ matrix.os }}-${{ matrix.msystem }}CBM_SKIP_PERF: ${{ inputs.skip_perf && '1' || '' }}- CBM_TEST_SELECTION_DIR: ${{ inputs.test_selection != '' && format('{0}/test-selection', runner.temp) || '' }}+ # Windows legs run every test: see the Linux x86_64-only fetch in test-unix.+ CBM_TEST_SELECTION_DIR: ''CCACHE_DIR: ${{ github.workspace }}/.ccacheCCACHE_MAXSIZE: 1500Mdiff --git a/docs/SMART_CI.md b/docs/SMART_CI.mdnew file mode 100644index 000000000..93d474d34--- /dev/null+++ b/docs/SMART_CI.md@@ -0,0 +1,504 @@+# Smart CI: pull-request test selection on GitHub Actions++Smart CI runs, for each pull request, only the CI jobs and tests that the+change can reach. This page explains how this repository does it and how+another repository on GitHub Actions could do the same with the released+`codebase-memory-mcp` binary.++Status: experimental. Every answer carries `"experimental": true`. The+selection narrows real test runs only while the repository variable+`TEST_IMPACT_MODE` is `gate`; otherwise it runs in report-only (shadow) mode.++> **Read the scope section before you start.** The lane layer is a pattern+> any repository can copy. The test layer narrows only C/C++ code whose tests+> follow this repository's test-framework conventions (or declared+> equivalents), and only with a per-test coverage map that you must produce+> yourself. In any other repository the engine answers "run everything". That+> is safe, but it saves nothing.++## The guarantee++Smart CI never runs fewer tests unless it can show that the omitted tests+cannot be affected. When it is unsure, it runs everything:++- a path that no rule knows, an empty or truncated file list, or a change to+ the selection's own configuration, tooling or workflows;+- a shallow clone, a diff that cannot be read in full, or an invalid config;+- no coverage map, or a coverage map that is not admitted (wrong commit, more+ than 7 days old, made for another platform or harness);+- a change that reaches the test runner's `main`;+- any failure of the selection job itself.++Each of these makes the run cost more CI minutes. None of them loses coverage.++## Two layers++```+changed files ──► Layer 1: lane selector ──► which CI jobs run+ (scripts/ci/select-lanes.sh, your own rules)+ │+ ▼ (Linux test legs only, in this repo)+merge base + PR ─► Layer 2: test-impact engine ─► which suites / tests run+ (codebase-memory-mcp test-impact select+ + team-artifact bundle from main)+```++| | Layer 1: lanes | Layer 2: tests |+|---|---|---|+| Question | Which jobs (lint, test legs, smoke, sanitizers) does this PR need? | Inside a test job, which suites and tests? |+| Input | The PR's changed-file list | Git history, the code graph, a per-test coverage map |+| Implementation | `scripts/ci/select-lanes.sh` (repository-specific rules) | The binary's `test-impact select` subcommand |+| Unknown input | Every lane runs | Every test runs (`run_all` with reasons) |+| Portable? | As a pattern: you write your own rules | C/C++ with supported test conventions only (see below) |++## Can your repository use it?++| Piece | General? | What you provide |+|---|---|---|+| Lane selection (Layer 1) | Pattern only | Your own path → category → lanes rules. `select-lanes.sh` encodes this repository's paths. |+| Engine (`test-impact select`) | Ships in the binary | Nothing to build. |+| Source languages it can narrow | **C family only**: `.c .h .cc .cpp .hpp .m .mm .cxx .hh` | Every other changed file must match a config rule (`ignore`, `referencing_tests`, ...). Otherwise the answer is `run_all` (`UNMAPPED_FILE`). |+| Test model | **C family only** | The `c-cbm` preset (this repository's `TEST`/`SUITE`/`RUN_TEST`/`RUN_SELECTED_SUITE` macros, see `tests/test_framework.h`), or custom `tests.conventions` records for equivalent C macros. |+| Coverage map | **Required to narrow at all** | Format-1 files (`functions.tsv`, `tests.tsv`, `meta.json`). This repository produces them with an LLVM-instrumented runner and `scripts/test-impact/coverage-map.py`, which are both specific to its harness. |+| Runner filter | Pattern | A test runner that can run a `suite` / `suite:test` list and fails when a listed test does not exist. |++The other presets (`pytest`, `go`, `junit`, `gtest`, `rust`, `jest`) are+accepted switches, but the engine does not model them. An enabled `gtest`+blocks narrowing for C++ files. Custom `tests.conventions` are covered by the+model's unit tests. The engine's end-to-end tests use `c-cbm` only. Treat+custom conventions as unproven until you have shadow evidence.++Without admitted coverage the engine marks every suite `whole`, and the lane+reports `run_all`. Static reachability alone never omits a suite.++## Prerequisites++1. **The binary, pinned.** Use the same release in the producer and the PR+ jobs. Download that release's Linux archive and verify it against the+ release's `checksums.txt`, as this repository's shadow job does+ (`scripts/ci/test-impact-shadow.sh --fetch-release`):++ ```bash+ CBM_VERSION=vX.Y.Z # a release that contains the features you use (see below)+ asset=codebase-memory-mcp-linux-amd64.tar.gz+ gh release download "$CBM_VERSION" --repo DeusData/codebase-memory-mcp \+ --pattern "$asset" --pattern checksums.txt --dir "$RUNNER_TEMP/cbm"+ (cd "$RUNNER_TEMP/cbm" && grep " $asset\$" checksums.txt | sha256sum -c - &&+ tar -xzf "$asset" codebase-memory-mcp)+ "$RUNNER_TEMP/cbm/codebase-memory-mcp" --version+ ```++ For a quick start, `install.sh` installs the latest release with the same+ checks (HTTPS only, SHA-256 against `checksums.txt`, the archive's member+ list, `--version`); `--skip-config` skips agent configuration, which a CI+ runner does not need. It has no version flag, so it is not a pin.++ **Version note.** `v0.12.0` has `test-impact select`/`publish`. It does+ not have `key: "path"`, `unreferenced`, `--vetoed-out` or `run_all_rules`;+ they ship in the first release after `v0.12.0`. With `v0.12.0`, a config+ that uses those keys is invalid, and every answer is `run_all`. Until that+ release, build the binary from source (`make -f Makefile.cbm cbm`), as this+ repository's producer and `select-tests` jobs do.++2. **Full git history.** Check out with `fetch-depth: 0` in every job that+ runs the engine. The engine verifies the history it diffs and refuses a+ shallow clone (`GIT_UNAVAILABLE`, everything runs).++3. **A runner that runs a named subset.** See "The test job" below.++4. **A coverage producer on the default branch** that writes the format-1 map+ for every test, child processes included. A test whose coverage is+ uncertain must be marked `incomplete`. An incomplete test is always+ selected.++5. **`gh`, `python3`, and `GH_TOKEN` with `actions: read`** in the PR job, to+ fetch the bundle. GitHub-hosted runners include `gh` and `python3`.++## Recipe++Copy these files from this repository and adapt the marked lines:++| File | Adapt |+|---|---|+| `scripts/ci/test-impact-bundle.sh` | `WORKFLOW=` (producer file name) and the hard-coded `main` branch filter. |+| `scripts/ci/test-impact-select.sh` | `--lane unit` (your lane name) and the `PLATFORM` default (must equal the producer's). |+| `scripts/test-impact/selection.py` | Nothing, if your runner accepts `suite` / `suite:test` lines. |++### (a) Producer: publish a bundle for every commit on main++The bundle holds the commit's frozen graph, its coverage map and a+`receipt.json` that binds both by SHA-256. It is uploaded as the Actions+artifact `test-impact-<sha>`. `test-impact-bundle.sh` accepts a bundle only+from a successful `push`, `schedule` or `workflow_dispatch` run of the+producer workflow, in the same repository, on `main`, whose head is exactly+the requested commit.++```yaml+# .github/workflows/test-impact-artifact.yml (the name test-impact-bundle.sh looks for)+name: test-impact-artifact+on:+ push:+ branches: [main]+ schedule:+ - cron: "23 3 * * 0" # weekly full refresh+ workflow_dispatch:+permissions:+ contents: read+ actions: read # fetch the previous bundle (incremental mode)+concurrency:+ group: test-impact-artifact # bundles chain: never overlap, never cancel+ cancel-in-progress: false+jobs:+ publish:+ runs-on: ubuntu-24.04+ steps:+ - uses: actions/checkout@<pinned-sha>+ with:+ fetch-depth: 0+ persist-credentials: false+ - name: Install codebase-memory-mcp+ run: <the pinned install from Prerequisites>+ - name: Per-test coverage map # YOURS: format 1, see coverage-map.py+ run: |+ echo "OBSERVED=$(date +%s)" >> "$GITHUB_ENV" # when the coverage run starts+ ./ci/coverage-map.sh --out "$RUNNER_TEMP/coverage"+ - name: Publish the bundle+ run: |+ export CBM_CACHE_DIR="$RUNNER_TEMP/ti-cache"+ export CBM_RUNTIME_DIR="$(mktemp -d /tmp/cbm-rt.XXXXXX)" # short: sun_path+ mkdir -p "$RUNNER_TEMP/ti-work" && chmod 700 "$RUNNER_TEMP/ti-work"+ "$RUNNER_TEMP/cbm/codebase-memory-mcp" test-impact publish \+ --repo "$GITHUB_WORKSPACE" --out "$RUNNER_TEMP/bundle" \+ --work "$RUNNER_TEMP/ti-work" --coverage "$RUNNER_TEMP/coverage" \+ --observed-at "$OBSERVED" --platform linux-x86_64-clang21+ - uses: actions/upload-artifact@<pinned-sha>+ with:+ name: test-impact-${{ github.sha }}+ path: ${{ runner.temp }}/bundle+ include-hidden-files: true # the graph lives in .codebase-memory/+ retention-days: 30+ if-no-files-found: error+```++This repository's producer (`.github/workflows/test-impact-artifact.yml` with+`scripts/ci/test-impact-publish.sh`) adds an incremental mode. A push re-runs+coverage only for the suites that its own selection picks and merges them into+the previous map (`coverage-merge.py`). The graph is built incrementally from+the previous bundle (`--previous`). The weekly run rebuilds everything and+fails if the incremental graph topology differs from the full one. The+incremental mode is an optimisation. A full coverage run on every push is+simpler and just as correct.++The receipt keeps the time of the oldest coverage observation. An incremental+publish carries it forward unchanged. A map whose oldest observation is more+than 7 days old is refused (`TOO_OLD`), so a full refresh has to run more often+than that.++### (b) PR job, shadow mode (report only)++```yaml+ test-impact-shadow:+ runs-on: ubuntu-latest+ continue-on-error: true # can never block or pass a merge+ permissions:+ contents: read+ actions: read # the merge base's bundle+ steps:+ - uses: actions/checkout@<pinned-sha>+ with:+ fetch-depth: 0+ persist-credentials: false+ - name: Install codebase-memory-mcp+ run: <the pinned install from Prerequisites>+ - name: Select with the team artifact (shadow)+ env:+ GH_TOKEN: ${{ github.token }}+ run: scripts/ci/test-impact-select.sh --binary "$RUNNER_TEMP/cbm/codebase-memory-mcp" --out "$RUNNER_TEMP/test-impact"+ - uses: actions/upload-artifact@<pinned-sha>+ if: ${{ always() }}+ with:+ name: test-impact-prediction+ path: |+ ${{ runner.temp }}/test-impact/selection-engine.json+ ${{ runner.temp }}/test-impact/summary-engine.md+```++Leave this job out of your aggregate required check. What+`test-impact-select.sh` does:++1. Takes the base side of the PR merge commit (`HEAD^1`) and fetches that+ commit's bundle.+2. If the producer skipped that commit (merge bursts: GitHub keeps one pending+ run per concurrency group), it uses the nearest first-parent ancestor that+ has a bundle, up to 20 commits back, and diffs against that ancestor. If the+ PR reverts a change that main made after the ancestor, the ancestor's map+ cannot speak for that file, so the script selects without coverage (the+ revert guard).+3. Passes `--artifact-verified` only for a bundle that it fetched and checked+ itself. Nothing inside a bundle can assert where the bundle came from.+4. Runs `test-impact select` and writes `selection-engine.json`. It also+ writes a Markdown summary to the job's step summary.++The engine reads `.codebase-memory.json` from the **merge base**, not from the+PR. A PR cannot loosen its own selection. A PR that changes the config runs+everything (`builtin:test-impact-config`).++### (c) Gate job and the test job++```yaml+ select-tests:+ if: ${{ vars.TEST_IMPACT_MODE == 'gate' }}+ runs-on: ubuntu-24.04+ permissions:+ contents: read+ actions: read+ outputs:+ selection: ${{ steps.select.outputs.selection }}+ steps:+ - uses: actions/checkout@<pinned-sha>+ with:+ fetch-depth: 0+ persist-credentials: false+ - name: Install codebase-memory-mcp+ run: <the pinned install from Prerequisites>+ - id: select+ env:+ GH_TOKEN: ${{ github.token }}+ run: scripts/ci/test-impact-select.sh --binary "$RUNNER_TEMP/cbm/codebase-memory-mcp" --out "$RUNNER_TEMP/test-impact" --gate "$RUNNER_TEMP/test-selection"+ - if: ${{ steps.select.outputs.selection == 'narrowed' }}+ uses: actions/upload-artifact@<pinned-sha>+ with:+ name: test-selection+ path: ${{ runner.temp }}/test-selection+ if-no-files-found: error++ test:+ needs: [select-tests]+ if: ${{ !cancelled() }} # a skipped or failed select-tests must NOT skip the tests+ runs-on: ubuntu-latest+ steps:+ - uses: actions/checkout@<pinned-sha>+ - if: ${{ needs.select-tests.result == 'success' && needs.select-tests.outputs.selection == 'narrowed' }}+ uses: actions/download-artifact@<pinned-sha>+ with:+ name: test-selection+ path: ${{ runner.temp }}/test-selection+ - run: ./ci/run-tests.sh # YOURS: narrows only if test-only.txt is present+```++With `--gate DIR`, the script runs `selection.py filter … --lane unit` and+writes `selection=narrowed` or `selection=all` to `$GITHUB_OUTPUT`. A narrowed+answer writes:++- `DIR/test-only.txt`: one token per line, either `suite` (run the whole+ suite) or `suite:test`;+- `DIR/optional-suites.txt`: selected suites that are registered only under a+ preprocessor condition. A build may lack them.++Everything else means `all`: a `run_all` answer, an unknown schema or filter+encoding, a filter that disagrees with the lane's suite list, a crash, and a+lane that selects nothing. The test job then gets no selection and runs every+test.++**The test job's runner** has to keep the same contract as this repository's+runner (`scripts/test.sh` → `scripts/run-tests-parallel.sh` →+`CBM_TEST_ONLY_FILE`, read by `tests/test_main.c`):++- launch only the suites that the tokens name, and only the named tests inside+ a `suite:test` suite;+- **fail** when the selection names a suite the build does not register,+ unless `optional-suites.txt` lists it;+- **fail** when a selected test cannot be found;+- **fail** when a selection was promised but the file is missing or empty.++A selection that is silently ignored, or partly ignored, would turn a narrowing+into missed coverage.++**A runner that starts itself again.** Tests often spawn the test binary as a+child (`<runner> __probe_x ...`) and its `main` hands over to a probe. A change+that reaches `main` reaches every test, so the engine runs everything+(`RUNNER_REACHED`). List the probes instead in a table in the runner's source,+one entry per line, as `tests/test_main.c` does:++```c+TF_ROLE(TF_PHASE_SEAMED, "__cbm_sockprobe", tf_maybe_run_socket_probe),+TF_ROLE(TF_PHASE_WORKER, "--index-worker", tf_maybe_run_index_worker),+TF_ROLE(TF_PHASE_SPAWNER, "CBM_INDEX_SUPERVISOR", tf_maybe_run_index_worker),+```++The engine reads the table: a change that only a probe's handler reaches+selects the tests whose source names one of that handler's literals (the argv+the child gets, or a switch that lets production code start it). A reached+handler that no test names, and a change reaching `main` any other way, still+run everything; the engine note names the call chain into `main`.++**Only the legs the coverage speaks for should narrow.** Here the coverage+comes from one Linux x86_64 clang-21 producer. Only the Linux x86_64 test leg+downloads the selection (`runner.os == 'Linux' && runner.arch == 'X64'` in+`_test.yml`). The arm64, macOS and Windows legs always run everything,+because code under architecture or platform `#ifdef`s has static evidence+only there.++### (d) Flip the variable++Shadow is the default: the variable is unset, `select-tests` is skipped, and+every test runs. When the evidence is in, set the repository variable:++```bash+gh variable set TEST_IMPACT_MODE --body gate # gate+gh variable delete TEST_IMPACT_MODE # back to shadow+```++Do not add `select-tests` to your required checks or to the aggregate gate.+When it breaks, PRs cost more minutes. They do not lose coverage.++### Optional: Layer 1 (lanes)++`scripts/ci/select-lanes.sh` is this repository's lane rule set. A `changes`+job lists the PR's files (the `pulls/{n}/files` API, with a git fallback),+runs the selector, and writes `tier`, `full`, `lanes` (a JSON list) and+`reasons` to `$GITHUB_OUTPUT`. Each lane job then runs+`if: contains(fromJSON(needs.changes.outputs.lanes), '<lane>')`. A single+aggregate job (`ci-ok`, `scripts/ci/require-all-green.sh`) is the only required+check. It fails when a *selected* lane was skipped, cancelled or missing.++For your own version, keep these properties:++- An unknown path, an empty list, workflow and harness changes, and a list+ truncated at the API's 3000-file cap all select every lane.+- The selector runs from a checkout without credentials, after the step that+ holds the token.+- Replay your PR history through the selector and check that every real+ failure had its catching lane selected. This repository's equivalent is+ `scripts/test-impact/replay-selector.sh`.++## Configuration: `.codebase-memory.json` → `test_impact`++| Key | Values | Default |+|---|---|---|+| `version` | `1` (required) | — |+| `tests.presets` | `{"c-cbm": true, ...}`. Unknown names are an error. | `c-cbm` off, the six others on |+| `tests.conventions` | C-family macro records: `case`, `suite`, `registration`, `suite_registration` | none |+| `rules` | ordered list, see below | none (built-ins only) |+| `lanes` | list of `{name, suites, exclude_suites?, default: "run"\|"skip", narrow?}` | one lane `unit`: all suites except `@perf`, `narrow: true` |+| `unmapped_files` | `"run_all"` (the only accepted value) | `run_all` |+| `coverage.compatibility_paths` | repo-relative files that the coverage map depends on (harness, runner, build flags) | none |++**Rules.** Each rule is `{id, paths, action, ...}`. `paths` are gitignore-style+globs with `{a,b}` alternatives. A pattern with a `/` is anchored at the+repository root. Without a `/`, it matches at any depth. `**` matches across+directories. Project rules come first, then the built-ins. For each changed+path, **the first matching rule wins**, so order matters.++| `action` | Effect |+|---|---|+| `run_all` | Any match runs everything. The summary names the rule (`run_all_rules`). |+| `ignore` | The path selects nothing. |+| `referencing_tests` | Selects the tests whose source contains the path as text. The engine tries the path itself, then its parent directories down to the `key`, each with and without its first segment. `key: "path_segment:N"` stops at segment N (zero-based). `key: "path"` tries the exact path only. If no test names the path, everything runs, unless `unreferenced: "ignore"` is set. |+| `suites` | Runs the named suites whole. |+| `lanes` | Activates the named lanes (for lanes with `default: "skip"`). |++Built-in rules, applied after yours:++| id | paths | action |+|---|---|---|+| `builtin:test-impact-config` | `.codebase-memory.json` | `run_all` |+| `builtin:build` | `Makefile*`, `CMakeLists.txt`, `*.cmake`, `meson.build`, `BUILD*`, `WORKSPACE`, `package*.json`, `go.mod`, `go.sum`, `Cargo.*`, `pom.xml`, `build.gradle*`, `pyproject.toml`, `setup.*`, `requirements*.txt` | `run_all` |+| `builtin:ci` | `.github/**`, `.gitlab-ci.yml`, `.circleci/**`, `Jenkinsfile*`, `.buildkite/**`, `azure-pipelines*.yml` | `run_all` |+| `builtin:vendor` | `vendor*/**`, `third_party/**` | `run_all` |+| `builtin:conftest` | `conftest.py` | `run_all` |+| `builtin:documentation` | `docs/**`, `**/*.md`, `LICENSE*` | `ignore` |++**Lanes.** A lane that you declare yourself does **not** narrow unless you set+`"narrow": true`. `signals` is accepted but has no effect yet.++**This repository's file, explained:**++| Rule | Why |+|---|---|+| `harness` → `run_all` | The test framework and the runner's `main` touch every suite. |+| `engine` → `run_all` | The selection's own code and config. A change to them could loosen what is selected. |+| `build` → `run_all` | Build and runner scripts: the file list cannot tell a flag change from a harmless one. `/.gitattributes` is anchored at the root. |+| `grammars` → `run_all` | Vendored parsers are not modelled per test. |+| `fixtures` → `referencing_tests`, `path_segment:2` | `tests/fixtures/<name>/...` selects the tests that mention the fixture, down to `tests/fixtures/<name>`. |+| `contracts` → `ignore` | Shell, Python and data contract tests run in every leg's contract step, which is never narrowed. |+| `notices` → `ignore` | Release notices. |+| `repo-data` → `referencing_tests`, `path`, `unreferenced: ignore` | Scripts, docs and packaging. A C test that reads one of these files is selected. A file that no test names selects nothing. |++`coverage.compatibility_paths` lists the harness and coverage tools. Changing+the bytes of any of them, or the `--platform` label, makes the existing coverage+map incompatible until the producer publishes a new one.++## Rollout and evidence++1. **Shadow.** Run (a) and (b). Leave `TEST_IMPACT_MODE` unset.+2. **Measure.** For each PR run, compare `selection-engine.json` with what+ failed in that run's full test legs.+ - A **miss** is a test that failed in the full run but was not selected.+ One unexplained miss blocks the flip.+ - **Savings** are the suites and tests that were not selected.++ Nothing in this repository computes misses for Layer 2 yet. Layer 1's+ history replay (`replay-selector.sh`) is the model to follow.+3. **Gate.** Set `TEST_IMPACT_MODE=gate`. Keep the shadow job running, so that+ the evidence keeps coming.++**Reading the step summary** (`### test-impact engine`):++| Line | Meaning |+|---|---|+| `decision: \`selected\`` / `\`run_all\`` / `\`nothing\``, then `run-all reasons [...]` | The top-level answer and why everything runs. `decided by rule(s) [...]` names the matched `run_all` rule ids. |+| `team artifact: fetched (ancestor …)` / `none`; `coverage \`admitted\`` / `\`rejected\` [reasons]` / `\`unavailable\`` | Whether a bundle was used, and whether its coverage was admitted. |+| `engine note: …` | The engine's first diagnostic line, such as the path that caused `UNMAPPED_FILE`, or the call chain into the runner's `main` for `RUNNER_REACHED`. |+| `lane \`unit\` (selected): N whole [REASON n, …], M narrowed (K tests)` | Per lane: suites that run whole (with a histogram of reasons), and suites narrowed to K tests. |+| `the runner-main veto (RUNNER_REACHED) discarded this selection:` | The change reached the runner's `main`, so everything runs. The lines below show what would have been selected otherwise. |+| `PR CI runs N selection tokens` / `PR CI runs every test (selection exit N)` | Gate mode only: what the test legs received. |++Common run-all reasons:++| Reason | Cause |+|---|---|+| `RULE_RUN_ALL` | A `run_all` rule matched (see `run_all_rules`). |+| `UNMAPPED_FILE` | A changed file matched no rule and is not C-family source. |+| `RULE_TARGET_UNKNOWN` | A `referencing_tests` path that no test names (without `unreferenced: "ignore"`). |+| `RUNNER_REACHED` | The change reaches the test runner's `main` (or a child role none of whose literals a test names). |+| `GIT_UNAVAILABLE` | No git, a shallow clone, or a diff that cannot be read in full. |+| `CONFIG_INVALID` / `POLICY_UNAVAILABLE` | The merge base's config or rules do not parse. |++Reasons per suite: `ARTIFACT_REJECTED` (no admitted coverage), `SETUP_HIT` /+`SETUP_UNKNOWN` (the suite's between-test setup ran changed code, or its+coverage is incomplete), `INVENTORY_UNKNOWN` (the suite cannot be read with+certainty), `CONDITIONAL` (`#if`-registered), `STATIC` / `CHANGED` / `COVERAGE`+/ `RULE` (the evidence that selected it).++## Failure modes++Every row below costs CI minutes, not coverage.++| What happens | Result |+|---|---|+| No bundle for the merge base | Nearest bundled ancestor, up to 20 first-parent commits back. Otherwise no coverage, and everything runs. |+| Bundle fetch fails (token, API) | Warning, no coverage, and everything runs. |+| The PR reverts a change that main made after the ancestor | Revert guard: no coverage, and everything runs. |+| Coverage older than 7 days, or a platform/compatibility mismatch | Map refused: every suite runs whole. |+| Shallow checkout | `GIT_UNAVAILABLE`: everything runs. |+| Engine deadline (default 1800 s) or crash | The job fails. The test job gets no selection, so everything runs. |+| `select-tests` skipped (shadow) or failed | Everything runs (`!cancelled()` on the test job). |+| The selection names a suite or test that the build lacks | The test run **fails**: a plumbing fault, reported, never skipped. |++## Known limits++- Narrowing covers C-family source and C test conventions only. Everything+ else is decided by rules or runs everything.+- The coverage map format and its producer come from this repository's LLVM+ toolchain and harness. You need your own equivalent.+- One producer platform. The selection narrows only the leg that matches the+ producer's platform; every other leg runs everything. Narrowing more legs+ needs a producer (and a bundle) per platform.+- The weekly full refresh and the 7-day age limit are the same length. Each+ week, when the refresh runs late, there can be a short window in which maps+ are refused and every test runs.+- In merge bursts the producer skips commits. The ancestor fallback covers up+ to 20 of them.+- The answer schema is `cbm.test_impact.v0` and is marked experimental. It may+ change between releases. Pin the binary.diff --git a/scripts/ci/select-lanes.sh b/scripts/ci/select-lanes.shindex 04abb1880..bd25e9761 100755--- a/scripts/ci/select-lanes.sh+++ b/scripts/ci/select-lanes.sh@@ -123,20 +123,53 @@ BUILD = {"Makefile.cbm", "scripts/test.sh", "scripts/run-tests-parallel.sh","scripts/env.sh", "scripts/build.sh", "scripts/clean.sh","scripts/path-safety.sh", "scripts/test-runtime.sh", "scripts/msan.sh","scripts/lint.sh", ".clang-format", ".clang-tidy",- "scripts/vendored-checksums.txt"}+ "scripts/vendored-checksums.txt", "scripts/run-test-wave.py",+ "scripts/embed-frontend.sh"}SMOKE = {"scripts/smoke-test.sh", "scripts/smoke-local.sh","scripts/smoke-fixture-server.py", "scripts/smoke-invariants.sh","test-infrastructure/vm/vm-smoke.sh","test-infrastructure/vm/windows-user-path-guard.ps1",- "scripts/test-windows.ps1", "scripts/smoke-wrappers.sh"}+ "scripts/test-windows.ps1", "scripts/smoke-wrappers.sh",+ "scripts/security-fuzz.sh", "scripts/security-fuzz-random.sh",+ "scripts/security-install.sh", "scripts/security-network.sh",+ "scripts/security-strings.sh", "scripts/test_mcp_interactive.py"}LINT_CONFIG = {"scripts/memory-core-baseline.txt", "scripts/lint-memory-core.py",- "scripts/hooks/pre-commit"}+ "scripts/hooks/pre-commit", ".cppcheck", "scripts/check-no-test-skips.sh",+ "scripts/check-nolint-whitelist.sh", "scripts/lint-mem-gate.py",+ "scripts/lint-mem-whitelist.txt", "scripts/lint-tidy-diff.sh"}+# Local tools and release-only jobs: no PR lane runs them.NON_GATING = {"scripts/package-release.sh", "scripts/benchmark-index.sh","scripts/benchmark-search-graph.sh", "scripts/benchmark-streaming.py",- "scripts/soak-test.sh", ".cbmignore", ".node-version", "flake.nix"}-PKG_FILES = {"install.sh", "install.ps1", "server.json", "package.json", "manifest.json"}+ "scripts/soak-test.sh", ".cbmignore", ".node-version", "flake.nix",+ "flake.lock", "scripts/soak-legs.sh", "scripts/repro.sh",+ "scripts/audit-grammar-security.sh", "scripts/check-dco.sh",+ "scripts/check-lsp-originality.sh", "scripts/clone-bench-repos.sh",+ "scripts/extract_nomic_vectors.py", "scripts/gen-pdf-unicode.py",+ "scripts/gen-py-stdlib.py", "scripts/generate-lang-code.py",+ "scripts/new-languages.json", "scripts/git-hooks/commit-msg",+ "scripts/install-git-hooks.sh", "scripts/sanitizer-coverage-map.py",+ "scripts/sanitizer-map.json", "scripts/test_mcp_rapid_init.py",+ "scripts/vendor-grammar.sh"}+# The license-gate lane runs these (and only that lane).+LICENSE_TOOLS = {"scripts/license-gate.sh", "scripts/license-gate-check.py",+ "scripts/license-gate-check-npm.py", "scripts/license-policy.json",+ "scripts/ui_browser_licenses.py"}+# security-static runs these; it runs on every PR (ALWAYS).+SECURITY_TOOLS = {"scripts/security-audit.sh", "scripts/security-allowlist.txt",+ "scripts/security-network-source-audit.py", "scripts/security-ui.sh"}+# Repository files C tests read: the test legs run (a docs-only tier runs no C+# suite, so test_cli's README/site contract would never see a README change).+READ_BY_TESTS = {"scripts/security-vendored.sh", ".codebase-memory.json", "README.md",+ "docs/index.html", "docs/llms.txt"}+# The test legs' failure report (tests/test_failure_report_contract.sh).+TEST_REPORT = {"scripts/suite-failure-report.sh"}+# The release notices ship inside every archive.+PKG_SCRIPTS = {"scripts/gen-third-party-notices.sh", "scripts/gen-ui-licenses.py"}+PKG_FILES = {"install.sh", "install.ps1", "server.json", "package.json", "manifest.json",+ "Formula"}DOC_SUFFIXES = (".md", ".png", ".svg", ".jpg", ".gif", ".txt")-DOC_FILES = {"LICENSE", "CODEOWNERS", ".gitignore", ".gitattributes"}+DOC_FILES = {"LICENSE", "CODEOWNERS", ".gitignore", ".gitattributes", "DCO",+ ".gitleaksignore", "glama.json"}def category(path):@@ -169,6 +202,18 @@ def category(path):return "build"if path in SMOKE:return "smoke"+ if path in LICENSE_TOOLS:+ return "license-tools"+ if path in SECURITY_TOOLS:+ return "security-tools"+ if path in READ_BY_TESTS:+ return "test"+ if path in TEST_REPORT:+ return "test-contract"+ if path in PKG_SCRIPTS:+ return "pkg"+ if path.startswith("scripts/") and path.endswith(".md"):+ return "docs"if path.startswith("tests/fixtures/"):return "test"if path.startswith("tests/windows/"):@@ -213,7 +258,8 @@ MID = {"pipeline", "mcp", "store", "cypher", "discover", "git", "graph_buffer",PLATFORM = {"daemon", "cli", "watcher", "ui", "foundation", "smoke", "pkg", "test-win"}CORE = {"mem-core", "build", "vendored", "ci-gate", "other", "scripts-other"}LOWER = {"test", "test-contract", "fuzz", "ui-frontend", "ci-other",- "local-infra", "docs", "lint-cfg", "memwaste-tools"}+ "local-infra", "docs", "lint-cfg", "memwaste-tools", "license-tools",+ "security-tools"}def normalized(cat):@@ -240,7 +286,8 @@ def tier_of(cats):return "T2-extract"if cats & {"test", "test-contract", "fuzz"}:return "T1-tests"- if cats & {"ui-frontend", "ci-other", "local-infra", "lint-cfg", "memwaste-tools"}:+ if cats & {"ui-frontend", "ci-other", "local-infra", "lint-cfg", "memwaste-tools",+ "license-tools", "security-tools"}:return "T0b-nonproduct"return "T0a-docs"@@ -270,7 +317,7 @@ R1 = {# because a pkg path is never docs-only (it lifts the tier to T4).ADD_ONS = [({"pkg"}, {"pkg-wrappers", "smoke-ubuntu", "smoke-mac", "smoke-win"}),- ({"vendored", "pkg", "ci-gate", "build"}, {"license-gate"}),+ ({"vendored", "pkg", "ci-gate", "build", "license-tools"}, {"license-gate"}),({"ui-frontend"}, {"windows-guards", "smoke-ubuntu"}),({"memwaste-tools", "mem-core"}, {"memwaste"}),({"test-win"}, {"windows", "windows-guards"}),diff --git a/scripts/ci/test-impact-select.sh b/scripts/ci/test-impact-select.shindex 39208683e..175c1fdb6 100755--- a/scripts/ci/test-impact-select.sh+++ b/scripts/ci/test-impact-select.sh@@ -15,7 +15,8 @@# bundle is fetched with scripts/ci/test-impact-bundle.sh, which only accepts# the main-branch producer's own run for exactly that commit; only then does# the selection pass --artifact-verified. Without a bundle the engine builds-# the graph itself and admits no coverage: every reached suite runs whole.+# the graph itself and admits no coverage: every suite runs whole (the lane+# then reports run_all; the summary shows why each suite runs whole).## Usage: scripts/ci/test-impact-select.sh --binary PATH --out DIR [--base REV]# [--platform LABEL] [--gate DIR]@@ -26,6 +27,7 @@ set -euo pipefailROOT="$(cd "$(dirname "$0")/../.." && pwd)"BINARY="" OUT="" BASE="HEAD^1" PLATFORM="linux-x86_64-clang21" GATE=""+ANCESTOR_MAX=20 # first-parent commits before the merge base whose bundle may stand inwhile [ $# -gt 0 ]; docase "$1" in--binary) BINARY="$2"; shift 2 ;;@@ -48,32 +50,96 @@ base="$(git -C "$ROOT" rev-parse "$BASE")"artifact=()bundle_rc=0+select_base="$base" # the commit the selection diffs against: the bundle's own+ancestor_note="""$ROOT/scripts/ci/test-impact-bundle.sh" --fetch "$base" "$WORK/bundle" || bundle_rc=$?+if [ "$bundle_rc" -eq 3 ]; then+ # The producer skips main commits in merge bursts (GitHub keeps one pending+ # run per concurrency group). Use the nearest first-parent ancestor A with+ # a bundle instead, and diff against A: A..HEAD carries main's own commits+ # since A as well as the PR, so A's coverage map stays exact for its base.+ for candidate in $(git -C "$ROOT" rev-list --first-parent --max-count="$((ANCESTOR_MAX + 1))" "$base" | tail -n +2); do+ rm -rf "$WORK/bundle"+ bundle_rc=0+ "$ROOT/scripts/ci/test-impact-bundle.sh" --fetch "$candidate" "$WORK/bundle" || bundle_rc=$?+ if [ "$bundle_rc" -ne 3 ]; then+ [ "$bundle_rc" -eq 0 ] && select_base="$candidate"+ break+ fi+ done+ if [ "$select_base" != "$base" ]; then+ # Exact-revert guard: a file main changed after A that the PR changes+ # back drops out of A..HEAD. Then A's map cannot speak for it: no coverage.+ missing=$(comm -23 <(git -C "$ROOT" diff --no-renames --name-only "$base" HEAD | sort -u) \+ <(git -C "$ROOT" diff --no-renames --name-only "$select_base" HEAD | sort -u))+ distance=$(git -C "$ROOT" rev-list --first-parent --count "$select_base..$base")+ if [ -n "$missing" ]; then+ echo "::warning::test-impact: ancestor bundle $select_base unusable (the change reverts main's own change in: $(echo "$missing" | head -3 | tr '\n' ' ')): selecting without coverage"+ ancestor_note="ancestor $select_base rejected by the revert guard"+ select_base="$base"+ bundle_rc=3+ else+ ancestor_note="ancestor $select_base, $distance first-parent commits before the merge base"+ fi+ fi+fiif [ "$bundle_rc" -eq 0 ]; then- artifact=(--artifact "$WORK/bundle" --artifact-commit "$base" --artifact-verified)+ artifact=(--artifact "$WORK/bundle" --artifact-commit "$select_base" --artifact-verified)elif [ "$bundle_rc" -ne 3 ]; then# No bundle means no coverage: more tests run, never fewer. Say so.echo "::warning::test-impact bundle fetch failed (exit $bundle_rc): selecting without coverage"fistarted=$(date +%s)-"$BINARY" test-impact select --repo "$ROOT" --base "$base" --work "$WORK/engine" \- --platform "$PLATFORM" ${artifact[@]+"${artifact[@]}"} > "$OUT/selection-engine.json"+rm -f "$OUT/selection-vetoed.json"+select_rc=0+"$BINARY" test-impact select --repo "$ROOT" --base "$select_base" --work "$WORK/engine" \+ --platform "$PLATFORM" ${artifact[@]+"${artifact[@]}"} \+ --vetoed-out "$OUT/selection-vetoed.json" > "$OUT/selection-engine.json" \+ 2> "$WORK/select-stderr.txt" || select_rc=$?+cat "$WORK/select-stderr.txt" >&2 # the engine's diagnostic stays in the log too+[ "$select_rc" -eq 0 ] || exit 1elapsed=$(( $(date +%s) - started ))-python3 - "$OUT/selection-engine.json" "$elapsed" "${#artifact[@]}" > "$OUT/summary-engine.md" <<'PY'-import json, sys+python3 - "$OUT/selection-engine.json" "$elapsed" "${#artifact[@]}" "$OUT/selection-vetoed.json" \+ "$ancestor_note" "$WORK/select-stderr.txt" > "$OUT/summary-engine.md" <<'PY'+import collections, json, os, sysanswer = json.load(open(sys.argv[1]))coverage = answer.get("receipt", {}).get("coverage", {})+++def lane_lines(doc, prefix):+ out = []+ for lane in doc.get("lanes") or []:+ suites = lane.get("suites") or []+ whole = [s for s in suites if s.get("mode") == "whole"]+ narrowed = {s["suite"]: len(s.get("tests") or []) for s in suites if s.get("mode") == "tests"}+ why = collections.Counter(r for s in whole for r in (s.get("reasons") or []))+ hist = ", ".join(f"{name} {n}" for name, n in why.most_common())+ because = (lane.get("because") or {}).get("reasons") or []+ out.append(f"{prefix}lane `{lane.get('lane')}` ({lane.get('decision')}): {len(whole)} whole"+ f"{f' [{hist}]' if hist else ''}, {len(narrowed)} narrowed "+ f"({sum(narrowed.values())} tests)"+ f"{f'; lane reasons {because}' if lane.get('decision') == 'run_all' and because else ''}")+ return out+++run_all_reasons = answer.get("run_all_reasons") or []+run_all_rules = answer.get("run_all_rules") or []+reasons_text = f"; run-all reasons {run_all_reasons}" if run_all_reasons else ""+if run_all_rules:+ reasons_text += f"; decided by rule(s) {run_all_rules}"lines = ["### test-impact engine", "",- f"- decision: `{answer.get('decision')}` in {sys.argv[2]} s",- f"- team artifact: {'fetched' if sys.argv[3] != '0' else 'none'}; coverage "+ f"- decision: `{answer.get('decision')}` in {sys.argv[2]} s{reasons_text}",+ f"- team artifact: {'fetched' if sys.argv[3] != '0' else 'none'}"+ f"{f' ({sys.argv[5]})' if sys.argv[5] else ''}; coverage "f"`{coverage.get('state')}` {coverage.get('rejection_reasons') or ''}"]-for lane in answer.get("lanes") or []:- suites = lane.get("suites") or []- whole = [s["suite"] for s in suites if s.get("mode") == "whole"]- narrowed = {s["suite"]: len(s.get("tests") or []) for s in suites if s.get("mode") == "tests"}- lines.append(f"- lane `{lane.get('lane')}` ({lane.get('decision')}): {len(whole)} whole, "- f"{len(narrowed)} narrowed ({sum(narrowed.values())} tests)")+note = open(sys.argv[6]).read().strip() if os.path.exists(sys.argv[6]) else ""+if note:+ lines.append(f"- engine note: `{note.splitlines()[0][:300]}`")+lines += lane_lines(answer, "- ")+if os.path.exists(sys.argv[4]):+ lines.append("- the runner-main veto (RUNNER_REACHED) discarded this selection:")+ lines += lane_lines(json.load(open(sys.argv[4])), " - ")print("\n".join(lines))PYdiff --git a/src/mcp/test_impact.h b/src/mcp/test_impact.hindex 56cc012b9..e0363ead1 100644--- a/src/mcp/test_impact.h+++ b/src/mcp/test_impact.h@@ -515,6 +515,11 @@ typedef struct {const char *const *lanes;int lane_count;int key_segment; /* zero-based path_segment:N; -1 for other actions */+ /* referencing_tests only. key_path: the key is the changed path itself (no+ * parent directories). unreferenced_ignore: a changed path no test names+ * selects nothing instead of running everything. */+ bool key_path;+ bool unreferenced_ignore;bool builtin;} cbm_test_rule_t;diff --git a/src/mcp/test_impact_cli.c b/src/mcp/test_impact_cli.cindex 4106d89db..74af90449 100644--- a/src/mcp/test_impact_cli.c+++ b/src/mcp/test_impact_cli.c@@ -78,7 +78,7 @@ static int tic_usage(void) {" codebase-memory-mcp test-impact select --repo DIR --base REF\n"" [--config FILE] [--artifact BUNDLE --artifact-commit SHA\n"" --artifact-verified] [--platform LABEL] [--work DIR]\n"- " [--deadline-s N]\n");+ " [--deadline-s N] [--vetoed-out FILE]\n");return 2;}@@ -125,6 +125,7 @@ static int tic_publish(int argc, char **argv) {static int tic_select(int argc, char **argv) {const char *repo = NULL, *base = NULL, *config = NULL, *artifact = NULL;const char *artifact_commit = NULL, *platform = NULL, *work = NULL, *deadline = NULL;+ const char *vetoed_path = NULL;bool verified = false;const tic_option_t options[] = {{"--repo", &repo, NULL},{"--base", &base, NULL},@@ -134,7 +135,8 @@ static int tic_select(int argc, char **argv) {{"--artifact-verified", NULL, &verified},{"--platform", &platform, NULL},{"--work", &work, NULL},- {"--deadline-s", &deadline, NULL}};+ {"--deadline-s", &deadline, NULL},+ {"--vetoed-out", &vetoed_path, NULL}};if (!tic_parse(argc, argv, options, sizeof(options) / sizeof(options[0])) || !repo || !base) {return tic_usage();}@@ -153,6 +155,10 @@ static int tic_select(int argc, char **argv) {.artifact_commit = artifact_commit,.artifact_verified = verified,.platform = platform};+ cbm_test_result_t *vetoed = NULL;+ if (vetoed_path) {+ request.vetoed_out = &vetoed;+ }cbm_test_result_t *result = NULL;char diagnostic[512] = "";cbm_test_impact_status_t status =@@ -162,12 +168,24 @@ static int tic_select(int argc, char **argv) {}if (status != CBM_TEST_IMPACT_OK) {(void)fprintf(stderr, "test-impact select: status %d\n", (int)status);+ cbm_test_result_free(vetoed);return 1;}size_t length = 0;const char *json = cbm_test_result_json(result, &length);bool ok = json && fwrite(json, 1, length, stdout) == length && fputc('\n', stdout) != EOF;cbm_test_result_free(result);+ /* The selection the runner-main veto discarded: a CI diagnostic, written+ * only when the veto alone made the answer run-all. */+ if (ok && vetoed) {+ const char *text = cbm_test_result_json(vetoed, &length);+ FILE *f = text ? cbm_fopen(vetoed_path, "wb") : NULL;+ ok = f && fwrite(text, 1, length, f) == length && fputc('\n', f) != EOF;+ if (f && fclose(f) != 0) {+ ok = false;+ }+ }+ cbm_test_result_free(vetoed);return ok ? 0 : 1;}diff --git a/src/mcp/test_impact_engine.c b/src/mcp/test_impact_engine.cindex 93a16f226..9d90b4e68 100644--- a/src/mcp/test_impact_engine.c+++ b/src/mcp/test_impact_engine.c@@ -495,7 +495,9 @@ static void te_receipt(te_ctx_t *c, cbm_test_result_receipt_t *r,te_artifact_receipt(c, &r->coverage, te_oid);}-static cbm_test_impact_status_t te_answer(te_ctx_t *c, cbm_test_result_t **out) {+/* mask_runner: the answer without the RUNNER_REACHED fallback (the CI's view+ * of what the veto discarded; see cbm_test_impact_request_t.vetoed_out). */+static cbm_test_impact_status_t te_answer(te_ctx_t *c, cbm_test_result_t **out, bool mask_runner) {cbm_test_result_rule_match_t *matches =cbm_arena_calloc(&c->arena, (size_t)(c->match_count + 1) * sizeof(*matches));if (!matches) {@@ -517,6 +519,23 @@ static cbm_test_impact_status_t te_answer(te_ctx_t *c, cbm_test_result_t **out)return CBM_TEST_IMPACT_OOM;}bool with_selection = c->selection && comparison == CBM_TEST_RESULT_COMPARISON_CHANGED;+ const cbm_test_result_fallback_t *fallbacks = c->fallbacks;+ size_t fallback_count = (size_t)c->fallback_count;+ cbm_test_result_fallback_t *kept = NULL;+ if (mask_runner) {+ kept = cbm_arena_calloc(&c->arena, (fallback_count + 1) * sizeof(*kept));+ if (!kept) {+ return CBM_TEST_IMPACT_OOM;+ }+ size_t n = 0;+ for (size_t i = 0; i < fallback_count; i++) {+ if (c->fallbacks[i] != CBM_TEST_RESULT_FALLBACK_RUNNER_REACHED) {+ kept[n++] = c->fallbacks[i];+ }+ }+ fallbacks = kept;+ fallback_count = n;+ }cbm_test_result_input_t input = {.comparison = comparison,.selection = with_selection ? c->selection : NULL,@@ -527,8 +546,8 @@ static cbm_test_impact_status_t te_answer(te_ctx_t *c, cbm_test_result_t **out).matched_rules = comparison == CBM_TEST_RESULT_COMPARISON_EMPTY ? NULL : matches,.matched_rule_count =comparison == CBM_TEST_RESULT_COMPARISON_EMPTY ? 0 : (size_t)c->match_count,- .fallbacks = c->fallbacks,- .fallback_count = (size_t)c->fallback_count,+ .fallbacks = fallbacks,+ .fallback_count = fallback_count,.warnings = c->warnings,.warning_count = (size_t)c->warning_count,.receipt = &receipt};@@ -615,10 +634,25 @@ static void *te_job_main(void *arg) {.rq = job->request, .diagnostic = job->diagnostic, .diagnostic_len = job->diagnostic_len};cbm_arena_init(&c.arena);te_steps(&c);- cbm_test_impact_status_t status = c.oom ? CBM_TEST_IMPACT_OOM : te_answer(&c, job->out);+ cbm_test_impact_status_t status = c.oom ? CBM_TEST_IMPACT_OOM : te_answer(&c, job->out, false);+ cbm_test_result_t **vetoed = job->request->vetoed_out;+ if (vetoed) {+ *vetoed = NULL;+ bool runner_veto_only =+ c.fallback_count == 1 && c.fallbacks[0] == CBM_TEST_RESULT_FALLBACK_RUNNER_REACHED;+ if (status == CBM_TEST_IMPACT_OK && runner_veto_only && c.selection &&+ te_answer(&c, vetoed, true) != CBM_TEST_IMPACT_OK) {+ cbm_test_result_free(*vetoed); /* a diagnostic only: never fails the answer */+ *vetoed = NULL;+ }+ }if (!c.oom && cbm_now_ms() > job->request->deadline_ms && status == CBM_TEST_IMPACT_OK) {cbm_test_result_free(*job->out);*job->out = NULL;+ if (vetoed) {+ cbm_test_result_free(*vetoed);+ *vetoed = NULL;+ }status = CBM_TEST_IMPACT_CANCELLED;}te_free(&c);diff --git a/src/mcp/test_impact_engine.h b/src/mcp/test_impact_engine.hindex 6ce3e51fb..39a1b4d85 100644--- a/src/mcp/test_impact_engine.h+++ b/src/mcp/test_impact_engine.h@@ -47,6 +47,11 @@ typedef struct {/* Platform/toolchain label of the leg the answer is for; part of the* coverage compatibility digest, so a map narrows only its own platform. */const char *platform;+ /* Optional, CI diagnostics only (never part of the MCP answer): when the+ * one run-all reason is RUNNER_REACHED, *vetoed_out receives the answer+ * with that veto masked — the selection the veto discarded. NULL+ * otherwise. The caller frees it with cbm_test_result_free. */+ cbm_test_result_t **vetoed_out;} cbm_test_impact_request_t;typedef enum {diff --git a/src/mcp/test_impact_engine_reach.c b/src/mcp/test_impact_engine_reach.cindex e54724aca..70e5affe4 100644--- a/src/mcp/test_impact_engine_reach.c+++ b/src/mcp/test_impact_engine_reach.c@@ -14,13 +14,19 @@#include "foundation/mem_core.h"#include "store/store_impact.h"+#include <stdio.h>#include <stdlib.h>#include <string.h>-/* The c-cbm runner's process-entry handlers: the runner re-executes itself- * with a role argument and these run product code in that child. They are- * reached, never expanded (their caller is the runner's main). */-#define TE_RUNNER_ROLE_PREFIX "tf_maybe_run_"+/* The c-cbm runner's child-process roles: a test re-executes the runner with+ * argv[1] = a role literal, and the runner's main dispatches it from its role+ * table — `TF_ROLE(phase, "literal", handler)` entries in a runner file — by+ * an exact argv[1] match, so a handler only ever runs in its own child. A+ * handler is a sink (reached, never expanded into main): reaching it selects+ * the tests that name its literal (te_role_lift). A handler the table does+ * not name, or a TF_ROLE line that does not parse, is no sink: reaching it+ * reaches main, which runs everything. */+#define TE_ROLE_MACRO "TF_ROLE("/* SPAWNS carries reach from a Process node, which enters the walk through* te_spawn_lift alone, and from a script of the repository (its Module /@@ -124,10 +130,28 @@ static int te_case_index(te_ctx_t *c, const char *file, const char *name) {return -1;}+static bool te_ids_has(const te_ids_t *a, int64_t id) {+ for (int i = 0; a && i < a->count; i++) {+ if (a->items[i] == id) {+ return true;+ }+ }+ return false;+}+/* Every line of a test file that contains `needle`: its enclosing- * definition is a fixture case or a seed. */+ * definition is a fixture case or a seed — unless it is one of `exclude`+ * (a role handler naming its own literal is not a test that spawns it). */+static bool te_scan_literal_ex(te_ctx_t *c, const char *needle, te_ids_t *seeds, bool *cases,+ bool *hit, const te_ids_t *exclude);+static bool te_scan_literal(te_ctx_t *c, const char *needle, te_ids_t *seeds, bool *cases,bool *hit) {+ return te_scan_literal_ex(c, needle, seeds, cases, hit, NULL);+}++static bool te_scan_literal_ex(te_ctx_t *c, const char *needle, te_ids_t *seeds, bool *cases,+ bool *hit, const te_ids_t *exclude) {int files = cbm_ti_source_file_count(c->source);size_t nlen = strlen(needle);for (int f = 0; f < files; f++) {@@ -153,7 +177,7 @@ static bool te_scan_literal(te_ctx_t *c, const char *needle, te_ids_t *seeds, bo"graph read failed") &&false;}- if (!d) {+ if (!d || te_ids_has(exclude, d->id)) {continue;}*hit = true;@@ -171,9 +195,11 @@ static bool te_scan_literal(te_ctx_t *c, const char *needle, te_ids_t *seeds, bo/* One fixture path: the path itself, then each parent down to the rule's* key segment; each with and without its first segment. The first key some* test file mentions decides. */+#define TE_FIXTURE_KEY_MAX 4096+static bool te_fixture(te_ctx_t *c, const char *path, int min_segments, te_ids_t *seeds,bool *cases, bool *hit) {- char key[4096];+ char key[TE_FIXTURE_KEY_MAX];size_t len = strlen(path);if (len >= sizeof(key)) {return true; /* unresolved: run-all through the rule */@@ -212,11 +238,22 @@ bool te_fixtures(te_ctx_t *c, int64_t **extra_seeds, int *extra_count, bool **ficonst cbm_test_rule_t *rules = cbm_test_policy_rules(c->policy, &rule_count);for (int i = 0; i < c->fixture_count; i++) {int r = c->fixture_rules[i];+ const char *path = c->fixture_paths[i];+ int min_segments = rules[r].key_segment + 1;+ if (rules[r].key_path) {+ min_segments = 1; /* the path itself only: never a parent directory */+ for (const char *p = path; *p; p++) {+ min_segments += *p == '/';+ }+ }bool hit = false;- if (!te_fixture(c, c->fixture_paths[i], rules[r].key_segment + 1, &seeds, cases, &hit)) {+ if (!te_fixture(c, path, min_segments, &seeds, cases, &hit)) {cbm_free(CBM_MEM_CLASS_EXTRACT, seeds.items);return false;}+ if (!hit && rules[r].unreferenced_ignore && strlen(path) < TE_FIXTURE_KEY_MAX) {+ continue; /* scanned, and no test names it: nothing can depend on it */+ }for (int m = 0; !hit && m < c->match_count; m++) {if (c->matches[m].rule_index == r) {c->matches[m].resolved = false; /* no test names it: run-all */@@ -231,11 +268,153 @@ bool te_fixtures(te_ctx_t *c, int64_t **extra_seeds, int *extra_count, bool **fi/* ── The walk ────────────────────────────────────────────────────── */+typedef struct {+ const char *literal; /* what a test that starts the role's child names */+ int64_t id; /* the handler's function node; one handler may have several */+ bool reached;+ bool scanned;+ bool named; /* some test or helper names the literal */+} te_role_t;+typedef struct {te_ids_t sinks;te_ids_t runner_main;+ te_role_t *roles;+ int role_count;+ int role_cap;} te_sinks_t;+static const char *te_skip_space(const char *p, const char *end) {+ while (p < end && (*p == ' ' || *p == '\t')) {+ p++;+ }+ return p;+}++/* One `TF_ROLE(phase, "literal", handler)` line. false: no entry here (the+ * macro's own #define included); *bad: an entry that does not parse. */+static bool te_role_parse(const char *text, size_t len, char *literal, size_t literal_cap,+ char *handler, size_t handler_cap, bool *bad) {+ *bad = false;+ const char *end = text + len;+ const char *p = te_skip_space(text, end);+ size_t macro_len = sizeof(TE_ROLE_MACRO) - 1;+ if (p >= end || *p == '#') {+ return false;+ }+ const char *at = NULL;+ for (const char *q = p; !at && q + macro_len <= end; q++) {+ at = memcmp(q, TE_ROLE_MACRO, macro_len) == 0 ? q : NULL;+ }+ if (!at) {+ return false;+ }+ *bad = true;+ p = at + macro_len;+ while (p < end && *p != ',') {+ p++; /* the phase */+ }+ p = te_skip_space(p + 1, end);+ if (p >= end || *p != '"') {+ return true;+ }+ const char *lit = ++p;+ while (p < end && *p != '"' && *p != '\\') {+ p++;+ }+ if (p >= end || *p != '"' || p == lit || (size_t)(p - lit) >= literal_cap) {+ return true;+ }+ memcpy(literal, lit, (size_t)(p - lit));+ literal[p - lit] = '\0';+ p = te_skip_space(p + 1, end);+ if (p >= end || *p != ',') {+ return true;+ }+ p = te_skip_space(p + 1, end);+ const char *name = p;+ while (p < end && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||+ (*p >= '0' && *p <= '9') || *p == '_')) {+ p++;+ }+ if (p == name || (size_t)(p - name) >= handler_cap) {+ return true;+ }+ memcpy(handler, name, (size_t)(p - name));+ handler[p - name] = '\0';+ p = te_skip_space(p, end);+ *bad = p >= end || *p != ')';+ return true;+}++/* The handler's function node: the one Function of that name in a runner or+ * test file. 0 when there is none or more than one (then it is no sink, and+ * reaching it reaches main). */+static bool te_role_handler(te_ctx_t *c, const char *name, int64_t *id) {+ cbm_node_t *nodes = NULL;+ int n = 0;+ *id = 0;+ if (cbm_store_find_nodes_by_name(c->store, "test-impact", name, &nodes, &n) != CBM_STORE_OK) {+ return te_fallback(c, CBM_TEST_RESULT_FALLBACK_GRAPH_UNAVAILABLE, "graph read failed") &&+ false;+ }+ int found = 0;+ int runners = 0;+ const cbm_test_runner_suite_t *runner = cbm_test_model_runner_suites(c->model, &runners);+ for (int i = 0; i < n; i++) {+ bool in_tests = nodes[i].file_path && te_test_file(c, nodes[i].file_path);+ for (int r = 0; !in_tests && nodes[i].file_path && r < runners; r++) {+ in_tests = runner[r].file && strcmp(runner[r].file, nodes[i].file_path) == 0;+ }+ if (in_tests && nodes[i].label && strcmp(nodes[i].label, "Function") == 0) {+ *id = nodes[i].id;+ found++;+ }+ }+ cbm_store_free_nodes(nodes, n);+ if (found != 1) {+ *id = 0;+ }+ return true;+}++/* The role table of one runner file: each entry's handler becomes a sink. */+static bool te_runner_roles(te_ctx_t *c, const char *file, te_sinks_t *s) {+ int f = cbm_ti_source_find(c->source, file);+ int lines = f >= 0 ? cbm_ti_source_line_count(c->source, f) : 0;+ for (int line = 1; line <= lines; line++) {+ size_t len = 0;+ const char *text = cbm_ti_source_line(c->source, f, line, &len);+ char literal[256];+ char handler[256];+ bool bad = false;+ if (!text ||+ !te_role_parse(text, len, literal, sizeof(literal), handler, sizeof(handler), &bad) ||+ bad) {+ continue; /* not an entry, or one that does not parse: no sink */+ }+ int64_t id = 0;+ if (!te_role_handler(c, handler, &id)) {+ return false;+ }+ if (!id) {+ continue;+ }+ if (!te_grow((void **)&s->roles, &s->role_cap, s->role_count, sizeof(*s->roles))) {+ return te_oom(c);+ }+ const char *owned = cbm_arena_strdup(&c->arena, literal);+ if (!owned) {+ return te_oom(c);+ }+ s->roles[s->role_count++] = (te_role_t){.literal = owned, .id = id};+ if (!te_ids_push(c, &s->sinks, id)) {+ return false;+ }+ }+ return true;+}+static bool te_runner_sinks(te_ctx_t *c, te_sinks_t *s) {int n = 0;const cbm_test_runner_suite_t *runner = cbm_test_model_runner_suites(c->model, &n);@@ -253,19 +432,18 @@ static bool te_runner_sinks(te_ctx_t *c, te_sinks_t *s) {false;}for (int k = 0; k < count; k++) {- if (!te_is_function(&nodes[k]) || nodes[k].variant_span) {+ if (!te_is_function(&nodes[k]) || nodes[k].variant_span ||+ strcmp(nodes[k].name, "main") != 0) {continue;}- bool main_fn = strcmp(nodes[k].name, "main") == 0;- bool role = strncmp(nodes[k].name, TE_RUNNER_ROLE_PREFIX,- sizeof(TE_RUNNER_ROLE_PREFIX) - 1) == 0;- if ((main_fn || role) && !te_ids_push(c, &s->sinks, nodes[k].id)) {- return false;- }- if (main_fn && !te_ids_push(c, &s->runner_main, nodes[k].id)) {+ if (!te_ids_push(c, &s->sinks, nodes[k].id) ||+ !te_ids_push(c, &s->runner_main, nodes[k].id)) {return false;}}+ if (!te_runner_roles(c, runner[i].file, s)) {+ return false;+ }}return true;}@@ -739,6 +917,186 @@ static bool te_spawn_lift(te_ctx_t *c, cbm_impact_walk_t *walk) {return ok;}+/* ── Child-process roles (TF_ROLE) ───────────────────────────────────+ * A reached role handler runs in the child its tests spawn by its literal.+ * Mark the reached handlers, and every handler that calls a reached one (its+ * child runs it in process); scan each role's literal in the test files —+ * handlers and the runner's main excluded, so a handler naming its own+ * literal is no spawner — selecting the tests that name it directly and+ * walking on from helpers that do. A reached role no test names runs+ * everything. Repeat until nothing new is reached. */+static bool te_role_mark(te_ctx_t *c, cbm_impact_walk_t *walk, te_sinks_t *s, bool *grew) {+ for (int i = 0; i < s->role_count; i++) {+ if (!s->roles[i].reached && cbm_impact_walk_reached(walk, s->roles[i].id)) {+ s->roles[i].reached = *grew = true;+ }+ }+ for (bool chained = true; chained;) {+ chained = false;+ for (int i = 0; i < s->role_count; i++) {+ if (!s->roles[i].reached) {+ continue;+ }+ cbm_edge_t *edges = NULL;+ int n = 0;+ if (cbm_store_find_edges_by_target_type(c->store, s->roles[i].id, "CALLS", &edges,+ &n) != CBM_STORE_OK) {+ return te_fallback(c, CBM_TEST_RESULT_FALLBACK_GRAPH_UNAVAILABLE,+ "graph read failed") &&+ false;+ }+ for (int e = 0; e < n; e++) {+ for (int k = 0; k < s->role_count; k++) {+ if (!s->roles[k].reached && s->roles[k].id == edges[e].source_id) {+ s->roles[k].reached = chained = *grew = true;+ }+ }+ }+ cbm_store_free_edges(edges, n);+ }+ }+ return true;+}++/* A reached handler none of whose literals any test names: its spawners are+ * unknown, so everything runs. One named literal names the handler's spawners+ * (the index worker: "--index-worker" or the CBM_INDEX_SUPERVISOR switch). */+static bool te_roles_named(te_ctx_t *c, const te_sinks_t *s) {+ for (int i = 0; i < s->role_count; i++) {+ const te_role_t *r = &s->roles[i];+ bool named = !r->reached;+ for (int k = 0; !named && k < s->role_count; k++) {+ named = s->roles[k].id == r->id && s->roles[k].named;+ }+ if (!named) {+ char note[320];+ snprintf(note, sizeof(note),+ "the change reaches the test-runner role %s, which no test names", r->literal);+ return te_fallback(c, CBM_TEST_RESULT_FALLBACK_RUNNER_REACHED, note);+ }+ }+ return true;+}++static bool te_role_lift(te_ctx_t *c, cbm_impact_walk_t *walk, te_sinks_t *s, bool *cases) {+ te_ids_t handlers = {0};+ bool ok = true;+ for (int i = 0; ok && i < s->role_count; i++) {+ ok = te_ids_push(c, &handlers, s->roles[i].id);+ }+ for (int i = 0; ok && i < s->runner_main.count; i++) {+ ok = te_ids_push(c, &handlers, s->runner_main.items[i]);+ }+ for (bool grew = ok; ok && grew;) {+ grew = false;+ ok = te_role_mark(c, walk, s, &grew);+ for (int i = 0; ok && i < s->role_count; i++) {+ te_role_t *r = &s->roles[i];+ if (!r->reached || r->scanned) {+ continue;+ }+ r->scanned = true;+ te_ids_t seeds = {0};+ ok = te_scan_literal_ex(c, r->literal, &seeds, cases, &r->named, &handlers);+ if (ok && seeds.count) {+ ok = cbm_impact_walk_run(walk, seeds.items, seeds.count) == CBM_STORE_OK ||+ (te_fallback(c, CBM_TEST_RESULT_FALLBACK_ENGINE_SATURATED,+ "the impact walk failed") &&+ false);+ grew = true;+ }+ cbm_free(CBM_MEM_CLASS_EXTRACT, seeds.items);+ }+ }+ cbm_free(CBM_MEM_CLASS_EXTRACT, handlers.items);+ return ok && te_roles_named(c, s);+}++/* The last two segments of a qualified name (`test_main.main`), or all of it. */+static const char *te_short_qn(const char *qn) {+ const char *last = strrchr(qn, '.');+ if (!last) {+ return qn;+ }+ const char *start = qn;+ for (const char *p = qn; p < last; p++) {+ if (*p == '.') {+ start = p + 1;+ }+ }+ return start;+}++/* prefix + the call chain the walk took from the changed code to `id`, in call+ * order (`id` first: "test_main.main -> a.b -> ... -> changed.fn"), cut short+ * with "..." when it does not fit. */+static void te_call_chain(const cbm_impact_walk_t *walk, int64_t id, const char *prefix, char *out,+ size_t cap) {+ int used = snprintf(out, cap, "%s", prefix);+ for (int step = 0; id && used >= 0 && (size_t)used < cap && step < 64; step++) {+ const cbm_impact_hit_t *hit = cbm_impact_walk_hit(walk, id);+ if (!hit) {+ break;+ }+ const char *name = hit->qualified_name ? te_short_qn(hit->qualified_name) : "?";+ int n = snprintf(out + used, cap - (size_t)used, "%s%s", step ? " -> " : "", name);+ if (n < 0 || (size_t)n >= cap - (size_t)used) {+ if (cap > 4) {+ memcpy(out + cap - 4, "...", 4);+ }+ return;+ }+ used += n;+ id = hit->via_id;+ }+}++/* Whether the walk reaches the runner's main through code that can run, and+ * through what: *way_in is main itself (a changed main, or a step that is no+ * edge: a platform variant, a route), the reached node main has a walked edge+ * to, or 0. An edge into a Field named like a suite main runs is no way in:+ * the C extractor takes the macro argument of RUN_SELECTED_SUITE(mcp) for a+ * use of some same-named data member (`char mcp[]` in an unrelated struct). */+static bool te_main_reached(te_ctx_t *c, const cbm_impact_walk_t *walk, int64_t main_id,+ int64_t *way_in) {+ *way_in = 0;+ const cbm_impact_hit_t *self = cbm_impact_walk_hit(walk, main_id);+ if (!self) {+ return true;+ }+ bool edge_step = false;+ for (size_t t = 0; self->via_edge && t < sizeof(te_walk_types) / sizeof(te_walk_types[0]);+ t++) {+ edge_step = edge_step || strcmp(self->via_edge, te_walk_types[t]) == 0;+ }+ if (!edge_step) {+ *way_in = main_id;+ return true;+ }+ cbm_edge_t *edges = NULL;+ int n = 0;+ if (cbm_store_find_edges_by_source(c->store, main_id, &edges, &n) != CBM_STORE_OK) {+ return te_fallback(c, CBM_TEST_RESULT_FALLBACK_GRAPH_UNAVAILABLE, "graph read failed") &&+ false;+ }+ for (int e = 0; !*way_in && e < n; e++) {+ const cbm_impact_hit_t *to = cbm_impact_walk_hit(walk, edges[e].target_id);+ bool walked = false;+ for (size_t t = 0;+ to && edges[e].type && t < sizeof(te_walk_types) / sizeof(te_walk_types[0]); t++) {+ walked = walked || strcmp(edges[e].type, te_walk_types[t]) == 0;+ }+ const char *name = walked && to->qualified_name ? strrchr(to->qualified_name, '.') : NULL;+ bool suite_arg =+ name && to->label && strcmp(to->label, "Field") == 0 && te_is_runner_suite(c, name + 1);+ if (walked && !suite_arg) {+ *way_in = edges[e].target_id;+ }+ }+ cbm_store_free_edges(edges, n);+ return true;+}+bool te_reach(te_ctx_t *c) {int64_t *extra = NULL;int extra_count = 0;@@ -746,14 +1104,23 @@ bool te_reach(te_ctx_t *c) {te_sinks_t sinks = {0};cbm_impact_walk_t *walk = NULL;bool ok = te_fixtures(c, &extra, &extra_count, &fixture_cases) && te_collect_sinks(c, &sinks) &&- te_walk(c, &sinks, extra, extra_count, &walk) && te_parse_gaps(c, walk);- if (ok) {- for (int i = 0; i < sinks.runner_main.count; i++) {- if (cbm_impact_walk_reached(walk, sinks.runner_main.items[i])) {- ok = te_fallback(c, CBM_TEST_RESULT_FALLBACK_RUNNER_REACHED,- "the change reaches the test runner's main");- break;- }+ te_walk(c, &sinks, extra, extra_count, &walk) && te_parse_gaps(c, walk) &&+ te_role_lift(c, walk, &sinks, fixture_cases) && te_parse_gaps(c, walk);+ for (int i = 0; ok && i < sinks.runner_main.count; i++) {+ int64_t way_in = 0;+ ok = te_main_reached(c, walk, sinks.runner_main.items[i], &way_in);+ if (ok && way_in) {+ const cbm_impact_hit_t *m = cbm_impact_walk_hit(walk, sinks.runner_main.items[i]);+ const char *main_name =+ m && m->qualified_name ? te_short_qn(m->qualified_name) : "main";+ bool direct = way_in == sinks.runner_main.items[i];+ char note[400];+ int used =+ snprintf(note, sizeof(note), "the change reaches the test runner's main: %s%s",+ direct ? "" : main_name, direct ? "" : " -> ");+ te_call_chain(walk, way_in, "", note + used, sizeof(note) - (size_t)used);+ ok = te_fallback(c, CBM_TEST_RESULT_FALLBACK_RUNNER_REACHED, note);+ break;}}/* After the runner check: the runner re-executing itself is a spawn too,@@ -766,5 +1133,6 @@ bool te_reach(te_ctx_t *c) {cbm_free(CBM_MEM_CLASS_EXTRACT, extra);cbm_free(CBM_MEM_CLASS_EXTRACT, sinks.sinks.items);cbm_free(CBM_MEM_CLASS_EXTRACT, sinks.runner_main.items);+ cbm_free(CBM_MEM_CLASS_EXTRACT, sinks.roles);return ok;}diff --git a/src/mcp/test_impact_policy.c b/src/mcp/test_impact_policy.cindex 2b523908c..fc703bd70 100644--- a/src/mcp/test_impact_policy.c+++ b/src/mcp/test_impact_policy.c@@ -587,6 +587,23 @@ static bool tp_key_segment(yyjson_val *value, int *segment) {return true;}+/* `unreferenced` of a referencing_tests rule: absent or "run_all" keeps the+ * fail-safe default (a path no test names runs everything); "ignore" lets it+ * select nothing — for data no test can depend on without naming it. */+static bool tp_unreferenced(yyjson_val *value, bool *ignore) {+ *ignore = false;+ if (!value)+ return true;+ const char *text = tp_string(value, NULL);+ if (!text)+ return false;+ if (strcmp(text, "ignore") == 0) {+ *ignore = true;+ return true;+ }+ return strcmp(text, "run_all") == 0;+}+static const char *const tp_build_paths[] = {"Makefile*", "CMakeLists.txt", "*.cmake", "meson.build", "BUILD*","WORKSPACE", "package*.json", "go.mod", "go.sum", "Cargo.*",@@ -626,6 +643,7 @@ static bool tp_parse_rule(cbm_test_policy_t *policy, yyjson_val *value, int indeyyjson_val *lanes = tp_field(value, "lanes", &valid);yyjson_val *suites = tp_field(value, "suites", &valid);yyjson_val *key = tp_field(value, "key", &valid);+ yyjson_val *unreferenced = tp_field(value, "unreferenced", &valid);const char *id_text = tp_string(id, NULL), *action_text = tp_string(action, NULL);if (!valid || !id_text || !action_text)return false;@@ -646,26 +664,33 @@ static bool tp_parse_rule(cbm_test_policy_t *policy, yyjson_val *value, int indereturn false;if (strcmp(action_text, "run_all") == 0) {rule->action = CBM_TEST_RULE_RUN_ALL;- return !lanes && !suites && !key;+ return !lanes && !suites && !key && !unreferenced;}if (strcmp(action_text, "ignore") == 0) {rule->action = CBM_TEST_RULE_IGNORE;- return !lanes && !suites && !key;+ return !lanes && !suites && !key && !unreferenced;}if (strcmp(action_text, "lanes") == 0) {rule->action = CBM_TEST_RULE_LANES;- return !suites && !key &&+ return !suites && !key && !unreferenced &&tp_string_array(policy, lanes, true, &rule->lanes, &rule->lane_count, NULL, false);}if (strcmp(action_text, "suites") == 0) {rule->action = CBM_TEST_RULE_SUITES;- return !lanes && !key &&+ return !lanes && !key && !unreferenced &&tp_string_array(policy, suites, true, &rule->suites, &rule->suite_count,&matchers->suites, true);}if (strcmp(action_text, "referencing_tests") == 0) {rule->action = CBM_TEST_RULE_REFERENCING_TESTS;- return !lanes && !suites && tp_key_segment(key, &rule->key_segment);+ if (lanes || suites || !tp_unreferenced(unreferenced, &rule->unreferenced_ignore))+ return false;+ const char *key_text = tp_string(key, NULL);+ if (key_text && strcmp(key_text, "path") == 0) {+ rule->key_path = true;+ return true;+ }+ return tp_key_segment(key, &rule->key_segment);}return false;}diff --git a/src/mcp/test_impact_result.c b/src/mcp/test_impact_result.cindex 783aec9e8..fed0d51ec 100644--- a/src/mcp/test_impact_result.c+++ b/src/mcp/test_impact_result.c@@ -1,5 +1,20 @@#include "mcp/test_impact_result_internal.h"+/* The ids of the matched run_all rules, in policy order: which rule made a+ * RULE_RUN_ALL answer run everything. Outside the decision hash. */+static tir_json *tir_run_all_rules(tir_context *c) {+ tir_json *array = tir_node(c, TIR_ARRAY);+ for (size_t i = 0; i < c->rule_count; i++) {+ if (!tir_step(c, 0, 1))+ return NULL;+ const tir_rule *rule = &c->rules[i];+ if (rule->matched && rule->source->action == CBM_TEST_RULE_RUN_ALL &&+ !tir_add(c, array, NULL, tir_string(c, rule->id)))+ return NULL;+ }+ return array;+}+static tir_json *tir_result_object(tir_context *c, cbm_test_result_t *result) {const char *decision = c->global ? "run_all" : (c->runnable ? "selected" : "nothing");tir_json *o = tir_node(c, TIR_OBJECT);@@ -7,6 +22,7 @@ static tir_json *tir_result_object(tir_context *c, cbm_test_result_t *result) {tir_add(c, o, "experimental", tir_bool(c, true));tir_add(c, o, "decision", tir_text(c, decision));tir_add(c, o, "run_all_reasons", c->global_json);+ tir_add(c, o, "run_all_rules", tir_run_all_rules(c));tir_add(c, o, "lanes", c->lane_json);tir_add(c, o, "warnings", tir_warnings_json(c));tir_add(c, o, "totals", tir_totals_json(c));diff --git a/src/mcp/test_impact_result_project.c b/src/mcp/test_impact_result_project.cindex 01cc334f9..0c62b3973 100644--- a/src/mcp/test_impact_result_project.c+++ b/src/mcp/test_impact_result_project.c@@ -5,6 +5,8 @@ typedef struct {tir_json *suites;uint64_t reasons;size_t members;+ size_t listed; /* member suites the plan lists (an omitted one is not) */+ size_t listed_whole; /* of those, the ones that run whole */tir_lane_decision decision;} tir_lane_plan;@@ -38,6 +40,8 @@ static bool tir_member_suite(tir_context *c, size_t lane_index, tir_lane_plan *pif (c->global)return true;plan->reasons |= reasons;+ plan->listed++;+ plan->listed_whole += whole;if (!tir_charge(c, &c->suite_occurrences, 1, UINT64_MAX))return false;if (whole)@@ -95,7 +99,10 @@ static bool tir_lane_plan_build(tir_context *c, size_t index, tir_lane_plan *plaelse if (!plan->suites->as.children.first)plan->reasons = TIR_REASON(TIR_REASON_NO_SELECTED_TESTS);else {- plan->decision = lane->source->narrow ? TIR_SELECTED : TIR_ALL;+ /* A lane that omits no member suite and runs every one whole runs+ * everything (e.g. no admitted coverage): say so, whatever the reasons. */+ bool runs_everything = plan->listed == plan->members && plan->listed_whole == plan->listed;+ plan->decision = lane->source->narrow && !runs_everything ? TIR_SELECTED : TIR_ALL;if (!tir_charge(c, &c->runnable, 1, UINT64_MAX))return false;}diff --git a/tests/fixtures/select-lanes/cases.tsv b/tests/fixtures/select-lanes/cases.tsvindex 15ce05df5..ff838416b 100644--- a/tests/fixtures/select-lanes/cases.tsv+++ b/tests/fixtures/select-lanes/cases.tsv@@ -3,7 +3,9 @@# Columns (TAB-separated): name, files (space-separated; "-" = empty list),# tier, full, lanes (space-separated, any order; "FULL" = every PR lane,# "FULL -a -b" = every PR lane except a and b).-docs-only README.md docs/BENCHMARK.md T0a-docs false contracts security-static+docs-only CONTRIBUTING.md docs/BENCHMARK.md T0a-docs false contracts security-static+readme-runs-the-test-legs README.md T1-tests false lint lint-mem security-static shard-completeness unix-macos14 unix-x86 windows+site-files-run-the-test-legs docs/index.html docs/llms.txt T1-tests false lint lint-mem security-static shard-completeness unix-macos14 unix-x86 windowsissue-template-is-docs .github/ISSUE_TEMPLATE/bug.yml T0a-docs false contracts security-staticlocal-infra test-infrastructure/run.sh T0b-nonproduct false contracts lint lint-mem security-staticlint-config scripts/memory-core-baseline.txt T0b-nonproduct false contracts lint lint-mem security-static@@ -38,7 +40,17 @@ vendored-code vendored/sqlite3/sqlite3.c T5-core true FULLgate-workflow .github/workflows/codeql.yml T5-core true FULLunmatched-top-level-path weird/new.file T5-core true FULLunmatched-src-directory src/newthing/x.c T5-core true FULL-unmatched-script scripts/README.md T5-core true FULL+unmatched-script scripts/new-tool.sh T5-core true FULL+scripts-readme-is-docs scripts/README.md T0a-docs false contracts security-static+license-tool-runs-license-gate scripts/license-gate.sh T0b-nonproduct false contracts license-gate lint lint-mem security-static+security-tool-runs-security-static scripts/security-ui.sh T0b-nonproduct false contracts lint lint-mem security-static+local-tool-is-non-gating scripts/repro.sh T0b-nonproduct false contracts lint lint-mem security-static shard-completeness unix-x86+lint-config-file .cppcheck T0b-nonproduct false contracts lint lint-mem security-static+script-c-tests-read scripts/security-vendored.sh T1-tests false lint lint-mem security-static shard-completeness unix-macos14 unix-x86 windows+engine-config-c-tests-read .codebase-memory.json T1-tests false lint lint-mem security-static shard-completeness unix-macos14 unix-x86 windows+test-failure-report scripts/suite-failure-report.sh T1-tests false lint lint-mem security-static shard-completeness unix-macos14 unix-x86 windows+smoke-security-script scripts/security-strings.sh T4-platform false FULL -msan -diag -memwaste+shipped-notices-are-pkg scripts/gen-third-party-notices.sh T4-platform false FULL -msan -diag -memwastenon-gate-workflow-forces-full .github/workflows/stale.yml T0b-nonproduct true FULLharness-main-forces-full tests/test_main.c T1-tests true FULLharness-framework-forces-full tests/test_framework.h T1-tests true FULLdiff --git a/tests/test_lane_wiring_contract.sh b/tests/test_lane_wiring_contract.shindex bd5f26b30..d79579725 100755--- a/tests/test_lane_wiring_contract.sh+++ b/tests/test_lane_wiring_contract.sh@@ -126,12 +126,17 @@ m = re.search(r"(?ms)^ test_selection:\n(.*?)(?=^ \S|^\S|\Z)", text("_require(m is not None and re.search(r"(?m)^ default: ''$", m.group(1)) is not None,"_test.yml must declare a test_selection input defaulting to '' (every test)")readers = sorted(job for job, body in test_wf.items() if "inputs.test_selection" in body)-require(readers == ["test-unix", "test-windows"],- f"only test-unix and test-windows may read test_selection, found {readers}")-for job in ("test-unix", "test-windows"):- require("CBM_TEST_SELECTION_DIR: ${{ inputs.test_selection != '' && " in test_wf.get(job, ""),- f"_test.yml {job} must hand the selection to scripts/test.sh as CBM_TEST_SELECTION_DIR "- f"only when one was passed")+# Only the Linux x86_64 leg narrows (user decision 2026-10-16): the coverage comes from+# the Linux x86_64 producer, so arm64, macOS and Windows legs run every test.+require(readers == ["test-unix"], f"only test-unix may read test_selection, found {readers}")+unix = test_wf.get("test-unix", "")+linux_x64 = "inputs.test_selection != '' && runner.os == 'Linux' && runner.arch == 'X64'"+require(f"if: ${{{{ {linux_x64} }}}}" in unix and+ f"CBM_TEST_SELECTION_DIR: ${{{{ {linux_x64} && " in unix,+ "_test.yml test-unix must fetch the selection and hand it to scripts/test.sh as "+ "CBM_TEST_SELECTION_DIR only on Linux x86_64 and only when one was passed")+require("CBM_TEST_SELECTION_DIR: ''" in test_wf.get("test-windows", ""),+ "_test.yml test-windows must run every test (CBM_TEST_SELECTION_DIR: '')")select = pr.get("select-tests", "")require(re.search(r"(?m)^ if: \$\{\{ vars\.TEST_IMPACT_MODE == 'gate' \}\}$", select) is not None,"pr.yml select-tests must run only when vars.TEST_IMPACT_MODE == 'gate'")diff --git a/tests/test_main.c b/tests/test_main.cindex 5ff6bdb9f..d6e3c2cb2 100644--- a/tests/test_main.c+++ b/tests/test_main.c@@ -1907,10 +1907,14 @@ extern void suite_dump_verify_io(void);* caches at thread teardown (pass_parallel.c). */extern void cbm_kind_in_set_free_cache(void);-/* Native subprocess capture probe; implemented with its tests. */-extern int tf_maybe_run_subprocess_stdout_probe(int argc, char **argv);+/* Runner roles and the runner-image bindings implemented with their tests. */+extern int tf_role_subprocess_stdin_probe(int argc, char **argv);+extern int tf_role_subprocess_stdout_probe(int argc, char **argv);+extern void tf_subprocess_set_binary(const char *path);extern void tf_test_impact_runner_filter_set_binary(const char *path);-extern int tf_maybe_run_git_facts_diff_probe(int argc, char **argv);+extern int tf_role_git_facts_diff_probe(int argc, char **argv);+extern int tf_role_git_facts_hostile_diff_probe(int argc, char **argv);+extern void tf_test_impact_git_set_binary(const char *path);/* The runner's own image, for the tests that start or copy it again. argv[0]* is the caller's spelling, and a Windows parent that found the runner by@@ -1934,35 +1938,201 @@ const char *tf_runner_image(int argc, char **argv) {return argc > 0 && argv ? argv[0] : NULL;}-const char *cbm_test_program_path;+static int tf_role_env_values(int argc, char **argv) {+ if (argc < 4 || argc % 2 != 0) {+ return -1;+ }+ for (int i = 2; i < argc; i += 2) {+ const char *value = getenv(argv[i]);+ if (!value || strcmp(value, argv[i + 1]) != 0) {+ return 61;+ }+ }+ return 0;+}-int main(int argc, char **argv) {- cbm_test_program_path = tf_runner_image(argc, argv);- if (argc >= 4 && argc % 2 == 0 && strcmp(argv[1], "__cbm_env_values") == 0) {- for (int i = 2; i < argc; i += 2) {- const char *value = getenv(argv[i]);- if (!value || strcmp(value, argv[i + 1]) != 0) {- return 61;- }+static int tf_role_env_isolation(int argc, char **argv) {+ if (argc < 5) {+ return -1;+ }+ const char *value = getenv(argv[2]);+ if (!value || strcmp(value, argv[3]) != 0) {+ return 61;+ }+ for (int i = 4; i < argc; i++) {+ if (getenv(argv[i])) {+ return 62;}- return 0;}- if (argc >= 5 && strcmp(argv[1], "__cbm_env_isolation") == 0) {- const char *value = getenv(argv[2]);- if (!value || strcmp(value, argv[3]) != 0) {- return 61;+ return 0;+}++/* Installation tests use this executable as a structurally real candidate.+ * Mirror the production binary's minimal verification contract. */+static int tf_role_version(int argc, char **argv) {+ (void)argv;+ if (argc != 2) {+ return -1;+ }+ (void)puts("codebase-memory-mcp test-runner");+ return 0;+}++static int tf_role_build_config(int argc, char **argv) {+ (void)argv;+ if (argc != 2) {+ return -1;+ }+#ifdef _WIN32+ if (_setmode(cbm_fileno(stdout), _O_BINARY) == -1) {+ fprintf(stderr, "failed to set build-config stdout to binary mode\n");+ return 2;+ }+#endif+#if defined(CBM_SANITIZED_BUILD) && CBM_SANITIZED_BUILD+ const int sanitized = 1;+#else+ const int sanitized = 0;+#endif+#if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS+ const int test_seams = 1;+#else+ const int test_seams = 0;+#endif+ (void)printf("sanitized=%d test_seams=%d\n", sanitized, test_seams);+ return 0;+}++/* #1830 userns smoke probe -- see the test that spawns it.+ *+ * The ancestor overflow uid is derived ONCE per process (pthread_once in+ * src/daemon/ipc.c) from /proc/self/uid_map. That file is not immutable:+ * unshare(CLONE_NEWUSER) is exactly what changes it, and pthread_once state+ * survives fork(). A forked child therefore keeps the HOST answer and never+ * re-derives inside its new namespace, so a fork-only smoke test refuses and+ * cannot pass once anything earlier in the suite has primed the cache --+ * seven call sites do. Re-exec into this probe so the decision is made by a+ * process that STARTED inside the namespace, which is the production shape+ * the test means to cover. */+static int tf_role_userns_secure_probe(int argc, char **argv) {+#if defined(__linux__) && defined(CBM_ENABLE_TEST_SEAMS)+ if (argc == 3) {+ /* _exit, not return: this process exists to answer ONE boolean. A+ * return runs the atexit chain, and the runner is built with+ * -fsanitize=address, so a future leak anywhere in the prologue would+ * exit 23 and read as a security verdict on a test that has none. */+ _exit(cbm_daemon_ipc_private_directory_secure(argv[2]) ? 0 : 1);+ }+#endif+ (void)argc;+ (void)argv;+ return -1;+}++/* The runner's subprocess roles: a test spawns this binary with argv[1] = the+ * literal, and main hands over to the handler at the entry's phase. A handler+ * returns the process's exit code, or -1 to let main continue.+ *+ * The test-impact engine reads this table (src/mcp/test_impact_engine_reach.c):+ * a change only a role reaches runs the tests that name the role's literal,+ * while one that reaches main itself runs every test. So every role main can+ * enter by its argv[1] belongs here, and each entry stays on one line (phase,+ * quoted literal, handler name) -- hence clang-format off. */+typedef enum {+ TF_PHASE_RAW, /* before anything else touches the process */+ TF_PHASE_GIT_CLEAN, /* after the caller's git environment is cleared */+ TF_PHASE_INSTALL, /* installation-candidate answers */+ TF_PHASE_SEAMED, /* after the spill and build-fingerprint pins */+ TF_PHASE_WORKER, /* after the fingerprint capture; the literal anywhere in argv */+ TF_PHASE_SPAWNER, /* never dispatched: one more literal a spawner names */+} tf_phase_t;++typedef struct {+ tf_phase_t phase;+ const char *literal;+ int (*run)(int argc, char **argv);+} tf_role_t;++#define TF_ROLE(phase, literal, handler) {phase, literal, handler}++// clang-format off+static const tf_role_t tf_roles[] = {+ TF_ROLE(TF_PHASE_RAW, "__cbm_env_values", tf_role_env_values),+ TF_ROLE(TF_PHASE_RAW, "__cbm_env_isolation", tf_role_env_isolation),+ TF_ROLE(TF_PHASE_GIT_CLEAN, "__cbm_subprocess_stdin_probe", tf_role_subprocess_stdin_probe),+ TF_ROLE(TF_PHASE_GIT_CLEAN, "__cbm_subprocess_stdout_probe", tf_role_subprocess_stdout_probe),+ TF_ROLE(TF_PHASE_GIT_CLEAN, "__cbm_git_facts_diff_probe", tf_role_git_facts_diff_probe),+ TF_ROLE(TF_PHASE_GIT_CLEAN, "__cbm_git_facts_hostile_diff_probe", tf_role_git_facts_hostile_diff_probe),+ TF_ROLE(TF_PHASE_GIT_CLEAN, "__cbm_windows_memory_limit_probe", tf_maybe_run_windows_memory_limit_probe),+ TF_ROLE(TF_PHASE_INSTALL, "--version", tf_role_version),+ TF_ROLE(TF_PHASE_INSTALL, "--build-config", tf_role_build_config),+ TF_ROLE(TF_PHASE_SEAMED, "--userns-secure-probe", tf_role_userns_secure_probe),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_mcp_idxfailclosed_probe", tf_maybe_run_mcp_idxfailclosed_probe),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_runtime_image_holder", tf_maybe_run_runtime_image_holder),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_runtime_hello_client", tf_maybe_run_runtime_hello_client),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_runtime_activation_client", tf_maybe_run_runtime_activation_client),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_runtime_mapped_hello_client", tf_maybe_run_runtime_mapped_hello_client),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_version_cohort_crash_holder", tf_maybe_run_version_cohort_crash_holder),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_daemon_ipc_lock_probe", tf_maybe_run_daemon_ipc_lock_probe),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_deleted_self_probe", tf_maybe_run_deleted_self_probe),+ TF_ROLE(TF_PHASE_SEAMED, "__cbm_sockprobe", tf_maybe_run_socket_probe),+ /* The supervised index worker (`<self> cli --index-worker ...`): production+ * code starts it only where a test re-enables the supervisor, which main+ * pins off for every test process, so a spawner names one of the two. */+ TF_ROLE(TF_PHASE_WORKER, "--index-worker", tf_maybe_run_index_worker),+ TF_ROLE(TF_PHASE_SPAWNER, "CBM_INDEX_SUPERVISOR", tf_maybe_run_index_worker),+ /* The blocking-git probe: argv[0] (this runner copied as git) enters it, so+ * main calls it directly; a spawner sets the marker it writes. */+ TF_ROLE(TF_PHASE_SPAWNER, "CBM_TEST_RUNTIME_BLOCKING_GIT_PID_FILE", tf_maybe_run_blocking_git_probe),+};+// clang-format on++/* Whether argv enters the role: argv[1] is its literal, or, for the index+ * worker, any argument is (its own parser refuses a misplaced flag loudly). */+static bool tf_role_named(tf_phase_t phase, int argc, char **argv, const char *literal) {+ if (phase != TF_PHASE_WORKER) {+ return strcmp(argv[1], literal) == 0;+ }+ for (int i = 1; i < argc; i++) {+ if (argv[i] && strcmp(argv[i], literal) == 0) {+ return true;}- for (int i = 4; i < argc; i++) {- if (getenv(argv[i])) {- return 62;- }+ }+ return false;+}++/* Hands over to the role argv names, if this phase has it: its exit code, or+ * -1 (no role here, or its handler let main continue). */+static int tf_role_dispatch(tf_phase_t phase, int argc, char **argv) {+ if (argc < 2 || !argv || !argv[1]) {+ return -1;+ }+ for (size_t i = 0; i < sizeof(tf_roles) / sizeof(tf_roles[0]); i++) {+ if (tf_roles[i].phase != phase || !tf_role_named(phase, argc, argv, tf_roles[i].literal)) {+ continue;+ }+ int rc = tf_roles[i].run(argc, argv);+ if (rc >= 0) {+ return rc;}- return 0;+ }+ return -1;+}++const char *cbm_test_program_path;++int main(int argc, char **argv) {+ cbm_test_program_path = tf_runner_image(argc, argv);+ int role_rc = tf_role_dispatch(TF_PHASE_RAW, argc, argv);+ if (role_rc >= 0) {+ return role_rc;}/* #2003: never let a caller's GIT_DIR/GIT_INDEX_FILE/... redirect fixture* git commands at the caller's real repository. */th_clear_git_repo_env();tf_test_impact_runner_filter_set_binary(tf_runner_image(argc, argv));+ tf_subprocess_set_binary(tf_runner_image(argc, argv));+ tf_test_impact_git_set_binary(tf_runner_image(argc, argv));#ifdef CBM_TEST_COVERAGEtf_coverage_process_init();#ifndef _WIN32@@ -1972,47 +2142,19 @@ int main(int argc, char **argv) {}#endif#endif- int stdout_probe_rc = tf_maybe_run_subprocess_stdout_probe(argc, argv);- if (stdout_probe_rc >= 0) {- return stdout_probe_rc;- }- int git_facts_probe_rc = tf_maybe_run_git_facts_diff_probe(argc, argv);- if (git_facts_probe_rc >= 0) {- return git_facts_probe_rc;- }- int memory_limit_probe_rc = tf_maybe_run_windows_memory_limit_probe(argc, argv);- if (memory_limit_probe_rc >= 0) {- return memory_limit_probe_rc;+ role_rc = tf_role_dispatch(TF_PHASE_GIT_CLEAN, argc, argv);+ if (role_rc >= 0) {+ return role_rc;}+ /* argv[0] (this runner copied as git) enters the blocking-git probe, not+ * argv[1], so main calls it here; tf_roles names its spawners. */int blocking_git_rc = tf_maybe_run_blocking_git_probe(argc, argv);if (blocking_git_rc >= 0) {return blocking_git_rc;}- /* Installation tests use this executable as a structurally real candidate.- * Mirror the production binary's minimal verification contract. */- if (argc == 2 && strcmp(argv[1], "--version") == 0) {- (void)puts("codebase-memory-mcp test-runner");- return 0;- }- if (argc == 2 && strcmp(argv[1], "--build-config") == 0) {-#ifdef _WIN32- if (_setmode(cbm_fileno(stdout), _O_BINARY) == -1) {- fprintf(stderr, "failed to set build-config stdout to binary mode\n");- return 2;- }-#endif-#if defined(CBM_SANITIZED_BUILD) && CBM_SANITIZED_BUILD- const int sanitized = 1;-#else- const int sanitized = 0;-#endif-#if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS- const int test_seams = 1;-#else- const int test_seams = 0;-#endif- (void)printf("sanitized=%d test_seams=%d\n", sanitized, test_seams);- return 0;+ role_rc = tf_role_dispatch(TF_PHASE_INSTALL, argc, argv);+ if (role_rc >= 0) {+ return role_rc;}/* A test's verdict is a pure function of code, test, platform and seed --* never of how full this machine's disk is. The spill store refuses to open@@ -2033,64 +2175,11 @@ int main(int argc, char **argv) {(void)cbm_setenv("CBM_TEST_BUILD_FINGERPRINT","0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", 1);}- /* #1830 userns smoke probe -- see the test that spawns it.- *- * The ancestor overflow uid is derived ONCE per process (pthread_once in- * src/daemon/ipc.c) from /proc/self/uid_map. That file is not immutable:- * unshare(CLONE_NEWUSER) is exactly what changes it, and pthread_once state- * survives fork(). A forked child therefore keeps the HOST answer and never- * re-derives inside its new namespace, so a fork-only smoke test refuses and- * cannot pass once anything earlier in the suite has primed the cache --- * seven call sites do. Re-exec into this probe so the decision is made by a- * process that STARTED inside the namespace, which is the production shape- * the test means to cover. */-#if defined(__linux__) && defined(CBM_ENABLE_TEST_SEAMS)- if (argc == 3 && strcmp(argv[1], "--userns-secure-probe") == 0) {- /* _exit, not return: this process exists to answer ONE boolean. A- * return runs the atexit chain, and the runner is built with- * -fsanitize=address, so a future leak anywhere in the prologue would- * exit 23 and read as a security verdict on a test that has none. */- _exit(cbm_daemon_ipc_private_directory_secure(argv[2]) ? 0 : 1);- }-#endif- int mcp_idxfailclosed_rc = tf_maybe_run_mcp_idxfailclosed_probe(argc, argv);- if (mcp_idxfailclosed_rc >= 0) {- return mcp_idxfailclosed_rc;- }- int runtime_image_rc = tf_maybe_run_runtime_image_holder(argc, argv);- if (runtime_image_rc >= 0) {- return runtime_image_rc;- }- int runtime_hello_rc = tf_maybe_run_runtime_hello_client(argc, argv);- if (runtime_hello_rc >= 0) {- return runtime_hello_rc;- }- int runtime_activation_rc = tf_maybe_run_runtime_activation_client(argc, argv);- if (runtime_activation_rc >= 0) {- return runtime_activation_rc;- }- int runtime_mapped_hello_rc = tf_maybe_run_runtime_mapped_hello_client(argc, argv);- if (runtime_mapped_hello_rc >= 0) {- return runtime_mapped_hello_rc;- }- int cohort_crash_rc = tf_maybe_run_version_cohort_crash_holder(argc, argv);- if (cohort_crash_rc >= 0) {- return cohort_crash_rc;- }- int daemon_ipc_probe_rc = tf_maybe_run_daemon_ipc_lock_probe(argc, argv);- if (daemon_ipc_probe_rc >= 0) {- return daemon_ipc_probe_rc;- }- int deleted_self_rc = tf_maybe_run_deleted_self_probe(argc, argv);- if (deleted_self_rc >= 0) {- return deleted_self_rc;- }-- /* #798 follow-up: if spawned as the socket-isolation probe, report whether an- * inheritable socket handle crossed into this child and exit before any suite. */- int probe_rc = tf_maybe_run_socket_probe(argc, argv);- if (probe_rc >= 0) {- return probe_rc;+ /* Roles that run after those pins: the #1830 userns probe, the daemon and+ * runtime clients and holders, the #798 socket-isolation probe (tf_roles). */+ role_rc = tf_role_dispatch(TF_PHASE_SEAMED, argc, argv);+ if (role_rc >= 0) {+ return role_rc;}/* Capture once so the parent tests and any re-exec'd worker bind to this@@ -2100,9 +2189,9 @@ int main(int argc, char **argv) {/* #832: if spawned as a supervised index worker, do the real work and exit* before any suite runs (see tf_maybe_run_index_worker). */- int worker_rc = tf_maybe_run_index_worker(argc, argv);- if (worker_rc >= 0) {- return worker_rc;+ role_rc = tf_role_dispatch(TF_PHASE_WORKER, argc, argv);+ if (role_rc >= 0) {+ return role_rc;}/* #845 belt-and-suspenders: this binary EMBEDS cbm_mcp_handle_tool. Thediff --git a/tests/test_select_lanes.sh b/tests/test_select_lanes.shindex 6cdc4bf84..a316630ce 100755--- a/tests/test_select_lanes.sh+++ b/tests/test_select_lanes.sh@@ -161,7 +161,7 @@ if rc != 2 or "Please consult --help." not in err:# the cap, or a list that reaches the cap selects FULL (file_list_truncated);# the tier still classifies what was listed. A complete list decides as usual# (renames add their old path, so a complete list may exceed the count).-DOCS = ["README.md", "docs/a.md", "docs/b.md"]+DOCS = ["CONTRIBUTING.md", "docs/a.md", "docs/b.md"]CAP_LIST = [f"docs/page{i:04d}.md" for i in range(3000)]diff --git a/tests/test_subprocess.c b/tests/test_subprocess.cindex 74fab4555..c7f78b3d8 100644--- a/tests/test_subprocess.c+++ b/tests/test_subprocess.c@@ -1784,18 +1784,23 @@ static void sp_stdout_payload(unsigned char bytes[SP_STDOUT_BYTES]) {bytes[SP_STDOUT_BYTES - 1] = 'Z'; /* final byte has no newline */}-/* Called before normal harness setup. Normal entry remembers argv[0], whose- * storage lasts through main; the private exact argv grammar never runs suites. */+/* Normal entry (test_main.c) remembers the runner image, whose storage lasts+ * through main. */+void tf_subprocess_set_binary(const char *path);+void tf_subprocess_set_binary(const char *path) {+ sp_stdout_test_binary = path;+}++/* Runner roles (test_main.c's role table), before normal harness setup; the+ * private exact argv grammar never runs suites. */static int sp_stdin_probe(int argc, char **argv);-const char *tf_runner_image(int argc, char **argv); /* test_main.c */-int tf_maybe_run_subprocess_stdout_probe(int argc, char **argv);-int tf_maybe_run_subprocess_stdout_probe(int argc, char **argv) {- if (argc >= 2 && argv && strcmp(argv[1], "__cbm_subprocess_stdin_probe") == 0)- return sp_stdin_probe(argc, argv);- if (argc < 2 || !argv || strcmp(argv[1], "__cbm_subprocess_stdout_probe") != 0) {- sp_stdout_test_binary = tf_runner_image(argc, argv);- return -1;- }+int tf_role_subprocess_stdin_probe(int argc, char **argv);+int tf_role_subprocess_stdin_probe(int argc, char **argv) {+ return sp_stdin_probe(argc, argv);+}++int tf_role_subprocess_stdout_probe(int argc, char **argv);+int tf_role_subprocess_stdout_probe(int argc, char **argv) {if (argc != 4 || (strcmp(argv[2], "binary") != 0 && strcmp(argv[2], "text") != 0 &&strcmp(argv[2], "empty") != 0))return 91;diff --git a/tests/test_test_impact.c b/tests/test_test_impact.cindex c88bdf909..0236535ea 100644--- a/tests/test_test_impact.c+++ b/tests/test_test_impact.c@@ -2563,6 +2563,42 @@ TEST(test_policy_config_change_runs_all) {PASS();}+TEST(test_policy_repository_rules_map_every_kind_of_path) {+ /* This repository's own rules: a path no rule maps runs every test (unmapped_files), so+ * each kind of tracked file has a rule, and only real build inputs run everything. */+ cbm_test_config_t *config = cbm_test_config_load(".codebase-memory.json", false);+ ASSERT_NOT_NULL(config);+ cbm_test_policy_t *policy = cbm_test_policy_new(config);+ ASSERT_NOT_NULL(policy);+ static const char *const cases[][2] = {+ {"graph-ui/package.json", "repo-data"},+ {"graph-ui/src/main.tsx", "repo-data"},+ {"tools/tree-sitter-pascal/src/parser.c", "repo-data"},+ {"tests/fuzz/corpus/cypher/match.seed", "repo-data"},+ {"flake.nix", "repo-data"},+ {"DCO", "repo-data"},+ {"server.json", "repo-data"},+ {"scripts/security-ui.sh", "repo-data"},+ {"tests/test_windows_preflight_contract.ps1", "contracts"},+ {".gitattributes", "build"},+ {"scripts/build.sh", "build"},+ {"Makefile.cbm", "builtin:build"},+ {"tests/test_main.c", "harness"},+ {"src/mcp/test_impact_engine.c", "engine"},+ {"src/pipeline/pipeline.c", NULL},+ {"src/server.json", NULL},+ };+ for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {+ if (!policy_matches(policy, cases[i][0], cases[i][1])) {+ printf(" %s: expected rule %s\n", cases[i][0], cases[i][1] ? cases[i][1] : "(none)");+ FAIL("repository rule mapping");+ }+ }+ cbm_test_policy_free(policy);+ cbm_test_config_free(config);+ PASS();+}+TEST(test_policy_lanes_and_semantic_perf_membership) {cbm_test_policy_t *policy = policy_of("{\"test_impact\":{\"version\":1,"@@ -3748,6 +3784,7 @@ SUITE(test_impact) {RUN_TEST(test_policy_defaults_and_first_match_before_target_resolution);RUN_TEST(test_policy_coverage_compatibility_paths_are_strict);RUN_TEST(test_policy_config_change_runs_all);+ RUN_TEST(test_policy_repository_rules_map_every_kind_of_path);RUN_TEST(test_policy_lanes_and_semantic_perf_membership);RUN_TEST(test_policy_globs_braces_escapes_and_directory_boundaries);RUN_TEST(test_policy_rejects_invalid_consumed_fields_without_changing_seed_loader);diff --git a/tests/test_test_impact_engine.c b/tests/test_test_impact_engine.cindex ea50101da..502bda2f6 100644--- a/tests/test_test_impact_engine.c+++ b/tests/test_test_impact_engine.c@@ -180,6 +180,9 @@ static void tie_close(tie_fixture_t *fx) {(void)th_rmtree(fx->home);}+/* The engine's diagnostic note of the last tie_answer_with call. */+static char tie_last_note[512];+/* The answer for the topic branch against main, as JSON (owned); with a* team artifact bundle when one is given. */static char *tie_answer_with(tie_fixture_t *fx, const char *bundle, const char *commit,@@ -201,6 +204,7 @@ static char *tie_answer_with(tie_fixture_t *fx, const char *bundle, const char *if (diagnostic[0]) {printf(" engine note: %s\n", diagnostic);}+ snprintf(tie_last_note, sizeof(tie_last_note), "%s", diagnostic);size_t len = 0;const char *json = cbm_test_result_json(out, &len);char *copy = json ? strdup(json) : NULL;@@ -212,6 +216,33 @@ static char *tie_answer(tie_fixture_t *fx) {return tie_answer_with(fx, NULL, NULL, false);}+/* The answer, plus in *vetoed the selection the runner veto discarded (NULL+ * when the engine wrote none). */+static char *tie_answer_vetoed(tie_fixture_t *fx, char **vetoed) {+ cbm_test_result_t *discarded = NULL;+ cbm_test_impact_request_t rq = {.repo_root = fx->repo,+ .base_ref = "main",+ .work_parent = fx->work,+ .deadline_ms = cbm_now_ms() + 120000U,+ .platform = "fixture",+ .vetoed_out = &discarded};+ cbm_test_result_t *out = NULL;+ char diagnostic[512];+ *vetoed = NULL;+ if (cbm_test_impact_run(&rq, &out, diagnostic, sizeof(diagnostic)) != CBM_TEST_IMPACT_OK) {+ printf(" engine: %s\n", diagnostic);+ return NULL;+ }+ size_t len = 0;+ const char *json = cbm_test_result_json(out, &len);+ const char *masked = discarded ? cbm_test_result_json(discarded, &len) : NULL;+ char *copy = json ? strdup(json) : NULL;+ *vetoed = masked ? strdup(masked) : NULL;+ cbm_test_result_free(out);+ cbm_test_result_free(discarded);+ return copy;+}+/* The "reasons" array of one suite's entry in the answer. */static bool tie_suite_has(const char *json, const char *suite, const char *reason) {char key[128];@@ -279,6 +310,7 @@ TEST(test_impact_engine_rules_unmapped_and_empty) {char *json = tie_answer(&fx);ASSERT_NOT_NULL(json);ASSERT_NOT_NULL(strstr(json, "\"decision\":\"nothing\""));+ ASSERT_NOT_NULL(strstr(json, "\"run_all_rules\":[]"));free(json);ASSERT_TRUE(tie_write(&fx, "Makefile", "all:\n\techo\n"));@@ -287,6 +319,8 @@ TEST(test_impact_engine_rules_unmapped_and_empty) {ASSERT_NOT_NULL(json);ASSERT_NOT_NULL(strstr(json, "\"decision\":\"run_all\""));ASSERT_NOT_NULL(strstr(json, "RULE_RUN_ALL"));+ /* The answer names the rule that ran everything (the repository rule wins). */+ ASSERT_NOT_NULL(strstr(json, "\"run_all_rules\":[\"build\"]"));free(json);const char *reset[] = {"reset", "--quiet", "--hard", "main", NULL};@@ -296,6 +330,367 @@ TEST(test_impact_engine_rules_unmapped_and_empty) {json = tie_answer(&fx);ASSERT_NOT_NULL(json);ASSERT_NOT_NULL(strstr(json, "UNMAPPED_FILE"));+ ASSERT_NOT_NULL(strstr(json, "\"run_all_rules\":[]"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* A referencing_tests rule keyed by the whole path, unreferenced: ignore. A+ * changed data file a test names selects that test; one no test names selects+ * nothing — instead of running everything (scripts, packaging and docs that no+ * C test reads cannot change a C test's outcome). */+static const char tie_config_named_data[] =+ "{\"test_impact\":{\"version\":1,\"tests\":{\"presets\":{\"c-cbm\":true}},"+ "\"rules\":[{\"id\":\"build\",\"paths\":[\"Makefile\"],\"action\":\"run_all\"},"+ "{\"id\":\"data\",\"paths\":[\"data/**\"],\"action\":\"referencing_tests\","+ "\"key\":\"path\",\"unreferenced\":\"ignore\"}]}}\n";++static const char tie_beta_reads_data[] = "TEST(beta_reads_table) {\n"+ " const char *path = \"data/named.txt\";\n"+ " return path[0] == 'd' ? 0 : 1;\n"+ "}\n"+ "SUITE(beta) {\n"+ " RUN_TEST(beta_reads_table);\n"+ "}\n";++/* The answer's top-level decision: its keys are written sorted, so the+ * document starts with it (a lane's own "decision" comes later). */+static bool tie_top_decision(const char *json, const char *want) {+ char prefix[64];+ snprintf(prefix, sizeof(prefix), "{\"decision\":\"%s\"", want);+ return json && strncmp(json, prefix, strlen(prefix)) == 0;+}++TEST(test_impact_engine_path_key_selects_naming_tests_or_ignores) {+ tie_fixture_t fx;+ const char *const files[] = {".codebase-memory.json", tie_config_named_data,+ "tests/test_beta.c", tie_beta_reads_data,+ "data/named.txt", "one\n",+ "data/other.txt", "two\n"};+ ASSERT_TRUE(tie_open_files(&fx, files, 4));+ ASSERT_TRUE(tie_write(&fx, "data/other.txt", "two, changed\n"));+ ASSERT_TRUE(tie_commit(&fx, "data no test names"));+ char *json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ if (tie_top_decision(json, "run_all")) {+ printf(" %.900s\n", json);+ }+ ASSERT_FALSE(tie_top_decision(json, "run_all"));+ ASSERT_NULL(strstr(json, "RULE_TARGET_UNKNOWN"));+ free(json);++ const char *reset[] = {"reset", "--quiet", "--hard", "main", NULL};+ ASSERT_TRUE(tie_git(&fx, reset));+ ASSERT_TRUE(tie_write(&fx, "data/named.txt", "one, changed\n"));+ ASSERT_TRUE(tie_commit(&fx, "data a test names"));+ json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ if (!tie_suite_has(json, "beta", "STATIC")) {+ printf(" named: %.1400s\n", json);+ }+ ASSERT_FALSE(tie_top_decision(json, "run_all"));+ ASSERT_TRUE(tie_suite_has(json, "beta", "STATIC"));+ ASSERT_FALSE(tie_suite_has(json, "alpha", "STATIC"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* ── Child-process roles: the runner's TF_ROLE table ─────────────────+ * The fixture runner dispatches its roles from a table by argv[1]; a change+ * that reaches a role handler selects the tests that spawn the role, not+ * every test (src/mcp/test_impact_engine_reach.c te_role_lift). */+static const char tie_roles_main[] =+ "#include \"test_framework.h\"\n"+ "#include <string.h>\n"+ "int lib_value(void);\n"+ "int lib_other(void);\n"+ "int lib_third(void);\n"+ "static int role_probe(int argc, char **argv) {\n"+ " return lib_value();\n"+ "}\n"+ "static int role_inner(int argc, char **argv) {\n"+ " return lib_third();\n"+ "}\n"+ "static int role_outer(int argc, char **argv) {\n"+ " return role_inner(argc, argv);\n"+ "}\n"+ "static int role_orphan(int argc, char **argv) {\n"+ " return lib_other();\n"+ "}\n"+ "typedef struct { const char *literal; int (*run)(int, char **); } tf_role_t;\n"+ "#define TF_ROLE(phase, literal, handler) {literal, handler}\n"+ "static const tf_role_t tf_roles[] = {\n"+ " TF_ROLE(0, \"__fx_probe_role\", role_probe),\n"+ " TF_ROLE(0, \"__fx_inner_role\", role_inner),\n"+ " TF_ROLE(0, \"__fx_outer_role\", role_outer),\n"+ " TF_ROLE(0, \"__fx_orphan_role\", role_orphan),\n"+ "};\n"+ "int main(int argc, char **argv) {\n"+ " for (int i = 0; argc > 1 && i < 4; i++) {\n"+ " if (strcmp(argv[1], tf_roles[i].literal) == 0) {\n"+ " return tf_roles[i].run(argc, argv);\n"+ " }\n"+ " }\n"+ " RUN_SELECTED_SUITE(alpha);\n"+ " RUN_SELECTED_SUITE(beta);\n"+ " RUN_SELECTED_SUITE(matrix);\n"+ " return 0;\n"+ "}\n";++/* beta spawns the probe role directly, the outer and inner roles directly,+ * and the probe role once more through a helper. */+static const char tie_roles_beta[] = "static int spawn_probe(void) {\n"+ " const char *argv1 = \"__fx_probe_role\";\n"+ " return argv1[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_spawns_probe) {\n"+ " const char *argv1 = \"__fx_probe_role\";\n"+ " return argv1[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_spawns_outer) {\n"+ " const char *argv1 = \"__fx_outer_role\";\n"+ " return argv1[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_spawns_inner) {\n"+ " const char *argv1 = \"__fx_inner_role\";\n"+ " return argv1[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_plain) {\n"+ " return 0;\n"+ "}\n"+ "SUITE(beta) {\n"+ " RUN_TEST(beta_spawns_probe);\n"+ " RUN_TEST(beta_spawns_outer);\n"+ " RUN_TEST(beta_spawns_inner);\n"+ " RUN_TEST(beta_plain);\n"+ "}\n";++/* matrix reaches the probe role only through a helper that names it. */+static const char tie_roles_matrix[] = "int spawn_probe_helper(void) {\n"+ " const char *argv1 = \"__fx_probe_role\";\n"+ " return argv1[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(matrix_via_helper) {\n"+ " return spawn_probe_helper();\n"+ "}\n"+ "SUITE(matrix) {\n"+ " RUN_TEST(matrix_via_helper);\n"+ "}\n";++static const char tie_roles_lib[] = "int lib_value(void) {\n"+ " return 1;\n"+ "}\n"+ "int lib_other(void) {\n"+ " return 2;\n"+ "}\n"+ "int lib_third(void) {\n"+ " return 3;\n"+ "}\n";++static bool tie_open_roles(tie_fixture_t *fx) {+ const char *const files[] = {"tests/test_main.c", tie_roles_main, "tests/test_beta.c",+ tie_roles_beta, "tests/test_matrix.c", tie_roles_matrix,+ "src/lib.c", tie_roles_lib};+ return tie_open_files(fx, files, 4);+}++/* A change reaching a role handler selects the tests that spawn the role+ * (directly, or through a helper that names it) — not every test. */+TEST(test_impact_engine_role_reach_selects_its_spawners) {+ tie_fixture_t fx;+ ASSERT_TRUE(tie_open_roles(&fx));+ ASSERT_TRUE(tie_write(&fx, "src/lib.c",+ "int lib_value(void) {\n return 1 + 0;\n}\n"+ "int lib_other(void) {\n return 2;\n}\n"+ "int lib_third(void) {\n return 3;\n}\n"));+ ASSERT_TRUE(tie_commit(&fx, "change lib_value"));+ char *json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ if (tie_top_decision(json, "run_all") || !tie_suite_has(json, "beta", "STATIC")) {+ printf(" %.1600s\n", json);+ }+ ASSERT_FALSE(tie_top_decision(json, "run_all"));+ ASSERT_TRUE(tie_suite_has(json, "alpha", "STATIC")); /* calls lib_value itself */+ ASSERT_TRUE(tie_suite_has(json, "beta", "STATIC")); /* spawns the probe role */+ ASSERT_TRUE(tie_suite_has(json, "matrix", "STATIC")); /* through its helper */+ free(json);+ tie_close(&fx);+ PASS();+}++/* A handler that calls another runs it in its own child: a change reaching+ * the inner handler selects the outer role's spawners as well. */+TEST(test_impact_engine_chained_roles_select_both_spawners) {+ tie_fixture_t fx;+ ASSERT_TRUE(tie_open_roles(&fx));+ ASSERT_TRUE(tie_write(&fx, "src/lib.c",+ "int lib_value(void) {\n return 1;\n}\n"+ "int lib_other(void) {\n return 2;\n}\n"+ "int lib_third(void) {\n return 3 + 0;\n}\n"));+ ASSERT_TRUE(tie_commit(&fx, "change lib_third"));+ char *json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ if (tie_top_decision(json, "run_all")) {+ printf(" %.1600s\n", json);+ }+ ASSERT_FALSE(tie_top_decision(json, "run_all"));+ ASSERT_TRUE(tie_suite_has(json, "beta", "STATIC"));+ ASSERT_FALSE(tie_suite_has(json, "alpha", "STATIC"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* Fail safe: a reached role no test names runs everything, and so does a+ * change reaching main by any other path. */+TEST(test_impact_engine_unspawned_role_and_main_still_run_all) {+ tie_fixture_t fx;+ ASSERT_TRUE(tie_open_roles(&fx));+ ASSERT_TRUE(tie_write(&fx, "src/lib.c",+ "int lib_value(void) {\n return 1;\n}\n"+ "int lib_other(void) {\n return 2 + 0;\n}\n"+ "int lib_third(void) {\n return 3;\n}\n"));+ ASSERT_TRUE(tie_commit(&fx, "change lib_other"));+ char *vetoed = NULL;+ char *json = tie_answer_vetoed(&fx, &vetoed);+ ASSERT_NOT_NULL(json);+ ASSERT_TRUE(tie_top_decision(json, "run_all"));+ ASSERT_NOT_NULL(strstr(json, "RUNNER_REACHED"));+ /* The veto is the one reason: CI also gets the selection it discarded. */+ ASSERT_NOT_NULL(vetoed);+ ASSERT_FALSE(tie_top_decision(vetoed, "run_all"));+ ASSERT_NULL(strstr(vetoed, "RUNNER_REACHED"));+ free(vetoed);+ free(json);++ const char *reset[] = {"reset", "--quiet", "--hard", "main", NULL};+ ASSERT_TRUE(tie_git(&fx, reset));+ ASSERT_TRUE(tie_write(&fx, "tests/test_main.c",+ "#include \"test_framework.h\"\n"+ "int lib_value(void);\n"+ "static int worker(int argc, char **argv) {\n"+ " return argc > 9 ? lib_value() : -1;\n"+ "}\n"+ "int main(int argc, char **argv) {\n"+ " if (worker(argc, argv) >= 0) {\n"+ " return 0;\n"+ " }\n"+ " RUN_SELECTED_SUITE(alpha);\n"+ " RUN_SELECTED_SUITE(beta);\n"+ " RUN_SELECTED_SUITE(matrix);\n"+ " return 0;\n"+ "}\n"));+ ASSERT_TRUE(tie_commit(&fx, "a role main calls directly"));+ const char *base[] = {"branch", "--quiet", "-f", "main", "HEAD", NULL};+ ASSERT_TRUE(tie_git(&fx, base));+ ASSERT_TRUE(tie_write(&fx, "src/lib.c",+ "int lib_value(void) {\n return 1 + 0;\n}\n"+ "int lib_other(void) {\n return 2;\n}\n"+ "int lib_third(void) {\n return 3;\n}\n"));+ ASSERT_TRUE(tie_commit(&fx, "change lib_value"));+ json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ ASSERT_TRUE(tie_top_decision(json, "run_all"));+ ASSERT_NOT_NULL(strstr(json, "RUNNER_REACHED"));+ /* The note names the way in: main, the role it calls, the changed code. */+ ASSERT_NOT_NULL(strstr(tie_last_note, "test_main.main -> test_main.worker -> lib.lib_value"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* The role fixture with a second, never-dispatched literal for the orphan role+ * and `beta` as given; the answer for a change that reaches only that role+ * (NULL on a fixture failure). */+static char *tie_answer_orphan_switch(tie_fixture_t *fx, const char *beta) {+ const char *anchor = " TF_ROLE(0, \"__fx_orphan_role\", role_orphan),\n";+ const char *at = strstr(tie_roles_main, anchor);+ size_t head = at ? (size_t)(at - tie_roles_main) + strlen(anchor) : 0;+ char runner[4096];+ int n = snprintf(runner, sizeof(runner),+ "%.*s TF_ROLE(9, \"__FX_ORPHAN_SWITCH\", role_orphan),\n%s", (int)head,+ tie_roles_main, tie_roles_main + head);+ const char *base[] = {"branch", "--quiet", "-f", "main", "HEAD", NULL};+ if (!at || n <= 0 || (size_t)n >= sizeof(runner) || !tie_open_roles(fx) ||+ !tie_write(fx, "tests/test_main.c", runner) || !tie_write(fx, "tests/test_beta.c", beta) ||+ !tie_commit(fx, "a second literal for the orphan role") || !tie_git(fx, base) ||+ !tie_write(fx, "src/lib.c",+ "int lib_value(void) {\n return 1;\n}\n"+ "int lib_other(void) {\n return 2 + 0;\n}\n"+ "int lib_third(void) {\n return 3;\n}\n") ||+ !tie_commit(fx, "change lib_other")) {+ return NULL;+ }+ char *json = tie_answer(fx);+ if (json && (strstr(json, "RUNNER_REACHED") || !tie_suite_has(json, "beta", "STATIC"))) {+ printf(" note: %s\n %.1600s\n", tie_last_note, json);+ }+ return json;+}++/* A handler with two literals (the index worker: its argv flag and the switch+ * that lets production code start it): a test naming either one is a spawner,+ * and the unnamed one alone vetoes nothing. */+TEST(test_impact_engine_role_with_two_literals_selects_both_spawners) {+ tie_fixture_t fx;+ char *json = tie_answer_orphan_switch(&fx, "TEST(beta_sets_switch) {\n"+ " const char *name = \"__FX_ORPHAN_SWITCH\";\n"+ " return name[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_plain) {\n return 0;\n}\n"+ "SUITE(beta) {\n"+ " RUN_TEST(beta_sets_switch);\n"+ " RUN_TEST(beta_plain);\n"+ "}\n");+ ASSERT_NOT_NULL(json);+ ASSERT_NULL(strstr(json, "RUNNER_REACHED"));+ ASSERT_TRUE(tie_suite_has(json, "beta", "STATIC"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* The literal behind a #define (the blocking-git marker): the tests that use+ * the macro are the spawners. */+TEST(test_impact_engine_role_literal_behind_a_define_selects_its_users) {+ tie_fixture_t fx;+ char *json = tie_answer_orphan_switch(&fx, "#define BETA_SWITCH \"__FX_ORPHAN_SWITCH\"\n"+ "TEST(beta_sets_switch) {\n"+ " const char *name = BETA_SWITCH;\n"+ " return name[0] == '_' ? 0 : 1;\n"+ "}\n"+ "TEST(beta_plain) {\n return 0;\n}\n"+ "SUITE(beta) {\n"+ " RUN_TEST(beta_sets_switch);\n"+ " RUN_TEST(beta_plain);\n"+ "}\n");+ ASSERT_NOT_NULL(json);+ ASSERT_NULL(strstr(json, "RUNNER_REACHED"));+ ASSERT_TRUE(tie_suite_has(json, "beta", "STATIC"));+ free(json);+ tie_close(&fx);+ PASS();+}++/* A struct member named like a suite: the extractor can take the macro argument+ * of RUN_SELECTED_SUITE(alpha) for a use of it. A changed member reaches main+ * only through that edge into a Field: no veto. */+TEST(test_impact_engine_field_call_is_no_way_into_main) {+ tie_fixture_t fx;+ ASSERT_TRUE(+ tie_open_with(&fx, "tests/shapes.h",+ "typedef struct {\n char alpha[8];\n int sides;\n} shape_t;\n"));+ ASSERT_TRUE(tie_write(&fx, "tests/shapes.h",+ "typedef struct {\n char alpha[16];\n int sides;\n} shape_t;\n"));+ ASSERT_TRUE(tie_commit(&fx, "widen the member"));+ char *json = tie_answer(&fx);+ ASSERT_NOT_NULL(json);+ if (strstr(json, "RUNNER_REACHED")) {+ printf(" note: %s\n", tie_last_note);+ }+ ASSERT_NULL(strstr(json, "RUNNER_REACHED"));free(json);tie_close(&fx);PASS();@@ -622,6 +1017,13 @@ SUITE(test_impact_engine) {RUN_TEST(test_impact_engine_reached_suites_carry_static);RUN_TEST(test_impact_engine_macro_registered_tests_select_their_suite);RUN_TEST(test_impact_engine_rules_unmapped_and_empty);+ RUN_TEST(test_impact_engine_path_key_selects_naming_tests_or_ignores);+ RUN_TEST(test_impact_engine_role_reach_selects_its_spawners);+ RUN_TEST(test_impact_engine_chained_roles_select_both_spawners);+ RUN_TEST(test_impact_engine_unspawned_role_and_main_still_run_all);+ RUN_TEST(test_impact_engine_role_with_two_literals_selects_both_spawners);+ RUN_TEST(test_impact_engine_role_literal_behind_a_define_selects_its_users);+ RUN_TEST(test_impact_engine_field_call_is_no_way_into_main);RUN_TEST(test_impact_engine_parse_gaps_reach_what_they_name);RUN_TEST(test_impact_engine_admitted_coverage_narrows_only_when_verified);RUN_TEST(test_impact_engine_coverage_reaches_unmapped_code_through_mapped_callers);diff --git a/tests/test_test_impact_git.c b/tests/test_test_impact_git.cindex 0964429b6..4f9fe1cc2 100644--- a/tests/test_test_impact_git.c+++ b/tests/test_test_impact_git.c@@ -50,37 +50,46 @@ static bool gf_write(const char *path, const void *bytes, size_t length) {return ok;}-/* Native executable fixture for Git's optional diff/textconv command. Extra- * arguments added by Git are deliberately ignored. Normal harness entry keeps- * argv[0] for a private executable copy; neither mode changes the environment. */-const char *tf_runner_image(int argc, char **argv); /* test_main.c */-int tf_maybe_run_git_facts_diff_probe(int argc, char **argv);-int tf_maybe_run_git_facts_diff_probe(int argc, char **argv) {- if (argc >= 2 && argv && strcmp(argv[1], "__cbm_git_facts_diff_probe") == 0) {- return argc >= 3 && gf_write(argv[2], "invoked\n", 8) ? 0 : 96;+/* Normal harness entry (test_main.c) keeps the runner image for a private+ * executable copy. */+void tf_test_impact_git_set_binary(const char *path);+void tf_test_impact_git_set_binary(const char *path) {+ gf_runner_binary = path;+}++/* Runner role (test_main.c's role table): the native executable fixture for+ * Git's optional diff/textconv command. Extra arguments added by Git are+ * deliberately ignored; the environment is left unchanged. */+int tf_role_git_facts_diff_probe(int argc, char **argv);+int tf_role_git_facts_diff_probe(int argc, char **argv) {+ return argc >= 3 && gf_write(argv[2], "invoked\n", 8) ? 0 : 96;+}++/* Runner role: only this isolated child mutates its environment, before+ * harness threads start, and returns -1 so main re-enters the existing+ * exact-diff test; the parent process remains untouched. An inherited+ * CBM_TEST_ONLY_FILE (a narrowed CI run) is cleared: the runner unions it with+ * CBM_TEST_ONLY, and one naming this suite would re-run the spawning test,+ * which spawns again. An inherited CBM_TEST_COVERAGE_DIR (a coverage-map run)+ * is cleared too: with it the child would start a coverage run of its own,+ * which refuses the per-test LLVM_PROFILE_FILE it inherits. Without it the+ * child's profile goes to that file, credited to the spawning test like any+ * other child process. */+int tf_role_git_facts_hostile_diff_probe(int argc, char **argv);+int tf_role_git_facts_hostile_diff_probe(int argc, char **argv) {+ if (argc != 2) {+ return -1;}- if (argc == 2 && argv && strcmp(argv[1], "__cbm_git_facts_hostile_diff_probe") == 0) {- /* Only this isolated child mutates its environment, before harness threads start.- * Re-enter the existing exact-diff test; the parent process remains untouched.- * An inherited CBM_TEST_ONLY_FILE (a narrowed CI run) is cleared: the runner- * unions it with CBM_TEST_ONLY, and one naming this suite would re-run the- * spawning test, which spawns again. An inherited CBM_TEST_COVERAGE_DIR (a- * coverage-map run) is cleared too: with it the child would start a coverage- * run of its own, which refuses the per-test LLVM_PROFILE_FILE it inherits.- * Without it the child's profile goes to that file, credited to the spawning- * test like any other child process. */- if (cbm_setenv("GIT_DIFF_OPTS", "--unified=999", 1) != 0 ||- cbm_setenv("CBM_TEST_ONLY_FILE", "", 1) != 0 ||- cbm_unsetenv("CBM_TEST_COVERAGE_DIR") != 0 ||- cbm_setenv(- "CBM_TEST_ONLY",- "test_impact_git:test_git_facts_diff_uses_merge_base_zero_context_and_nul_metadata",- 1) != 0) {- return 96;- }- argv[1] = "test_impact_git";+ if (cbm_setenv("GIT_DIFF_OPTS", "--unified=999", 1) != 0 ||+ cbm_setenv("CBM_TEST_ONLY_FILE", "", 1) != 0 ||+ cbm_unsetenv("CBM_TEST_COVERAGE_DIR") != 0 ||+ cbm_setenv(+ "CBM_TEST_ONLY",+ "test_impact_git:test_git_facts_diff_uses_merge_base_zero_context_and_nul_metadata",+ 1) != 0) {+ return 96;}- gf_runner_binary = tf_runner_image(argc, argv);+ argv[1] = "test_impact_git";return -1;}diff --git a/tests/test_test_impact_runner_filter.c b/tests/test_test_impact_runner_filter.cindex 3907798f3..0f206cecb 100644--- a/tests/test_test_impact_runner_filter.c+++ b/tests/test_test_impact_runner_filter.c@@ -57,6 +57,28 @@ TEST(test_impact_runner_filter_consumes_public_codec_bytes) {PASS();}+TEST(test_impact_runner_filter_lane_running_every_suite_whole_is_run_all) {+ /* A lane that lists every member suite whole runs everything: it says run_all+ * rather than handing the runner a token list that happens to name it all. */+ const rf_spec_t sole = {.suite = "str_intern", .test = "rf_case", .whole = true, .sole = true};+ rf_fixture_t fixture;+ bool prepared = rf_fixture_open(&fixture) && rf_prepare(&fixture, &sole);+ cbm_test_result_status_t status =+ prepared ? rf_build(&fixture, RF_JSON_CAP, false) : CBM_TEST_RESULT_INVALID;+ bool parsed = status == CBM_TEST_RESULT_OK && rf_parse(&fixture);+ yyjson_val *lane = parsed ? rf_lane(&fixture) : NULL;+ bool run_all = lane && yyjson_equals_str(yyjson_obj_get(lane, "decision"), "run_all");+ if (!run_all) {+ printf(" sole whole-suite lane: status=%d parsed=%d lane=%d\n", status, parsed,+ lane != NULL);+ }+ bool removed = rf_fixture_close(&fixture);+ ASSERT_TRUE(prepared);+ ASSERT_TRUE(run_all);+ ASSERT_TRUE(removed);+ PASS();+}+static bool rf_unknown_run(rf_fixture_t *fixture, const char *token, size_t length) {rf_run_t run = {0};char diagnostic[640];@@ -132,7 +154,7 @@ static bool rf_limit_control(void) {static bool rf_diagnostic_control(void) {char name[513];rf_identifier(name, 512);- const rf_spec_t spec = {.suite = name, .test = "rf_case", .whole = true};+ const rf_spec_t spec = {.suite = name, .test = "rf_case", .whole = true, .sole = true};rf_fixture_t fixture;bool prepared = rf_fixture_open(&fixture) && rf_prepare(&fixture, &spec);cbm_test_result_status_t status =@@ -165,6 +187,7 @@ TEST(test_impact_runner_filter_limits_and_diagnostic_domain) {SUITE(test_impact_runner_filter) {RUN_TEST(test_impact_runner_filter_consumes_public_codec_bytes);+ RUN_TEST(test_impact_runner_filter_lane_running_every_suite_whole_is_run_all);RUN_TEST(test_impact_runner_filter_literal_width_boundaries);RUN_TEST(test_impact_runner_filter_limits_and_diagnostic_domain);}diff --git a/tests/test_test_impact_runner_filter.h b/tests/test_test_impact_runner_filter.hindex 8bee58858..db9a0b2ff 100644--- a/tests/test_test_impact_runner_filter.h+++ b/tests/test_test_impact_runner_filter.h@@ -12,6 +12,7 @@ typedef struct {const char *test;bool whole;bool mixed;+ bool sole; /* no unselected rf_quiet suite: the spec's suites are the whole lane */} rf_spec_t;typedef struct {diff --git a/tests/test_test_impact_runner_filter_fixture.c b/tests/test_test_impact_runner_filter_fixture.cindex 16dbff2e2..ff822acbf 100644--- a/tests/test_test_impact_runner_filter_fixture.c+++ b/tests/test_test_impact_runner_filter_fixture.c@@ -46,29 +46,46 @@ static bool rf_model(rf_fixture_t *fixture, const rf_spec_t *spec) {!cbm_test_model_add_source(fixture->model, "tests/rf_whole.c", other, sizeof(other) - 1)) {return false;}+ /* A lane member the change does not reach keeps a whole-suite selection narrowed. */+ static const char quiet[] = "TEST(rf_quiet) {}\nSUITE(rf_quiet) { RUN_TEST(rf_quiet); }\n"+ "void quiet_main(void) { RUN_SELECTED_SUITE(rf_quiet); }\n";+ if (!spec->sole &&+ !cbm_test_model_add_source(fixture->model, "tests/rf_quiet.c", quiet, sizeof(quiet) - 1)) {+ return false;+ }return cbm_test_model_finish(fixture->model) && cbm_test_model_complete(fixture->model);}static bool rf_selection(rf_fixture_t *fixture, const rf_spec_t *spec) {char rows[4096];- int count = snprintf(rows, sizeof(rows),- "%s:*\tcomplete\t\t1\n%s:%s\tcomplete\t\t0\n"- "%s:rf_spare\tcomplete\t\t1\n%s",- spec->suite, spec->suite, spec->test, spec->suite,- spec->mixed ? "str_intern:*\tcomplete\t\t1\n"- "str_intern:rf_other\tcomplete\t\t1\n"- : "");+ int count =+ snprintf(rows, sizeof(rows),+ "%s:*\tcomplete\t\t1\n%s:%s\tcomplete\t\t0\n"+ "%s:rf_spare\tcomplete\t\t1\n%s%s",+ spec->suite, spec->suite, spec->test, spec->suite,+ spec->mixed ? "str_intern:*\tcomplete\t\t1\n"+ "str_intern:rf_other\tcomplete\t\t1\n"+ : "",+ spec->sole ? "" : "rf_quiet:*\tcomplete\t\t1\nrf_quiet:rf_quiet\tcomplete\t\t1\n");static const char functions[] = "0\tsrc/changed.c\tchanged\n1\tsrc/quiet.c\tquiet\n";if (count < 0 || (size_t)count >= sizeof(rows)) {return false;}fixture->coverage =cbm_coverage_map_parse(functions, sizeof(functions) - 1, rows, (size_t)count);- cbm_test_reach_t reach[] = {+ cbm_test_reach_t reach[4] = {{.file = "tests/rf_subject.c", .test = spec->test, .mapped = true, .reached = true},{.file = "tests/rf_subject.c", .test = "rf_spare", .mapped = true},- {.file = "tests/rf_whole.c", .test = "rf_other", .mapped = true},};+ size_t reach_count = 2;+ if (spec->mixed) {+ reach[reach_count++] =+ (cbm_test_reach_t){.file = "tests/rf_whole.c", .test = "rf_other", .mapped = true};+ }+ if (!spec->sole) {+ reach[reach_count++] =+ (cbm_test_reach_t){.file = "tests/rf_quiet.c", .test = "rf_quiet", .mapped = true};+ }cbm_test_suite_trigger_t trigger = {.suite = spec->mixed ? "str_intern" : spec->suite,.reached = true};const int changed = 0;@@ -76,7 +93,7 @@ static bool rf_selection(rf_fixture_t *fixture, const rf_spec_t *spec) {.model = fixture->model,.coverage = fixture->coverage,.reach = reach,- .reach_count = spec->mixed ? 3 : 2,+ .reach_count = reach_count,.suite_triggers = &trigger,.suite_trigger_count = spec->whole || spec->mixed ? 1 : 0,.changed_function_ids = &changed,