diff --git a/CHANGELOG.md b/CHANGELOG.md
index eebabe50..9afcd0a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,8 @@ adheres to [Semantic Versioning](https://semver.org/).
 - **`sqlite_sql_translate.py`'s 20 surviving mutants, closed** (#265). This module (`_translate_sql`/`_returning_was_stripped`, split out of `sqlite_compat.py` by #260) left 20 mutants surviving a scoped mutmut run — every one the same shape: a mutant dropping (or re-spelling the case of) the `flags=re.IGNORECASE` argument on one of the module's `re.sub`/`re.search` calls. Every existing case-insensitivity fixture supplies an input whose case already matches the pattern's own literal spelling, so the flag's presence was never observable. A rescoped run on this tree measured 19 of the 20 named ids still surviving (`mutmut_136` had flipped to killed between runs — non-deterministic mutant/worker ordering, not a real fix, folded back into the equivalent set below by direct regex comparison). Six are real gaps, closed with `tests_py/infrastructure/test_sqlite_sql_translate_265.py` supplying the opposite-case input for each: lowercase `DEFAULT now()`, an uppercase `&&`-overlap column, `XMAX`/`as` case variants on the xmax-drop rule, a lowercase `RETURNING` strip inside `_translate_sql` distinct from the one `_returning_was_stripped` already covered, an uppercase `ARRAY_LENGTH`, and lowercase `_returning_was_stripped` input under a monkeypatched `_SUPPORTS_RETURNING` — 6 new tests, all failing on pre-fix code. The remaining 14 are **documented equivalent mutants**: the mutation only re-spells the pattern's own literal case (`SERIAL`→`serial`, char classes `[a-z_]`↔`[A-Z_]`, etc.) while `re.IGNORECASE` stays in place, which Python's `re` semantics make provably irrelevant to the match — confirmed empirically with a differential harness (uppercase/lowercase/mixed-case probes against the original and mutated pattern, identical match results in every case) rather than asserted by inspection alone. Re-running the reproduction after the fix: 6 killed, 14 equivalent, 0 unaccounted-for survivors.
 - **`mcp-toplist-badge.yml`'s monthly refresh can now actually open its PR** (#273). A real `workflow_dispatch` run (triggered while dispatch-verifying #246) reached `Open refresh PR` and failed there: `GitHub Actions is not permitted to create or approve pull requests`. The repo had **"Allow GitHub Actions to create and approve pull requests"** unchecked at Settings → Actions → General, which blocks PR *creation* itself — a stronger failure than the one the workflow's own comment anticipated ("GitHub deliberately does not trigger workflows on `GITHUB_TOKEN`-authored PRs", which only explains why such a PR's checks don't start, not why it would fail to be created at all). Fixed at the repo-policy layer (`gh api -X PUT repos/cdeust/Cortex/actions/permissions/workflow -F can_approve_pull_request_reviews=true`), which is where the root cause lives — not in the workflow, which already had the correct `secrets.BADGE_REFRESH_TOKEN || secrets.GITHUB_TOKEN` fallback and needed no logic change. The workflow's comment now documents both distinct failure modes and the fix, so a future repo transfer or org policy reset that reintroduces this is diagnosable from the file alone. A stray `chore/mcp-toplist-badge-refresh` branch pushed-then-abandoned by the earlier failing run had already been deleted (confirmed absent by this fix); the verification run for this fix leaves no stray branch either — its outcome is quoted in PR #273's description.
 - **`sqlite_compat.py` relied on sqlite3's *implicit* default `datetime` adapter, deprecated as of Python 3.12** (#260), firing on 3 tests (`test_consolidate.py::test_with_memories`, `::test_protected_memories_skip_compression`, `test_memory_lifecycle.py::test_store_consolidate_recall`). Root cause: `cascade.py::_update_stage_entered` binds a raw `datetime.datetime` object as a SQL parameter instead of an ISO string — confirmed the **sole** such call site in this codebase by instrumenting all three `execute`/`executemany` paths in `sqlite_compat.py` and running the full suite against it. Fix: an explicit `sqlite3.register_adapter(datetime, _adapt_datetime_iso)` (the sanctioned Python-docs recipe the deprecation warning itself points to), writing the same "T"-separated `.isoformat()` spelling every other datetime write path here already produces (`sqlite_store._now_iso()`, etc.) — one canonical wire format instead of two. Old rows on disk (the deprecated adapter's space-separated spelling) keep reading correctly: `datetime.fromisoformat()` — the read path every consumer here uses — parses both spellings to an identical value (verified empirically and pinned by a test), so **no migration is required**. A `pyproject.toml` `filterwarnings` entry turns this specific DeprecationWarning into a hard failure going forward — a regression tripwire, not a silence. Boy-scout: `sqlite_compat.py` was already 335 lines — over this repo's 300-line file cap — before this change touched it; split the pure SQL-dialect translation logic (`_translate_sql`/`_returning_was_stripped`/`_SUPPORTS_RETURNING`) into a new `sqlite_sql_translate.py` module (behaviour-preserving, byte-identical logic), retargeting the two existing tests that monkeypatched `_SUPPORTS_RETURNING` to the module that actually defines it. Scoped mutation testing (mutmut) against the touched `sqlite_compat.py` surfaced 13 pre-existing gaps in `_CompatCursor`/`_CompatExecutingCursor`/`PsycopgCompatConnection` field wiring (not the datetime fix itself) — added targeted tests for all of them; one mutant (`executemany`'s `self.lastrowid = None`) is a documented equivalent (`sqlite3.Cursor.lastrowid` is only meaningful after a single-row `execute()` INSERT, so it is always `None` after `executemany()` regardless of which literal is written). A separate mutation gap in `_translate_sql` itself (20 survivors, verbatim regex-translation code moved unchanged from `sqlite_compat.py`, same tests before/after) predates this change and is filed as #265 rather than folded in, per §14.3.
