fix(876): sweep session narrative out of hooks, workflows, scripts, tests and code comments; grow the detector to the process corpus

`docs.no-session-narrative` reaches every durable artifact, but its detector scanned only
`docs/**/*.md` and root markdown, and nothing had ever swept the rest. The issue named four sites
from one grep and called them a floor. Deriving the population instead — a whitespace-joined sweep
over every tracked file outside the detector, for the detector's own phrasings plus the attribution
and review-round class #812 found — gave 453 sites in 108 files at `fb5592971`, and a second pass
for phrasings the first list missed (hyphenated `round-N`, "an earlier version", "the reviewer
proved") added residuals in the same files. Every site was classified with #812's three
dispositions (CUT / SEVER / KEEP with its sub-kind) under the who-benefits test; the per-site
manifests are on the PR. The rejected designs, tested-and-rejected fixtures, measurements and
traps stay; the attribution of who found them and the round in which they were found go.

The detector's population grows to `.claude/`, `.gitea/`, `.husky/` and `scripts/` regardless
of extension, minus the detector and its own test (whose fixtures ARE the phrasings) and minus
`scripts/tests/fixtures/` (test data, including decision-record copies — the same reasoning as
the records' own exemption, and what keeps the record's depth measurement true), and `--all`
lists tracked REGULAR files only — a symlink's content is its target and a gitlink has none. The #812
argument for leaving `docs/superpowers/**` in the population runs the other way here: `--diff`
sees only ADDED lines, and 287 of the 453 sites were under 30 days old — this corpus is where
narrative is being added, so the advisory nudge has reach. Density agrees: 56 line-mode hits over
the 113 regular files the predicate admits, against 9 over 66 docs files before #812. `web/` and C# stay out on the same
measurement (3 of 74 PATTERNS-matching sites, ~4,600 files). The predicate did not grow: PATTERNS
matched 74 of 453 sites, and widening the word list to the attribution class is the treadmill
the withdrawn parity test ran on. The population oracle is restated over segments with the new
arms, the synthetic cross product gains the process heads and non-markdown extensions, a fixture
witnesses that a tracked symlink is neither scanned nor counted, a `.py.bak` axis separates a
by-name exemption from a `startswith` over the same tuple, and eight mutants (drop the process
arm, drop the by-name exemption, exempt by `startswith`, drop or add a prefix, drop the fixtures
exemption, list only markdown, drop the symlink filter, test the mode per row instead of per
path) each
redden it. A pre-existing silent drop in `--diff` goes with it: git tab-terminates a `+++`
filename that contains a space, and the kept tab made `is_scanned_path` refuse the file with no
notice — fixed, with a positive control and its own mutant.

Code is unchanged by construction, measured per file type against `origin/main`: Python modules
are AST-equal with docstrings stripped, except `#` lines inside the embedded fixture programs
(string literals) of three test modules; workflows differ only in `#` lines inside `run:` block
scalars; shell, C#, TypeScript and jq are equal with comment lines stripped. The stated
exceptions: the detector and its test, 26 vitest titles that carried review-round or severity
labels or a reviewer attribution (call sites whose title changed — every changed title line
walked back to its `it(` / `it.each(...)(` anchor, so a `' + '` concatenation counts once), two
registry note strings and the mutation manifest's prose fields. scripts/tests: 1565 passed.
Web: lint, typecheck, 1319 tests green. Closes #876.

Decisions-Edit: yes
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PEcBoFw7ctrf3Nb7R7x7wk

scripts/tests/test_decisions_validate.py

@@ -915,10 +915,9 @@ def test_a_wing_root_README_is_exempt_by_PATH_not_by_basename(tmp_path):
     """`docs/decisions/archive/README.md` really exists (a hand-written directory README), so it
     must be exempt — but by exact relative path, not by basename.
 
-    An earlier version excluded ANY wing-root `README.md` on the stated grounds that no such file
-    existed. That was false, and it would additionally have exempted a future
-    `records/README.md` — reintroducing the basename hole one directory over, in the wing that
-    matters most."""
+    Excluding ANY wing-root `README.md` on the grounds that no such file exists is false, and it
+    would additionally exempt a future `records/README.md` — reintroducing the basename hole one
+    directory over, in the wing that matters most."""
     records, archive = _wing(tmp_path)
     (records / "ci" / "good.md").write_text(_GOOD)
     (archive / "README.md").write_text("# archive\n\nHand-written directory README.\n")
@@ -1067,7 +1066,7 @@ def test_ceiling_calibration_detects_drift_in_BOTH_directions():
     assert not dv.ceiling_calibration(recs, 10).marks_tail, "below p90 it cuts into the bulk"
     assert not dv.ceiling_calibration(recs, 999).marks_tail, "above p95 it is parked among outliers"
 
-    # BOTH ends of `marks_tail` are inclusive. Review found the upper one unpinned — `ceiling <= p95`
+    # BOTH ends of `marks_tail` are inclusive. The upper one was unpinned — `ceiling <= p95`
     # mutated to `<` survived the whole suite. It is notice-only rather than blocking, but an
     # unpinned boundary is how a documented claim quietly stops being true.
     assert dv.ceiling_calibration(recs, 20).marks_tail, "p90 itself must satisfy the lower bound"
@@ -1083,10 +1082,10 @@ def test_ceiling_calibration_detects_drift_in_BOTH_directions():
 def test_the_coarse_bound_REJECTS_a_badly_placed_ceiling():
     """The blocking property must have teeth.
 
-    Review's strongest finding on the first draft: a floor of `fraction_over > 0` was nearly
-    unfalsifiable — measured on the live corpus it accepted every ceiling from 39 to 229, including
-    the ceiling of 200 the docstring itself offered as the case it catches, because one 230-line
-    record keeps the count nonzero. A FRACTION floor is what restores the teeth.
+    A floor of `fraction_over > 0` is nearly unfalsifiable — measured on the live corpus it
+    accepted every ceiling from 39 to 229, including the ceiling of 200 the docstring itself
+    offered as the case it catches, because one 230-line record keeps the count nonzero. A
+    FRACTION floor is what restores the teeth.
 
     The rejections are pinned on a SYNTHETIC distribution: asserting that a specific absurd ceiling
     stays rejected by the live corpus is itself growth-coupled (three new 200+ line records flip the
@@ -1094,9 +1093,9 @@ def test_the_coarse_bound_REJECTS_a_badly_placed_ceiling():
     """
     # The TEETH are demonstrated on an owned distribution, for the reason in
     # `test_v4_would_have_reddened_where_v5_holds`: an assertion that a specific absurd ceiling is
-    # rejected by the LIVE corpus is itself growth-coupled (review found that three new 200+ line
-    # records would flip the 200 arm). 100 records of 30 lines and one of 230 — an outlier-only
-    # tail, which is precisely the shape a badly-placed ceiling fails to distinguish.
+    # rejected by the LIVE corpus is itself growth-coupled (three new 200+ line records would flip
+    # the 200 arm). 100 records of 30 lines and one of 230 — an outlier-only tail, which is
+    # precisely the shape a badly-placed ceiling fails to distinguish.
     synthetic = [_rec_body(f"a.s{i}", 30) for i in range(100)] + [_rec_body("a.outlier", 230)]
 
     for bad in (200, 229, 230):
@@ -1121,7 +1120,7 @@ def test_ceiling_calibration_is_empty_safe():
 
 
 def test_the_minority_band_BOUNDARIES_are_exactly_where_documented():
-    """Pins both constants AND both inclusivities, which review found entirely unmutated.
+    """Pins both constants AND both inclusivities, which were entirely unmutated.
 
     Mutating `0.02 -> 0.03`, `0.25 -> 0.30`, or either `<=` to `<` passed all eight calibration
     tests. These are not free parameters — they ARE the documented CI-red thresholds, so a silent
@@ -1164,7 +1163,7 @@ def test_the_minority_band_BOUNDARIES_are_exactly_where_documented():
 
 
 def test_ceiling_calibration_IGNORES_keyless_records_and_counts_the_rest():
-    """`n` and the `if r.key` filter, both of which review found unpinned.
+    """`n` and the `if r.key` filter, both of which were unpinned.
 
     `main()` passes the UNFILTERED record list, so the filter is load-bearing in production while
     every live-corpus test hands this function a pre-filtered list — the oracle and production's
@@ -1175,9 +1174,9 @@ def test_ceiling_calibration_IGNORES_keyless_records_and_counts_the_rest():
     `n` itself lost its only pin when the over-tight live test was deleted: a mutation returning
     `n=1` passed everything, which would print a wrong denominator in the drift notice.
 
-    The oracle is DYNAMIC and runs at two distinct cardinalities on purpose. The first attempt
-    asserted `n == 10` against a ten-record fixture, and review killed it: a mutation returning a
-    constant 10 for every input satisfied it while changing the live denominator from 183 to 10 —
+    The oracle is DYNAMIC and runs at two distinct cardinalities on purpose. Asserting `n == 10`
+    against a ten-record fixture does not hold it: a mutation returning a constant 10 for every
+    input satisfies it while changing the live denominator from 183 to 10 —
     preserving the exact production defect the test claims to close. A single hardcoded count
     cannot distinguish "counts the input" from "returns this number".
     """
@@ -1219,7 +1218,7 @@ def test_v4_would_have_reddened_where_v5_holds():
     """The v4-vs-v5 contrast, on a distribution the test OWNS rather than the live corpus.
 
     THIRD TIME for this defect class in one change, which is why the fix is to remove the coupling
-    rather than patch the instance. Round 1 of review caught it in the drift test; round 2 caught it
+    rather than patch the instance. The same coupling turned up in the drift test and again
     here, in what looked like a safe `if before.marks_tail:` guard — the GUARD was conditional but
     the CONCLUSION was still an assertion about live order statistics, and appending 16 ordinary
     30-line records (nothing long, nothing unusual) makes `after.marks_tail` true again and fires it:
@@ -1445,9 +1444,9 @@ def test_main_reports_ceiling_drift_as_a_NOTICE_and_still_exits_0(capsys):
     red — the entire point of the v5 split.
 
     The ceiling is DERIVED as one line above the longest record, so it is off the tail boundary by
-    definition. A hardcoded 999 looked safe and was not: review showed ten valid 1000-line records
-    would put p95 at 1000, making 999 calibrated — so the notice would stop firing and this test
-    would go RED, for a corpus change that is nobody's defect.
+    definition. A hardcoded 999 looked safe and was not: ten valid 1000-line records would put p95
+    at 1000, making 999 calibrated — so the notice would stop firing and this test would go RED,
+    for a corpus change that is nobody's defect.
     """
     longest = max(dv.record_prose_lines(r) for r in dl.all_active_records() if r.key)
     assert dv.main(["--record-ceiling", str(longest + 1)]) == 0
@@ -1460,8 +1459,8 @@ def test_main_reports_ceiling_drift_as_a_NOTICE_and_still_exits_0(capsys):
 def test_main_reports_drift_IFF_the_ceiling_is_off_the_tail_boundary(capsys):
     """The complement of the test above — asserting the WIRING, not the corpus's current state.
 
-    The obvious way to write this is `dv.main([]); assert "drifted" not in err`, and that is a trap
-    review caught: `main()` emits the notice exactly when `p90 <= 60 <= p95` is false over the LIVE
+    The obvious way to write this is `dv.main([]); assert "drifted" not in err`, and that is a
+    trap: `main()` emits the notice exactly when `p90 <= 60 <= p95` is false over the LIVE
     corpus, so such a test fails under precisely the condition #688 exists to stop failing — it
     would move v4's assertion three functions down and leave it in the same blocking job. Today p90
     sits exactly ON the ceiling, so ONE new over-ceiling record would have reddened it.
@@ -1475,9 +1474,9 @@ def test_main_reports_drift_IFF_the_ceiling_is_off_the_tail_boundary(capsys):
     assert recs, "corpus is empty — the derived ceilings need at least one record"
     lengths = sorted(dv.record_prose_lines(r) for r in recs)
 
-    # Both ceilings are DERIVED so each branch is guaranteed by construction, not by luck. Review
-    # caught the earlier version relying on the live 60/999 pair: once one 61-line record lands,
-    # BOTH of those drift, and an UNCONDITIONAL notice would have passed the test.
+    # Both ceilings are DERIVED so each branch is guaranteed by construction, not by luck. Relying
+    # on the live 60/999 pair does not: once one 61-line record lands,
+    # BOTH of those drift, and an UNCONDITIONAL notice would pass the test.
     #   * p90 itself is always calibrated — `p90 <= p90 <= p95` holds for any distribution.
     #   * one line above the longest record is always off the tail — it exceeds p95 by definition.
     quiet_ceiling = lengths[min(int(len(lengths) * 0.90), len(lengths) - 1)]