release: v1.108.67 - demote the language enum under compact_schemas

The language filter's ~76-value enum (the full LANGUAGE_REGISTRY, ~200 tokens
of mechanical names an agent already knows) is demoted to a plain string filter
under compact_schemas, while the full surface keeps the enum. The param stays
fully usable (the tool accepts any language string). This brings core_compact
back under the section-10 <=4000 success criterion (4162 -> 3956) after recent
tool additions pushed it over, and also trims standard_compact.

Generalized by param name via _COMPACT_DEMOTE_ENUM_PARAMS so every tool with a
language enum benefits. schema_baseline.json refreshed to honest live counts;
new test_compact_demotes_language_enum_keeps_capability pins the behavior.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: jgravelle

CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to jcodemunch-mcp are documented here.
 
+## [1.108.67] - 2026-06-21 - Demote the language enum under compact_schemas
+
+### Changed
+
+- **The `language` filter's ~76-value enum is demoted to a plain string under
+  `compact_schemas`**, reclaiming ~200 tokens from the smallest tool surfaces
+  while keeping the parameter fully usable (the tool already accepts any
+  language string; an unknown one simply matches nothing). The full
+  (non-compact) surface keeps the enum unchanged. This brings `core_compact`
+  back under the 4,000-token §10 success criterion (4,162 → 3,956) after recent
+  releases had pushed it over, and also trims `standard_compact`. Generalized by
+  parameter name via `_COMPACT_DEMOTE_ENUM_PARAMS`, so every tool exposing a
+  `language` enum benefits. `benchmarks/schema_baseline.json` refreshed to the
+  new honest live counts; new `test_compact_demotes_language_enum_keeps_capability`
+  pins the behavior (enum gone under compact, present in full).
+
 ## [1.108.66] - 2026-06-21 - The Counter: adaptive tool surface (order / menu / route)
 
 ### Added

CLAUDE.md

@@ -1,6 +1,7 @@
 # jcodemunch-mcp — Project Brief
 
 ## Current State
