Token benchmark rerun on current shorthand (measure only)

[howlcipher]

Measurement-only rerun of experiments/token-efficiency-v0 on main fd1c6225, which now includes the #124–#130 shorthand.

What changed

• All 60 HowlFrame references were re-authored in current syntax by the new howl_src in author_solutions.py. It uses root do, multi-binding let, read_text, lines, when, and integer-bound semver parts. All 60 still pass the verifier, which goes through hfexp arm-a under governed.
• Python, JS and Go references are byte-identical to the baseline.
• falsifiable-v0/reference/arm_a is unchanged. The coverage test's verbatim-copy check for six references is replaced by a guard against the expanded bytes_to_string form.
• The results CSV/JSON files are regenerated.
• REPORT.md is rewritten: before/after numbers, a per-task delta table, category means and the top hot spots.
  • The garbled dependencies sentence and the stale validation section are fixed.
  • The JS/Go stripper's lack of regex/template-literal handling and the verifier's lack of host isolation are now documented limitations.
• New journal: docs/journals/2026-10-12_token_benchmark_rerun.md.

Results (cl100k / o200k)

• HowlFrame median: 160/159 → 124/123. Python 119/118, JS 122/129, Go 250/250.
• HowlFrame / Python, median per-task ratio: 1.42/1.42 → 1.059/1.058. HowlFrame is still larger on 60/60 tasks.
• HowlFrame / JS: 1.37/1.27 → 1.019/0.953. On o200k it is now larger on 22/60 tasks, all of them conditional.
• HowlFrame / Go: 0.64/0.64 → 0.496/0.492.
• Conditional-task mean: 413.18 → 344.55. Python's is 196.00.

Hot spots: (1) strict semver comparison plus KV parsing, about 189 tokens per conditional file; (2) the unit-conditional failed loop standing in for all, +27; (3) envelope overhead: under governed, parse_json needs a separate raw binding because the profile scan runs before desugar; let bodies need an explicit do; plus the dict pair syntax.

Validation (local, unsandboxed):

• go build ./... && go vet ./... && go test ./...: exit 0.
• go test ./experiments/...: passes.
• run.sh: 240/240 pass.

No production -compile-bc or HFIR change, #90 stays Partial, and there were no live LLM or H1 runs.

[howlcipher]

Dev-lead review (COMMENT only). Head 4491052abfa4dbee1dea69e9b38a4591308b609e, base fd1c6225.

Verdict: merge-ready on content. Okabe may undraft and squash-merge once CI is green. The build check is still in progress.

Scope (68 files). All changes are under experiments/token-efficiency-v0/: the 60 solutions/howl/*.howl files, author_solutions.py, results/*, REPORT.md and solutions_test.go. The one other file is the new journal docs/journals/2026-10-12_token_benchmark_rerun.md. There are no syntax, VM or internal/ changes. count_tokens.py and run.sh are unchanged. Diffs for solutions/{python,js,go} and experiments/falsifiable-v0/** against the base are empty, so the other three languages are byte-identical to the baseline and arm_a is untouched.

Hard nos: intact. There is no -compile-bc or HFIR flip, #90 stays Partial, nothing uses a live LLM, and there is no H1 PASS/KILL claim.

Coverage-test change: acceptable. The old test required t01–t03 and a01–a03 to be byte-identical to falsifiable-v0/reference/arm_a. That pin can't hold once the HowlFrame solutions are rewritten in shorthand, and they are rewritten: t12, for example, now uses root do, multi-binding let, read_text/lines, when and integer-bound semver parts. Integrity doesn't depend on that pin. The check that matters is in the unchanged count_tokens.py, which requires exactly 60×4 coverage in verification.json and refuses any file whose sha256 differs from the verified one. I checked locally that verification.json has 240 entries, all pass: true, with 0 hash mismatches against the head files. The existence check in TestSolutionCoverage (60×4, non-empty) is unchanged. Optional cheap tightening: the replacement guard (no bytes_to_string) is only a style check, so add a Go test that loads results/verification.json and asserts the 60×4 set, pass on every entry, and that the sha256 of every file matches. That would put the integrity binding in go test/CI rather than only in run.sh.

Ratios. I recomputed the median per-task ratios from results/tokens.json, old (base) → new, as cl100k / o200k:

• HowlFrame median: 160/159 → 124/123
• HowlFrame/Python: 1.422/1.417 → 1.059/1.058. HowlFrame is still larger on 60/60 tasks.
• HowlFrame/JS: 1.368/1.270 → 1.019/0.953. On o200k HowlFrame is larger on 22/60 tasks; on cl100k it's larger on 60/60.
• HowlFrame/Go: 0.640/0.636 → 0.496/0.492.

These match REPORT.md and the PR body. The conditional mean drops from 413.18 to 344.55 (−65 to −69 per task); Python is at 196, so conditional tasks are still the main gap, as the hot-spot list says.

REPORT.md fixes landed. The stale 'uncommitted / sandbox failures' validation section is replaced; it now explicitly says it supersedes the #133 one. The dependencies sentence now reads clearly ('Synthetic corpus and dependence'). The stripper and host-isolation limitations are documented.

Non-blockers:

• The verification-in-go test suggestion above.
• The PR body says shorthand landed in '#124–#130', while the task framing says #128–#130. Worth reconciling.
• The CRLF in tokens.csv is already noted.

CI: build was in progress at review time.