jcodemunch-mcp 1.108.332__tar.gz → 1.108.334__tar.gz

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "jcodemunch",
   "displayName": "jCodeMunch",
-  "version": "1.108.332",
+  "version": "1.108.334",
   "description": "Token-efficient MCP server for source code exploration via tree-sitter AST parsing",
   "author": {
     "name": "J. Gravelle",

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/CHANGELOG.md

@@ -2,6 +2,124 @@
 
 ## [Unreleased]
 
+## [1.108.334] - 2026-10-08 - a semantic search writes no vector of a second model
+
+### Fixed
+
+- **A semantic search no longer writes a second model's vectors into the store (LEDGER
+  L-121).** `search_symbols` with `semantic=true` embeds every symbol that has no vector and
+  writes it. `embed_repo` has compared the stored model with the active one since #500; the
+  search, the other of the two vector writers, compared nothing. So after a change of embedding
+  model, one semantic search on a repo with a new symbol wrote that symbol at the new width
+  beside the old vectors (`evidence/l121_before_after.txt`, a mocked provider: five vectors at
+  width 8, then `{4: 1, 8: 5}`). The matrix keeps the first width and drops the rest, so the
+  new symbol read as missing on every later search and each one called the provider for it
+  again (two calls per search in that file, the query and the symbol).
+  The rule now has one home, `stale_reason` in `storage/embedding_store.py`, and both writers
+  ask it. It covers a changed model, a changed task type, and vectors with no metadata; an
+  unknown stored model is still not a change, and there the width decides. On a reason the
+  search does not rebuild: a search is a read, and two clients on one store with different
+  providers would re-embed the whole repo on every search from the other. It writes nothing,
+  calls the provider for nothing, ranks without the semantic channel, and says so in the
+  response body as `semantic_store_mismatch` (`reason`, `stored_model`, `active_model`,
+  `remedy`), with `channels.semantic: "unavailable"` in the verdict. `semantic_only` returns
+  no row there. Where the stored model is unknown and only the width differs, the reason is
+  `embedding_dimension_mismatch` with `stored_dimension` and `active_dimension`; the provider
+  is called once there, for the query, and its width is compared with the width of the stored
+  vectors themselves. `embed_repo` rebuilds, as before, and the next search scores again.
+  One store changes behaviour on upgrade: vectors with no metadata, which every full re-index
+  left before 1.108.331 (#522). A semantic search scored and topped those up; it now answers
+  `embedding_metadata_missing` and ranks without the semantic channel until `embed_repo` runs,
+  which re-embeds the repo.
+  The rule reads what is recorded about the vectors, so the record no longer outlives them:
+  `EmbeddingStore.clear()` removes the dimension, model and task type with the vectors, and a
+  writer that finds a record beside no vectors removes it with a statement that cannot delete
+  a vector. Before, a rebuild whose every batch failed left an empty store named for the old
+  model, and the retry wrote the new model's vectors under that name and reported
+  `embedding_dimension` from the old one.
+  Each writer decides its write from a reading taken over the connection it writes with.
+  `embed_repo` reads once, and that reading decides both the rebuild and what it reports. The
+  search reads again at its write, after its provider calls, so a store another client rebuilt
+  in between is left alone. The read-only reading the search starts from sees nothing under a
+  storage path that holds `#` (LEDGER L-137); there the search learns of a changed model only
+  at the write, after it has called the provider, and still writes nothing.
+  A test scans `src/` and fails on a function that calls `set_many` without asking
+  (`tests/test_semantic_topup_checks_the_stored_model.py`).
+  Not changed: the fusion exit (`fusion=true`) still scores a query from the active model
+  against a stored model's vectors (LEDGER L-135), and `embed_repo` without `force` on a store
+  whose model is unknown still writes a new width beside the old one (LEDGER L-136).
+
+## [1.108.333] - 2026-10-07 - the parse budget stops a slow parse again on a fresh install
+
+### Fixed
+
+- **`init`'s index line reports what the indexer did (reported by Dave).** After indexing,
+  `jcodemunch-mcp init` printed `indexed <folder> (? files, ? symbols)`. The line read
+  `files_indexed` and `symbols_indexed` from the indexer's result. No run returns the second,
+  and only a run cut short by the file cap returns the first. A full index answers `file_count` and `symbol_count`, a run that
+  re-indexes some files answers `changed`, `new`, `deleted` and `symbol_count`. So the line has
+  read `? symbols` for every index `init` ran since the command arrived (2026-04-03), and
+  `? files` for all but a capped one. It also
+  read `indexed` for a run the indexer had refused, a folder with no source file among them.
+  The line now has one form per answer (`evidence/init_index_line.txt`, the real indexer on a
+  scratch project): `indexed <folder> (2 files, 3 symbols)`,
+  `indexed <folder> (1 changed, 1 new, 1 deleted, 3 symbols)`,
+  `<folder> is up to date (nothing changed since the last index)`, and
+  `indexing failed: No source files found`. A count the result does not carry is left out, and
+  a run the file cap cut short adds `the file cap was reached, 2 of 4 files are in the index` to
+  whichever form it has.
+  Nothing had tested the line: the `init` tests replace the function that writes it. The new
+  tests run the real indexer on a project they own
+  (`tests/test_init_index_summary_reads_the_indexers_result.py`). The index itself was correct.
+  Not changed: the indexer's `warnings` (a file skipped by the parse budget, a provider skipped)
+  are still not printed by `init`. A test that reads the same absent key is LEDGER L-134.
+
+- **Three more ways a macro got the wrong docstring (LEDGER L-129, L-130, L-131).** 1.108.332
+  gave a dbt or Jinja/Twig directive the `{# comment #}` that ends directly above it; its
+  review found three inputs the rule still read wrongly, measured through `parse_file` on
+  1.108.332 and then on the fix (`evidence/l129_l131_before_after.txt`). A comment that TRAILS
+  code on its line was taken by the directive on the next line: after
+  `{% macro a() %}select 1{% endmacro %} {# end of a #}`, `b` read `end of a` and reads nothing.
+  The comment must now be first on its line, with only other comments (or a `--` lead) before it
+  there. A `{#`
+  inside an expression opened a comment: with `{{ '{#' }}` in the macro above, `second` read
+  `' }}{% endmacro %}` and the line after it, and reads `about second`. The file is read as
+  Jinja reads it, `{{ ... }}`, `{% ... %}` and `{# ... #}` left to right, each to its first
+  closer. And a whitespace-control mark was dropped whatever the dialect: `{#~approx 5 rows#}`
+  in a `.sql` read `approx 5 rows` and reads `~approx 5 rows`; `{#+1 to the offset #}` in a
+  `.twig` read `1 to the offset` and reads `+1 to the offset`. `-` is a mark everywhere, `+` in
+  Jinja and dbt, `~` in Twig. Nothing inside `{% raw %}` or `{% verbatim %}` is a delimiter, and
+  a byte-order mark or a zero-width space before a comment is not text, so a file that starts
+  with a BOM keeps its first docstring. ⚠ The docstring changes on unchanged content, so
+  `PARSER_GENERATION` is 11 and an existing index re-parses once at its next index run; no
+  symbol id moves. ⚠ What reads WORSE than on 1.108.332 (LEDGER L-132, same evidence file):
+  a stray `{{` or `{%` outside a raw block that has a later closer is one expression up to that
+  closer, so `-- wrap in {{ to call` above a documented macro, with a `{{ x }}` further down,
+  costs that macro its docstring (`doc` before, nothing now); Jinja itself refuses such a file.
+  A closer inside a string in an expression (`{{ '}}' }}`) still ends the expression there, and
+  when the leftover holds an opener (`{{ '}} {%' }}`) the documented macro below it loses its
+  docstring too.
+  Not run: a dbt, Jinja or Twig corpus.
+
+- **The parse budget stops a slow parse again on a fresh install (reported by Dave).** The
+  per-file budget (`JCODEMUNCH_PARSE_BUDGET_SECONDS`, 1.108.329) stops tree-sitter's C parse
+  through `Parser.timeout_micros`. tree-sitter 0.26.0 removed that attribute, and the
+  dependency read `tree-sitter>=0.25` with no upper bound, so an install that resolved 0.26.0
+  could no longer stop a parse. Its only sign was one line at index time: `the installed
+  tree-sitter has no Parser.timeout_micros`. Measured with this tree's source and a 0.5 s budget
+  on a 405,035-byte Python file (`evidence/tree_sitter_026.txt`): on tree-sitter 0.25.2 the file
+  is stopped after 0.54 s; on 0.26.0 after 7.06 s, when the parse had run to its end. Through
+  `index_folder` the file is named as skipped on both (`parse exceeded the 0.5s budget`), so no
+  wrong symbol was served; the time was spent. CI never saw
+  it: it installs from `uv.lock`, which pins 0.25.2, and the guard that fails on a binding
+  without the attribute runs there. The range is now `>=0.25,<0.26`, so an upgrade moves such an
+  install back to a version that can stop a parse, and
+  `tests/test_tree_sitter_range_is_the_tested_range.py` fails when the declared range admits any
+  release past the locked minor, an exclusion such as `!=0.26.0` included. The warning now names
+  the remedy. Not changed: tree-sitter
+  0.26 is not supported; its replacement for the timeout, a progress callback, crashed the
+  interpreter when it was tried on 0.25.2 (LEDGER L-133).
+
 ## [1.108.332] - 2026-10-07 - a macro's docstring is the comment directly above it
 
 ### Fixed

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/ISSUE-HISTORY.md

@@ -2228,3 +2228,31 @@ The 1.108.331 entry, verbatim, dropped when it was compressed to a `Prior` line:
 The `Tests:` line's 1.108.329 count, verbatim:
 
 - ⚠ Prior (1.108.329): 14726 passed, 25 skipped, **0 failed** (14751 total).
+
+## Current State rotation (2026-10-07, release 1.108.333)
+
+The 1.108.330 entry, verbatim as it stood in `CLAUDE.md`:
+
+- **Prior (1.108.330):** **The parse budget bounds a file's Python-side time** (L-116): `parse_budget.checkpoint()` raises inside `parse_file` once the file's deadline has passed, and every loop on the parse path starts with one (rules: the Env Vars row; residue L-117, L-118). Also a bare Python module name resolves to the script directory beside the importer (#972, @whakomatic; L-120). Full text: `CHANGELOG.md`; verbatim in `ISSUE-HISTORY.md` (2026-10-06, release 1.108.331).
+
+The 1.108.332 entry, verbatim, dropped when it was compressed to a `Prior` line:
+
+- **Version:** 1.108.332 — **A macro's docstring is the comment directly above it** (L-126): `_PrecedingComments` (`parser/sql_preprocessor.py`) gives a dbt or Jinja/Twig directive the `{# #}` that ENDS where the text before it ends, less one whitespace-control mark per side. ⚠ `PARSER_GENERATION` is 10: a stored docstring moved on unchanged content. ⚠ Residue, each owing its own generation: L-129, L-130, L-131. Also three loops on the parse path are linear in the file (L-117; residue L-127, L-128). Forensics: `CHANGELOG.md`, `docs/workflows/LEDGER.md`.
+
+The `Tests:` line's 1.108.330 count, verbatim:
+
+- ⚠ Prior (1.108.330): 14783 passed, 25 skipped, **0 failed** (14808 total).
+
+## Current State rotation (2026-10-08, release 1.108.334)
+
+The 1.108.331 entry, verbatim as it stood in `CLAUDE.md`:
+
+- **Prior (1.108.331):** **A full re-index keeps the embedding metadata beside its vectors** (#522, @lsg1103275794): `save_index` leaves the `meta` keys under `embedding_store.META_KEY_PREFIX`. ⚠ `embed_repo` after a full re-index re-embeds everything only on `force=true` (residue L-121, L-122). Also its task-type gate has THREE states (#523): `None` is never recorded and is not a change, `""` is a recorded value, and vectors with no embedding metadata are still rebuilt, named by `rebuild_reason`. Full text: `CHANGELOG.md`; verbatim in `ISSUE-HISTORY.md` (2026-10-07, release 1.108.332).
+
+The 1.108.333 entry, verbatim, dropped when it was compressed to a `Prior` line:
+
+- **Version:** 1.108.333 — **The parse budget stops a slow parse again on a fresh install** (reported by Dave): `pyproject.toml` declares `tree-sitter>=0.25,<0.26`. ⚠⚠ **The range stops at the minor `uv.lock` pins, and `tests/test_tree_sitter_range_is_the_tested_range.py` fails when it admits a later one**: tree-sitter 0.26.0 removed `Parser.timeout_micros`, CI installs from the lock, and a user installs from the range, so the cancel guard never ran on what users got. Moving to a later tree-sitter means moving the lock first (0.26 is unsupported, L-133); the lock's `requires-dist` line is edited by hand with it. Also `init`'s index line reads the keys `index_folder` returns (`cli/init.py` `_index_summary`; it printed `? files, ? symbols`; residue L-134), and three more inputs gave a macro the wrong docstring (L-129, L-130, L-131; residue L-132). ⚠ `PARSER_GENERATION` is 11. Forensics: `CHANGELOG.md`, `docs/workflows/LEDGER.md`.
+
+The `Tests:` line's 1.108.331 count, verbatim:
+
+- ⚠ Prior (1.108.331): 14800 passed, 25 skipped, **0 failed** (14825 total).

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jcodemunch-mcp
-Version: 1.108.332
+Version: 1.108.334
 Summary: Token-efficient MCP server for source code exploration via tree-sitter AST parsing
 Project-URL: Homepage, https://github.com/jgravelle/jcodemunch-mcp
 Project-URL: Repository, https://github.com/jgravelle/jcodemunch-mcp
@@ -27,7 +27,7 @@ Requires-Dist: pathspec>=0.12.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tree-sitter-fsharp==0.3.12
 Requires-Dist: tree-sitter-language-pack<1.0.0,>=0.7.0
-Requires-Dist: tree-sitter>=0.25
+Requires-Dist: tree-sitter<0.26,>=0.25
 Provides-Extra: all
 Requires-Dist: anthropic>=0.40.0; extra == 'all'
 Requires-Dist: anyio>=4.14.2; extra == 'all'
@@ -246,10 +246,10 @@ That's the highlight reel. The complete tour of 90+ tools, the MUNCH compact wir
 <!-- WHATSNEW:START -->
 #### What's new
 
+- **[v1.108.334](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.334)** (2026-10-08) — a semantic search writes no vector of a second model
+- **[v1.108.333](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.333)** (2026-10-07) — the parse budget stops a slow parse again on a fresh install
 - **[v1.108.332](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.332)** (2026-10-07) — a macro's docstring is the comment directly above it
 - **[v1.108.331](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.331)** (2026-10-06) — a full re-index keeps the embedding metadata beside its vectors
-- **[v1.108.330](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.330)** (2026-10-06) — the parse budget bounds a file's Python-side time
-- **[v1.108.329](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.329)** (2026-10-05) — the parse budget stops a slow parse
 <!-- WHATSNEW:END -->
 
 ---

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/README.md

@@ -158,10 +158,10 @@ That's the highlight reel. The complete tour of 90+ tools, the MUNCH compact wir
 <!-- WHATSNEW:START -->
 #### What's new
 
+- **[v1.108.334](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.334)** (2026-10-08) — a semantic search writes no vector of a second model
+- **[v1.108.333](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.333)** (2026-10-07) — the parse budget stops a slow parse again on a fresh install
 - **[v1.108.332](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.332)** (2026-10-07) — a macro's docstring is the comment directly above it
 - **[v1.108.331](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.331)** (2026-10-06) — a full re-index keeps the embedding metadata beside its vectors
-- **[v1.108.330](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.330)** (2026-10-06) — the parse budget bounds a file's Python-side time
-- **[v1.108.329](https://github.com/jgravelle/jcodemunch-mcp/releases/tag/v1.108.329)** (2026-10-05) — the parse budget stops a slow parse
 <!-- WHATSNEW:END -->
 
 ---

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/docs/harness/ARCHAEOLOGY.md

@@ -39,7 +39,7 @@ reason could not be found it was marked UNCLEAR, not LOAD-BEARING.
 ### Scars worth naming (odd inputs that are wounds)
 
 - `tests/test_server.py` pins `len(tools) == 90` as a literal while the live `full` profile serves 91; its docstring says `test_summarizer` is disabled by default. A literal count is a second copy of the surface; flagged for the coverage map, not changed.
-- `tests/test_suggest_queries.py` empty-index case is conditional and can pass vacuously.
+- `tests/test_suggest_queries.py` empty-index case was conditional and passed vacuously until 2026-10-07 (LEDGER L-134): its fixture, a lone `README.md`, is refused by the indexer, and its `if` read a key the indexer does not return. It indexes a source file with no symbol now and asserts unconditionally.
 - `tests/test_nesting_depth_channels.py` scans for a stray 0x08 BACKSPACE byte because one once replaced a backslash in a regex and compiled.
 - `tests/test_v1_108_84.py` carries a real reporter's macOS path as the INPUT; the path is the defect's shape (#357), not an environment leak.
 - `tests/test_watcher_serve.py` uses a literal Windows system path as a MOCKED fixture because #447 wrote a real file into a real system directory once.
@@ -186,6 +186,7 @@ Criterion codes: 1 correctness, 2 token reduction, 3 freshness/caches/absence, 4
 | tests/test_embed_task_type_gate.py | `embed_repo`'s task-type gate tells three states apart: a recorded and different task type rebuilds (including a toggle from the recorded empty string), an absent row beside a recorded dimension is unknown and re-embeds nothing, and vectors with no embedding metadata at all are rebuilt with `rebuild_reason: embedding_metadata_missing`; and embed, full re-index, embed again embeds only the new symbol (the #522 pair). | "fix: embed_repo treats a never-recorded task type as unknown, not as a change (#523)" | 3 | LOAD-BEARING | Mocks `embed_texts` and the provider resolver only; each reintroduced defect in `evidence/f523_mutants.txt` fails a test; the pair test guards #522's fix, not this gate |
 | tests/test_embedding_model_change.py | `embed_repo` detects a stored-model change and rebuilds instead of mixing vector widths; the exclusion count is reported. | 57d19ab "fix(embed): detect a model change instead of mixing vector widths (#500)"; c8dd085 (#488) | 3 | LOAD-BEARING | Patches `_detect_provider` through its shared source |
 | tests/test_full_save_keeps_embedding_meta.py | A full `save_index` keeps the embedding store's `meta` rows (`embed_dimension`, `embed_model`, `embed_task_type`) beside the vectors it also keeps, and still removes an index key the new index does not write and a key that only resembles the prefix. | "fix: a full re-index keeps the embedding metadata beside the vectors it describes (#522)" | 3 | LOAD-BEARING | Reads the `_EMBED_*_KEY` names off `embedding_store`; the end-to-end half (embed, full re-index, model change) is in `tests/test_embedding_model_change.py` |
+| tests/test_semantic_topup_checks_the_stored_model.py | A semantic `search_symbols` asks what built the stored vectors before its top-up writes: on a changed model, a changed task type or vectors with no metadata it writes nothing, calls the provider for nothing, and returns `semantic_store_mismatch`; on a width other than the stored vectors' it calls the provider for the query only and returns the same field; the same model and an unknown model at the same width still top up; a store with no vectors has no stamp (`clear()` removes it, and a writer removes one left behind without `clear()`); each writer decides its write from a reading over its write connection, tested on a real storage path holding `#` and on a store rebuilt by another client during the top-up. | "fix: a semantic search writes no vector of a second model (LEDGER L-121)" | 3 | LOAD-BEARING | The #500 guard drove `embed_repo` only, one of two callers of `set_many`; an AST scan of `src/` fails on a caller that does not call `stale_reason`. `read_meta` is asserted not to move the .db or its sidecars |
 | tests/test_embedding_provider_advice.py | All three provider-advice sites (embed_repo error, `semantic` param description, search_symbols no-provider error) name the bundled ONNX encoder from one shared message. | 6a43655 "fix(embeddings): one source for provider advice, bundled encoder first (#489)" | 4 | LOAD-BEARING | Source ratchet via `inspect.getsource` asserting the old literal is absent and `NO_PROVIDER_MESSAGE` is used |
 | tests/test_endpoint_impact.py | `get_endpoint_impact` resolves verb+path to handlers from decorator (Flask) and string-dispatch (Django) routes and returns their blast radius. | bdebb63 "v1.108.90 — new tool: get_endpoint_impact" | 1 | LOAD-BEARING | Builds real fixture repos via index_folder |
 | tests/test_endpoint_infra_impact.py | `include_infra=True` on get_endpoint_impact fuses `collect_project_intel` cross-refs and upstream `exposes[]` into the endpoint result. | 789aa12 "v1.108.91 — endpoint-scoped infrastructure links"; 8417eca "v1.108.93: upstream exposes[]" | 1 | LOAD-BEARING | Cites docs/prd-endpoint-infra-impact.md P1; 19 tests |
@@ -248,6 +249,7 @@ Criterion codes: 1 correctness, 2 token reduction, 3 freshness/caches/absence, 4
 | tests/test_init.py | `init` client detection, `_patch_mcp_config` backup/merge, CLAUDE.md/Cursor/Windsurf installs, hooks install, audit, and the client registry incl. Codex/opencode. | `e176e7a v1.21.26 Cursor/Windsurf rules + --demo`; `8c6f85b v1.108.35 fix CI-only break`; `c0a82da feat(init): register Codex CLI and opencode` | 6 | LOAD-BEARING | 44 tests; the largest init surface; per-client schema shapes are in test_init_client_schemas.py. |
 | tests/test_init_client_schemas.py | Each host gets its own config shape (Codex TOML with resolved binary and never `uvx`, opencode `mcp` array command, VS Code `servers`, Gemini/Cline detection). | `c0a82da feat(init): register Codex CLI and opencode, each on its own schema`; `8c7a6d8 feat(init): register Gemini CLI, Cline and VS Code/Copilot` | 6 | LOAD-BEARING | Docstring: a wrong schema produces no error (silent no-tools); cites CLIENTS.md multi-hour hang. |
 | tests/test_init_hooks_paths.py | Hook commands are written with forward slashes on Windows (bash eats backslashes) and re-running `init` never appends duplicate hooks (subcommand-keyed dedupe). | `105e5a1 fix: Windows hook path bash-escape eating + duplicate hook accumulation (v1.108.7)`; `9b375cd fix(hooks): ten confirmed defects` | 6 | LOAD-BEARING | Patches `_hook_invocation` to return literal `C:\Python314\...` and `C:\Program Files\...` paths (intentional inputs). |
+| tests/test_init_index_summary_reads_the_indexers_result.py | `init`'s index line reports what `index_folder` returned: files and symbols for a full index, changed/new/deleted and symbols for a run that re-indexed some files, `up to date` when nothing changed, `indexing failed` with the indexer's error for a refusal, and how many files the index holds when the file cap cut the walk short; never `?`, and no count the result lacks. | "fix: init's index line reads the keys the indexer returns" (a user report by email, 2026-10-07) | 6 | LOAD-BEARING | Five cases run the REAL indexer in a project and a store the test owns: the line read `symbols_indexed`, which no run returns, and `files_indexed`, which only a capped run returns, and the only tests near it (`test_init_minimal.py`, `test_init_policy_matches_surface.py`) replace `run_index` whole, so a mock would supply whichever keys its author expected. |
 | tests/test_init_minimal.py | `init --minimal` registers the MCP server and touches no other channel (no CLAUDE.md, rules, AGENTS.md, hooks, index, audit). | `aa4cb54 release: v1.108.22 — ... init --minimal ...`; `e3663c5 test: retire the src.jcodemunch_mcp package twin` | 6 | LOAD-BEARING | 3 tests, spies on every helper. |
 | tests/test_init_policy_matches_surface.py | The policy `init` writes names only tools the advertised surface carries — after `load_config`, honouring `tool_surface` and profile — and `--minimal --hooks` installs hooks (#397). | `d7e3b17 release: v1.108.206 - init wrote a policy for a decision it had not made yet`; `054755d (#507)`; `9cf763e refactor: break three import cycles` | 4 | LOAD-BEARING | Header warns patches must target `cli.policy`, not `init` re-exports (monkeypatch trap). |
 | tests/test_install_copilot_hooks.py | `init --copilot-hooks` writes `.github/hooks/hooks.json` with one postToolUse rule keyed by subcommand, idempotently. | `aede3b2 release: v1.81.0 — VS Code extension, Copilot hooks`; `1650270 test(hooks): assert the Copilot rule by subcommand, not by bare-name substring` | 6 | LOAD-BEARING | Asserts outcome not string shape (Windows `.EXE` absolute path). |
@@ -351,9 +353,10 @@ Criterion codes: 1 correctness, 2 token reduction, 3 freshness/caches/absence, 4
 | tests/test_paid_embeddings_optin.py | `_detect_provider` never selects a paid cloud embedding provider from an API key alone -- the explicit `*_EMBED_MODEL` is the opt-in and the local ONNX encoder wins at priority 0. | `2971bb2 test: pin that a bare cloud key cannot select a paid embedding provider`; docstring: suite-parity check for a jdocmunch defect, deliberately NOT a port of its gate | 8 | LOAD-BEARING | Pins a property jcm already had so a "simplification" cannot remove it; env-only, no network. |
 | tests/test_parity_map.py | `get_parity_map` classifies ported/renamed/diverged/added/orphaned symbols across two scopes, computes `parity_pct`, orders the port plan topologically with SCC grouping, errors on same scope/unindexed/empty, and is read-only. | `07bbb0c get_parity_map: correspondence-aware migration parity map (v1.108.111)`; docstring | 1 | LOAD-BEARING | Fixture is a legacy/ vs v2/ tree with commented expected outcomes per symbol. |
 | tests/test_parse_budget_cancels.py | An over-budget tree-sitter parse is stopped at `JCODEMUNCH_PARSE_BUDGET_SECONDS` and the file is named in `warnings`, on `parse_file`, a full index and an incremental re-index, at any file size; a stop is recognised without a clock; another thread's time is not charged to the file; a first index starts no wait thread; the installed binding can still cancel a parse. | LEDGER L-114 (2026-10-04): the thread wait could not return while the parse held the GIL | 5 | LOAD-BEARING | The slow input is L-113's shape; each cancelled case costs its 0.25 s budget. The fake-parser cases pin both directions of the stop rule and the expired-deadline branch (review rounds found mutants that passed an earlier form). `test_a_first_index_leaves_no_thread_behind` predates L-116's fix and still holds; every route is in `tests/test_parse_budget_python_side.py`. `OLD_WAIT_GATE` is the retired wait's 128 KiB threshold, kept as a fixture boundary. The binding canary fails when `Parser.timeout_micros` is gone |
+| tests/test_tree_sitter_range_is_the_tested_range.py | The `tree-sitter` range `pyproject.toml` declares admits the version `uv.lock` pins, admits no version of a later minor or major over a grid of them (so an exclusion such as `!=0.26.0` fails, twelve spellings pinned), refuses 0.26.0 by name, and equals the range the lock records; the requirement is read from the parsed TOML, every extra and dependency group included. | "fix: the tree-sitter range stops at the locked minor, so the parse budget can stop a parse" (a user report by email, 2026-10-07) | 7 | LOAD-BEARING | CI installs from the lock and a user installs from the range, so a guard that runs on the installed binding (`test_parse_budget_cancels.py`) says nothing about what a user gets. This reads the two files as text and compares them. Raising the cap means moving the lock in the same change; do not widen the range to make this pass. |
 | tests/test_parse_budget_python_side.py | A file's Python-side work is stopped at `JCODEMUNCH_PARSE_BUDGET_SECONDS` in the parsing thread and the file is named: the generic walker, dedicated parsers, a regex language, seven walkers on a tree that builds no symbol, and three quadratic loops that are no recursion. Over the source: every `for`/`while` in the six parse-path modules starts with a checkpoint (three named exemptions), no recursion lacks one, every module of `parser/` is classified. Also: a parser that swallows the stop builds nothing more; a parser-side stop raises at the next checkpoint; a file that ends past its deadline with no checkpoint having seen it is named; time the thread did not spend is not charged; a first index and a re-index name the same file the same way; every file is parsed on the calling thread; no clock is read outside a file or with the budget off. | LEDGER L-116 (2026-10-05): the thread wait was wall-clock, skipped one route and left its worker running | 5 | LOAD-BEARING | The clock is the test's: the deadline passes 5.5 s into a 5 s budget when the file's C parse returns, so nothing depends on a slow fixture and a far-over-only stop fails. ⚠ A new loop on the parse path fails the scan until its first statement is `parse_budget.checkpoint()`; do NOT add it to the exemption table to pass (each entry there has its reason beside it). A new module in `parser/` must be put on or off the path. The scans see statements, not a comprehension, a loop's iterable or one slow call (L-118) |
-| tests/test_parse_path_loops_are_linear.py | Three loops on the parse path are linear in the file: attributing calls to their enclosing symbol, the Razor `@code {` brace scan, and the dbt/Jinja directive loop. Each fix returns what the implementation it replaced returns (kept in the file as an oracle) on seeded generated input (since L-126 a directive's docstring is the one exception: the old loop's docstring was that defect, so the field is held to the rule, written the slow way beside the oracle), finishes a file twice as big before the oracle finishes the small one, and where `parse_budget.checkpoint()` sees the loop, passes under 2.6 times the checkpoints for twice the file. The Razor scan searches under 2.6 times the characters for twice the blocks when each opens an unclosed comment; the directive loop copies or searches under 2.6 times the characters for twice the directives; the call sweep raises under 2.6 times the line events for twice the calls. No module of `parser/` counts newlines up to an offset (`_line_numbers` is the one table), and that scan sees both spellings. Also: a call inside two symbols goes to the inner one; a brace in a string or a comment does not close a block; a macro keeps its line, its end and its `--` comment. | "fix: three loops on the parse path take time proportional to the file (LEDGER L-117)" | 5 | LOAD-BEARING | The race is against the oracle on the same machine in the same test, never against a typed number of seconds. A count of checkpoints is blind to work inside one C call (a slice, a `count`, a regex search), which is why the race is there too. The race is blind to a rescan cheaper than the old loop (a copy of the file per directive wins it), which is why the character and line-event counts are there: a new loop on these paths needs a count that can see its work, not only a race. The race is at TWICE the size, not more: coverage's C tracer (the 3.10 and 3.11 jobs) slows the fix and not the oracle, and at eight times the size the fix lost. Before changing a size, read the margins with the tracer on. The oracles are the old code and must not be edited to agree with a change. |
-| tests/test_a_macro_docstring_is_the_comment_above_it.py | A dbt macro, a Jinja template macro and a Twig macro and block each take the `{# comment #}` that ends directly above them as their docstring, through `parse_file`; the dashes of `{#- ... -#}` are not part of it; a comment elsewhere in the file, a stray `#}`, text that only ends like a comment and an unclosed comment are nobody's docstring; of two comments the nearer one is used; a `--` comment nearer than a Jinja one wins; 300 documented macros each keep their own; `PARSER_GENERATION` is at least 10. | "fix: a macro's docstring is the comment directly above it (LEDGER L-126)" | 1 | LOAD-BEARING | The lookup returned the FIRST comment of the file for any directive under a `#}`, so a one-macro fixture cannot fail on it: every case here has a first comment that is NOT the answer. The generation assertion is a floor, not an equality, so the next bump does not edit this file. |
+| tests/test_parse_path_loops_are_linear.py | Three loops on the parse path are linear in the file: attributing calls to their enclosing symbol, the Razor `@code {` brace scan, and the dbt/Jinja directive loop. Each fix returns what the implementation it replaced returns (kept in the file as an oracle) on seeded generated input (since L-126 a directive's docstring is the one exception: the old loop's docstring was that defect, so the field is held to the rule, written the slow way beside the oracle), finishes a file twice as big before the oracle finishes the small one, and where `parse_budget.checkpoint()` sees the loop, passes under 2.6 times the checkpoints for twice the file. The Razor scan searches under 2.6 times the characters for twice the blocks when each opens an unclosed comment; the directive loop copies or searches under 2.6 times the characters, and passes under 2.6 times the checkpoints, for twice the directives, over ten shapes; the call sweep raises under 2.6 times the line events for twice the calls. No module of `parser/` counts newlines up to an offset (`_line_numbers` is the one table), and that scan sees both spellings. Also: a call inside two symbols goes to the inner one; a brace in a string or a comment does not close a block; a macro keeps its line, its end and its `--` comment. | "fix: three loops on the parse path take time proportional to the file (LEDGER L-117)" | 5 | LOAD-BEARING | The race is against the oracle on the same machine in the same test, never against a typed number of seconds. A count of checkpoints is blind to work inside one C call (a slice, a `count`, a regex search), which is why the race is there too. The race is blind to a rescan cheaper than the old loop (a copy of the file per directive wins it), which is why the character and line-event counts are there: a new loop on these paths needs a count that can see its work, not only a race. The race is at TWICE the size, not more: coverage's C tracer (the 3.10 and 3.11 jobs) slows the fix and not the oracle, and at eight times the size the fix lost. Before changing a size, read the margins with the tracer on. The oracles are the old code and must not be edited to agree with a change. |
+| tests/test_a_macro_docstring_is_the_comment_above_it.py | A dbt macro, a Jinja template macro and a Twig macro and block each take the `{# comment #}` that ends directly above them as their docstring, through `parse_file`; the dashes of `{#- ... -#}` are not part of it; a comment that trails code on its line is nobody's, and one after a `--` lead is still the docstring (L-129); a `{#` inside `{{ ... }}` or `{% ... %}` opens no comment (L-130); `+` is a mark in Jinja and dbt and text in Twig, `~` the reverse (L-131); nothing inside `{% raw %}` or `{% verbatim %}` is a delimiter; a file that starts with a byte-order mark keeps its first docstring; one case pins a reading the ledger calls a loss (L-132: a stray `{{` with a later closer), so that a fix has to move it on purpose; a comment elsewhere in the file, a stray `#}`, text that only ends like a comment and an unclosed comment are nobody's docstring; of two comments the nearer one is used; a `--` comment nearer than a Jinja one wins; 300 documented macros each keep their own; `PARSER_GENERATION` is at least 11. | "fix: a macro's docstring is the comment directly above it (LEDGER L-126)" | 1 | LOAD-BEARING | The lookup returned the FIRST comment of the file for any directive under a `#}`, so a one-macro fixture cannot fail on it: every case here has a first comment that is NOT the answer. The generation assertion is a floor, not an equality, so the next bump does not edit this file. |
 | tests/test_parse_cache.py | Content-addressed parse cache is a passthrough when disabled, returns identical symbols on hit, and FIFO-evicts past `DEFAULT_MAX_ROWS`. | `c57b070 release: v1.108.40 -- content-addressed parse cache for shared-host indexing`; `444925e v1.108.41 -- bound the shared parse cache (FIFO eviction)` | 3 | LOAD-BEARING | Env-gated by `JCODEMUNCH_PARSE_CACHE`; compares `dataclasses.asdict` of symbols. |
 | tests/test_parse_warnings.py | `index_folder` reports `missing_extractors` for a language with symbols but no import extractor (Elixir), and `get_dead_code_v2` emits `framework_warning` when no entry points are found. | `b4db152 release: v1.21.19 -- Phase 5 uncertainty disclosure (T15-T18)`; docstring T17/T18 | 9 | LOAD-BEARING | Elixir is the representative gap; if an Elixir import extractor is added this fixture language must change. |
 | tests/test_parser.py | Core `parse_file` extraction for Python plus Lua, JS/TS const constants, and Astro frontmatter/components. | `ac91053 feat: add Lua language support (v1.0.1)`; `c984804 feat: extract JS/TS const declarations as constants`; `d1aa0e5 feat(parser): enhance Astro support ... regression tests` | 1 | LOAD-BEARING | Phase 1 file that accreted language cases; one `read_text` on a fixture. |
@@ -491,7 +494,7 @@ Criterion codes: 1 correctness, 2 token reduction, 3 freshness/caches/absence, 4
 | tests/test_strict_deny_requires_resolvable_target.py | The bash hook's strict deny stays silent on unexpanded shell expansions ($HOME, $B) and drive-letter paths but still denies regex-anchor searches like "foo$". | `0d951fb fix(hooks): a strict deny requires a target the hook can resolve`; docstring #541 | 6 | LOAD-BEARING | Literal `C:/Users/j/x.md` and `/c/Users/j/x.md` params (reporter's paths, inputs only). |
 | tests/test_subprocess_encoding_guard.py | Every text-mode subprocess call in src/ passes encoding=; the known-gap allowlist is empty. | `bf1a543 release: v1.108.232 - git output is decoded as UTF-8, not as cp1252` | 8 | LOAD-BEARING | AST ratchet over src/**/*.py; Windows-only cp1252 failure invisible in CI. |
 | tests/test_suggest_corrections.py | Regret signals are mined from a seeded ranking_events ledger, the no-telemetry path fabricates nothing, and suggest_corrections writes no user file. | `c472c29 release: v1.108.68 - retrieval-regret loop`; `85f3fb6 test: two guards read ambient machine state instead of declaring it` (#437 shape) | 9 | LOAD-BEARING | Patches token_tracker._state per test. |
-| tests/test_suggest_queries.py | suggest_queries errors on unindexed/empty repos and returns suggestions for an indexed one. | `94f9ed2 release: v1.21.18 — Phase 4 test infrastructure (T12/T13/T14)` | 1 | LOAD-BEARING | Empty-index test is conditional on indexer output (`if r_idx["success"]`), can pass vacuously. |
+| tests/test_suggest_queries.py | suggest_queries errors on unindexed/empty repos and returns suggestions for an indexed one. | `94f9ed2 release: v1.21.18 — Phase 4 test infrastructure (T12/T13/T14)` | 1 | LOAD-BEARING | The empty-index test indexes a comment-only `.py` (success, 1 file, 0 symbols) and asserts the error unconditionally; until 2026-10-07 it was conditional and never reached its assertion (LEDGER L-134). |
 | tests/test_summarize_from_docstrings.py | summarize_from_docstrings default-on, opt-out falls to signature fallback, per-repo override honoured (IPI defense F-04). | `aa4cb54 release: v1.108.22 — docstring opt-out`; docstring P1.5 | 8 | LOAD-BEARING | Config-gate test. |
 | tests/test_summarizer.py | Docstring extraction, provider detection (paid auto-detect opt-in), Gemini/OpenAI batch summarizers, circuit breaker, timeout and openai_extra_body (#323). | `a04df81 release: v1.108.128 — never auto-bill a paid cloud provider`; `f008def fix: OpenAI summarizer honors the circuit breaker`; #323 | 6 | LOAD-BEARING | Mocks httpx.Client; sets JCODEMUNCH_ALLOW_PAID_SUMMARIES; 900+ lines. |
 | tests/test_surface_cli.py | `jcodemunch-mcp surface` routes correctly, emits the --json receipt shape, and reflects env-selected surface/profile. | `5296846 release: v1.108.154 — surface CLI subcommand` | 4 | LOAD-BEARING | Spawns `python -m jcodemunch_mcp` subprocesses (120s timeout). |

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/docs/workflows/LEDGER.md

@@ -169,14 +169,20 @@ with jjg's reason. Keep the row. To promote a row to an issue, set Status to
 | L-118 | 2026-10-05, L-116 review round 3 | Three regex calls over a whole file are superlinear on unclosed delimiters, and a regex call cannot be stopped part-way by the parse budget (it passes no checkpoint and holds the interpreter), so the caller waits for it and the file is named afterwards. At a 0.5 s budget (`evidence/l116_one_call_shapes.txt`): a 140,000-byte EJS file of `<% x` lines held its caller 30.90 s (`_EJS_SCRIPTLET_RE.finditer`), a 149,996-byte Astro file of `<!-- x` lines 11.16 s (the comment mask's `sub`), a 150,000-byte dbt `.sql` of `{% x` lines 23.63 s (`JINJA_PATTERN.sub`). The same on 1.108.329 (30.62, 11.21, 23.76 s). With the budget off the time about quadruples per doubling of the file: EJS 0.38, 1.47 and 6.50 s at 15, 30 and 60 KB, Astro 0.13, 0.54 and 2.01 s, dbt 0.29, 1.12 and 4.20 s (the same file's GROWTH lines). 61 `for` statements in the six parse-path modules iterate a `finditer`, `findall`, `split` or `splitlines` call, 57 of them in `extractor.py` (`evidence/l116_regex_iterables.txt`); each such call runs before its loop's checkpoint. Not run: which of those patterns can backtrack; any size above 150 KB. | `src/jcodemunch_mcp/parser/extractor.py` (`_parse_ejs_symbols`, the Astro comment mask); `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`strip_jinja`) | defect | medium | OPEN |
 | L-119 | 2026-10-05, L-116 review round 2 | A Racket file with 12,500 nested parentheses (25,000 bytes) raises `RecursionError` out of `parse_file`, on 1.108.329 and after L-116 (`evidence/l116_one_call_shapes.txt`, first line of each half). The reader in `racket_reader.py` recurses per nesting level. What a user sees was not traced: whether the index names the file as a parse failure or loses it. Not run: the depth at which it starts; other recursive walkers on deeply nested input in other languages. | `src/jcodemunch_mcp/parser/racket_reader.py` | defect | low | OPEN |
 | L-120 | 2026-10-05, review of contributor PR #972 | A bare Python module name is resolved against the importer's script directory since #972 (`resolve_specifier`), and four spellings of the same dependency can still build no edge, so `find_importers` returns nothing for the target and `find_dead_code` can list it. (1) A dotted name through a directory with no `__init__.py`: `from helpers import util` beside a namespace `helpers/` (the branch is gated on a name with no dot; in a repo with no package the dotted form does resolve, through the source-root lookup). (2) A nested test directory importing a module that sits beside a `conftest.py` above it (`tests/unit/test_x.py` importing `tests/helpers.py` by bare name; pytest's rootdir insertion is not modelled). (3) A sibling that exists only as `.pyi`. (4) A real script directory kept inside a package (`pkg/tests/`, `pkg/demos/`): the follow-up commit on #972 refuses a directory with no `__init__.py` under a package at any level, because the same shape is a namespace sub-package where the edge is false (reproduced: `import openai` in `app/llms/openai/common_utils.py` resolved to an unimported `app/llms/openai/openai.py`, and `find_dead_code` then listed no dead file). The reviewer counted the branch's firings in the site-packages of this box's `C:\Program Files\Python310` (37,971 `.py`/`.pyi` files): 112 unguarded, 100 with the standard-library refusal, 47 with a refusal on the parent directory alone (round 1), 39 with the any-level refusal that shipped (round 2). Round 2 classed the 53 that the parent-only refusal drops as 39 plausible script edges and 14 names that are also an installed distribution, and the 8 more that the any-level refusal drops as one self-edge and 7 plausible script edges (`onnx/test/version_converter`, `pythonwin/pywin/Demos/app` and `ocx`). The standard-library refusal reads the SERVER's interpreter, so `distutils` is refused on 3.10 and not on 3.12. Also unmodelled: `-m` from the root, `PYTHONPATH`, and a standard-library name a script directory really does shadow. Not run: any corpus but that site-packages tree and this repo (58 new edges, all kept by both refusals). The counts are the review's probe output, not a file under `evidence/`. | `src/jcodemunch_mcp/parser/imports.py` (`resolve_specifier`) | gap | low | OPEN |
-| L-121 | 2026-10-06, review of the #522 fix | The semantic top-up in `search_symbols` embeds every symbol that has no vector with the CURRENT model and writes it, and compares no stored model first; #500's model-change check lives only in `embed_repo`, the other of the two vector writers. After a model change, one semantic `search_symbols` on a repo with a new symbol leaves vectors of two widths in the store, on the incremental path and after a full re-index alike. Reviewer's probe (mocked provider, not an evidence file): embed with model A at width 8, add a file, re-index, semantic search under model B at width 4, then the store held one width-4 vector beside three width-8 ones. Before #522's fix a full re-index made it worse: the top-up found no stored dimension and stamped the store with model B, after which `embed_repo` answered `cached: True` over the mixed store. With the fix the stored model stays A and the next `embed_repo` rebuilds. `EmbeddingMatrix` takes its width from the first row and drops rows that differ, so the matrix keeps the three OLD vectors and drops the new one, and a query embedded with model B scores against none of them (round 2's probe: `dim=8`, three ids, `skipped=1`, `score_all` of a width-4 query empty): until the next `embed_repo` no symbol gets a similarity score. The dropped symbol also reads as missing on every semantic search, so each search calls the provider for it again (one batch of 1 on the first search and on the second). Not read: per-result scores in the response. Not run: a real provider; the fusion exit. | `src/jcodemunch_mcp/tools/search_symbols.py` (the top-up near `emb_store.set_many`) | defect | medium | OPEN |
+| L-121 | 2026-10-06, review of the #522 fix | The semantic top-up in `search_symbols` embeds every symbol that has no vector with the CURRENT model and writes it, and compares no stored model first; #500's model-change check lives only in `embed_repo`, the other of the two vector writers. After a model change, one semantic `search_symbols` on a repo with a new symbol leaves vectors of two widths in the store, on the incremental path and after a full re-index alike. Reviewer's probe (mocked provider, not an evidence file): embed with model A at width 8, add a file, re-index, semantic search under model B at width 4, then the store held one width-4 vector beside three width-8 ones. Before #522's fix a full re-index made it worse: the top-up found no stored dimension and stamped the store with model B, after which `embed_repo` answered `cached: True` over the mixed store. With the fix the stored model stays A and the next `embed_repo` rebuilds. `EmbeddingMatrix` takes its width from the first row and drops rows that differ, so the matrix keeps the three OLD vectors and drops the new one, and a query embedded with model B scores against none of them (round 2's probe: `dim=8`, three ids, `skipped=1`, `score_all` of a width-4 query empty): until the next `embed_repo` no symbol gets a similarity score. The dropped symbol also reads as missing on every semantic search, so each search calls the provider for it again (one batch of 1 on the first search and on the second). Not read: per-result scores in the response. Not run: a real provider; the fusion exit. | `src/jcodemunch_mcp/tools/search_symbols.py` (the top-up near `emb_store.set_many`) | defect | medium | FIXED 2026-10-08 (`fix/L-121-semantic-topup-checks-the-stored-model`). The rule moved to `stale_reason` in `storage/embedding_store.py` and both writers ask it; on a reason the search writes nothing, calls the provider for nothing, scores no similarity and returns `semantic_store_mismatch` in the body. It does not rebuild; `embed_repo` does. `evidence/l121_before_after.txt` (mocked provider): on `origin/main` one search under model B left `{4: 1, 8: 5}` and two provider calls per search; on the branch `{8: 5}` and none. `tests/test_semantic_topup_checks_the_stored_model.py` scans `src/` for a `set_many` caller that does not ask; the scan matches a call spelled `set_many`, so a writer that aliases the method passes it. Found by the review and fixed with it: `EmbeddingStore.clear()` kept the dimension, model and task type rows, so a rebuild whose every batch failed left an empty store named for the old model and the retry wrote the new model's vectors under that name; `clear()` removes the rows now, and a writer that finds rows beside no vectors removes them with `drop_orphan_stamp`, one statement that cannot delete a vector. `embed_repo` reads the store once, over its read-write connection, for the rebuild and for what it reports; the search reads again at its write, on a connection of its own, so a rebuild by another client between that reading and the write is still not seen (review round 7, read from the source). The scan for `clear()` callers matches the variable name `emb_store`. Residue: L-135, L-136, L-137. |
 | L-122 | 2026-10-06, review of the #522 fix | `embed_repo` without `force` embeds only symbols that have no vector, keyed by symbol id, so a symbol whose body changed keeps the vector of its old body and a symbol that no longer exists keeps its row: no caller of `EmbeddingStore.delete_many` exists in `src/`. This was already so after an incremental re-index. After a full re-index it was hidden until #522's fix, because the full save erased the `embed_task_type` row and the `task_type` gate (#523) then re-embedded everything. Reviewer's probe (mocked provider): add one file, delete one, rewrite one body, full re-index, `embed_repo` with the same model: 5 symbols embedded and no orphan before the fix, 1 embedded, one orphan row and one stale vector after it, the same as the incremental path gives on both trees. `force=true` rebuilds. Not run: how similarity ranking moves with stale vectors on a real corpus. | `src/jcodemunch_mcp/tools/embed_repo.py`; `src/jcodemunch_mcp/storage/embedding_store.py` | defect | low | OPEN |
 | L-123 | 2026-10-06, CI on PR #980 | `tests/test_v1_108_225.py::TestCachedFreshnessIsRevalidated::test_a_revalidated_hit_does_not_corrupt_later_hits` failed once on `full: test (windows-latest, 3.11)` (run 37464102292, 1 failed of 14812, `a revalidated hit must be reproducible, not a one-shot correction`) and passed when that job was re-run with no change. The other seven matrix jobs of the same run passed, and the test passed in all five local full-tier runs of that branch that day. PR #980 changes which `meta` rows a full save deletes and touches nothing the test exercises (a commit, then two cached `search_symbols` reads of row freshness). The job log shows `assert 'fresh' != 'fresh'` under the failure: the assertion is `first_hit == second_hit != "fresh"`, so the two cached reads AGREED and both said `fresh` after the commit. The hits were reproducible; what failed is that neither read saw the commit, which points at freshness detection after `_commit_edit` (the index's stored HEAD against git's, or a cached HEAD read) and away from the cache write-through the test is named for. Cause not established beyond that. Not run: the test in a loop on a Windows runner. | `tests/test_v1_108_225.py` | flake | low | OPEN |
 | L-124 | 2026-10-06, L-115 fix | In a Vue or Svelte `<script>`, the docstring taken from a `/* block comment */` above a declaration keeps the closing delimiter: `/* block comment */` is served as `block comment */`. `_preceding_comment` strips leading `/` and `*` and never the trailing `*/`. Pinned as it is by `tests/test_vue_svelte_comment_lookup_is_linear.py` so that L-115's fix moved no docstring. A fix changes stored docstrings on unchanged files and needs a `PARSER_GENERATION` bump. The review ran three more: a JSDoc block keeps its inner ` * ` lines and the closing `*/`; `/**/` and `/***/` give the docstring `/`. All the same on 1.108.330. Not run: the same lookup in Astro. | `src/jcodemunch_mcp/parser/extractor.py` (`_preceding_comment` in `_parse_vue_symbols` and `_parse_svelte_symbols`) | defect | low | OPEN |
 | L-125 | 2026-10-06, CI on PR #984 | `tests/test_parse_budget_cancels.py::test_a_first_index_leaves_no_thread_behind` failed once on `full: test (windows-latest, 3.13)` (run 37517459287) and passed when that job was re-run with no change. PR #984 changes one package block of `uv.lock` and no code. The failing assertion is `result.get("symbol_count", 0) >= 2`, and the count read 1. The test indexes two files under a short real-time parse budget, one of them large, so a slow runner that spends the budget on the large file leaves one symbol: that reading fits the count and is not confirmed from the log. Second timing-sensitive test to fail once on a Windows runner that day (L-123 is the first). Not run: the test in a loop on a Windows runner. Second occurrence, 2026-10-07, PR #985: `full: test (ubuntu-latest, 3.10)` (run 37623527802), the same assertion (`assert (True is True and 1 >= 2)`, 1 failed of 14832), passed when that job was re-run with no change; the other seven matrix jobs passed. So it is not a Windows-runner effect. | `tests/test_parse_budget_cancels.py` | flake | low | OPEN |
 | L-126 | 2026-10-06, L-117 fix | A dbt macro (or a Jinja `macro`/`block`) that follows a `{# comment #}` is given the FIRST `{# ... #}` of the file as its docstring, whichever comment it follows. The lookup searches the text before the directive from the start of the file and takes the first match; it checks only that the text ends with `#}`. `evidence/l126_first_comment.txt` on `main`: `{# about first #}` above `first`, `{# about second #}` above `second` gives `second` the docstring `about first`. A macro under `--` lines is right. The L-117 fix keeps this as it was, so it moves no symbol field; fixing it changes docstrings on unchanged files and owes a `PARSER_GENERATION` bump. Not run: how many macros in a real dbt project sit under a second or later Jinja comment. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments`) | defect | high | FIXED 2026-10-07 (`fix/l126-macro-docstring-comment`). `_PrecedingComments` lists the file's comments once, left to right, and a directive takes the one that ENDS where the text before it ends; a `#}` that closes no comment falls through to the `--` lines. `evidence/l126_before_after.txt`, `parse_file`, `main` then the fix: `second` read `about first` and reads `about second`; a `.j2` `button` read `renders a field` and reads `renders a button`. `PARSER_GENERATION` 10: the docstring moves on unchanged content. Guard: `tests/test_a_macro_docstring_is_the_comment_above_it.py`; the L-117 oracle test holds every field but the docstring to the old loop and the docstring to the rule. Review round 1: the dashes of `{#- ... -#}` were served as part of the docstring (`- about m -`, the same on `main` for a file's first comment); they are dropped, in the same generation, with Jinja's `+` and Twig's `~` (review round 2), one mark per side. What the rule still gets wrong: L-129, L-130, L-131. Not run: a dbt or Jinja corpus. |
 | L-127 | 2026-10-06, L-117 fix | Three shapes on the paths L-117 fixed are still superlinear; each time about quadruples when the file doubles, the same on `main` and after the fix (`evidence/l117_before_after.txt`, the residue lines, budget off). (1) Razor `@code {` blocks nested in each other: every block's body is parsed as C#, and an outer body holds the inner ones, so 150 nested blocks took 0.458 s and 300 took 1.846 s. Not valid Razor; a real file has one or two blocks. (2) The directive regex (`_directive_pattern`) on an unclosed `{% macro m(`: each one reads on for its `)`, so 2000 such lines took 0.681 s and 4000 took 2.577 s. One regex call, so the budget cannot stop it part-way: the L-118 class, and not in L-118's list. (3) A directive on a `--` line takes every `--` line above it as its docstring, so N macros each on its own `--` line produce docstrings that total N * N: 500 took 0.124 s and 1000 took 0.432 s. The output is that size by its own definition. | `src/jcodemunch_mcp/parser/extractor.py` (`_parse_razor_symbols`); `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_directive_pattern`, `_PrecedingComments.before`) | defect | low | OPEN |
-| L-128 | 2026-10-07, L-117 review round 3 | The count instruments of `tests/test_parse_path_loops_are_linear.py` wrap the spellings the old loops used and nothing else, so a per-item rescan in another spelling passes all 35 tests. The reviewer put five back into a copy of the fix and each stayed green: `text.rfind(...)`, `x in text`, `text.partition(...)` and a slice of the undecoded bytes per directive, and `list(callable_syms)` per call (one line event, however long the list). None of the five has been in the tree. A list membership test per call is seen by the wall-clock race alone. The durable form is a counted `str` that fails on any method it does not list. Also `monkeypatch.undo()` inside the two counting helpers undoes the autouse `_every_language_enabled` patch for the rest of that test; no caller parses a file after a helper today. | `tests/test_parse_path_loops_are_linear.py` (`_characters_read_by_the_directive_loop`, `_line_events`, `_characters_searched`) | test | low | OPEN |
-| L-129 | 2026-10-07, L-126 review round 1 | A Jinja comment that trails code on its own line is taken as the docstring of the directive on the NEXT line: `{% macro a() %}x{% endmacro %} {# end of a #}` then `{% macro b() %}` gives `b` the docstring `end of a`. The `--` branch requires a comment line to start with `--`; the Jinja branch asks only that the comment END where the text before the directive ends. The same on `main` when that comment is the file's first. `tests/test_a_macro_docstring_is_the_comment_above_it.py` pins the same-line reading (`{# a #} x {# b #}` gives `b`), so a fix inverts that case. ⚠ A fix moves stored docstrings on unchanged content and owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments.before`) | defect | low | OPEN |
-| L-130 | 2026-10-07, L-126 review round 1 | The comment table of `_PrecedingComments` reads `{#` wherever it stands, an expression or a string included: `{% macro first() %}{{ '{#' }}{% endmacro %}`, then `{# about second #}`, then `{% macro second() %}` gives `second` the docstring `' }}{% endmacro %}` + newline + `{# about second` (code in a docstring). `main` gave `about first`: wrong before, wrong differently now. Jinja's own lexer reads `{{ ... }}`, `{% ... %}` and `{# ... #}` left to right, so a `{#` inside an expression opens no comment; `JINJA_PATTERN` in the same module already lexes that way. ⚠ A fix owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments.__init__`) | defect | low | OPEN |
-| L-131 | 2026-10-07, L-126 review round 3 | The whitespace-control marks dropped from a Jinja comment's ends are the same three for every dialect (`-`, `+`, `~`), and `~` is a mark in Twig only, `+` in Jinja only. A comment whose text starts or ends flush against the delimiter with the other dialect's mark loses that character: in a `.sql`, `{#~approx 5 rows#}` reads `approx 5 rows`; a Twig `{#+1 to the offset #}` reads `1 to the offset`. One punctuation character, and only with no space beside the delimiter (`{# ~approx #}` is untouched). The exact form passes the dialect's marks in beside `directive_keywords`. ⚠ A fix owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_WHITESPACE_CONTROL_MARKS`, `_PrecedingComments.before`) | defect | low | OPEN |
+| L-128 | 2026-10-07, L-117 review round 3 | The count instruments of `tests/test_parse_path_loops_are_linear.py` wrap the spellings the old loops used and nothing else, so a per-item rescan in another spelling passes all 35 tests. The reviewer put five back into a copy of the fix and each stayed green: `text.rfind(...)`, `x in text`, `text.partition(...)` and a slice of the undecoded bytes per directive, and `list(callable_syms)` per call (one line event, however long the list). None of the five has been in the tree. A list membership test per call is seen by the wall-clock race alone. The durable form is a counted `str` that fails on any method it does not list. Also `monkeypatch.undo()` inside the two counting helpers undoes the autouse `_every_language_enabled` patch for the rest of that test; no caller parses a file after a helper today. The same holds for the walk L-129 added (`_is_first_on_its_line`): its review put back `text.rfind(...)` with `set(self._line_starts)` per step, and `dict(self._comment_body_start).get(pos)` per step, and all tests stayed green. Round 2 of that review: dropping the cache write in `_first_text_of` passes too; no shape has long leading whitespace before a chain of comments on one line. | `tests/test_parse_path_loops_are_linear.py` (`_characters_read_by_the_directive_loop`, `_line_events`, `_characters_searched`) | test | low | OPEN |
+| L-129 | 2026-10-07, L-126 review round 1 | A Jinja comment that trails code on its own line is taken as the docstring of the directive on the NEXT line: `{% macro a() %}x{% endmacro %} {# end of a #}` then `{% macro b() %}` gives `b` the docstring `end of a`. The `--` branch requires a comment line to start with `--`; the Jinja branch asks only that the comment END where the text before the directive ends. The same on `main` when that comment is the file's first. `tests/test_a_macro_docstring_is_the_comment_above_it.py` pins the same-line reading (`{# a #} x {# b #}` gives `b`), so a fix inverts that case. ⚠ A fix moves stored docstrings on unchanged content and owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments.before`) | defect | low | FIXED 2026-10-07 (`fix/l129-l131-macro-docstring-residue`). The comment must be first on its line, with only other comments before it there (`_PrecedingComments._is_first_on_its_line`). `evidence/l129_l131_before_after.txt`: `b` read `end of a` and reads nothing. The pinned `{# a #} x {# b #}` case is inverted. Review round 1: a byte-order mark or a zero-width space before the comment is not text (a file starting with a BOM lost its first docstring in the first form of this fix). `PARSER_GENERATION` 11, shared with L-130 and L-131. |
+| L-130 | 2026-10-07, L-126 review round 1 | The comment table of `_PrecedingComments` reads `{#` wherever it stands, an expression or a string included: `{% macro first() %}{{ '{#' }}{% endmacro %}`, then `{# about second #}`, then `{% macro second() %}` gives `second` the docstring `' }}{% endmacro %}` + newline + `{# about second` (code in a docstring). `main` gave `about first`: wrong before, wrong differently now. Jinja's own lexer reads `{{ ... }}`, `{% ... %}` and `{# ... #}` left to right, so a `{#` inside an expression opens no comment; `JINJA_PATTERN` in the same module already lexes that way. ⚠ A fix owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments.__init__`) | defect | low | FIXED 2026-10-07 (`fix/l129-l131-macro-docstring-residue`). The comment table reads `{{`, `{%` and `{#` left to right, each to its first closer; a kind with no closer left is text from there on. `evidence/l129_l131_before_after.txt`: `second` reads `about second`. Nothing inside `{% raw %}` or `{% verbatim %}` is a delimiter (review round 1: the first form of this fix lost the docstring below a raw block holding a `{{`). What the lexer reads worse than 1.108.332 did: L-132. `PARSER_GENERATION` 11. |
+| L-131 | 2026-10-07, L-126 review round 3 | The whitespace-control marks dropped from a Jinja comment's ends are the same three for every dialect (`-`, `+`, `~`), and `~` is a mark in Twig only, `+` in Jinja only. A comment whose text starts or ends flush against the delimiter with the other dialect's mark loses that character: in a `.sql`, `{#~approx 5 rows#}` reads `approx 5 rows`; a Twig `{#+1 to the offset #}` reads `1 to the offset`. One punctuation character, and only with no space beside the delimiter (`{# ~approx #}` is untouched). The exact form passes the dialect's marks in beside `directive_keywords`. ⚠ A fix owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_WHITESPACE_CONTROL_MARKS`, `_PrecedingComments.before`) | defect | low | FIXED 2026-10-07 (`fix/l129-l131-macro-docstring-residue`). `extract_dbt_directives` takes `whitespace_marks` (`JINJA_WHITESPACE_MARKS` by default, `TWIG_WHITESPACE_MARKS` from `template_shared` for Twig). `evidence/l129_l131_before_after.txt`: `{#~approx 5 rows#}` in a `.sql` reads `~approx 5 rows`; `{#+1 to the offset #}` in a `.twig` reads `+1 to the offset`. `PARSER_GENERATION` 11. |
+| L-132 | 2026-10-07, L-129/L-130/L-131 review round 1 | Two inputs read worse after L-130's lexer than on 1.108.332 (`evidence/l129_l131_before_after.txt`, the L-132 line; the second from the review's probe). (1) A stray `{{` or `{%` outside a raw block that has a later closer of its kind is read as one expression up to that closer, so every comment between is not a comment: `-- wrap in {{ to call`, then `{# doc #}`, then `{% macro m() %}`, with a `{{ x }}` further down, gave `m` the docstring `doc` and gives it nothing. Jinja refuses such a file, so a rendered dbt project cannot hold one; a `.sql` that is never rendered can. `test_a_stray_opener_with_a_later_closer_is_one_expression_to_that_closer` pins the reading. (2) A closer inside a string in an expression still ends the expression there, and the leftover can pair with a later closer: `{{ '}} {%' }}` above a documented macro costs it its docstring. Reading strings inside an expression needs a state-shared scan to stay linear (the L-117 Razor problem). A third the review found, a comment after a `--` lead (`-- note {# doc #}`), was fixed in the same change: a `--` lead is a comment, so `doc` is still the docstring. Review round 2 added two readings that are odd and not worse than 1.108.332: a `--` that starts a continuation line INSIDE a comment trailing code counts as a `--` lead (`x {# a`, newline, `-- still a #} {# b #}` gives `b`, where the same without the `--` gives nothing); and a line holding only a zero-width space is a blank line to the `--` branch, so `-- a`, that line, `-- b` reads both lines where 1.108.332 read `b`. ⚠ A fix moves stored docstrings and owes its own `PARSER_GENERATION` bump. | `src/jcodemunch_mcp/parser/sql_preprocessor.py` (`_PrecedingComments.__init__`, `before`) | defect | low | OPEN |
+| L-133 | 2026-10-07, a user report by email (Dave) | tree-sitter 0.26 is not supported: it removed `Parser.timeout_micros`, the one mechanism the parse budget has for stopping a C parse, so the dependency is capped at `<0.26` (`evidence/tree_sitter_026.txt`: a 0.5 s budget stopped a 405,035-byte file after 0.54 s on 0.25.2 and after 7.06 s on 0.26.0). To probe 0.26 again: the capped range no longer resolves it, so resolve this project's requirements, set the `tree-sitter` line to the version wanted, and run with `uv run --no-project --with-requirements` and `PYTHONPATH=src` (the evidence file's header). The replacement is `parse(progress_callback=)`; on 0.25.2 it was ignored for a bytestring and killed the interpreter with an access violation with a read callback, on all eight variants probed (`parser/parse_budget.py` module docstring). Probed on 0.26.0, 2026-10-08 (`evidence/progress_callback_026.txt`, Windows): on Python 3.12.4 the callback is ignored for a bytestring (the binding warns) and the interpreter dies with an access violation the first time it is due with a read callback; a file too small to reach the first call parses. The cause is in the binding, not here: `parser_progress_callback` (`tree_sitter/binding/parser.c`, the same in 0.25.2 and 0.26.0) builds the call's arguments with the format `"Ip"`, `Py_BuildValue` accepts `p` only from Python 3.14, so on 3.10 to 3.13 the call returns NULL and the next line passes it to `PyObject_IsTrue`. On Python 3.14.6 the same probe stops the 405,035-byte file after 0.57 s with `ValueError: Parsing failed`, and the stopped parser must be `reset()` before reuse (the next parse returned the old source's tree). Upstream fix: tree-sitter/py-tree-sitter PR 503 ("make progress_callback work on Python < 3.14"), open and unreleased on 2026-10-08; 0.26.0 is the newest release. So no released binding can stop a 0.26 parse on any Python this project supports, and the cap stays. TO CLOSE, once a release carries that fix: a read-callback path in `_BudgetedParser.parse` for a binding without `timeout_micros` (source fed in slices, the callback returning true past the deadline, `reset()` after a stop), the lock moved to that release so `test_the_installed_tree_sitter_can_cancel_a_parse` runs on it, then the range. Not measured: what parsing through a read callback costs against a bytestring. Until then a host that needs tree-sitter 0.26 for another package cannot install both. | `src/jcodemunch_mcp/parser/parse_budget.py` (`bind`, `_BudgetedParser`); `pyproject.toml` | enhancement | medium | OPEN |
+| L-134 | 2026-10-07, a user report by email (Dave), second finding | `tests/test_suggest_queries.py:28` reads `symbols_indexed` off `index_folder`'s result with a default of 0. No run returns that key (the indexer answers `symbol_count`), so the condition is true for any successful run and the `empty index` branch does not depend on the count it names. The branch is also not reached today: the fixture holds only a `README.md`, so the indexer refuses with `No source files found`. Found while fixing the same key in `cli/init.py`. To close: a fixture the indexer accepts with no symbol in it, and `symbol_count`. | `tests/test_suggest_queries.py` (`test_empty_index_returns_error`) | test | low | FIXED 2026-10-07 (`fix/L-134-suggest-queries-empty-index-test`). The fixture is a comment-only `.py`, which the indexer accepts with 1 file and 0 symbols; the test asserts that, then that `suggest_queries` answers its empty-index error, with no `if`. With the tool's empty-index check removed the old test passed and the new one fails (`evidence/old_test_is_vacuous.txt`, `evidence/red.txt`). The product was correct throughout. |
+| L-135 | 2026-10-08, the L-121 fix | The fusion exit of `search_symbols` (`fusion=true`) embeds the query with the ACTIVE model and scores it against the stored matrix without asking what built the stored vectors: it calls `get_matrix` and `score_all` and never `stale_reason`. When the stored model differs and the widths differ, `score_all` answers `{}` and the similarity channel is empty with `similarity_used` true. When the widths agree the channel ranks by vectors of two models. The semantic exit refuses this case since L-121. Read from the source, not run: no probe, no evidence file. The exit writes no vector. | `src/jcodemunch_mcp/tools/search_symbols.py` (`_search_symbols_fusion`, the similarity channel) | defect | low | OPEN |
+| L-136 | 2026-10-08, the L-121 fix | `embed_repo` without `force`, on a store whose model name is unknown (a store from before #500, or one embedded with an empty model name), seeds `dim` from the stored dimension and writes the new vectors with `set_many` whatever their width, so a model of another width leaves two widths in the store. `stale_reason` answers None there by design (unknown is not a change). The semantic exit compares the width of its query vector with the width of the stored vectors since L-121 and writes nothing on a difference; `embed_repo` has no such check. Run by the L-121 review (round 4, a scratchpad probe, not an evidence file): stored model absent, width 8, one new symbol, `embed_repo` at width 4 left `{8: 5, 4: 1}` on `origin/main` and on the branch. `force=true` rebuilds. | `src/jcodemunch_mcp/tools/embed_repo.py` (the batch loop) | defect | low | OPEN |
+| L-137 | 2026-10-08, the L-121 review (round 4) | `storage/generation.py` `readonly_uri` builds `file:{path}?mode=ro` without quoting the path, so under a storage path that holds `#` or `%` the read-only open fails or opens another file, and every reader built on `connect_readonly` answers as if nothing were stored. Reviewer's probe (a scratchpad script, not an evidence file), over a store holding 6 vectors: `has_any()` answered False in a directory named `c#proj` and None in one named `a%20b`, and `iter_raw()` was empty in both. `has_any()` documents False as nothing embedded, so the first is a false absence. The same on `origin/main`. With `#` the open does not fail: the query string falls into the URI fragment, SQLite opens the path up to the `#` and creates an empty file there (`c` beside `c#proj`), and the read fails on a missing table (review round 5's probe). `embed_repo` reads what is recorded over its read-write connection since L-121 and is not affected in that reading; The semantic exit of `search_symbols` loads its matrix through `iter_raw`, so under such a path it finds no stored vector and embeds every symbol on each search (review round 6's probe, `c#proj`, six symbols: provider calls `[1, 6]` per search). On `origin/main` that search then overwrote all six vectors with the active model's under the old stamp when the widths agreed; since L-121 it reads the stamp again at the write and writes nothing, after paying for the calls. Not run: which other tools read through `connect_readonly` under such a path; a path with `?`. | `src/jcodemunch_mcp/storage/generation.py` (`readonly_uri`) | defect | medium | OPEN |

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jcodemunch-mcp"
-version = "1.108.332"
+version = "1.108.334"
 description = "Token-efficient MCP server for source code exploration via tree-sitter AST parsing"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -64,7 +64,13 @@ dependencies = [
     # The F# wheel's grammar is ABI 15, which a tree-sitter runtime older than
     # 0.25 cannot load: `Language()` raises and F# indexes as empty. The pack
     # carried that floor only transitively, and its own spec does not promise it.
-    "tree-sitter>=0.25",
+    # CAPPED at the locked minor: the per-file parse budget stops a slow parse
+    # through `Parser.timeout_micros`, and tree-sitter 0.26.0 removed it. With
+    # no cap an install resolved 0.26.0 and lost the stop, while CI, locked to
+    # 0.25.2, saw nothing. Raise the cap only together with `uv.lock`, so
+    # `tests/test_parse_budget_cancels.py` runs on the new version first
+    # (`tests/test_tree_sitter_range_is_the_tested_range.py`).
+    "tree-sitter>=0.25,<0.26",
     "pathspec>=0.12.0",
     "pyyaml>=6.0",
 ]

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/server.json

@@ -3,12 +3,12 @@
   "name": "io.github.jgravelle/jcodemunch-mcp",
   "title": "jCodemunch MCP",
   "description": "Token-efficient code exploration via tree-sitter AST parsing. 70+ languages, 86-99% token savings.",
-  "version": "1.108.332",
+  "version": "1.108.334",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "jcodemunch-mcp",
-      "version": "1.108.332",
+      "version": "1.108.334",
       "transport": {
         "type": "stdio"
       }

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/src/jcodemunch_mcp/cli/init.py

@@ -1134,14 +1134,45 @@ def run_index(*, dry_run: bool = False) -> str:
 
     try:
         from ..tools.index_folder import index_folder
-        result = index_folder(path=cwd)
-        files = result.get("files_indexed", "?")
-        symbols = result.get("symbols_indexed", "?")
-        return f"  indexed {cwd} ({files} files, {symbols} symbols)"
+        return _index_summary(cwd, index_folder(path=cwd))
     except Exception as e:
         return f"  indexing failed: {e}"
 
 
+def _index_summary(cwd: str, result: dict) -> str:
+    """One line for what `index_folder` answered. It answers in four shapes:
+    a refusal (`success` false, `error`), a full index (`file_count`), a run
+    that re-indexed some files (`changed`/`new`/`deleted`, `symbol_count`) and
+    a run that found nothing changed (the three counts at 0, no symbol count).
+    A count the result does not carry is left out, never printed as `?`.
+    Any successful shape can also say the file cap cut the walk short
+    (`truncated`); the line then says how many files the index holds."""
+    if not result.get("success"):
+        return f"  indexing failed: {result.get('error') or 'the indexer gave no reason'}"
+    parts = []
+    unchanged = False
+    if "file_count" in result:
+        parts.append(f"{result['file_count']} files")
+    elif "changed" in result:
+        touched = [result.get(key, 0) for key in ("changed", "new", "deleted")]
+        unchanged = not any(touched)
+        parts.append(
+            "nothing changed since the last index" if unchanged
+            else "{} changed, {} new, {} deleted".format(*touched)
+        )
+    if result.get("symbol_count") is not None:
+        parts.append(f"{result['symbol_count']} symbols")
+    detail = ", ".join(parts)
+    if result.get("truncated"):
+        capped = "the file cap was reached, {} of {} files are in the index".format(
+            result.get("files_indexed", "some"), result.get("files_discovered", "the")
+        )
+        detail = f"{detail}; {capped}" if detail else capped
+    if unchanged:
+        return f"  {cwd} is up to date ({detail})"
+    return f"  indexed {cwd} ({detail})" if detail else f"  indexed {cwd}"
+
+
 # ---------------------------------------------------------------------------
 # Audit agent config
 # ---------------------------------------------------------------------------

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/src/jcodemunch_mcp/encoding/schemas/search_symbols.py

@@ -28,7 +28,9 @@ _META_JSON = ("verdict", "exact_match")
 # on the shipped default), and an undeclared dict is dropped by the encoder.
 # semantic_channel_error (L-108): why the fusion exit's similarity channel did not
 # run, e.g. a refused local model. A BODY dict for the same reason.
-_JSON_BLOBS = ("semantic_topup", "semantic_channel_error")
+# semantic_store_mismatch (L-121): the stored vectors were built by another
+# model, so the semantic exit wrote and scored nothing. A BODY dict likewise.
+_JSON_BLOBS = ("semantic_topup", "semantic_channel_error", "semantic_store_mismatch")
 
 
 def encode(tool: str, response: dict) -> tuple[str, str]:

{jcodemunch_mcp-1.108.332 → jcodemunch_mcp-1.108.334}/src/jcodemunch_mcp/parser/parse_budget.py

@@ -16,9 +16,13 @@ is left of the deadline as its own timeout, and the C parser stops itself.
 in favour of `parse(progress_callback=)`. The callback is not usable: it is
 ignored for a bytestring, and with a read callback it killed the interpreter
 with an access violation on all eight variants probed (tree-sitter 0.25.2,
-Python 3.12.4, Windows). A binding without the attribute leaves only the thread
-wait; `bind()` says so once in the log and
-`tests/test_parse_budget_cancels.py` fails on it.
+Python 3.12.4, Windows). A binding without the attribute cannot stop the C
+parse: the file is named only when the parse returns and the next checkpoint
+fires. `bind()` says so once in the log and
+`tests/test_parse_budget_cancels.py` fails on it. ⚠⚠ tree-sitter 0.26.0 IS
+such a binding, and that test runs on the LOCKED version only, so the
+dependency range is capped at the locked minor (`pyproject.toml`,
+`tests/test_tree_sitter_range_is_the_tested_range.py`).
 
 ⚠ Many dedicated parsers catch `Exception` around their parse and return `[]`
 (a grammar that failed to load is "indexed for text search only"). A cancel
@@ -298,7 +302,8 @@ def bind(parser):
             _warned_no_timeout = True
             logger.warning(
                 "the installed tree-sitter has no Parser.timeout_micros; "
-                "JCODEMUNCH_PARSE_BUDGET_SECONDS cannot stop a slow parse on it"
+                "JCODEMUNCH_PARSE_BUDGET_SECONDS cannot stop a slow parse on it. "
+                'tree-sitter 0.26 removed it: upgrade jcodemunch-mcp, or install "tree-sitter>=0.25,<0.26"'
             )
         return parser
     return _BudgetedParser(parser, scope)