+- **Version:** 1.108.67 — Demote the `language` enum under `compact_schemas`. The `language` filter's full LANGUAGE_REGISTRY enum (~76 values, ~200 tokens of mechanical names an agent already knows) is dropped to a plain `type:string` filter under compact (capability preserved — the tool accepts any language string; unknown → empty match); the full surface keeps the enum. Brings `core_compact` back under the §10 ≤4000 line (4162→**3956**, ~44 margin) after 1.108.55-66 tool additions pushed it to 4146; also trims `standard_compact` (16339→16149). New `_COMPACT_DEMOTE_ENUM_PARAMS` frozenset (keyed by PARAM name, so search_symbols/search_ast/etc. all benefit) + an enum-demotion pass alongside the existing `_COMPACT_STRIP_PARAMS` loop in `_build_tools_list`. `schema_baseline.json` refreshed to honest live counts (the wholesale `capture_schema_baseline.py` run is now CORRECT — it writes 3956, the very thing that made it wrong at v1.108.66 when it wrote 4146). New `test_compact_demotes_language_enum_keeps_capability` pins it (enum gone under compact, present in full). Closes the open follow-up from the Counter release. No behavior change on the full tier.
 - **Version:** 1.108.66 — The Counter: adaptive tool surface (`order` / `menu` / `route`). Collapses the ~83-tool footprint behind a 3-tool front door to cut the per-turn schema tax + dispatch dilution, without removing any capability. New `JCODEMUNCH_TOOL_SURFACE` env / `tool_surface` config: `counter` makes `list_tools` return only the front door + `_ALWAYS_PRESENT_TOOLS`; any other value (default `full`) is **byte-identical** to prior behavior (front-door tools hidden, still callable). **`order(action,args)`** re-enters the normal `call_tool` pipeline after a charter gate (read-only by default; index/session state-changers need `allow_state_change=true`; exec/file-write verbs refused unconditionally — a forward-looking tripwire, the suite ships none). **`menu(query?,limit?)`** = idf-weighted catalog search. **`route(task,repo?,execute?)`** = curated intent map (`_INTENT_RULES`) + catalog-search fallback → ranked actions w/ arg templates; `execute=true` recommends AND dispatches in one call; recommends `assemble_task_context`/`plan_turn` for context intents (honest mapper, NOT a plan_turn reskin — plan_turn recommends symbols, not tools). New `counter.py` (pure logic, no server import) + 4 surgical `server.py` edits (front-door globals after `_UNDISABLEABLE_TOOLS`; surface-collapse in `_build_tools_list`; handlers before `call_tool`; early front-door branch inside `call_tool`). `tests/test_counter.py` (19) incl. a charter CI gate (no catalog action trips the exec/write tripwire) + a STATE_CHANGING-in-catalog drift guard. Full surface stays 83 tools; front door appears only under `tool_surface=counter`. Pre-existing schema-budget drift (unrelated, proven via stash) fixed by a surgical `schema_baseline.json` refresh of the two breached keys (`core_full`→5097, `standard_full`→17360); core_compact LIVE 4146 is over the 4000 v2 design intent (prior-release bloat, separate trim-or-relax follow-up). See `docs/prd-adaptive-tool-surface.md` + memory `project_tool_router_prd`.
 - **Version:** 1.108.65 — Surface the composition tools (`assemble_task_context` / `plan_turn`) in agent-facing docs. Answers the "these code-index tools work in isolation" critique (a competitor's launch claim, see memory `reference_competitor_atelier`): the suite already HAS an orchestration layer — `assemble_task_context` (one-call, intent-classified, single-budget capsule) and `plan_turn` (confidence-routed opening move) — it just wasn't legible. `assemble_task_context` was absent from every agent-facing surface; now added to `_CLAUDE_MD_POLICY` (init.py — the injected CLAUDE.md/Cursor/Windsurf policy) "Opening move" as the one-call shortcut, plus a new README "What you get → One-call task orchestration" subsection + "Why agents need this" bullet. `skills.py` SKILL.md already had a "Task orchestration" section (unchanged). Docs + one policy constant; **no tool behavior change**. `test_claude_md_policy.py` REQUIRED_POLICY_TERMS pins `assemble_task_context` so visibility can't regress (the line is full-tier only, so `_filter_policy_for_tools` drops it under core/standard exactly like `plan_turn` — existing filter tests unaffected, 22 pass). Legibility fix, not capability chase ([[feedback_clean_room_innovation]]).
 - **Version:** 1.108.64 — Logging honors the `log_file` / `log_level` config keys. `_setup_logging` read only `args.log_file`/`args.log_level` (argparse defaults baked from `JCODEMUNCH_LOG_FILE`/`JCODEMUNCH_LOG_LEVEL` env), so a path set via `config set log_file <path>` was **inert** — the `log_file` config key existed (DEFAULTS/CONFIG_TYPES/template, "=== Logging ===") but the server never read it. New pure helper `_resolve_log_config(args)` applies one precedence chain: **explicit CLI flag > env var > config key > hardcoded default** (WARNING / stderr); `_add_common_args` `--log-level`/`--log-file` defaults changed `None` so the chain (not argparse) owns env resolution. **Why:** lets the jMunch Console enable server file logging by writing the config key + restarting the server (the server is client-launched, so the Console can't inject an env var into it; and `_setup_logging` ignored config). Purely additive — nothing set anywhere → WARNING+stderr exactly as before; an explicit env/CLI from the launching client still wins over config. `_setup_logging` is the only reader of those args (verified). New `tests/test_v1_108_64.py` (6: default/config-file/config-level/env-overrides-config/cli-wins/uppercased). See [[project_jmunch_console]].

benchmarks/schema_baseline.json

@@ -1,8 +1,8 @@
 {
-  "core_compact": 3977,
+  "core_compact": 3956,
   "core_full": 5097,
-  "standard_compact": 15585,
+  "standard_compact": 16149,
   "standard_full": 17360,
-  "full_compact": 16895,
-  "full_full": 17840
+  "full_compact": 17459,
+  "full_full": 18670
 }

pyproject.toml

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

src/jcodemunch_mcp/server.py

@@ -525,6 +525,14 @@ async def _apply_model_announcement(model: str) -> dict:
     "index_folder": {"extra_ignore_patterns", "incremental"},
 }
 
+# Params whose enum is demoted to a plain string filter under compact_schemas.
+# The `language` enum is the full LANGUAGE_REGISTRY (~76 values) — ~200 tokens
+# of mechanical names an agent already knows. Dropping the enum keeps the param
+# fully usable as a free-string filter (the tool tolerates any language string)
+# while reclaiming the tokens. Keyed by param name so every tool that exposes a
+# `language` enum (search_symbols, search_ast, ...) benefits across all tiers.
+_COMPACT_DEMOTE_ENUM_PARAMS: frozenset[str] = frozenset({"language"})
+
 # Tools eligible for Agent Selector complexity scoring
 _AGENT_SELECTOR_TOOLS = frozenset({
     "get_ranked_context", "get_context_bundle", "search_symbols",
@@ -3566,12 +3574,21 @@ def _build_tools_list() -> list[Tool]:
     # --- Compact schemas: strip rarely-used params ---------------------------
     if config_module.get("compact_schemas", False):
         for tool in tools:
+            if not isinstance(tool.inputSchema, dict):
+                continue
+            props = tool.inputSchema.get("properties")
+            if not props:
+                continue
             strip_set = _COMPACT_STRIP_PARAMS.get(tool.name)
-            if strip_set and isinstance(tool.inputSchema, dict):
-                props = tool.inputSchema.get("properties")
-                if props:
-                    for param in strip_set:
-                        props.pop(param, None)
+            if strip_set:
+                for param in strip_set:
+                    props.pop(param, None)
+            # Demote large mechanical enums to free-string filters (capability
+            # preserved; the tool accepts any string for these params).
+            for param in _COMPACT_DEMOTE_ENUM_PARAMS:
+                pschema = props.get(param)
+                if isinstance(pschema, dict) and "enum" in pschema:
+                    props[param] = {k: v for k, v in pschema.items() if k != "enum"}
 
     # Merge descriptions from config (runs after disabled_tools filter)
     _apply_description_overrides(tools)

tests/test_schema_budget.py

@@ -93,3 +93,35 @@ def test_v2_success_criterion_core_compact_under_4000():
         f"v2.0.0 success criterion requires core + compact_schemas <= 4000 tokens; "
         f"current baseline is {core_compact}."
     )
+
+
+def test_compact_demotes_language_enum_keeps_capability():
+    """Under compact_schemas, the ~76-value `language` enum is demoted to a
+    plain string filter (reclaims ~200 tokens) but the param stays usable. The
+    full surface keeps the enum. Guards the core_compact-under-4000 headroom."""
+    from jcodemunch_mcp import config as config_module
+    from jcodemunch_mcp.server import _build_tools_list
+
+    cfg = config_module._GLOBAL_CONFIG  # type: ignore[attr-defined]
+    original = {k: cfg.get(k) for k in ("tool_profile", "compact_schemas")}
+    try:
+        cfg["tool_profile"] = "core"
+
+        cfg["compact_schemas"] = True
+        ss = next(t for t in _build_tools_list() if t.name == "search_symbols")
+        lang = ss.inputSchema["properties"]["language"]
+        assert "enum" not in lang, "language enum must be demoted under compact"
+        assert lang.get("type") == "string", "demoted language must remain a string filter"
+        assert lang.get("description"), "demoted language must keep its description"
+
+        cfg["compact_schemas"] = False
+        ss_full = next(t for t in _build_tools_list() if t.name == "search_symbols")
+        assert len(ss_full.inputSchema["properties"]["language"].get("enum", [])) > 10, (
+            "full surface must keep the language enum"
+        )
+    finally:
+        for k, v in original.items():
+            if v is None:
+                cfg.pop(k, None)
+            else:
+                cfg[k] = v