✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.

[taras]

Why

Agents run the whole corpus under three runtimes after every change, and CI spends
306–316 s doing the same. #280 rules that agents run only the tests their branch and
worktree affect, decided by Deno's native selection, while CI keeps running everything.

This is PR A of two: the mechanism, with no policy change. AGENTS.md's default and
the exhaustive CI jobs are untouched, so the command ships alongside the existing battery
and can be exercised before anything depends on it. PR B records CI-measured weights,
installs the sharded matrix and its aggregate, updates the docs, and closes#280.

What changes

Before: the only local test commands run the complete corpus — deno task test,
pnpm test:node, bun run test:bun.

After: deno task test:affected runs the tests a change affects, under all three
runtimes, from one selected set.

$ deno task test:affected --base HEAD # one changed file in packages/acp/src
changed paths (1)
M packages/acp/src/session-key.ts
selected 9 of 174 test files
d n b packages/acp/tests/acceptance.test.ts
…
results
deno passed in 47s
node passed in 56.2s
bun passed in 40.9s
this command runs tests only — still applicable:
deno task lint / check / check:jsr / compiled smoke / xmd test packages/core/src --raw
CI runs the complete corpus under every runtime. This run is not equivalent to it.

66 s against roughly ten minutes for the three full suites.

How it works

git change set → classification → reachability proof → Deno's selection → 3 runtimes

1. Change set (scripts/lib/git-changes.ts) — merge-base diff, staged, unstaged, and
   untracked, parsed NUL-safely and status-aware with explicit -M -C. A rename
   contributes both paths, the old one as a deletion; a copy contributes only its new
   path, because the source still exists.
2. Classification (scripts/lib/change-classes.ts) — every path lands in exactly one
   class, and anything unmatched is unknown, which runs everything. Deletions,
   configuration, dependency state, the selector itself, the shared harness, runtime-read
   documents and fixtures, and bundle inputs each run the full corpus.
3. Reachability proof (--related) — selection says nothing about a file in no test's
   graph, so any changed TypeScript with no static dependent runs the whole corpus rather
   than reporting a narrow green.
4. Selection (--changed + --no-run, one candidate per probe) — Deno's answer,
   captured before anything runs.
5. Three runtimes — the same set, minus each runtime's recorded exclusions, run
   concurrently under allSettled.

Review guide

Start with:scripts/lib/affected.ts — the module doc records why every other seam
was rejected.

Then review:

1. scripts/lib/change-classes.ts — the trigger table and its unknown fallback
2. scripts/lib/git-changes.ts — rename versus copy, and the statuses it refuses
3. scripts/affected-tests.ts — failure semantics and the report
4. scripts/lib/shard.ts, scripts/measure-weights.ts — weighted partitioning (used by PR B)

Look carefully at:

• The two different failures in scripts/affected-tests.ts: an unreadable change set
  stops with remediation; a probe that fails afterwards widens to the full corpus.
  Narrowing is never the response to an error.

What must stay true

• Type-checking stays on in the probe — under --no-check the sweep silently loses
  every test that reaches a change only through import type. Enforced by the shared
  FLAGS and checked by "selects a test that reaches the change only through
  import type".
• Escalation is one-way — checked by the deletion, rename, fixture, document, unknown,
  unreachable, and probe-failure cases.
• One discovery — CI will hand explicit lists to all three runners, so
  scripts/lib/test-files.ts must find everything Deno's glob would. Checked by
  scripts/tests/test-file-discovery.test.ts.
• Every file, exactly once, in the partition — checked by scripts/tests/shard.test.ts.

How to verify it

Every correctness case runs against a scratch git repository the test builds, so no
fixture depends on the state of this repository.

• "selects the tests that import a changed module, and nothing else" fails if selection
  widens or narrows.
• "selects a test that reaches the change only through import type" fails if the probe
  ever adopts --no-check.
• "runs everything when a changed module is in no test's graph" fails if a
  dynamically-loaded or subprocess-loaded file is trusted to select honestly.
• "runs everything for a deletion, which selects nothing on its own" fails if a deleted
  path is treated as an ordinary change — the false green Deno produces natively.
• "reports both sides of a committed rename" and "takes only the new path of a copy"
  fail if rename and copy are conflated.
