fix(rule_fast): keep literal constant assignments in file skeletons

The LLM-in-the-loop eval caught what the substring benchmark scored at
50%: file-read compression kept signatures but dropped body values, so
a real model scored 0% QA on 'what value is assigned to limit?'.

Keep literal constant assignments (numeric/string RHS, one line each)
in the skeleton. Computed expressions stay dropped.

Measured after the fix:
- substring: file_read retention 50% -> 100%; overall 92.9% -> 99.1%,
  all-facts rate 78.6% -> 98.5%, token reduction unchanged (83.6%)
- LLM eval (Qwen2.5-0.5B CPU): file_read QA 0% -> 50% (parity with raw
  at 308 vs 1128 tokens); overall compressed now BEATS raw 69.2% vs
  67.7% at 66% fewer tokens

Regression floors raised: overall retention >= 97%, file_read == 100%.

Co-authored-by: Daniel <DJLougen@users.noreply.github.com>

Author: cursoragent

README.md

@@ -55,9 +55,9 @@ the *same* token budget:
 
 | Metric (rule_fast, seed=42) | Before fidelity fixes | Current | Naive truncation |
 |---|---|---|---|
-| Token reduction | 95.4% | 83.7% | 83.7% (matched) |
-| Critical-fact retention | 40.7% | **92.9%** | 28.7% |
-| Messages with *all* facts intact | 26.4% | **78.6%** | 41.3% |
+| Token reduction | 95.4% | 83.6% | 83.6% (matched) |
+| Critical-fact retention | 40.7% | **99.1%** | 28.7% |
+| Messages with *all* facts intact | 26.4% | **98.5%** | 41.3% |
 
 Per category (fact retention at the shown token reduction):
 
@@ -67,7 +67,7 @@ Per category (fact retention at the shown token reduction):
 | command/build output | 75.7% | 100% (error line + exit code) |
 | tracebacks | 0% (kept verbatim by design) | 100% |
 | search results | 5.5% | 92.5% |
-| file reads | 82.7% | 50% (signatures kept, bodies dropped) |
+| file reads | 82.6% | 100% (signatures + literal constants kept) |
 
 Honest caveats, measured not asserted:
 
@@ -76,9 +76,9 @@ Honest caveats, measured not asserted:
 - **Search results barely compress** (5.5%). The compressor cannot know which
   hit is the answer, so it keeps all hit locations. Dense grep output has
   little safely-removable bloat.
-- **File reads lose body detail by design** (50% substring retention, 0% LLM
-  QA accuracy on a 0.5B CPU model): signatures survive so the agent can
-  re-read a precise range, but a value inside a function body does not.
+- **File reads keep signatures and literal constants, not full bodies**:
+  computed expressions inside functions are dropped; the agent re-reads a
+  precise range when it needs one.
 - **Still not measured**: multi-step task success (SWE-bench resolve rate
   with Hive on vs. off) and `busybee` routing accuracy.
 
@@ -97,14 +97,19 @@ Run on CPU with `Qwen/Qwen2.5-0.5B-Instruct` (31 messages, seed=7):
 
 | Metric | Raw context | Compressed context |
 |---|---|---|
-| QA accuracy (graded facts) | 67.7% | 60.0% |
-| Messages fully answered | 32.3% | 38.7% |
-| Avg prompt tokens | 657 | 220 (**-66.5%**) |
-
-Per category: pytest logs and search results hold accuracy at **90% fewer
-tokens**; file reads drop to 0% QA accuracy (signatures survive, body
-values do not — matches the substring benchmark); command output actually
-*improves* (58% vs 50%) because compression strips noise.
+| QA accuracy (graded facts) | 67.7% | **69.2%** |
+| Messages fully answered | 32.3% | **38.7%** |
+| Avg prompt tokens | 657 | 221 (**-66.4%**) |
+
+Compressed context matches or beats raw in **every category** at 66% fewer
+tokens: pytest logs hold 82.4% at a tenth of the tokens; file reads hold
+parity (50%) at 308 vs 1128 tokens; command output *improves* (58.3% vs
+50.0%) because compression strips noise a small model trips over.
+
+An earlier run of this same eval caught a real defect: file reads scored
+**0%** because the skeleton kept signatures but dropped body values. Keeping
+literal constant assignments (one line each) closed the gap — the
+benchmark-fix-rerun loop working as intended.
 
 Reproduce: `pip install torch transformers && python3 scripts/llm_fidelity_eval.py`
 

docs/benchmarks/fidelity.md

@@ -8,25 +8,25 @@ report measures whether it is *safe*.
 - Corpus: 201 messages (seed=42, 40/category + real captured fixtures)
 - Baseline: head-truncation of the raw message to the **same** token budget
 - Machine: x86_64 / x86_64 / Linux
