release: v1.108.130 — correct receipt price table to current Opus pricing (+ Fable 5)

Author: jgravelle

CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to jcodemunch-mcp are documented here.
 
+## [1.108.130] - 2026-07-16 - receipt price table corrected to current Opus pricing (+ Fable 5)
+
+The `receipt` CLI's model price table carried a stale Opus input rate of
+$15/MTok (the retired Opus 4.0/4.1 price). Current Opus (4.8/4.7/4.6) is
+$5/MTok, so `receipt --model opus` overstated dollar savings roughly 3x.
+
+### Fixed
+- `cli/receipt.py`: `_MODEL_PRICES_USD_PER_MTOK` corrected to the live rates
+  (Opus $5, Sonnet $3, Haiku $1). Comment now cites the dated source
+  (anthropic.com/pricing, 2026-06-24).
+- `tests/test_receipt.py`: the two assertions that pinned the stale rates
+  ($15 Opus, $0.80 Haiku) updated to the correct values.
+
+### Added
+- Claude Fable 5 ($10/MTok) as a selectable `--model` value and an
+  alternate-model comparison line (both derive from the price table, so they
+  pick it up automatically).
+- A dated-source rate pin over the whole table in `tests/test_receipt.py`, so a
+  future price drift fails loudly instead of silently misreporting.
+
+Present-value note: `receipt` is a per-call estimator ("what this session would
+cost at current prices"). It does not feed the public token-savings counter,
+which stores tokens (not dollars) and values them at display time. jcm's own
+`storage/token_tracker.PRICING` was already correct at $5; `receipt` was the
+sole stale spot. No INDEX_VERSION bump, no tool-count change, no wire-shape
+change.
+
 ## [1.108.129] - 2026-07-14 - Keystone-protected structural compression for get_ranked_context
 
 `get_ranked_context` gains an opt-in `compress=True` that fits **more** relevant

CLAUDE.md

@@ -1,6 +1,7 @@
 # jcodemunch-mcp — Project Brief
 
 ## Current State
+- **Version:** 1.108.130 — **`receipt` CLI price table corrected to current Opus pricing (+ Fable 5).** The `receipt` model price table (`cli/receipt.py` `_MODEL_PRICES_USD_PER_MTOK`) carried a stale $15/MTok Opus rate (the retired 4.0/4.1 price); current Opus 4.8/4.7/4.6 is $5/MTok, so `receipt --model opus` overstated dollar savings ~3x. Corrected to Opus $5 / Sonnet $3 / Haiku $1, added **Claude Fable 5 ($10)** as a selectable model + alternate comparison line (both derive from the table, auto-picked-up), and dated the source comment (anthropic.com/pricing 2026-06-24). `tests/test_receipt.py`: the two stale-rate assertions ($15 Opus, $0.80 Haiku) fixed + hardened into a dated-source pin over the whole table (future drift fails loudly) + a Fable test. **Present-value only: a per-call "what this session costs at current prices" estimator; does NOT feed the public token-savings counter, which stores tokens and values them at display time.** jcm's own `storage/token_tracker.PRICING` was already correct at $5 — `receipt` was the sole stale spot. Sibling parity: jdoc v1.97.0 / jdata v1.19.0 fix the same stale $15 in their `token_tracker.PRICING`, which DID feed live per-response `_meta.cost_avoided` (overstating every jdoc/jdata response's Opus figure 3x). NO INDEX_VERSION / tool-count / wire change.
 - **Version:** 1.108.129 — **Keystone-protected structural compression for `get_ranked_context` (opt-in `compress=True`; clean-room F-15, competitor unnamed in shipped artifacts).** Renovates an entropy/relevance-guided context-selection idea into jcm's read-only/local/model-free idiom: an oversized symbol body is pruned toward a per-item soft cap so MORE relevant symbols fit the same `token_budget`. New `retrieval/entropy_prune.py` — `prune_source(source, max_tokens, count_tokens)` ranks lines by `line_signal` (normalized Shannon token-entropy × length-weight), keeps the highest-signal lines, and ALWAYS keeps `is_keystone` lines (control-flow/return/raise/yield/assert, signatures `def`/`class`/`@`/`func`/etc., operators `!=`/`==`/`->`/`=>`, and NL constraint cues `must`/`only if`/`unless`/`never`/`require`); dropped runs collapse to an honest `… N low-signal line(s) elided …` marker. O(L) — one token-cost measurement per line; `max_tokens` is a SOFT cap (keystone protection + elision markers can exceed it slightly; the outer `_pack_budget` still enforces the hard total). Wired into BOTH the default and `fusion=True` paths via shared `_compressing_get_tokens(base_get_tokens, token_budget, registry)` (constants `_COMPRESS_TARGET_ITEMS=8`/`_COMPRESS_MIN_ITEM_TOKENS=120`) + `_prune_fields()`; pruned items carry `source_pruned`/`source_kept_lines`/`source_elided_lines`/`source_total_lines`/`source_is_pruned_view`. **Default `compress=False` is byte-identical**; param compact-stripped (`_COMPACT_STRIP_PARAMS["get_ranked_context"]`) so `core_compact` unchanged; NO new tool, NO tool-count change, NO INDEX_VERSION bump. Live-index smoke: 1500-tok budget delivered 12 symbols vs 9 default (3 pruned), same total. New `tests/test_v1_108_129.py` (13); ruff clean; ranked-context/negative-evidence/schema-budget/dispatch-parity/server suites green (150). Origin: a clean-room F-15 renovation of an Atelier-family runtime's entropy/perplexity context-compression stage (competitor unnamed in shipped artifacts, [[feedback_no_competitor_names_in_shipped_artifacts]]; intel kept in session memory); the versus.php warn-box conceded their selection stage was ahead — this closes it.
 - **Version:** 1.108.128 — **Never auto-bill a paid cloud provider from a bare env key (money-safety, jjg-reported).** A bare `ANTHROPIC_API_KEY` (or any cloud key) in the environment silently enabled AI summarization under the default `use_ai_summaries="auto"` — `get_provider_name` (`summarizer/batch_summarize.py`) walked `_AUTO_DETECT_ORDER` and returned the first provider whose key was present, billing per-symbol on every index. Acute because an editor running on OAuth + an ambient key = quiet spend ("falls out of OAuth mode and eats balance"). Fix: new `_PAID_CLOUD_PROVIDERS` frozenset + `_auto_entry_is_paid_cloud()` (openai counts as paid only when `OPENAI_API_BASE` is off-localhost) + `_paid_summaries_allowed()`; the auto-detect loop now SKIPS a paid-cloud entry unless opted in, with a one-time `logger.warning` naming the exact setting. **Opt-in is explicit**: `summarizer_provider=<name>` (already bypasses auto-detect, unchanged) OR new `JCODEMUNCH_ALLOW_PAID_SUMMARIES=1` / `allow_paid_summaries` config key (added to DEFAULTS/CONFIG_TYPES/template/ENV_VAR_MAPPING). Free/local endpoints (localhost `OPENAI_API_BASE`) still auto-enable. Verified end-to-end: bare ANTHROPIC_API_KEY + default config → provider None, no summarizer, warning emitted; opt-in restores it. NO INDEX_VERSION bump. New `tests/test_v1_108_128.py` (9); 7 existing auto-detect tests updated to set the opt-in flag (they test the mapping/priority mechanism, which now requires opt-in). ruff clean; summarizer/config/guard suites green (270). **Sibling parity: jdoc auto-detects on bare `OPENAI_API_KEY` too (same footgun) — needs the same guard; jdata summarizer doesn't cloud-auto-detect (embeddings gated on explicit `*_EMBED_MODEL`).**
 - **Version:** 1.108.127 — **Fix `index_repo` full re-index crash `'dict' object has no attribute 'summary'` (#367, @jgravelle).** A non-incremental `index_repo` re-index crashed while `index_folder` on the same repo succeeded. Root cause: loaded indexes carry symbols as **dicts** (`SQLiteIndexStore._build_index_from_rows` → `_row_to_symbol_dict`), but `index_repo`'s full-path summary-preservation map (`index_repo.py` ~L537) read them by ATTRIBUTE (`s.summary`/`s.file`/`s.name`/`s.kind`); `index_folder` (~L2171) already used dict access (`s["file"]`/`s.get("summary")`) — the divergence. The comprehension only fires when a prior index exists AND ≥1 file is unchanged (hash match) AND has a stored summary, so it needed a real re-index-with-summaries to trip (matching the report). Fixed to key access, mirroring `index_folder`. Incremental path was already clean (routes through `store.incremental_save`/`parse_and_prepare_incremental`, never attribute-accesses loaded symbols). Pure read path, NO INDEX_VERSION bump. New `tests/test_v1_108_127.py` (2: no-AttributeError full re-index over a pre-seeded index with mocked GitHub fetch + a loaded-symbols-are-dicts contract guard); verified the test fails with the pre-fix code. ruff clean; index_repo/server/storage suites green (96).

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jcodemunch-mcp"
-version = "1.108.129"
+version = "1.108.130"
 description = "Token-efficient MCP server for source code exploration via tree-sitter AST parsing"
 readme = "README.md"
 requires-python = ">=3.10"

src/jcodemunch_mcp/cli/receipt.py

@@ -98,12 +98,15 @@
 # typically 10% of normal input pricing for Anthropic models, but we use
 # normal input pricing here because savings are computed against a
 # counterfactual (naive Read+Grep would have been *fresh* input, not
-# cached). Opus is the default — most jcodemunch users are running an
-# Opus-grade model where savings actually move a budget needle.
+# cached). Opus is the default: most jcodemunch users run an Opus-grade
+# model where savings actually move a budget needle.
+# Rates as of 2026-06-24 (anthropic.com/pricing). Update when the public
+# price list changes; the test suite pins these to that dated source.
 _MODEL_PRICES_USD_PER_MTOK: dict[str, float] = {
-    "sonnet": 3.0,    # Claude Sonnet 4.x
-    "opus":   15.0,   # Claude Opus 4.x
-    "haiku":  0.80,   # Claude Haiku 4.x
+    "fable":  10.0,   # Claude Fable 5 ($10/MTok input)
+    "opus":   5.0,    # Claude Opus 4.8 / 4.7 / 4.6 ($5/MTok input; retired 4.0/4.1 were $15)
+    "sonnet": 3.0,    # Claude Sonnet 5 / 4.6 ($3/MTok input)
+    "haiku":  1.0,    # Claude Haiku 4.5 ($1/MTok input)
 }
 
 _DEFAULT_MODEL = "opus"
@@ -308,7 +311,7 @@ def render_text(agg: dict, *, days: int, model: str, primary_only: bool = False)
     out.write(f"  Saved at {model.title()} pricing (${rate:.2f}/MTok input):  ${primary_dollars:,.2f}\n")
 
     if not primary_only:
-        for other in ("sonnet", "opus", "haiku"):
+        for other in ("fable", "opus", "sonnet", "haiku"):
             if other == model.lower():
                 continue
             other_rate = _MODEL_PRICES_USD_PER_MTOK[other]

tests/test_receipt.py

@@ -175,10 +175,14 @@ def test_sonnet_rate(self):
         assert dollar_savings(1_000_000, "sonnet") == pytest.approx(3.0)
 
     def test_opus_rate(self):
-        assert dollar_savings(1_000_000, "opus") == pytest.approx(15.0)
+        # Opus 4.8 / 4.7 / 4.6 = $5/MTok input (retired 4.0/4.1 were $15).
+        assert dollar_savings(1_000_000, "opus") == pytest.approx(5.0)
 
     def test_haiku_rate(self):
-        assert dollar_savings(1_000_000, "haiku") == pytest.approx(0.80)
+        assert dollar_savings(1_000_000, "haiku") == pytest.approx(1.0)
+
+    def test_fable_rate(self):
+        assert dollar_savings(1_000_000, "fable") == pytest.approx(10.0)
 
     def test_unknown_model_zero(self):
         assert dollar_savings(1_000_000, "made-up") == 0.0
@@ -242,11 +246,24 @@ def test_json_payload_shape(self):
 
 
 class TestModelPriceTable:
+    # Pinned to anthropic.com/pricing as of 2026-06-24. Update this table AND
+    # the source table in cli/receipt.py together when the price list changes.
+    _EXPECTED_RATES = {
+        "fable": 10.0,
+        "opus": 5.0,
+        "sonnet": 3.0,
+        "haiku": 1.0,
+    }
+
     def test_known_models_present(self):
-        for m in ("sonnet", "opus", "haiku"):
+        for m in ("fable", "sonnet", "opus", "haiku"):
             assert m in _MODEL_PRICES_USD_PER_MTOK
             assert _MODEL_PRICES_USD_PER_MTOK[m] > 0
 
+    def test_rates_match_dated_source(self):
+        for model, rate in self._EXPECTED_RATES.items():
+            assert _MODEL_PRICES_USD_PER_MTOK[model] == pytest.approx(rate)
+
     def test_opus_more_expensive_than_sonnet(self):
         assert _MODEL_PRICES_USD_PER_MTOK["opus"] > _MODEL_PRICES_USD_PER_MTOK["sonnet"]