• "fails rather than reporting no changes when the base cannot be resolved" fails if an
  unreadable git state degrades to "nothing changed".
• "runs everything and says which probe failed" fails if an error narrows the run.
• "still covers the corpus when nothing has been measured" fails if unweighted files
  pile into one shard — it caught exactly that defect during development.

Manual: deno task test:affected --base HEAD after touching one source file.

Scope

Included

• deno task test:affected and its libraries, with the full regression suite
• deno task weights:measure and the workflow_dispatch job that runs it on ubuntu-latest

Intentionally unchanged

• AGENTS.md still requires the full battery; affected mode is not yet the default
• ci.yml still runs the unsharded corpus; the sharded matrix and runtime-tests
  aggregate are PR B
• test-weights.json is not committed here — weights are recorded from a CI run in PR B
• Deno --parallel stays out of Shard exhaustive CI runtime suites under five minutes #280: it is 3.7× faster locally and currently exits 1

New abstractions

• Probe (scripts/lib/affected.ts) exists so selection can be driven by the real
  deno test and by a stub that fails on demand.
• captured() (scripts/lib/captured.ts) exists because exec(...).join() forwards child
  output as it arrives, and three concurrent suites would interleave into one terminal.

Risks and limitations

• Make the full verification battery safe to run concurrently #279 Stage 2 is still open. This PR depends on the Stage-1 repair merged in 🤖 Freeze the lock at the task boundary, and prove builds change nothing #304
  (root lock.frozen, the inert build flags) and adopts the same --frozen flag for probe
  and run. If Stage 2 changes that flag set, probe and run must move together — a mismatch
  costs a full re-type-check rather than being wrong.
• Local timing quoted above was measured on a contended machine; CI is the authority, and
  PR B's five runs are where the three-minute target is proved.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Part of #280

[github-actions]

PR #311: ✨ Run the tests a change affects, and weigh the corpus for shards (#280, PR A of two)

17 files, +1915 / -0

Scope

🔴 PR has 1915 lines changed. Split into focused PRs.

🟡 1915 lines changed. PRs under 400 receive more thorough review.

🟡 PR mixes config and source changes.

Structural

🟡 18 console statements.

Slop

✅ Slop indicators look low.

Static Analysis

✅ Oxlint found no issues.

Correctness

No extraneous code patterns detected.

[taras]

Closing without merging: the prerequisite is unmet. #279 Stage 2 has not merged and #279
is still open, and the #280 ruling puts PR A after both. The branch
feat/issue-280-affected-tests is preserved at 490de0b; this is a sequencing close, not
an abandonment.

Recorded for the rebase, once #279 closes — revalidate against its final interfaces first
(the inert flag set probe and run must adopt together, the task-entry lock protection,
and the scripts/lib/ helpers), then repair:

1. Code rules. Swept the additions; exactly four violations, no others:

• scripts/affected-tests.ts:298 and scripts/measure-weights.ts:98 — top-level await main(...)
• scripts/affected-tests.ts:46 — as const on RUNTIMES
• scripts/tests/affected-selection.test.ts:23 — the fixture's explicit Promise<unknown> annotation

2. Complete the approved automated matrix. Currently missing: cross-workspace
transitivity; the --no-check negative case as its own assertion rather than only the
positive type-only case; a real copy record and a real staged deletion (git rm) driven
through git rather than the parser alone; renames into and out of a triggering directory;
both dynamic-import cases (analyzable template and computed target); every classification
exercised through scratch selection rather than the pure table; and ignored output versus
tracked generator inputs.

3. Command-level tests. None exist today — scripts/affected-tests.ts is covered only
end to end by hand. Needed: remediation on an unreadable base, full-corpus fallback after a
probe failure, allSettled behaviour when one runtime fails, complete first-failure output,
cancellation terminating every child process, and clean state after success, failure, and
cancellation.

4. AGENTS.md stays unchanged in PR A — it already does here, and it stays that way.
Agents do not learn to run affected tests until PR B lands it beside exhaustive sharded CI.

5. Re-verification. Complete pinned battery on the rebased head, tracked-tree
cleanliness proven, fully green CI and zero unresolved threads before re-review.

Then stop after PR A. PR B changes the agent default and closes #280.