+- **The typecheck gate's zero-diagnostic verdict was a property of the pip resolver, not of the source** (#249). `mcp_server/core/ast_parser.py:88` called `tree_sitter_language_pack.get_parser(language)` with a plain `str`; `get_parser`'s declared parameter type differs across the package's own releases — a `SupportedLanguage` `Literal` union in 1.6.2 (what `uv.lock` resolved when this was filed) versus a plain `str` in 1.13.5 (what both `uv.lock` and a fresh pip resolution give today) — so the same call was a pyright error under one and silently clean under the other, and a `set[str]` `in` test narrowed nothing either way. `AST_SUPPORTED` is now a `Literal` union (`_SupportedLanguage`) narrowed via a `TypeGuard` (`_is_ast_supported`) rather than a bare `set[str]`; reproduced against both a live 1.6.2 install and the current 1.13.5 one (`pyright mcp_server/`: 1 error → 0 under 1.13.5; the 1.6.2 stub's own `SupportedLanguage` omits `"csharp"` outright — a pre-existing grammar-availability gap in that release, not a narrowing defect, and unreachable under any version this repo's floor resolves to today). The typecheck CI job now quotes the resolved `tree-sitter-language-pack` version in its log, since that resolution is now load-bearing evidence for the verdict, not incidental (the job's environment reproducibility and its `uv.lock`-drift guard were already closed by #244's hash-pinned `requirements/ci-typecheck.txt`). Boy-scout pass on the touched file: the flat `calls` list every per-language extractor computed via `extract_calls_generic` and `parse_file_ast` immediately discarded (superseded by `calls_per_function`, never itself consumed) is removed rather than given a test; Swift and Rust parsing had zero test coverage through `parse_file_ast` (`_extract_swift`/`_extract_rust` were unreachable from any existing test — the Go equivalent bypassed its own wrapper by calling `extract_go_definitions` directly) and now do, alongside coverage gaps in `is_available`, `_node_text`, `_extract_module_doc`'s docstring/comment branches, `content_hash` length, and `calls_per_function`'s populated content. Suite grows 6526 → 6549.
+- **`ast_parser`'s per-language extractors carried a dead return value, and two grammars had zero test coverage through their real call path** (boy-scout follow-on from #249; the resolver-dependent typecheck defect #249 itself named was independently closed by #253/#251's `_is_ast_language`/`SupportedLanguage`-derived-`AST_SUPPORTED` fix, already on `main`). Every per-language extractor (`_extract_python`/`_extract_js`/`_extract_go`/`_extract_swift`/`_extract_rust`, plus the JVM/C-family/scripting extractors `ast_extractor_registry.build_extra_extractors` composes) computed a flat `calls` list via `extract_calls_generic` and returned it as a 3rd tuple element that `parse_file_ast` immediately discarded — superseded by `calls_per_function`, the value actually consumed downstream. Removed; `Extractor` is now a 2-tuple `(imports, definitions)`. That element was the entire production call graph of `extract_calls_generic` (`mcp_server/core/ast_extractors.py`) — with it gone, the function had no caller left but its own direct unit test, so `extract_calls_generic` itself, its `TestCallExtraction` unit test, and the stale "also provides the generic call-site extractor used by all languages" line in the module docstring are removed/corrected too. Swift and Rust parsing had never been exercised through `parse_file_ast` by any existing test (the Go equivalent bypassed its own wrapper by calling `extract_go_definitions` directly) — added `TestParseFileGo`/`TestParseFileSwift`/`TestParseFileRust`. Smaller gaps closed alongside: both branches of `is_available()`, the docstring/comment-extraction branches of `_node_text`/`_extract_module_doc` (via fake-`Node` unit tests), `content_hash`'s length invariant, `calls_per_function`'s populated content, and malformed-UTF-8 decode robustness (`errors="replace"`). Net +20 tests relative to `main` (23 added, 3 removed: 2 with `extract_calls_generic`'s own unit test, plus a rebase-time removal below of a since-obsoleted mutation-guard test whose call site this same change deletes); no absolute total is stated here per #293/#294 — `assets/badge-tests.svg` is the one artifact that still states one, precisely because a CHANGELOG entry hand-carrying a total goes stale the moment any other PR merges first.
 - **A `created_at` that states a timezone was stored as the wrong instant** (#252). `normalize_date_to_iso` had no timezone policy on any of its paths, so three defects stacked: (1) the "already ISO" guard was the substring test `"T" in raw`, and every US zone abbreviation contains a T — `8 May 2023 13:56 EST` was returned unparsed; (2) the built-in fast path matches the date at the START of the string and discards the rest, so `8 May 2023 13:56 +02:00` became midnight, dropping both the time and the offset; (3) on the dateutil path an abbreviation it cannot resolve is dropped with a warning nobody sees, leaving a naive datetime that PostgreSQL's `timestamptz` cast and `compute_recency_boost` both read as UTC. The instant was up to a day off and nothing was emitted. A stated zone is now honoured or the value is refused: `mcp_server/core/temporal_timezones.py` supplies dateutil a `tzinfos` resolver over the **RFC 5322 §4.3 obs-zone table** (the normative answer to "which EST?" — cross-checked against CPython's `email._parseaddr._timezones`), and any abbreviation outside it is refused with a warning naming the input, the abbreviation and the fix, rather than defaulted. Parsing no longer depends on the host's local zone name, and no `warnings.catch_warnings()` — process-global and not thread-safe — is taken on a store write path. `normalize_date_to_iso` moves out of `core/temporal.py` into `core/temporal_normalize.py`: storage normalization must not lose precision, retrieval scoring may, and they are now separate modules (both stores import from the new path). The refusal also covers the degraded path — a string that states a zone is never salvaged to a naive date, whatever made the parse fail.
 - **`python-dateutil` is now a declared dependency** (#252). `normalize_date_to_iso` has always parsed free-form dates with a time of day through it — the LoCoMo shape `1:56 pm on 8 May, 2023` its own docstring cites — but it was never declared and arrived only by transitive luck. It was absent from every `requirements/ci-*.txt`, so **every CI test job ran with that parser missing**: the fallback was dead code in CI, and any install resolving without it kept dates it could not read. Declared, locked and hash-pinned into the 9 exported requirement sets, so the write path behaves identically on every install and both backends.
 - **Both stores skipped the normalization entirely for the dates that needed it most** (#252, the same substring defect one layer up). `PgMemoryStore._build_insert_params` and `SqliteMemoryStore._insert_memory_rows` each guarded the call with `"T" not in raw_created` as a cheap "is it already ISO?" test — so `8 May 2023 13:56 EST` (and every `PST`/`CST`/`MST` string) went to the database untouched, whichever way `normalize_date_to_iso` behaved. The guard is gone from both: deciding what is already ISO belongs to the function that owns it, which returns a real ISO datetime unchanged. Asserted on the stored row, not just on the parser, and asserted equal across the two backends.
@@ -55,7 +57,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).
+- **`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). *(Retired below, same [Unreleased]: the ast_parser dead-code-removal entry deletes `extract_calls_generic` and its call site outright, so `_make_extractor__mutmut_10` can no longer be generated and the test this paragraph added is removed with it — see `tests_py/core/test_ast_extractors_multilang.py`'s in-file note at the deletion site.)*
 - **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 8e770857..94e76d65 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="6768 tests passing">
-  <title>6768 tests passing</title>
+<svg xmlns="http://www.w3.org/2000/svg" width="126" height="20" viewBox="0 0 126 20" role="img" aria-label="6788 tests passing">
+  <title>6788 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">6768 passing</text>
-    <text x="84.5" y="14" fill="#fff" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6768 passing</text>
+    <text x="84.5" y="15" fill="#000" fill-opacity="0.25" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6788 passing</text>
+    <text x="84.5" y="14" fill="#fff" text-anchor="middle" textLength="69" lengthAdjust="spacingAndGlyphs">6788 passing</text>
   </g>
 </svg>
diff --git a/mcp_server/core/ast_extractor_registry.py b/mcp_server/core/ast_extractor_registry.py
index 287af6b7..b626f345 100644
--- a/mcp_server/core/ast_extractor_registry.py
+++ b/mcp_server/core/ast_extractor_registry.py
@@ -1,6 +1,6 @@
 """Registry for the extra-language tree-sitter extractors.
 
-Builds the (imports, definitions, calls) extractor callables for the JVM,
+Builds the (imports, definitions) extractor callables for the JVM,
 C-family, and scripting language groups and merges them into one dict for
 ast_parser._EXTRACTORS. Split out so ast_parser.py stays under 300 lines.
 
@@ -12,7 +12,6 @@
 from typing import TYPE_CHECKING, Callable
 
 from mcp_server.core.codebase_parser import ImportInfo, SymbolDef
-from mcp_server.core.ast_extractors import extract_calls_generic
 from mcp_server.core.ast_extractors_clike import (
     extract_c_definitions,
     extract_c_imports,
@@ -37,27 +36,30 @@
     from tree_sitter import Node
     from tree_sitter_language_pack import SupportedLanguage
 
-Extractor = Callable[
-    ["Node", bytes], tuple[list[ImportInfo], list[SymbolDef], list[str]]
-]
+Extractor = Callable[["Node", bytes], tuple[list[ImportInfo], list[SymbolDef]]]
 
 
 def _make_extractor(
     imports_fn: Callable[["Node", bytes], list[ImportInfo]],
     defs_fn: Callable[["Node", bytes], list[SymbolDef]],
 ) -> Extractor:
-    """Compose an extractor from an imports fn, a defs fn, and generic calls."""
-
-    def _extract(
-        root: Node,
-        source: bytes,
-    ) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-
-        return (
-            imports_fn(root, source),
-            defs_fn(root, source),
-            extract_calls_generic(root, source),
-        )
+    """Compose an extractor from an imports fn and a defs fn.
+
+    Precondition: `imports_fn`/`defs_fn` are pure (no I/O), taking the same
+    `(root, source)` pair.
+    Postcondition: returns a callable producing `(imports, definitions)` —
+    the flat per-file call list this used to also return was computed via
+    `extract_calls_generic(root, source)` and then discarded by every
+    caller (`parse_file_ast` only reads the `calls_per_function` map,
+    populated separately via `extract_calls_per_function`); the tuple
+    element was removed as dead code (issue #249 boy-scout pass). With
+    this the only production call site gone, `extract_calls_generic` had
+    no caller left but its own direct unit test — deleted from
+    `ast_extractors.py` rather than kept for a hypothetical future one.
+    """
+
+    def _extract(root: Node, source: bytes) -> tuple[list[ImportInfo], list[SymbolDef]]:
+        return imports_fn(root, source), defs_fn(root, source)
 
     return _extract
 
diff --git a/mcp_server/core/ast_extractors.py b/mcp_server/core/ast_extractors.py
index 558a8c76..58c17e45 100644
--- a/mcp_server/core/ast_extractors.py
+++ b/mcp_server/core/ast_extractors.py
@@ -1,7 +1,6 @@
 """Tree-sitter AST extractors for Python and JavaScript/TypeScript.
 
 Additional languages (Go, Swift, Rust) in ast_extractors_extra.py.
-Also provides the generic call-site extractor used by all languages.
 
 Pure functions — no I/O.
 """
@@ -217,25 +216,6 @@ def _extract_js_class(
             _extract_js_node(child, source, defs, cls_name)
 
 
-# ── Generic call extraction ──────────────────────────────────────────────
-
-
-def extract_calls_generic(root: Node, source: bytes) -> list[str]:
-    """Extract all function/method call names from AST."""
-    calls: list[str] = []
-    seen: set[str] = set()
-    for call_type in ("call", "call_expression"):
-        for node in _walk_type(root, call_type):
-            func = node.child_by_field_name("function")
-            if not func:
-                continue
-            name = _text(func, source).strip()
-            if name and name not in seen and len(name) < _MAX_CALL_NAME_LEN:
-                calls.append(name)
-                seen.add(name)
-    return calls
-
-
 # ── Per-function call extraction (caller-qualified) ─────────────────────
 
 # Tree-sitter node types that represent a function/method definition
@@ -297,41 +277,54 @@ def extract_calls_per_function(
     qname means we can't attach edges to them.
     """
     out: dict[str, list[str]] = {}
-
-    def walk(node: Node, class_scope: str) -> None:
-        for child in node.children:
-            ntype = child.type
-            if ntype in _CLASS_NODE_TYPES:
-                name_node = child.child_by_field_name("name")
-                cls = _text(name_node, source) if name_node else class_scope
-                body = child.child_by_field_name("body") or child
-                walk(body, cls or class_scope)
-            elif ntype == "decorated_definition":
-                walk(child, class_scope)
-            elif ntype in _FUNCTION_NODE_TYPES:
-                name_node = child.child_by_field_name("name")
-                fn_name = _text(name_node, source) if name_node else ""
-                body = child.child_by_field_name("body") or child
-                if fn_name:
-                    qname = f"{class_scope}.{fn_name}" if class_scope else fn_name
-                    calls: list[str] = []
-                    seen: set[str] = set()
-                    for call_type in _CALL_NODE_TYPES:
-                        for call in _walk_type(body, call_type):
-                            base = _callee_basename(call, source)
-                            if (
-                                base
-                                and base not in seen
-                                and len(base) < _MAX_CALL_NAME_LEN
-                            ):
-                                calls.append(base)
-                                seen.add(base)
-                    out[qname] = calls
-                # Recurse into body for nested definitions (inner
-                # functions, closures that define named functions).
-                walk(body, class_scope)
-            else:
-                walk(child, class_scope)
-
-    walk(root, "")
+    _walk_for_calls(root, "", source, out)
     return out
+
+
+def _walk_for_calls(
+    node: Node,
+    class_scope: str,
+    source: bytes,
+    out: dict[str, list[str]],
+) -> None:
+    """Recurse through ``node``'s children, tracking the enclosing class.
+
+    Precondition: `out` is the accumulator `extract_calls_per_function`
+    returns; this function only adds keys, it does not read existing ones.
+    Postcondition: every named function/method reachable from `node` has
+    its qualified name mapped to its deduped callee-basename list in `out`.
+    """
+    for child in node.children:
+        ntype = child.type
+        if ntype in _CLASS_NODE_TYPES:
+            name_node = child.child_by_field_name("name")
+            cls = _text(name_node, source) if name_node else class_scope
+            body = child.child_by_field_name("body") or child
+            _walk_for_calls(body, cls or class_scope, source, out)
+        elif ntype == "decorated_definition":
+            _walk_for_calls(child, class_scope, source, out)
+        elif ntype in _FUNCTION_NODE_TYPES:
+            name_node = child.child_by_field_name("name")
+            fn_name = _text(name_node, source) if name_node else ""
+            body = child.child_by_field_name("body") or child
+            if fn_name:
+                qname = f"{class_scope}.{fn_name}" if class_scope else fn_name
+                out[qname] = _collect_call_basenames(body, source)
+            # Recurse into body for nested definitions (inner
+            # functions, closures that define named functions).
+            _walk_for_calls(body, class_scope, source, out)
+        else:
+            _walk_for_calls(child, class_scope, source, out)
+
+
+def _collect_call_basenames(body: Node, source: bytes) -> list[str]:
+    """Deduped, order-preserving callee basenames for every call under `body`."""
+    calls: list[str] = []
+    seen: set[str] = set()
+    for call_type in _CALL_NODE_TYPES:
+        for call in _walk_type(body, call_type):
+            base = _callee_basename(call, source)
+            if base and base not in seen and len(base) < _MAX_CALL_NAME_LEN:
+                calls.append(base)
+                seen.add(base)
+    return calls
diff --git a/mcp_server/core/ast_parser.py b/mcp_server/core/ast_parser.py
index a1c5c91d..598c5e9e 100644
--- a/mcp_server/core/ast_parser.py
+++ b/mcp_server/core/ast_parser.py
@@ -27,7 +27,6 @@
 from mcp_server.core.codebase_parser import parse_file
 from mcp_server.core.ast_extractors import (
     extract_calls_per_function,
-    extract_calls_generic,
     extract_python_definitions,
     extract_python_imports,
     extract_js_definitions,
@@ -101,7 +100,7 @@ def parse_file_ast(path: str, content: bytes) -> FileAnalysis:
         return parse_file(path, text)
 
     extractor, tree = result
-    imports, definitions, calls = extractor(tree.root_node, content)
+    imports, definitions = extractor(tree.root_node, content)
     docstring = _extract_module_doc(tree.root_node, language, content)
     # Caller-qualified call map — works across every language the
     # extractor covers because it targets tree-sitter node types shared
@@ -156,13 +155,12 @@ def _extract_module_doc(
 def _extract_python(
     root: Node,
     source: bytes,
-) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-    """Extract Python imports, definitions, and call sites."""
+) -> tuple[list[ImportInfo], list[SymbolDef]]:
+    """Extract Python imports and definitions."""
 
     imports = extract_python_imports(root, source)
     definitions = extract_python_definitions(root, source)
-    calls = extract_calls_generic(root, source)
-    return imports, definitions, calls
+    return imports, definitions
 
 
 # ── JS/TS extractor ──────────────────────────────────────────────────────
@@ -171,13 +169,10 @@ def _extract_python(
 def _extract_js(
     root: Node,
     source: bytes,
-) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-    """Extract JavaScript/TypeScript imports, definitions, and calls."""
+) -> tuple[list[ImportInfo], list[SymbolDef]]:
+    """Extract JavaScript/TypeScript imports and definitions."""
 
-    imports = extract_js_imports(root, source)
-    definitions = extract_js_definitions(root, source)
-    calls = extract_calls_generic(root, source)
-    return imports, definitions, calls
+    return extract_js_imports(root, source), extract_js_definitions(root, source)
 
 
 # ── Go extractor ─────────────────────────────────────────────────────────
@@ -186,40 +181,28 @@ def _extract_js(
 def _extract_go(
     root: Node,
     source: bytes,
-) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-    """Extract Go imports, definitions, and calls."""
+) -> tuple[list[ImportInfo], list[SymbolDef]]:
+    """Extract Go imports and definitions."""
 
-    return (
-        extract_go_imports(root, source),
-        extract_go_definitions(root, source),
-        extract_calls_generic(root, source),
-    )
+    return extract_go_imports(root, source), extract_go_definitions(root, source)
 
 
 def _extract_swift(
     root: Node,
     source: bytes,
-) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-    """Extract Swift imports, definitions, and calls."""
+) -> tuple[list[ImportInfo], list[SymbolDef]]:
+    """Extract Swift imports and definitions."""
 
-    return (
-        extract_swift_imports(root, source),
-        extract_swift_definitions(root, source),
-        extract_calls_generic(root, source),
-    )
+    return extract_swift_imports(root, source), extract_swift_definitions(root, source)
 
 
 def _extract_rust(
     root: Node,
     source: bytes,
-) -> tuple[list[ImportInfo], list[SymbolDef], list[str]]:
-    """Extract Rust imports, definitions, and calls."""
+) -> tuple[list[ImportInfo], list[SymbolDef]]:
+    """Extract Rust imports and definitions."""
 
-    return (
-        extract_rust_imports(root, source),
-        extract_rust_definitions(root, source),
-        extract_calls_generic(root, source),
-    )
+    return extract_rust_imports(root, source), extract_rust_definitions(root, source)
 
 
 # Keyed by the language pack's own `SupportedLanguage` literal, not by `str`:
diff --git a/tests_py/core/test_ast_extractors.py b/tests_py/core/test_ast_extractors.py
index 75c5f4cb..1158a57a 100644
--- a/tests_py/core/test_ast_extractors.py
+++ b/tests_py/core/test_ast_extractors.py
@@ -119,42 +119,6 @@ def test_interface_and_type(self) -> None:
             assert r.language == "typescript"
 
 
-class TestCallExtraction:
-    def test_python_calls(self) -> None:
-        code = b"""
-result = process(data)
-x = helper(1, 2)
-obj.method()
-"""
-        if _HAS_TREE_SITTER:
-            from mcp_server.core.ast_extractors import extract_calls_generic
-            from tree_sitter_language_pack import get_parser
-
-            tree = get_parser("python").parse(code)
-            calls = extract_calls_generic(tree.root_node, code)
-            assert "process" in calls
-            assert "helper" in calls
-        else:
-            r = parse_file_ast("test.py", code)
-            assert r.language == "python"
-
-    def test_js_calls(self) -> None:
-        code = b"""
-const x = fetchData(url);
-console.log("hello");
-"""
-        if _HAS_TREE_SITTER:
-            from mcp_server.core.ast_extractors import extract_calls_generic
-            from tree_sitter_language_pack import get_parser
-
-            tree = get_parser("javascript").parse(code)
-            calls = extract_calls_generic(tree.root_node, code)
-            assert any("fetchData" in c for c in calls)
-        else:
-            r = parse_file_ast("app.js", code)
-            assert r.language == "javascript"
-
-
 class TestGoExtractors:
     def test_go_struct_and_method(self) -> None:
         code = b"""
diff --git a/tests_py/core/test_ast_extractors_multilang.py b/tests_py/core/test_ast_extractors_multilang.py
index 47cb5ee1..75ab6c39 100644
--- a/tests_py/core/test_ast_extractors_multilang.py
+++ b/tests_py/core/test_ast_extractors_multilang.py
@@ -8,7 +8,6 @@
 
 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")
@@ -89,37 +88,22 @@ def test_php() -> None:
     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"]
+# `test_make_extractor_threads_the_real_source_into_calls_extraction` (added
+# by #269/#286 to pin mutmut mutant
+# `ast_extractor_registry.x__make_extractor__mutmut_10`, which replaced the
+# `source` argument threaded into a 3rd, calls-list-producing
+# `extract_calls_generic(root, source)` call) is deleted here, not merely
+# updated: this branch's own dead-code removal (issue #249 boy-scout pass)
+# deletes that call site and `extract_calls_generic` itself, so the mutant
+# the test existed to kill can no longer be generated from the source at
+# all — mutating an argument to a call that does not exist is not a
+# mutant, it is a no-op. `_make_extractor` now composes exactly two calls
+# (`imports_fn(root, source)`, `defs_fn(root, source)`), and a
+# `source`-argument mutant on either is already killed by the 7
+# per-language tests above: each asserts on `_imports`/`_defs` output that
+# is only correct when the REAL source bytes reach
+# `imports_fn`/`defs_fn` (e.g. `test_java`'s
+# `"java.util.List" in _imports(...)`), so replacing `source` with `None`
+# there breaks parsing and fails the assertion. No coverage regression:
+# verified by re-running `scripts/mutation_check.sh` scoped to
+# `ast_extractor_registry.py` (see this PR's report).
diff --git a/tests_py/core/test_ast_parser.py b/tests_py/core/test_ast_parser.py
index 1bd69fee..5d8cdfe3 100644
--- a/tests_py/core/test_ast_parser.py
+++ b/tests_py/core/test_ast_parser.py
@@ -3,10 +3,20 @@
 Tests adapt to the environment:
 - With tree-sitter: verifies full AST extraction (imports, classes, methods, etc.)
 - Without tree-sitter: verifies regex fallback produces valid FileAnalysis
+
+The fake-Node direct unit tests for `_extract_module_doc`/`_node_text`
+(`TestExtractModuleDoc`, `TestNodeText`, `_FakeNode`) live in the sibling
+`test_ast_parser_node_extraction.py` — split out to keep this file, which
+grew with the Go/Swift/Rust wrapper classes below, under the repo's
+300-line/file cap (CLAUDE.md, Code Style).
 """
 
 from __future__ import annotations
 
+import sys
+
+import pytest
+
 from mcp_server.core.ast_parser import is_available, parse_file_ast
 
 _HAS_TREE_SITTER = is_available()
@@ -107,6 +117,42 @@ def test_fallback_returns_valid_analysis(self) -> None:
         assert r.language == "python"
         assert r.line_count >= 2
 
+    def test_content_hash_length(self) -> None:
+        r = parse_file_ast("a.py", b"def foo(): pass")
+        assert len(r.content_hash) == 16
+
+    def test_calls_per_function_populated(self) -> None:
+        r = parse_file_ast("auth/middleware.py", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            assert "AuthMiddleware.authenticate" in r.calls_per_function
+            assert "verify_jwt" in r.calls_per_function["AuthMiddleware.authenticate"]
+        else:
+            assert r.calls_per_function == {}
+
+    def test_decodes_malformed_utf8_without_raising(self) -> None:
+        """`errors="replace"` must survive a resolver swap, per issue #249."""
+        r = parse_file_ast("bad.py", b"\xff\xfe def foo(): pass")
+        assert isinstance(r.line_count, int)
+
+
+def test_is_available_reflects_installed_tree_sitter() -> None:
+    """Pins is_available()'s True branch — a mutant flipping it to False
+    would still leave every _HAS_TREE_SITTER-gated assertion above passing
+    trivially (the gated branch is simply skipped)."""
+    if not _HAS_TREE_SITTER:
+        pytest.skip("tree-sitter not installed")
+    assert is_available() is True
+
+
+def test_is_available_false_when_tree_sitter_import_fails(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Pins the except-ImportError branch, unreachable when tree-sitter IS
+    installed (this environment): forcing the import to fail is the only
+    way to exercise it directly."""
+    monkeypatch.setitem(sys.modules, "tree_sitter_language_pack", None)
+    assert is_available() is False
+
 
 class TestParseFileTypeScript:
     SAMPLE = b"""import { Request } from 'express';
@@ -169,3 +215,9 @@ def test_unknown_extension_uses_regex(self) -> None:
         r = parse_file_ast("readme.md", b"# Hello")
         assert r.language == "unknown"
         assert r.definitions == []
+
+
+# TestParseFileGo/TestParseFileSwift/TestParseFileRust live in the sibling
+# test_ast_parser_extra_langs.py — split out to keep this file under the
+# repo's 300-line/file cap once those three classes were added (issue #249
+# mutation-testing pass).
diff --git a/tests_py/core/test_ast_parser_extra_langs.py b/tests_py/core/test_ast_parser_extra_langs.py
new file mode 100644
index 00000000..56b8a4ef
--- /dev/null
+++ b/tests_py/core/test_ast_parser_extra_langs.py
@@ -0,0 +1,122 @@
+"""Go/Swift/Rust parse_file_ast integration tests.
+
+Split out of test_ast_parser.py (Extract Module, behavior-preserving — see
+CHANGELOG's [Unreleased] entry for this PR): these three classes were
+added by the issue #249 mutation-testing pass to close a real coverage
+gap — `_extract_swift`/`_extract_rust` were never exercised through
+`parse_file_ast` by any existing test, and the Go equivalent bypassed its
+own wrapper by calling `extract_go_definitions` directly
+(`TestGoExtractors` in `test_ast_extractors.py`) — and pushed
+test_ast_parser.py to 405 lines, over this repo's 300-line/file cap
+(CLAUDE.md, Code Style). Zero behavior change: same fixtures, same
+assertions, same test names, moved as a unit.
+"""
+
+from __future__ import annotations
+
+from mcp_server.core.ast_parser import is_available, parse_file_ast
+
+_HAS_TREE_SITTER = is_available()
+
+
+class TestParseFileGo:
+    """Exercises ast_parser._extract_go through the public parse_file_ast
+    entry point — TestGoExtractors (test_ast_extractors.py) calls
+    extract_go_definitions directly and never reaches this wrapper
+    (issue #249 mutation-testing pass)."""
+
+    SAMPLE = b"""package main
+
+import "fmt"
+
+type Server struct {
+    port int
+}
+
+func (s *Server) Start() error {
+    return nil
+}
+
+func NewServer(port int) *Server {
+    return &Server{port: port}
+}
+"""
+
+    def test_returns_file_analysis(self) -> None:
+        r = parse_file_ast("main.go", self.SAMPLE)
+        assert r.language == "go"
+
+    def test_imports(self) -> None:
+        r = parse_file_ast("main.go", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            assert "fmt" in [i.module for i in r.imports]
+
+    def test_definitions(self) -> None:
+        r = parse_file_ast("main.go", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            names = [d.name for d in r.definitions]
+            assert "Server.Start" in names
+            assert "NewServer" in names
+
+
+class TestParseFileSwift:
+    """Exercises ast_parser._extract_swift through parse_file_ast — no
+    prior test reached this wrapper at all (issue #249 mutation-testing
+    pass: 12/12 mutants reported "no tests" before this class)."""
+
+    SAMPLE = b"""import Foundation
+
+class AuthService {
+    func verify(token: String) -> Bool {
+        return true
+    }
+}
+"""
+
+    def test_returns_file_analysis(self) -> None:
+        r = parse_file_ast("Auth.swift", self.SAMPLE)
+        assert r.language == "swift"
+
+    def test_imports(self) -> None:
+        r = parse_file_ast("Auth.swift", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            assert "Foundation" in [i.module for i in r.imports]
+
+    def test_definitions(self) -> None:
+        r = parse_file_ast("Auth.swift", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            names = [d.name for d in r.definitions]
+            assert "AuthService" in names
+
+
+class TestParseFileRust:
+    """Exercises ast_parser._extract_rust through parse_file_ast — no
+    prior test reached this wrapper at all (issue #249 mutation-testing
+    pass: 12/12 mutants reported "no tests" before this class)."""
+
+    SAMPLE = b"""use std::fmt;
+
+struct Server {
+    port: u16,
+}
+
+fn new_server(port: u16) -> Server {
+    Server { port }
+}
+"""
+
+    def test_returns_file_analysis(self) -> None:
+        r = parse_file_ast("main.rs", self.SAMPLE)
+        assert r.language == "rust"
+
+    def test_imports(self) -> None:
+        r = parse_file_ast("main.rs", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            assert "std::fmt" in [i.module for i in r.imports]
+
+    def test_definitions(self) -> None:
+        r = parse_file_ast("main.rs", self.SAMPLE)
+        if _HAS_TREE_SITTER:
+            names = [d.name for d in r.definitions]
+            assert "Server" in names
+            assert "new_server" in names
diff --git a/tests_py/core/test_ast_parser_node_extraction.py b/tests_py/core/test_ast_parser_node_extraction.py
new file mode 100644
index 00000000..5eb9a24c
--- /dev/null
+++ b/tests_py/core/test_ast_parser_node_extraction.py
@@ -0,0 +1,103 @@
+"""Direct unit tests for ast_parser's docstring/comment-extraction helpers.
+
+Split out of test_ast_parser.py (Extract Module, behavior-preserving — see
+CHANGELOG's [Unreleased] entry for this PR): `_extract_module_doc` and
+`_node_text` are exercised here through fake, duck-typed `_FakeNode`
+instances rather than through `parse_file_ast`, so they belong with the
+other direct-unit-test group, not the parse_file_ast integration classes
+that make up the rest of test_ast_parser.py. Growing that file with the
+Go/Swift/Rust wrapper classes (issue #249 mutation-testing pass) pushed it
+to 405 lines, over this repo's 300-line/file cap (CLAUDE.md, Code Style);
+this split is the fix, not a rename — zero behavior change, same fake-Node
+fixtures, same assertions, same test names, moved as a unit.
+"""
+
+from __future__ import annotations
+
+from mcp_server.core.ast_parser import _extract_module_doc, _node_text
+
+
+class _FakeNode:
+    """Minimal duck-typed stand-in for a tree_sitter.Node.
+
+    ast_parser's docstring/comment extraction only reads `.type`,
+    `.children`, `.start_byte`, `.end_byte` — a real grammar is not needed
+    to pin these functions' branches precisely.
+    """
+
+    def __init__(
+        self,
+        node_type: str,
+        children: list["_FakeNode"] | None = None,
+        start_byte: int = 0,
+        end_byte: int = 0,
+    ) -> None:
+        self.type = node_type
+        self.children = children or []
+        self.start_byte = start_byte
+        self.end_byte = end_byte
+
+
+class TestExtractModuleDoc:
+    """Direct unit tests for the docstring/comment-extraction branches —
+    fake nodes pin exact behavior without depending on a specific grammar's
+    tree shape (issue #249 mutation-testing pass)."""
+
+    def test_no_children_returns_empty(self) -> None:
+        root = _FakeNode("module", children=[])
+        assert _extract_module_doc(root, "python", b"") == ""
+
+    def test_python_bare_string_first_child(self) -> None:
+        source = b'"""hello"""'
+        string_node = _FakeNode("string", start_byte=0, end_byte=len(source))
+        root = _FakeNode("module", children=[string_node])
+        assert _extract_module_doc(root, "python", source) == "hello"
+
+    def test_python_expression_statement_wrapper(self) -> None:
+        source = b'"""Xylophone is great."""'
+        string_node = _FakeNode("string", start_byte=0, end_byte=len(source))
+        other = _FakeNode("other")
+        expr_stmt = _FakeNode("expression_statement", children=[string_node, other])
+        root = _FakeNode("module", children=[expr_stmt])
+        assert _extract_module_doc(root, "python", source) == "Xylophone is great."
+
+    def test_python_docstring_truncated_at_200(self) -> None:
+        body = "x" * 250
+        source = f'"""{body}"""'.encode()
+        string_node = _FakeNode("string", start_byte=0, end_byte=len(source))
+        root = _FakeNode("module", children=[string_node])
+        doc = _extract_module_doc(root, "python", source)
+        assert len(doc) == 200
+
+    def test_non_python_comment_first_child(self) -> None:
+        source = b"# Xray diagnostics."
+        comment = _FakeNode("comment", start_byte=0, end_byte=len(source))
+        root = _FakeNode("module", children=[comment])
+        assert _extract_module_doc(root, "javascript", source) == "Xray diagnostics."
+
+    def test_comment_truncated_at_200(self) -> None:
+        source = ("# " + "y" * 250).encode()
+        comment = _FakeNode("comment", start_byte=0, end_byte=len(source))
+        root = _FakeNode("module", children=[comment])
+        doc = _extract_module_doc(root, "javascript", source)
+        assert len(doc) == 200
+
+    def test_neither_string_nor_comment_returns_empty(self) -> None:
+        root = _FakeNode("module", children=[_FakeNode("class_declaration")])
+        assert _extract_module_doc(root, "go", b"") == ""
+
+
+class TestNodeText:
+    def test_extracts_slice_as_utf8(self) -> None:
+        source = b"hello world"
+        node = _FakeNode("identifier", start_byte=0, end_byte=5)
+        assert _node_text(node, source) == "hello"
+
+    def test_replaces_invalid_utf8_instead_of_raising(self) -> None:
+        """`errors="replace"` must survive a resolver swap, per issue #249:
+        an invalid error-handler name (a stub/version mismatch) raises
+        LookupError here instead of degrading gracefully."""
+        source = b"\xff\xfe"
+        node = _FakeNode("raw", start_byte=0, end_byte=len(source))
+        text = _node_text(node, source)
+        assert isinstance(text, str)