diff --git a/CHANGELOG.md b/CHANGELOG.md
index d30cffc0..083aa1e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -53,6 +53,7 @@ adheres to [Semantic Versioning](https://semver.org/).
 - **The doc-claim gate's own vacuity guard could be held open by a number that was never a claim.** `TEST_CLAIM` matches any `N tests` phrase in a scanned file, so an incidental count — "12 tests skipped locally that CI runs", a true and dated measurement — was read as an advertisement of the suite size. That line is not yet on `main`: it arrives with #231, whose `Test (Python 3.12)` leg fails today on exactly `CONTRIBUTING.md:36: advertises 12 tests` while its `Lint` leg passes, because the static gate skips the test-count family when no `--test-count` is given. This change is therefore the build-first half of that pair — it lands the mechanism, and #231 declares the marker on its own line. Two defects followed, and the second is the dangerous one: the false positive *counted as a match*, so `check_counts`' vacuity guard (the thing that turns a reworded or deleted claim into a build failure rather than an unnoticed loss of coverage) stayed silent. Probed on the pre-fix code: a tree whose only `N tests` text was that incidental line returned a mismatch, not the vacuity message — every real `6268 tests` claim could have been deleted and the guard would not have fired. A line whose number counts something else now declares `[not-a-count-claim: <label>]` and is skipped **for that family only**, so the same line still answers to every other one; the prose keeps its number, its date and its breakdown, because rewording a true measurement to keep a gate quiet hides the measurement instead of fixing the gate. Declared exemptions form a registry that is printed on every successful run and pinned by name in a test, so an exemption is added deliberately or not at all, and the marker fails closed — a misspelled or wrong-family label exempts nothing. Also folded away a second, hand-rolled copy of the vacuity guard for the with-integrations tool claim, which had no test of its own; it now runs through `check_counts` like every other family and has one. Scoped mutation run: **0 surviving mutants on the changed code** (`collect_failures` went 45 → 0 once the composition was driven against a deliberately stale repository rather than only the green real tree); 25 survivors remain in the untouched `canonical_*` helpers, filed as #235.
 - **The test-count family was checked in exactly one place on earth.** `collect_failures` skips `TEST_CLAIM` entirely when no `--test-count` is passed, and only the Python 3.12 matrix leg of the test job passes one — so the repository-level test that runs everywhere never exercised the most drift-prone claim in the project, and five of the six CI jobs were blind to it. `test_every_advertised_test_count_states_the_same_number` asserts instead that every advertised count *agrees with the others*, which needs no live `pytest --collect-only` and therefore runs in the local suite and in all six jobs; a half-updated count now fails before it reaches CI.
 - **`scripts/` was unreachable by the mutation runner**, so no gate, hook or helper under it had ever been mutation-tested. Three things blocked it: `[tool.mutmut] source_paths` was `mcp_server`-only (a source outside it is silently never mutated, and the run then reports zero survivors because it mutated nothing); `also_copy` omitted the documentation surface, so a module that resolves repository files relative to its own location raised `FileNotFoundError` under every mutant; and the test loaded the gate under a bare module name while mutmut keys its trampolines on the dotted path, which made every mutant look unreached. `scripts/mutation_check.sh` now unions the sources' roots into `source_paths`, `also_copy` carries the files the gate reads, and the test loads it as `scripts.check_doc_claims`.
+- **`scripts/mutation_check.sh` false-reported 50 survivors for `ast_extractor_registry.py`'s `_make_extractor`/`build_extra_extractors`** (#269) — mutmut's per-mutant test attribution is recorded once, from a coverage trace of the FIRST test whose call reaches the mutated line; `ast_parser._EXTRACTORS = {..., **build_extra_extractors()}` builds its dispatch table once, eagerly, at import time, so every test after the first exercises the already-built, cached closures without ever re-invoking the mutated functions — mutmut narrowed the per-mutant rerun to one (often irrelevant) test and reported "survived" for all 50 mutants even though the full 3-file test selection genuinely kills every one. `scripts/mutation_recheck_survivors.py` closes the gap generically, for any source, not by special-casing this one file: every mutant mutmut reports "survived" is re-run against the FULL declared test selection before the verdict is trusted, and a mutant the full selection kills is reported as **RECOVERED** — a distinct, visible category, never silently folded into "killed" (a false-survivor report otherwise either blocks a correct commit or trains reviewers to wave off real survivors as "probably a tooling artifact"). `scripts/mutation_check.sh` also gained multi-file test-selection support (`<test_paths>` now accepts a space-separated list), needed because `_make_extractor`/`build_extra_extractors` require `ast_parser.py`'s own repeatedly-called functions in the same run for mutmut's OWN forced-fail bootstrap check to succeed at all (mutating `ast_extractor_registry.py` alone starves that check of anything to re-invoke). Re-running the full reproduction surfaced ONE genuine (non-false) survivor mutmut's current version generates that the issue's original reproduction did not: `_make_extractor__mutmut_10` replaces the `source` argument to the calls-extractor with `None`, invisible to every existing per-language test because `extract_calls_generic`'s hardcoded node-type list (`"call"`/`"call_expression"`) never matches any of the 7 languages' own call-expression node type (Java's is `method_invocation`, for instance — a separate, pre-existing, out-of-scope language-coverage gap); a new test (`test_make_extractor_threads_the_real_source_into_calls_extraction`) monkeypatches `extract_calls_generic` to assert `_make_extractor`'s own composition contract directly, closing it. Verified: 0 genuine survivors remain in `ast_extractor_registry.py`; `json_native.py`'s existing scoped run is unchanged (same 5 documented-equivalent survivors); `scripts/mutation_recheck_survivors.py` itself carries **0 surviving mutants** on its own committed scope (32 new tests).
 - **An unreadable wiki `README.md` was overwritten instead of preserved.** `wiki_store._try_reindex` promises "never clobber a hand-written README", but when the marker check could not read the file (permissions, non-UTF-8 bytes) the failure was swallowed and `should_write` stayed `True` — the README was replaced with generated content. Surfaced by the #197 S110 sweep; an unreadable README is now left untouched and the read failure is reported via `silent_failure` (`wiki_store.readme_read`). Regression test: `tests_py/infrastructure/test_s110_sweep_infrastructure.py::TestWikiStoreReadmeGuard::test_unreadable_readme_is_not_clobbered`.
 - **The wiki pipeline was silently dead on the SQLite backend** (#206) — the default for plugin installs, `.mcpb`/Cowork, and every sandboxed launch (`PRIVACY.md` lines 26–38). `PsycopgCompatConnection` exposed no `cursor()`, so all six stages (`extract → resolve → emerge → synthesize → curate → compile`) and `wiki_migrate` raised `AttributeError`; each error was captured as a string and `backfill_memories` returned a **success-shaped payload with zero pages and no log line** — the FlashRank silent-failure mode a third time. A fresh SQLite install reported a successful backfill and produced no wiki. The **entire `wiki` schema is now ported to SQLite** (`infrastructure/sqlite_schema_wiki.py`: the eight `wiki.*` tables flattened to `wiki_*`, since SQLite has no schema namespaces, plus every index except the PostgreSQL-only HNSW/GIN families), and the compat layer grew the translations the shared SQL actually needs: `cursor()` (context-managing, dict-returning, accepting psycopg's `row_factory=`), `%(name)s` → `:name`, `wiki.<t>` → `wiki_<t>`, `array_length(c,1)` → `json_array_length(c)`, `= ANY(?)` and `&&` → `json_each` membership/intersection tests, `::int[]` casts (the trailing `[]` included), `IS DISTINCT FROM` → `IS NOT`, `UPDATE t alias` → `UPDATE t AS alias`, and `RETURNING id, (xmax = 0) AS inserted` → `RETURNING id` (kept natively on SQLite ≥ 3.35, because `lastrowid` does not identify the row an upsert *updated*). `INTEGER[]`/`JSONB` columns are declared `JSON` and round-trip through a registered converter/adapter pair, so `entity_ids` returns a `list[int]` as psycopg gives — without it the column returned `"[1,2]"` and `for eid in entity_ids` would have iterated **character-wise**, yielding garbage ids and never raising. Two of the defects made stages *report success while doing nothing*: untranslated `%(name)s` extracted **zero claims**, and `wiki_resolve`'s `WHERE entity_ids = '{}'` (PostgreSQL's empty-array literal, which never matches SQLite's `'[]'`) made resolution a **permanent no-op** — that predicate is now the backend-agnostic `COALESCE(array_length(entity_ids, 1), 0) = 0`, and `wiki_emerge`'s bare `COUNT(*)` is aliased, since psycopg names that column `count` and SQLite names it `COUNT(*)`. Both `wiki_pipeline._safe_call` and `backfill_memories`' pipeline `except` clause now **log** the failure instead of only recording it. Verified end-to-end on SQLite (4 memories → 3 claims → 3 concepts → 3 drafts → 3 published pages) against a paired PostgreSQL control on the same commit; existing SQLite databases gain the tables on next open via the `CREATE TABLE IF NOT EXISTS` init path, no shim.
 - **The stage-aware context assembler dropped memories it had selected, instead of condensing them** (#196). Its own contract reads "may truncate individual chunks but never reduces the count of selected items"; the code did the opposite — Phase 2 skipped any memory that did not fit the remaining budget and Phase 3 broke out of its loop, so the longest memories (the ones retrieval had just ranked highest) vanished from both the rendered text and `selected_memories`, while Phase 1's 60 % share was never computed at all. Measured pre-fix with two ~760-token adjacent memories at a 120-token budget: zero phase-2 memories and empty adjacent text. The domain-aware condensers in `core/context_assembly/condensers.py` were written for exactly this reduction and had no caller — they are now the packing rule's reduction step (`core/context_assembly/stage_phases.py`), giving every item a share of the budget (the Swift ContextDecomposer rule, now a single definition in `budget.proportional_share`) and condensing the over-share ones. One output per input, never a drop. Behaviour is unchanged when `token_budget is None`, which is what every current caller passes. Also fixed: `condense_assistant_message` could return an empty string — a single code block larger than the whole budget kept no blocks and joined an empty list, deleting the memory outright — and now falls back to `truncate_to_budget` like every sibling condenser.
diff --git a/assets/badge-tests.svg b/assets/badge-tests.svg
index 55bab0af..3dc6bc8c 100644
--- a/assets/badge-tests.svg
+++ b/assets/badge-tests.svg
@@ -1,5 +1,5 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="126" height="20" viewBox="0 0 126 20" role="img" aria-label="6706 tests passing">
-  <title>6706 tests passing</title>
+<svg xmlns="http://www.w3.org/2000/svg" width="126" height="20" viewBox="0 0 126 20" role="img" aria-label="6739 tests passing">
+  <title>6739 tests passing</title>
   <!-- GENERATED by scripts/generate_repo_badges.py — do not hand-edit.
        Source: the count pytest collects on this tree.
        Committed rather than hotlinked so the claim cannot be
@@ -15,7 +15,7 @@
   <g font-family="Verdana,DejaVu Sans,Geneva,sans-serif" font-size="11">
     <text x="21.5" y="15" fill="#000" fill-opacity="0.25" text-anchor="middle" textLength="29" lengthAdjust="spacingAndGlyphs">tests</text>
     <text x="21.5" y="14" fill="#f8f7f2" text-anchor="middle" textLength="29" lengthAdjust="spacingAndGlyphs">tests</text>
-    <text x="84.5" y="15" fill="#000" fill-opacity="0.25" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6706 passing</text>
-    <text x="84.5" y="14" fill="#fff" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6706 passing</text>
+    <text x="84.5" y="15" fill="#000" fill-opacity="0.25" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6739 passing</text>
+    <text x="84.5" y="14" fill="#fff" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6739 passing</text>
   </g>
 </svg>
diff --git a/scripts/mutation_check.sh b/scripts/mutation_check.sh
index b818050f..8ee56cf8 100755
--- a/scripts/mutation_check.sh
+++ b/scripts/mutation_check.sh
@@ -1,13 +1,31 @@
 #!/usr/bin/env bash
 #
 # Scoped mutation-testing run (mutmut 3.x) — rules/coding-standards.md §12.
-# Mutates ONLY the given source file(s) against the given test path, then
+# Mutates ONLY the given source file(s) against the given test path(s), then
 # restores pyproject.toml's [tool.mutmut] block untouched. Standard: 0
 # surviving non-equivalent mutants on the changed code.
 #
-#   usage: scripts/mutation_check.sh <test_path> <source.py> [source.py ...]
+#   usage: scripts/mutation_check.sh <test_paths> <source.py> [source.py ...]
 #   e.g.   scripts/mutation_check.sh tests_py/shared/test_json_native.py \
 #                                     mcp_server/shared/json_native.py
+#   <test_paths> may be a single file or a space-separated list quoted as
+#   one argument, e.g. "tests_py/a/test_a.py tests_py/b/test_b.py" — a
+#   module mutated by more than one test file needs its full selection
+#   here (see the eager-import re-verification note below; issue #269).
+#
+# Any mutant mutmut itself reports "survived" is re-verified against the
+# FULL test selection above before being trusted (scripts/
+# mutation_recheck_survivors.py): mutmut's per-mutant test attribution is
+# recorded once, from the first test whose coverage trace reaches the
+# mutated line. A module that builds a dispatch table eagerly at import
+# time (memoizing the built closures) is invisible to that attribution
+# for every later test, so mutmut narrows the per-mutant rerun to just
+# the first (often irrelevant) test and reports "survived" even when the
+# full suite kills the mutant — issue #269's root cause, reproduced and
+# fixed there. A mutant the full selection actually kills is reported as
+# RECOVERED, never silently folded into "killed": the false-survivor
+# cause must stay visible to the reader (issue #269 acceptance criterion
+# 2), not just absorbed.
 #
 set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
@@ -19,6 +37,7 @@ if [ $# -lt 2 ]; then
 fi
 
 TESTS="$1"; shift
+read -r -a TEST_ARR <<< "$TESTS"
 PY="$ROOT/pyproject.toml"
 BAK="$(mktemp)"
 cp "$PY" "$BAK"
@@ -30,9 +49,12 @@ trap cleanup EXIT
 # copies those into mutants/, and a source outside them is silently never
 # mutated — the run then reports 0 survivors because it mutated nothing. Rooted
 # at the committed value so a run inside mcp_server/ keeps its existing scope.
-python3 - "$PY" "$TESTS" "$@" <<'PYEOF'
+python3 - "$PY" "${TEST_ARR[@]}" -- "$@" <<'PYEOF'
 import re, sys
-path, tests, *sources = sys.argv[1], sys.argv[2], *sys.argv[3:]
+args = sys.argv[2:]
+sep = args.index("--")
+tests, sources = args[:sep], args[sep + 1:]
+path = sys.argv[1]
 fmt = lambda xs: "[" + ", ".join(f'"{x}"' for x in xs) + "]"
 src = open(path).read()
 roots = sorted({s.split("/", 1)[0] for s in sources})
@@ -40,7 +62,7 @@ declared = re.search(r'^source_paths = \[(.*)\]$', src, flags=re.M)
 existing = re.findall(r'"([^"]+)"', declared.group(1)) if declared else []
 src, n1 = re.subn(r'^only_mutate = .*$', "only_mutate = " + fmt(sources), src, count=1, flags=re.M)
 src, n2 = re.subn(r'^pytest_add_cli_args_test_selection = .*$',
-                  "pytest_add_cli_args_test_selection = " + fmt([tests]), src, count=1, flags=re.M)
+                  "pytest_add_cli_args_test_selection = " + fmt(tests), src, count=1, flags=re.M)
 src, n3 = re.subn(r'^source_paths = .*$',
                   "source_paths = " + fmt(sorted(set(existing) | set(roots))), src, count=1, flags=re.M)
 assert n1 and n2 and n3, "pyproject [tool.mutmut] must define only_mutate, source_paths and pytest_add_cli_args_test_selection"
@@ -49,5 +71,12 @@ PYEOF
 
 echo ">>> mutating: $* | tests: $TESTS"
 uv run mutmut run
-echo ">>> survivors (must be empty, or documented equivalents):"
-uv run mutmut results | grep -iE 'survived' || echo "  none — 0 surviving mutants 🎉"
+echo ">>> mutmut-reported survivors (must be empty, or documented equivalents):"
+RESULTS="$(uv run mutmut results)"
+if echo "$RESULTS" | grep -qiE 'survived'; then
+  echo "$RESULTS" | grep -iE 'survived'
+  echo ">>> re-verifying against the FULL test selection before trusting the verdict (issue #269):"
+  echo "$RESULTS" | uv run python3 "$ROOT/scripts/mutation_recheck_survivors.py" "$ROOT/mutants" "${TEST_ARR[@]}"
+else
+  echo "  none — 0 surviving mutants 🎉"
+fi
diff --git a/scripts/mutation_recheck_survivors.py b/scripts/mutation_recheck_survivors.py
new file mode 100644
index 00000000..56b7154c
--- /dev/null
+++ b/scripts/mutation_recheck_survivors.py
@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Re-verify mutmut "survived" mutants against the FULL test selection.
+
+mutmut 3.x attributes each mutant to only the test(s) its coverage-tracing
+trampoline recorded as calling the mutated function during the one-time
+baseline stats pass (`mutants/mutmut-stats.json`,
+`tests_by_mangled_function_name`). A module that builds a dispatch table
+**once, eagerly, at import time** — e.g. `ast_parser._EXTRACTORS = {...,
+**build_extra_extractors()}` — is invisible to that attribution for every
+test after the first: later tests exercise the already-built, cached
+closures without ever re-invoking `build_extra_extractors`/`_make_extractor`,
+so mutmut re-runs the mutant against only the first (often irrelevant)
+test and reports "survived" even though the full suite kills it.
+
+This module closes that gap generically — for ANY source file, not just
+one hand-identified case — by re-running every mutant mutmut reports
+"survived" against the FULL declared test selection (the same tests a
+human would use to reproduce the bug by hand) before trusting the
+verdict. A mutant recovered this way is reported as such, never silently
+reclassified: coding-standards.md issue #269 acceptance criterion 2
+requires the false-survivor cause stay visible to the reader, not just
+absorbed.
+
+Pure decision logic (parse_survivors, format_report,
+any_genuine_survivors) takes no I/O; only recheck_survivor's `runner`
+touches the filesystem/process table, and it is injected so tests can
+substitute a fake for the real pytest invocation.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+_SURVIVED_SUFFIX = ": survived"
+
+# source: structural — <mutants_dir> + at least one <test_path>.
+_MIN_ARGC = 2
+
+
+def parse_survivors(mutmut_results_output: str) -> list[str]:
+    """Extract mutant names `mutmut results` marked "survived".
+
+    Precondition: `mutmut_results_output` is the text `mutmut results`
+    (or `mutmut results --all`) printed to stdout, one `<name>: <status>`
+    line per mutant (leading whitespace allowed, per mutmut's own
+    `print(f"    {k}: {status}")`).
+    Postcondition: returns every `<name>` whose status is exactly
+    "survived", in the order encountered; a name is never returned twice
+    even if the input repeats a line.
+    """
+    survivors: list[str] = []
+    for line in mutmut_results_output.splitlines():
+        stripped = line.strip()
+        if not stripped.endswith(_SURVIVED_SUFFIX):
+            continue
+        name = stripped[: -len(_SURVIVED_SUFFIX)]
+        if name and name not in survivors:
+            survivors.append(name)
+    return survivors
+
+
+@dataclass(frozen=True)
+class RecheckOutcome:
+    """The full-selection verdict for one mutmut-reported survivor."""
+
+    mutant_name: str
+    genuinely_survived: bool
+    exit_code: int
+
+
+# Runs a command in `cwd` with `env` and returns the completed process;
+# injected so tests never spawn a real pytest subprocess.
+Runner = Callable[[list[str], dict[str, str], Path], "subprocess.CompletedProcess[str]"]
+
+
+def default_runner(
+    cmd: list[str], env: dict[str, str], cwd: Path
+) -> "subprocess.CompletedProcess[str]":
+    return subprocess.run(cmd, env=env, cwd=cwd, capture_output=True, text=True)  # noqa: PLW1510 — exit code is read by the caller, not raised
+
+
+def recheck_survivor(
+    mutant_name: str,
+    full_test_selection: Sequence[str],
+    *,
+    mutants_dir: Path,
+    base_env: dict[str, str],
+    runner: Runner = default_runner,
+) -> RecheckOutcome:
+    """Re-run one mutmut-reported survivor against the full test selection.
+
+    Precondition: `mutant_name` is a mutmut mutant identifier already
+    generated under `mutants_dir` by a prior `mutmut run` (dotted module
+    path + mangled function key, e.g.
+    `mcp_server.core.ast_extractor_registry.x__make_extractor__mutmut_1`);
+    `full_test_selection` is non-empty.
+    Postcondition: `genuinely_survived` is True iff every test in
+    `full_test_selection` passed with this mutant active (pytest exit 0)
+    — i.e. no test in the FULL selection pins this mutant's behavior.
+    False means the full selection kills it; mutmut's narrower per-mutant
+    attribution was a false survivor, not a real test gap.
+    """
+    env = dict(base_env)
+    env["MUTANT_UNDER_TEST"] = mutant_name
+    cmd = [sys.executable, "-m", "pytest", "-q", *full_test_selection]
+    result = runner(cmd, env, mutants_dir)
+    return RecheckOutcome(
+        mutant_name=mutant_name,
+        genuinely_survived=result.returncode == 0,
+        exit_code=result.returncode,
+    )
+
+
+def recheck_all_survivors(
+    survivors: Sequence[str],
+    full_test_selection: Sequence[str],
+    *,
+    mutants_dir: Path,
+    base_env: dict[str, str],
+    runner: Runner = default_runner,
+) -> list[RecheckOutcome]:
+    """Recheck every reported survivor; empty input yields an empty result.
+
+    Precondition: `full_test_selection` is non-empty whenever `survivors`
+    is non-empty (there is nothing meaningful to re-verify against zero
+    tests).
+    """
+    if survivors and not full_test_selection:
+        raise ValueError("full_test_selection must be non-empty to recheck survivors")
+    return [
+        recheck_survivor(
+            name,
+            full_test_selection,
+            mutants_dir=mutants_dir,
+            base_env=base_env,
+            runner=runner,
+        )
+        for name in survivors
+    ]
+
+
+def any_genuine_survivors(outcomes: Sequence[RecheckOutcome]) -> bool:
+    return any(outcome.genuinely_survived for outcome in outcomes)
+
+
+def format_report(outcomes: Sequence[RecheckOutcome]) -> str:
+    """Render the human-readable recheck report.
+
+    Postcondition: a recovered (false-survivor) mutant is always listed
+    under its own labeled section, distinct from a genuine survivor —
+    the false-survivor cause must stay visible to the reader rather than
+    being silently absorbed into a plain "killed" count (issue #269
+    acceptance criterion 2).
+    """
+    if not outcomes:
+        return "  none — 0 mutmut-reported survivors to recheck"
+
+    recovered = [o for o in outcomes if not o.genuinely_survived]
+    genuine = [o for o in outcomes if o.genuinely_survived]
+
+    lines: list[str] = []
+    if recovered:
+        lines.append(
+            f">>> {len(recovered)} mutmut-reported survivor(s) RECOVERED: killed by "
+            "the full test selection, invisible to mutmut's per-mutant test "
+            "attribution (eager module-level dispatch table — see issue #269):"
+        )
+        lines += [f"    {o.mutant_name} (pytest exit {o.exit_code})" for o in recovered]
+    if genuine:
+        lines.append(
+            f">>> {len(genuine)} GENUINE surviving mutant(s) — a real test gap:"
+        )
+        lines += [f"    {o.mutant_name}" for o in genuine]
+    else:
+        lines.append(">>> 0 genuine survivors after full-selection reverification 🎉")
+    return "\n".join(lines)
+
+
+def _main(argv: list[str], *, runner: Runner = default_runner) -> int:
+    """CLI entry point.
+
+    Precondition: `argv` is `[mutants_dir, test_path, ...]`; stdin carries
+    `mutmut results` output. `runner` is injected (defaulting to the real
+    subprocess runner) so tests can exercise the full survivors-present
+    path without spawning pytest.
+    Postcondition: returns 2 on a malformed invocation, 1 if any GENUINE
+    survivor remains after full-selection reverification, 0 otherwise
+    (no survivors reported, or every reported survivor was recovered).
+    """
+    if len(argv) < _MIN_ARGC:
+        print(
+            "usage: mutation_recheck_survivors.py <mutants_dir> <test_path> "
+            "[test_path ...]   (reads `mutmut results` output on stdin)",
+            file=sys.stderr,
+        )
+        return 2
+
+    mutants_dir = Path(argv[0])
+    full_test_selection = argv[1:]
+    survivors = parse_survivors(sys.stdin.read())
+
+    outcomes = recheck_all_survivors(
+        survivors,
+        full_test_selection,
+        mutants_dir=mutants_dir,
+        base_env=dict(os.environ),
+        runner=runner,
+    )
+    print(format_report(outcomes))
+    return 1 if any_genuine_survivors(outcomes) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main(sys.argv[1:]))
diff --git a/tests_py/core/test_ast_extractors_multilang.py b/tests_py/core/test_ast_extractors_multilang.py
index 126f1e92..47cb5ee1 100644
--- a/tests_py/core/test_ast_extractors_multilang.py
+++ b/tests_py/core/test_ast_extractors_multilang.py
@@ -8,6 +8,7 @@
 
 import pytest
 
+from mcp_server.core import ast_extractor_registry
 from mcp_server.core.ast_parser import AST_SUPPORTED, is_available, parse_file_ast
 
 pytestmark = pytest.mark.skipif(not is_available(), reason="tree-sitter not installed")
@@ -86,3 +87,39 @@ def test_php() -> None:
     assert defs["Foo.m"] == "method"
     assert defs["top"] == "function"
     assert "App\\Bar" in _imports("foo.php", src)
+
+
+def test_make_extractor_threads_the_real_source_into_calls_extraction(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """`_make_extractor`'s composed extractor must call the shared calls
+    extractor with the REAL `source` it was given, not a placeholder.
+
+    Regression guard for mutmut mutant
+    `ast_extractor_registry.x__make_extractor__mutmut_10`, which replaces
+    that argument with a literal `None`. None of `test_java`/`test_kotlin`/
+    etc. above catch it: `extract_calls_generic`'s hardcoded node-type
+    list ("call", "call_expression") never matches any of these 7
+    languages' own call-expression node type (Java's is
+    `method_invocation`, for instance — a separate, pre-existing
+    language-coverage gap, out of scope here), so the returned calls list
+    is `[]` regardless of which `source` was passed, real or `None`.
+    Monkeypatching `extract_calls_generic` isolates `_make_extractor`'s
+    own composition contract from that unrelated gap (issue #269).
+    """
+    captured: dict[str, object] = {}
+
+    def fake_extract_calls_generic(root: object, source: object) -> list[str]:
+        captured["source"] = source
+        return ["irrelevant"]
+
+    monkeypatch.setattr(
+        ast_extractor_registry, "extract_calls_generic", fake_extract_calls_generic
+    )
+    extractor = ast_extractor_registry._make_extractor(
+        lambda root, source: [], lambda root, source: []
+    )
+    _imports_out, _defs_out, calls = extractor(object(), b"real bytes")
+
+    assert captured["source"] == b"real bytes"
+    assert calls == ["irrelevant"]
diff --git a/tests_py/scripts/test_mutation_recheck_survivors.py b/tests_py/scripts/test_mutation_recheck_survivors.py
new file mode 100644
index 00000000..35b467b8
--- /dev/null
+++ b/tests_py/scripts/test_mutation_recheck_survivors.py
@@ -0,0 +1,449 @@
+"""Tests for scripts/mutation_recheck_survivors.py — issue #269.
+
+Root cause under test: mutmut's per-mutant test attribution is recorded
+once, from a coverage trace of the FIRST test to reach a mutated line. A
+module that builds a dispatch table eagerly at import time (memoizing
+closures) makes every later test invisible to that attribution, so
+mutmut narrows the per-mutant rerun to just the first test and reports
+"survived" even when the full suite kills the mutant. This module's job
+is to catch that: re-run every mutmut-reported survivor against the full
+test selection before trusting the verdict.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import importlib.util
+import io
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+
+# Dotted to match the path-derived name mutmut keys mutant trampolines on
+# ("scripts.mutation_recheck_survivors.*") — issue #262/#264 precedent.
+_spec = importlib.util.spec_from_file_location(
+    "scripts.mutation_recheck_survivors",
+    REPO / "scripts" / "mutation_recheck_survivors.py",
+)
+mrs = importlib.util.module_from_spec(_spec)
+sys.modules[_spec.name] = mrs
+_spec.loader.exec_module(mrs)
+
+
+class ParseSurvivorsTests(unittest.TestCase):
+    def test_extracts_only_survived_lines(self) -> None:
+        output = (
+            "    pkg.mod.x_foo__mutmut_1: killed\n"
+            "    pkg.mod.x_foo__mutmut_2: survived\n"
+            "    pkg.mod.x_bar__mutmut_1: no tests\n"
+        )
+        self.assertEqual(mrs.parse_survivors(output), ["pkg.mod.x_foo__mutmut_2"])
+
+    def test_no_survived_lines_yields_empty_list(self) -> None:
+        self.assertEqual(
+            mrs.parse_survivors("    pkg.mod.x_foo__mutmut_1: killed\n"), []
+        )
+
+    def test_empty_input_yields_empty_list(self) -> None:
+        self.assertEqual(mrs.parse_survivors(""), [])
+
+    def test_duplicate_survived_lines_are_deduplicated_in_order(self) -> None:
+        output = (
+            "    pkg.mod.x_a__mutmut_1: survived\n"
+            "    pkg.mod.x_b__mutmut_1: survived\n"
+            "    pkg.mod.x_a__mutmut_1: survived\n"
+        )
+        self.assertEqual(
+            mrs.parse_survivors(output),
+            ["pkg.mod.x_a__mutmut_1", "pkg.mod.x_b__mutmut_1"],
+        )
+
+    def test_status_containing_survived_as_a_substring_is_not_matched(self) -> None:
+        # Regression guard for a naive `"survived" in line` check, which
+        # would also match a hypothetical "not survived" or similar status.
+        self.assertEqual(
+            mrs.parse_survivors("    pkg.mod.x_a__mutmut_1: not survived\n"), []
+        )
+
+
+class RecheckSurvivorTests(unittest.TestCase):
+    def test_pytest_exit_zero_means_genuinely_survived(self) -> None:
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001 — test double, signature matches Runner
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        outcome = mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_1",
+            ["tests/test_foo.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertTrue(outcome.genuinely_survived)
+        self.assertEqual(outcome.exit_code, 0)
+
+    def test_pytest_nonzero_exit_means_recovered_not_genuine(self) -> None:
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(cmd, returncode=1)
+
+        outcome = mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_1",
+            ["tests/test_foo.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertFalse(outcome.genuinely_survived)
+        self.assertEqual(outcome.exit_code, 1)
+
+    def test_mutant_under_test_env_var_is_set_to_the_mutant_name(self) -> None:
+        captured: dict[str, object] = {}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured["env"] = env
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_7",
+            ["tests/test_foo.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={"PATH": "/usr/bin"},
+            runner=fake_runner,
+        )
+        self.assertEqual(
+            captured["env"]["MUTANT_UNDER_TEST"], "pkg.mod.x_foo__mutmut_7"
+        )
+        # base_env must not be mutated in place, and its other keys preserved.
+        self.assertEqual(captured["env"]["PATH"], "/usr/bin")
+
+    def test_base_env_dict_passed_in_is_not_mutated(self) -> None:
+        base_env = {"PATH": "/usr/bin"}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_1",
+            ["tests/test_foo.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env=base_env,
+            runner=fake_runner,
+        )
+        self.assertEqual(base_env, {"PATH": "/usr/bin"})
+
+    def test_the_full_command_is_python_dash_m_pytest_dash_q_plus_tests(self) -> None:
+        # Exact equality, not a suffix check: every fixed token ("-m",
+        # "pytest", "-q") is load-bearing and a lone suffix assertion
+        # would leave each one an unkilled mutant.
+        captured: dict[str, object] = {}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured["cmd"] = cmd
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_1",
+            ["tests/test_a.py", "tests/test_b.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(
+            captured["cmd"],
+            [
+                sys.executable,
+                "-m",
+                "pytest",
+                "-q",
+                "tests/test_a.py",
+                "tests/test_b.py",
+            ],
+        )
+
+    def test_the_runner_is_invoked_with_mutants_dir_as_cwd(self) -> None:
+        captured: dict[str, object] = {}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured["cwd"] = cwd
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        mutants_dir = Path("/tmp/mutants-xyz")
+        mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_1",
+            ["tests/test_a.py"],
+            mutants_dir=mutants_dir,
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(captured["cwd"], mutants_dir)
+
+    def test_the_outcome_carries_the_input_mutant_name_back(self) -> None:
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        outcome = mrs.recheck_survivor(
+            "pkg.mod.x_foo__mutmut_42",
+            ["tests/test_a.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(outcome.mutant_name, "pkg.mod.x_foo__mutmut_42")
+
+
+class RecheckAllSurvivorsTests(unittest.TestCase):
+    def test_empty_survivors_list_short_circuits_without_calling_the_runner(
+        self,
+    ) -> None:
+        calls: list[object] = []
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            calls.append(cmd)
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        outcomes = mrs.recheck_all_survivors(
+            [],
+            [],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(outcomes, [])
+        self.assertEqual(calls, [])
+
+    def test_nonempty_survivors_with_empty_test_selection_raises(self) -> None:
+        with self.assertRaises(ValueError) as ctx:
+            mrs.recheck_all_survivors(
+                ["pkg.mod.x_foo__mutmut_1"],
+                [],
+                mutants_dir=Path("/tmp/mutants"),
+                base_env={},
+            )
+        self.assertEqual(
+            str(ctx.exception),
+            "full_test_selection must be non-empty to recheck survivors",
+        )
+
+    def test_each_survivor_is_rechecked_independently(self) -> None:
+        # mutant_1 recovered (pytest catches it), mutant_2 genuine survivor.
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(
+                cmd, returncode=1 if env["MUTANT_UNDER_TEST"].endswith("_1") else 0
+            )
+
+        outcomes = mrs.recheck_all_survivors(
+            ["pkg.mod.x_foo__mutmut_1", "pkg.mod.x_foo__mutmut_2"],
+            ["tests/test_foo.py"],
+            mutants_dir=Path("/tmp/mutants"),
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(len(outcomes), 2)
+        self.assertFalse(outcomes[0].genuinely_survived)
+        self.assertTrue(outcomes[1].genuinely_survived)
+
+    def test_mutants_dir_is_forwarded_to_every_recheck_call(self) -> None:
+        captured_cwds: list[object] = []
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured_cwds.append(cwd)
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        real_mutants_dir = Path("/tmp/real-mutants-dir")
+        mrs.recheck_all_survivors(
+            ["pkg.mod.x_foo__mutmut_1", "pkg.mod.x_foo__mutmut_2"],
+            ["tests/test_foo.py"],
+            mutants_dir=real_mutants_dir,
+            base_env={},
+            runner=fake_runner,
+        )
+        self.assertEqual(captured_cwds, [real_mutants_dir, real_mutants_dir])
+
+
+class AnyGenuineSurvivorsTests(unittest.TestCase):
+    def test_empty_outcomes_is_false(self) -> None:
+        self.assertFalse(mrs.any_genuine_survivors([]))
+
+    def test_all_recovered_is_false(self) -> None:
+        outcomes = [mrs.RecheckOutcome("m1", genuinely_survived=False, exit_code=1)]
+        self.assertFalse(mrs.any_genuine_survivors(outcomes))
+
+    def test_one_genuine_is_true(self) -> None:
+        outcomes = [
+            mrs.RecheckOutcome("m1", genuinely_survived=False, exit_code=1),
+            mrs.RecheckOutcome("m2", genuinely_survived=True, exit_code=0),
+        ]
+        self.assertTrue(mrs.any_genuine_survivors(outcomes))
+
+
+class FormatReportTests(unittest.TestCase):
+    def test_empty_outcomes_reports_nothing_to_recheck(self) -> None:
+        # Exact equality: a substring check like assertIn("none", ...)
+        # survives a case/wording mutation of the rest of the literal.
+        self.assertEqual(
+            mrs.format_report([]),
+            "  none — 0 mutmut-reported survivors to recheck",
+        )
+
+    def test_all_recovered_names_issue_269_and_lists_each_mutant(self) -> None:
+        outcomes = [
+            mrs.RecheckOutcome("m1", genuinely_survived=False, exit_code=1),
+            mrs.RecheckOutcome("m2", genuinely_survived=False, exit_code=3),
+        ]
+        report = mrs.format_report(outcomes)
+        self.assertEqual(
+            report,
+            "\n".join(
+                [
+                    ">>> 2 mutmut-reported survivor(s) RECOVERED: killed by "
+                    "the full test selection, invisible to mutmut's per-mutant "
+                    "test attribution (eager module-level dispatch table — "
+                    "see issue #269):",
+                    "    m1 (pytest exit 1)",
+                    "    m2 (pytest exit 3)",
+                    ">>> 0 genuine survivors after full-selection reverification 🎉",
+                ]
+            ),
+        )
+
+    def test_a_genuine_survivor_is_never_absorbed_into_the_recovered_section(
+        self,
+    ) -> None:
+        outcomes = [
+            mrs.RecheckOutcome("recovered_one", genuinely_survived=False, exit_code=1),
+            mrs.RecheckOutcome("genuine_one", genuinely_survived=True, exit_code=0),
+        ]
+        report = mrs.format_report(outcomes)
+        recovered_section, _, genuine_section = report.partition("GENUINE")
+        self.assertIn("recovered_one", recovered_section)
+        self.assertNotIn("genuine_one", recovered_section)
+        self.assertIn("genuine_one", genuine_section)
+
+    def test_all_genuine_no_recovered_section_at_all(self) -> None:
+        # Exact equality pins the "GENUINE surviving mutant(s)" wording AND
+        # that no RECOVERED section (nor the "0 genuine" fallback line,
+        # which only applies when genuine is empty) appears.
+        outcomes = [mrs.RecheckOutcome("m1", genuinely_survived=True, exit_code=0)]
+        report = mrs.format_report(outcomes)
+        self.assertEqual(
+            report,
+            "\n".join(
+                [
+                    ">>> 1 GENUINE surviving mutant(s) — a real test gap:",
+                    "    m1",
+                ]
+            ),
+        )
+
+
+class MainCliTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self._old_stdin = sys.stdin
+
+    def tearDown(self) -> None:
+        sys.stdin = self._old_stdin
+
+    def test_missing_args_prints_usage_and_returns_2(self) -> None:
+        self.assertEqual(mrs._main([]), 2)
+
+    def test_a_single_arg_is_still_missing_args(self) -> None:
+        # Regression guard for `len(argv) < 2` weakening to `< 1` or `<= 1`
+        # meaning something other than "need mutants_dir + >=1 test path".
+        self.assertEqual(mrs._main(["/tmp/mutants"]), 2)
+
+    def test_missing_args_prints_the_exact_usage_line_to_stderr(self) -> None:
+        # Exact equality: assertIn("usage:", ...) still passes against a
+        # mutated middle segment of the same literal (e.g. an "XX"-wrapped
+        # or upper-cased fragment mutmut generates), since "usage:" and
+        # the module name survive untouched either way.
+        captured_stderr = io.StringIO()
+        with contextlib.redirect_stderr(captured_stderr):
+            mrs._main([])
+        self.assertEqual(
+            captured_stderr.getvalue(),
+            "usage: mutation_recheck_survivors.py <mutants_dir> <test_path> "
+            "[test_path ...]   (reads `mutmut results` output on stdin)\n",
+        )
+
+    def test_no_survivors_on_stdin_returns_0_without_a_runner_call(self) -> None:
+        calls: list[object] = []
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            calls.append(cmd)
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: killed\n")
+        result = mrs._main(["/tmp/mutants", "tests/test_a.py"], runner=fake_runner)
+        self.assertEqual(result, 0)
+        self.assertEqual(calls, [])
+
+    def test_a_recovered_survivor_on_stdin_returns_0(self) -> None:
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(
+                cmd, returncode=1
+            )  # killed by full selection
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: survived\n")
+        result = mrs._main(["/tmp/mutants", "tests/test_a.py"], runner=fake_runner)
+        self.assertEqual(result, 0)
+
+    def test_a_genuine_survivor_on_stdin_returns_1(self) -> None:
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(
+                cmd, returncode=0
+            )  # still passes -> genuine
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: survived\n")
+        result = mrs._main(["/tmp/mutants", "tests/test_a.py"], runner=fake_runner)
+        self.assertEqual(result, 1)
+
+    def test_mutants_dir_argv0_is_forwarded_to_the_runner_as_cwd(self) -> None:
+        captured: dict[str, object] = {}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured["cwd"] = cwd
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: survived\n")
+        mrs._main(["/tmp/mutants-abc", "tests/test_a.py"], runner=fake_runner)
+        self.assertEqual(captured["cwd"], Path("/tmp/mutants-abc"))
+
+    def test_all_argv_after_mutants_dir_are_the_test_selection(self) -> None:
+        captured: dict[str, object] = {}
+
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            captured["cmd"] = cmd
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: survived\n")
+        mrs._main(
+            ["/tmp/mutants", "tests/test_a.py", "tests/test_b.py"], runner=fake_runner
+        )
+        self.assertEqual(captured["cmd"][-2:], ["tests/test_a.py", "tests/test_b.py"])
+
+    def test_the_recheck_report_is_actually_printed_to_stdout(self) -> None:
+        # Regression guard for `print(None)` or `format_report(None)`
+        # silently replacing the real, computed report.
+        def fake_runner(cmd, env, cwd):  # noqa: ANN001, ARG001
+            return subprocess.CompletedProcess(cmd, returncode=0)
+
+        sys.stdin = io.StringIO("    pkg.mod.x_a__mutmut_1: survived\n")
+        captured_stdout = io.StringIO()
+        with contextlib.redirect_stdout(captured_stdout):
+            mrs._main(["/tmp/mutants", "tests/test_a.py"], runner=fake_runner)
+        self.assertEqual(
+            captured_stdout.getvalue().rstrip("\n"),
+            mrs.format_report(
+                [
+                    mrs.RecheckOutcome(
+                        "pkg.mod.x_a__mutmut_1", genuinely_survived=True, exit_code=0
+                    )
+                ]
+            ),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()