-- Commit: `0fed7e6` — 2026-06-09T22:33:48+00:00
+- Commit: `fababb1` — 2026-06-09T22:53:39+00:00
 
 ## Overall
 
 | Metric | rule_fast | naive truncation (same budget) |
 |---|---|---|
-| Token reduction | 83.7% | 83.7% (matched) |
-| Fact retention | **92.9%** | 28.7% |
-| Messages with *all* facts intact | **78.6%** | 41.3% |
+| Token reduction | 83.6% | 83.6% (matched) |
+| Fact retention | **99.1%** | 28.7% |
+| Messages with *all* facts intact | **98.5%** | 41.3% |
 
-Throughput on this machine: 2,120 msg/s (single core).
+Throughput on this machine: 2,369 msg/s (single core).
 
 ## By category
 
 | Category | Msgs | Token reduction | Fact retention | All-facts rate | Naive retention |
 |---|---|---|---|---|---|
 | pytest_log | 41 | 97.4% | 100.0% | 100.0% | 4.3% |
 | traceback | 40 | 0.0% | 100.0% | 100.0% | 100.0% |
-| file_read | 40 | 82.7% | 50.0% | 0.0% | 15.0% |
+| file_read | 40 | 82.6% | 100.0% | 100.0% | 15.0% |
 | search_results | 40 | 5.5% | 92.5% | 92.5% | 92.5% |
 | command_output | 40 | 75.7% | 100.0% | 100.0% | 7.5% |
 
@@ -35,7 +35,7 @@ Throughput on this machine: 2,120 msg/s (single core).
 | Source | Msgs | Token reduction | Fact retention | All-facts rate |
 |---|---|---|---|---|
 | real | 1 | 77.0% | 100.0% | 100.0% |
-| synthetic | 200 | 83.7% | 92.9% | 78.5% |
+| synthetic | 200 | 83.6% | 99.1% | 98.5% |
 
 ## How to read this
 

docs/benchmarks/llm-fidelity.md

@@ -8,22 +8,22 @@ Grading is automatic against corpus ground truth.
 - Corpus: 31 messages (seed=7, 6/category + real fixture, scale=0.2)
 - Compressor: rule_fast via `HiveStack.compress`
 - Machine: x86_64 / Linux / 4 cores
-- Commit: `1010e8e` — 2026-06-09T22:51:26+00:00
+- Commit: `fababb1` — 2026-06-09T22:56:36+00:00
 
 ## Overall
 
 | Metric | Raw context | Compressed context |
 |---|---|---|
-| QA accuracy (graded facts) | 67.7% | **60.0%** |
+| QA accuracy (graded facts) | 67.7% | **69.2%** |
 | Messages fully answered | 32.3% | 38.7% |
-| Avg prompt tokens | 657 | 220 (**-66.5%**) |
+| Avg prompt tokens | 657 | 221 (**-66.3%**) |
 
 ## By category (QA accuracy)
 
 | Category | Raw | Compressed | Raw tokens | Compressed tokens |
 |---|---|---|---|---|
 | command_output | 50.0% | 58.3% | 302 | 209 |
-| file_read | 50.0% | 0.0% | 1128 | 298 |
+| file_read | 50.0% | 50.0% | 1128 | 308 |
 | pytest_log | 82.4% | 82.4% | 1286 | 132 |
 | search_results | 91.7% | 91.7% | 206 | 218 |
 | traceback | 58.3% | 58.3% | 256 | 256 |

hive/rule_fast/__init__.py

@@ -166,8 +166,16 @@ def _classify(role: str, content_type: str, content: str = "") -> str:
 _MAX_SKELETON_LINES = 200
 
 _RE_ERRORISH = re.compile(r"error|fail|fatal|denied|exception|timed? ?out", re.I)
+# Skeleton keeps: signatures, imports, top-level assignments, and *literal*
+# constant assignments inside bodies (`limit = 1234`, `URL = "..."`). The
+# LLM fidelity eval showed body values are what agents go looking for in
+# file reads; literal assignments are one line each and carry most of that
+# signal. Computed assignments (`x = payload.get(...)`) stay dropped.
 _RE_SIGNATURE = re.compile(
-    r"^\s*(?:async\s+def|def|class|pub fn|fn|function|export)\b|^[A-Za-z_]\w*\s*=\s|^(?:import|from)\s"
+    r"^\s*(?:async\s+def|def|class|pub fn|fn|function|export)\b"
+    r"|^[A-Za-z_]\w*\s*=\s"
+    r"|^(?:import|from)\s"
+    r"|^\s+[A-Z_a-z]\w*\s*(?::[^=]+)?=\s*(?:-?\d|[\"'])[^(]*$"
 )