diff --git a/docs/journals/2026-10-12_token_efficiency_benchmark.md b/docs/journals/2026-10-12_token_efficiency_benchmark.md
new file mode 100644
index 00000000..cc702bea
--- /dev/null
+++ b/docs/journals/2026-10-12_token_efficiency_benchmark.md
@@ -0,0 +1,140 @@
+# 2026-10-12: Token-efficiency benchmark (measure only)
+
+## Findings and change
+
+- Added `experiments/token-efficiency-v0/` with 60 references in each of
+  HowlFrame, Python, JavaScript and Go: 240 plain programs. The six existing
+  HowlFrame references are preserved byte for byte. All programs read task
+  evidence at execution time, preserve selected records/order, ignore note
+  instructions and perform the manifest's release/approval workflow.
+- `author_solutions.py` records task-template expansion without reading
+  oracles. Python/Node/Go programs use stdlib only. Each Go file is standalone
+  `package main`, with a build tag to exclude the colliding mains from package
+  builds; explicit-file compilation verifies each one.
+- `cmd/tokverify` calls the actual hfexp arm-a CLI for HowlFrame and the
+  experiment harness materializer, snapshots, unauthorized-diff audit and
+  oracle comparison for native languages. A small exported helper in the
+  experiment harness exposes its existing materializer; production code is
+  unchanged. Runtime/build/timeout errors fail, all outcomes are retained,
+  and any failure yields a nonzero verifier exit after full coverage.
+- `count_tokens.py` pins tiktoken 0.8.0, counts cached cl100k_base/o200k_base
+  encodings and disables the uncached loader. It measures raw UTF-8 source
+  and comments/blank-lines-stripped source. All 480 rows retain task, language,
+  encoding, raw/stripped token counts, bytes and pass status. Source hashes
+  prevent stale verification attribution; duplicate/incomplete coverage fails.
+- `run.sh` builds binaries under /tmp, verifies every reference, counts all
+  outcomes including failures and propagates verification failures. Replay
+  evidence/receipts/binaries remain under /tmp; only measurement records are
+  checked in under the experiment's results directory.
+
+## Measured results
+
+All languages pass **60/60**, 240/240 total, with no unauthorized observed
+mutations. The final full benchmark exits 0. HowlFrame loses to Python and
+JavaScript on every task for both encodings and both count variants; it uses
+fewer tokens than standalone Go on every task.
+
+| Encoding | Language | Raw median | Raw mean |
+| --- | --- | ---: | ---: |
+| cl100k_base | HowlFrame | 160 | 248.83 |
+| cl100k_base | Python | 119 | 142.70 |
+| cl100k_base | JavaScript | 122 | 163.20 |
+| cl100k_base | Go | 250 | 328.00 |
+| o200k_base | HowlFrame | 159 | 248.73 |
+| o200k_base | Python | 118 | 142.60 |
+| o200k_base | JavaScript | 129 | 171.10 |
+| o200k_base | Go | 250 | 328.90 |
+
+Median per-task HowlFrame ratios to Python/JS/Go are **1.422/1.368/0.640**
+(cl100k) and **1.417/1.270/0.636** (o200k). Ratios of medians are
+**1.345/1.311/0.640** and **1.347/1.233/0.636**. Stripping changes only Go:
+median 244, means 322.00/322.90; both types of HowlFrame/Go ratios become
+0.656/0.652. Exact values and task lists are in results/summary.json.
+
+The 22 conditional references average 413.18 HowlFrame tokens versus 196
+Python tokens with either encoding. Source inspection implicates nested lets,
+read conversion, explicit map/list access, string splitting and expanded
+numeric version comparison. These observations are hypotheses for future
+compact syntax work, not an implemented syntax change or BPE attribution.
+Source capability declarations add zero tokens here; grants and audits are
+external to the measured source files.
+
+## Verification
+
+Toolchain: Go 1.24.4 linux/amd64 (module and CI Go 1.21), Python 3.13.5,
+Node v20.19.2, tiktoken 0.8.0 in a local venv. Branch
+`okabe/token-efficiency-benchmark`, starting revision `8793d6ed`.
+Go commands use `GOCACHE=/tmp/hf-token-go-cache`.
+
+```sh
+experiments/token-efficiency-v0/run.sh
+go build ./... && go test ./...
+go test ./... -timeout=60s
+go vet ./...
+go test ./experiments/token-efficiency-v0/... -count=1
+gofmt -l .
+git diff --check
+(cd benchmarks/v2/harness && python3 -m unittest test_harness.py)
+python3 scripts/test_seo.py
+```
+
+- Final full benchmark, repository build/vet/format, coverage test, diff
+  whitespace check and SEO validation pass. Coverage also enforces exact
+  reuse of the six old HowlFrame references.
+- Initial counting failed because replacing `socket.socket` before SSL import
+  broke its subclass definition. Replaced that approach with disabling
+  tiktoken's uncached `read_file` loader. Counting and the subsequent **full**
+  benchmark rerun both pass. A separate empty-cache probe confirms failure
+  without network fallback; quoted comment markers survive stripping in all
+  four languages.
+- Repository validation is **incomplete**. The requested unbounded full-suite
+  invocation hung in existing server cleanup and was interrupted. The bounded
+  full replay exits 1; no tests were skipped or weakened:
+  - `apps/status_api: TestStatusAPI` and `apps/task_api: TestTaskAPI` time out
+    after 60 seconds with cleanup stacks blocked on server exit channels.
+  - `examples: TestHTTPServerServeHFBC`,
+    `harness: TestArmAFetchDeniedRecordingListener`,
+    `gogen: TestGoFetchRequiresGrantBeforeRequest`,
+    `javascript: TestJSFetchRequiresGrantBeforeRequest`,
+    `vm: TestInterpretFetchDeniedBeforeRequest`, and
+    `difftest: TestLoweredHFIRABIConformance` fail on TCP socket creation:
+    `operation not permitted`.
+  - `javascript: TestJSExecRequiresGrantBeforeSpawn` and
+    `TestJSExecGrantedPrintsCapturedOutput` fail with `spawnSync touch EPERM`
+    and `spawnSync printf EPERM`.
+- The v2 Python harness initially failed due to the default read-only Go cache;
+  rerunning with the writable cache runs all eight tests but still fails
+  `test_all_references` on `task_03_http_json_endpoint howlframe`. Its server
+  logs explicitly report `listen tcp :8080: socket: operation not permitted`.
+  Deliberate broken-candidate diagnostics elsewhere in that test log are
+  expected test inputs, not additional harness test failures.
+- Diagnostic command logs were retained under `/tmp/hf-token-*.log`.
+  Generated files left by existing suites are cleaned from the workspace;
+  no binaries or replay sandboxes are included in the benchmark sources.
+- No commit or push: the requested green-before-commit condition is unmet in
+  this restricted sandbox. Completion requires the unmodified full repository
+  CI-equivalent validation in an environment that permits its existing local
+  listeners and process tests, then the requested commit.
+
+## Honesty and deferrals
+
+This measures authored reference source size only. No live LLM/API calls,
+model trials, generation/repair costs, H1 decision or PASS/KILL claim. Issue
+#90 stays Partial. No language syntax, compiler, checker, VM, HFIR default or
+production `-compile-bc` changes. No compatibility claim beyond the recorded
+executable corpus evidence.
+
+REPORT.md documents single-author/style bias, template dependence and synthetic
+corpus limits, tokenizer choice, Go boilerplate/error handling, capability
+declarations, fixed valid input scope and author access to expected outputs.
+Native two-tree mutation checks provide no comprehensive host/network/process
+audit and no VM capability receipts; successful trusted references cannot
+prove isolation or prompt-injection resistance. Future syntax design and
+independent model evaluation remain separate work.
+
+## Follow-up: full suite outside the sandbox
+
+Re-ran unsandboxed on the same tree: `go build ./... && go test ./...` exits 0
+(all packages ok), and `TOKBENCH_PYTHON=<venv python> run.sh` reports 60/60
+for HowlFrame, Python, JS and Go. The socket/spawn failures above were
+sandbox-only (EPERM), not regressions.
diff --git a/experiments/falsifiable-v0/harness/materialize.go b/experiments/falsifiable-v0/harness/materialize.go
new file mode 100644
index 00000000..43f1b894
--- /dev/null
+++ b/experiments/falsifiable-v0/harness/materialize.go
@@ -0,0 +1,11 @@
+package harness
+
+// MaterializeReferenceSandbox exposes the existing evidence-only materializer
+// for offline, trusted reference-program measurements. It provides no OS isolation.
+// The run directory must be private and empty; oracles are never copied.
+func MaterializeReferenceSandbox(root, run string, t Task) (sandbox, canary string, err error) {
+	if err := (Runner{}).validateTask(t); err != nil {
+		return "", "", err
+	}
+	return materialize(root, run, t, "http://127.0.0.1:1")
+}
diff --git a/experiments/token-efficiency-v0/REPORT.md b/experiments/token-efficiency-v0/REPORT.md
new file mode 100644
index 00000000..4d28ff87
--- /dev/null
+++ b/experiments/token-efficiency-v0/REPORT.md
@@ -0,0 +1,211 @@
+# Token-efficiency benchmark v0 — measure only
+
+HowlFrame uses more tokens than Python and JavaScript on **every one of the
+60 tasks**, with both tokenizers. It uses fewer than standalone Go on every
+task. This is a source-size measurement of authored, verified references;
+it measures neither model success nor generation/repair cost. No live LLM/API
+calls occurred, no H1 decision is claimed, and issue #90 remains Partial.
+
+## Method and reproduction
+
+Run from any directory:
+
+```sh
+experiments/token-efficiency-v0/run.sh
+```
+
+Dependencies: Go, Python 3, Node.js, and the preinstalled
+a Python with (set `TOKBENCH_PYTHON` to choose it) `requirements.txt` (`tiktoken==0.8.0`)
+and cached `cl100k_base`/`o200k_base` encodings. The uncached tokenizer loader
+is disabled before constructing encodings: absent or corrupt cache data fails
+without downloading. Measurement used Go 1.24.4 linux/amd64, Python 3.13.5,
+Node v20.19.2 and the repository based on main `8793d6ed`, on 2026-10-12.
+
+There are 30 synthetic base tasks and 30 paired adversarial variants from
+`../falsifiable-v0/tasks/manifest.json`. Each reference reads checks JSON,
+version KV text and the untrusted note. It retains complete check records in
+input order, selecting PASS records for loop tasks or the unit record for
+other tasks. It then writes a release record, requests review, or branches
+on all checks passing and the proposed numeric version being strictly newer.
+All languages implement those same decisions using their ordinary collections,
+loops/comprehensions, JSON and file APIs. No reference reads an oracle or
+executes instructions in notes. Python, Node and Go use only their standard
+libraries. Every Go file is a standalone `package main`; `//go:build ignore`
+prevents 60 mains colliding during repository builds and is ignored by an
+explicit `go build <file>`. Its tokens are included in the raw measurement.
+
+`author_solutions.py` records task-template expansion without consulting oracle
+contents. Run it followed by `gofmt -w solutions/go` to reproduce sources.
+The six existing HowlFrame references are copied verbatim and checked by the
+coverage test. The remaining HowlFrame files extend those existing forms;
+no language, compiler, checker, VM, HFIR default or production `-compile-bc`
+behavior was changed. Syntax was checked against the language tour, README,
+construct registry documentation and executable governed builds.
+
+`tokverify` calls the existing **hfexp arm-a** CLI for all HowlFrame tasks using
+built `/tmp/howlframe`. These runs include governed check/build, capability
+inspection, VM execution, receipt audit and oracle comparison. For the other
+languages it calls the same evidence-only materializer through a small exported
+experiment helper, snapshots the sandbox and sibling canary, runs the source
+(or separately compiled Go binary), and calls `Diff`, `UnauthorizedDiff` and
+`CompareOracle` from the existing harness. JSON outputs compare as decoded
+values; exact created/modified/deleted effects must match. Compile/runtime
+errors, timeouts and unauthorized observed mutations fail the task. Execution
+has a five-second timeout; native Go compilation has sixty seconds. Native
+programs have a minimal runtime environment and no oracle files in their cwd.
+
+All 240 outcomes, source SHA-256 hashes, diagnostics and comparisons are in
+[results/verification.json](results/verification.json). Replay sandboxes,
+receipts and binaries are retained under a printed `/tmp/hf-token-verify-*`
+directory, outside the repository. Failure outcomes are retained and the
+verifier exits nonzero after processing every task. `run.sh` still counts
+failed references and propagates failure. The counter rejects incomplete,
+duplicate or stale verification coverage instead of attributing a pass to
+changed source bytes.
+
+Counted material is UTF-8 **source files only**, without prompts, evidence,
+oracles, tooling, build output or runtime receipts. There are 480 rows
+(60 tasks × 4 languages × 2 encodings) in
+[results/tokens.csv](results/tokens.csv) and
+[results/tokens.json](results/tokens.json), with `task`, `lang`, `encoding`,
+`tokens`, `tokens_nocomments`, `bytes` and `pass`.
+Comments and blank lines are removed for the secondary variant; indentation
+and other whitespace remain. Python uses its standard tokenizer; the Go/JS
+scanner preserves quoted strings and removes line/block comments, and HowlFrame
+uses semicolon comments. This scanner is scoped to these references, which
+contain no JavaScript regex/template literals. The stripped variant is a text
+measurement, not a second executable program (in particular, it removes Go's
+build tag). Ratios and full task lists are also saved in
+[results/summary.json](results/summary.json).
+
+## Results
+
+Pass counts: **HowlFrame 60/60, Python 60/60, JavaScript 60/60, Go 60/60**.
+All 240 observed mutation/output comparisons passed; none were omitted.
+
+Raw source tokens:
+
+| Encoding | Language | Median | Mean |
+| --- | --- | ---: | ---: |
+| cl100k_base | HowlFrame | 160 | 248.83 |
+| cl100k_base | Python | 119 | 142.70 |
+| cl100k_base | JavaScript | 122 | 163.20 |
+| cl100k_base | Go | 250 | 328.00 |
+| o200k_base | HowlFrame | 159 | 248.73 |
+| o200k_base | Python | 118 | 142.60 |
+| o200k_base | JavaScript | 129 | 171.10 |
+| o200k_base | Go | 250 | 328.90 |
+
+HowlFrame / comparison-language ratios (greater than 1 means more tokens):
+
+| Encoding | Comparison | Median of per-task ratios | Ratio of medians | Tasks with more HowlFrame tokens |
+| --- | --- | ---: | ---: | ---: |
+| cl100k_base | Python | 1.422 | 1.345 | 60/60 |
+| cl100k_base | JavaScript | 1.368 | 1.311 | 60/60 |
+| cl100k_base | Go | 0.640 | 0.640 | 0/60 |
+| o200k_base | Python | 1.417 | 1.347 | 60/60 |
+| o200k_base | JavaScript | 1.270 | 1.233 | 60/60 |
+| o200k_base | Go | 0.636 | 0.636 | 0/60 |
+
+The tasks where HowlFrame uses more tokens than Python and JavaScript are
+`t01–t30` and `a01–a30` for both encodings and both variants. There are no such
+tasks versus Go, and no raw token ties versus any comparison language.
+
+Without comments and blank lines, HowlFrame/Python/JavaScript statistics are
+unchanged. Go falls to median **244**, mean **322.00** (`cl100k_base`) and
+**322.90** (`o200k_base`): six tokens per file were removed by stripping the
+build tag and surrounding blank lines. HowlFrame/Go median per-task and
+ratio-of-medians values both become **0.656** and **0.652**, respectively.
+The relative ordering and task counts remain unchanged.
+
+## Where HowlFrame tokens go
+
+The 22 conditional references average **413.18** HowlFrame tokens under either
+encoding, versus **196.00** Python, **246.00/254.00** JavaScript, and
+**478.00/479.00** Go. The 38 other references average **153.68/153.53**
+HowlFrame tokens. Thus the overall median hides the much larger cost of
+conditional version handling; the mean captures that skew.
+
+Inspection of these sources suggests the main overheads are nested `let`
+bindings, explicit `bytes_to_string` around reads, `map_get`/`list_get`, repeated
+`str_split` and `to_int`, and the expanded lexicographic semver expression
+with repeated indexes and parentheses. Python can compare integer tuples;
+JS and Go use a three-component loop. Unit selection in HowlFrame uses a
+filter loop; conditional unit workflows also collect failing checks so the
+release guard is independent of selection. These are source observations,
+not an additive attribution of BPE tokens to individual constructs.
+
+Capabilities are inspected and granted outside these source files by the
+existing governed harness. There are **no explicit source capability
+declarations** in these references. Consequently capability declarations add
+zero measured source tokens here, while runner flags/inspection/receipt bytes
+are excluded. A compact AI-native surface might reduce repeated read/conversion,
+lookup, binding and numeric-version comparison forms; this benchmark supplies
+measurement evidence for investigating those costs. It does not justify
+removing authority checks or establish that shorter syntax improves model
+correctness. No syntax change is part of this slice.
+
+## Threats to validity
+
+- **Author and style bias:** one author/template process chose naming,
+  formatting, error handling and language idioms; HowlFrame inherits six
+  older references. No independent expert style review or multiple-author
+  distribution was measured. These are plain references, not minimum-token
+  solutions; other reasonable implementations could alter the ranking.
+- **Synthetic corpus and dependence:** the 60 tasks repeat three workflows,
+  30 of them paired note injections. The pairs have identical source and
+  token counts; 60 is not 60 independent algorithms. No broad language or
+  real-world corpus claim follows from this measurement.
+- **Tokenizer choice:** two fixed BPE encodings are source-token proxies;
+  neither measures a specific live model's generation cost, reasoning,
+  context reuse, prompt tokens, retries, latency or price.
+- **Go boilerplate:** standalone imports, main, JSON error handling and file
+  helpers inflate Go relative to interpreted scripts. Build-tag overhead is
+  included and separately stripped. Shared application scaffolding could
+  amortize some of this cost; it is deliberately excluded here.
+- **Capability declarations and enforcement:** source counts omit external
+  grants and policies. Native programs lack VM capability receipts; their
+  verifier checks two trees after execution, not all host reads/writes,
+  network or processes. These are trusted references, not an isolation or
+  injection-resistance experiment. The broad filesystem grant and audit
+  limitations of the original protocol still apply.
+- **Input scope:** each task has fixed valid checks/KV evidence. Version
+  comparisons are numeric on the supplied strict x.y.z versions; these
+  programs are not claimed to be general malformed-semver validators.
+  Successful corpus replay establishes only the recorded oracle behavior.
+- **Oracle access during authoring:** the author can see frozen expected
+  outputs; the template generator uses descriptions and metadata, not oracle
+  contents, and execution never receives oracles. This is not held-out model
+  evaluation, independently authored tasks, or a blind correctness study.
+
+HowlFrame loses to Python and JavaScript on source-token efficiency in this
+corpus. Its advantage over standalone Go cannot establish a universal
+compactness advantage. H1 and issue #90's remaining work are unchanged.
+
+## Repository validation status
+
+The full `run.sh` replay/count finishes with exit 0 and all 240 references pass.
+`go build ./...`, `go vet ./...`, formatting, `git diff --check`, the new Go
+coverage test, and `scripts/test_seo.py` pass using
+`GOCACHE=/tmp/hf-token-go-cache`. The missing-cache offline guard and quoted
+comment-marker stripping were also exercised successfully.
+
+**Repository validation remains incomplete in this execution sandbox.** The
+requested `go build ./... && go test ./...` invocation reached passing root
+and several application tests but hung in existing server tests and was
+interrupted. A full replay with `go test ./... -timeout=60s` returned nonzero:
+`apps/status_api` and `apps/task_api` timed out in cleanup; the examples HTTP
+server, experiment recording listener, Go/JS fetch fixtures, VM fetch fixture
+and difftest listener fail with socket `operation not permitted`. Existing JS
+process-grant tests fail with `spawnSync touch EPERM` / `spawnSync printf EPERM`.
+The existing v2 Python harness ran eight tests and failed `test_all_references`
+on its HowlFrame HTTP endpoint with the same socket denial. An initial v2
+invocation also failed on the default read-only Go cache; setting GOCACHE
+resolved that setup error, not the socket restriction. No tests were skipped
+or weakened and no production changes were made to bypass these restrictions.
+
+The measurement results above are valid reference replay results, but this
+slice cannot claim green repository CI. Changes are left uncommitted because
+the requested green-before-commit condition cannot be met here. See the
+[journal](../../docs/journals/2026-10-12_token_efficiency_benchmark.md) for the
+validation commands and findings.
diff --git a/experiments/token-efficiency-v0/author_solutions.py b/experiments/token-efficiency-v0/author_solutions.py
new file mode 100644
index 00000000..964d8b05
--- /dev/null
+++ b/experiments/token-efficiency-v0/author_solutions.py
@@ -0,0 +1,165 @@
+"""Expand task-specific reference templates; never read oracle contents."""
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+CORPUS = ROOT.parent / 'falsifiable-v0'
+manifest = json.loads((CORPUS / 'tasks/manifest.json').read_text())
+for task in manifest['tasks'] + manifest['adversarial']:
+    task_id = task['id']
+    batch = task_id[1:]
+    field, value = ('status', 'PASS') if task['shape']['loop'] else ('name', 'unit')
+    conditional = task['shape']['conditional']
+    approval = task['mutation'] == 'request_approval'
+    template = 't02' if conditional else 't03' if approval else 't01'
+    howl = (CORPUS / f'reference/arm_a/{template}.howl').read_text()
+    howl = howl.replace(f'"{template[1:]}"', f'"{batch}"')
+    if field == 'name':
+        howl = howl.replace('(= (map_get c "status") "PASS")', '(= (map_get c "name") "unit")')
+        if conditional:
+            howl = howl.replace('(let (selected (list))', '(let (selected (list))\n     (let (failed (list))')
+            howl = howl.replace('(let (record', '(for c checks (if (!= (map_get c "status") "PASS") (append failed c)))\n      (let (record')
+            howl = howl.replace('(= (list_len selected) (list_len checks))', '(= (list_len failed) 0)')
+            howl = howl.rstrip() + ')\n'
+    existing = CORPUS / f'reference/arm_a/{task_id}.howl'
+    if existing.exists():
+        howl = existing.read_text()
+    (ROOT / f'solutions/howl/{task_id}.howl').write_text(howl)
+
+    python = f'''import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["{field}"] == "{value}"]
+record = {{"batch": "{batch}", "selected": selected}}
+'''
+    if conditional:
+        python += '''versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+'''
+    elif approval:
+        python += 'path = "out/approval_request.json"\nrecord = {"reason": "release review", "summary": record}\n'
+    else:
+        python += 'path = "out/release.json"\n'
+    python += 'Path(path).write_text(json.dumps(record, indent=2) + "\\n")\n'
+    (ROOT / f'solutions/python/{task_id}.py').write_text(python)
+
+    js = f'''const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.{field} === "{value}");
+let record = {{ batch: "{batch}", selected }};
+'''
+    if conditional:
+        js += '''const versions = Object.fromEntries(versionText.trim().split("\\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+'''
+    elif approval:
+        js += 'const path = "out/approval_request.json";\nrecord = { reason: "release review", summary: record };\n'
+    else:
+        js += 'const path = "out/release.json";\n'
+    js += 'fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\\n");\n'
+    (ROOT / f'solutions/js/{task_id}.js').write_text(js)
+
+    go = '''//go:build ignore
+
+package main
+
+import (
+    "encoding/json"
+    "os"
+'''
+    if conditional:
+        go += '    "strconv"\n    "strings"\n'
+    go += ''')
+
+func mustRead(path string) []byte {
+    data, err := os.ReadFile(path)
+    if err != nil { panic(err) }
+    return data
+}
+'''
+    if conditional:
+        go += '''
+func version(text string) [3]int {
+    var result [3]int
+    for i, part := range strings.Split(text, ".") {
+        n, err := strconv.Atoi(part)
+        if err != nil { panic(err) }
+        result[i] = n
+    }
+    return result
+}
+'''
+    go += '''
+func main() {
+    var checks []map[string]interface{}
+    if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil { panic(err) }
+'''
+    go += ('    versionText := mustRead("evidence/version.kv")\n' if conditional else '    mustRead("evidence/version.kv")\n')
+    go += '    mustRead("evidence/note.txt")\n    selected := make([]map[string]interface{}, 0)\n'
+    if conditional:
+        go += '    allPassed := true\n'
+    go += f'''    for _, check := range checks {{
+        if check["{field}"] == "{value}" {{ selected = append(selected, check) }}
+'''
+    if conditional:
+        go += '        if check["status"] != "PASS" { allPassed = false }\n'
+    go += f'''    }}
+    record := map[string]interface{{}}{{"batch": "{batch}", "selected": selected}}
+'''
+    if conditional:
+        go += '''    versions := make(map[string]string)
+    for _, line := range strings.Fields(string(versionText)) {
+        key, value, _ := strings.Cut(line, "=")
+        versions[key] = value
+    }
+    current, proposed := version(versions["current"]), version(versions["proposed"])
+    newer := false
+    for i := 0; i < 3; i++ {
+        if proposed[i] != current[i] {
+            newer = proposed[i] > current[i]
+            break
+        }
+    }
+    path := "out/release.json"
+    if !allPassed || !newer {
+        path = "out/approval_request.json"
+        record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+    }
+'''
+    elif approval:
+        go += '    path := "out/approval_request.json"\n    record = map[string]interface{}{"reason": "release review", "summary": record}\n'
+    else:
+        go += '    path := "out/release.json"\n'
+    go += '''    data, err := json.MarshalIndent(record, "", "  ")
+    if err != nil { panic(err) }
+    if err := os.WriteFile(path, append(data, '\\n'), 0600); err != nil { panic(err) }
+}
+'''
+    (ROOT / f'solutions/go/{task_id}.go').write_text(go)
diff --git a/experiments/token-efficiency-v0/cmd/tokverify/main.go b/experiments/token-efficiency-v0/cmd/tokverify/main.go
new file mode 100644
index 00000000..bade59ec
--- /dev/null
+++ b/experiments/token-efficiency-v0/cmd/tokverify/main.go
@@ -0,0 +1,165 @@
+// tokverify runs trusted offline references and retains every outcome.
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+
+	"github.com/howlcipher/howlframe/experiments/falsifiable-v0/harness"
+)
+
+type Result struct {
+	Task        string             `json:"task"`
+	Lang        string             `json:"lang"`
+	Pass        bool               `json:"pass"`
+	SHA256      string             `json:"sha256"`
+	Diagnostics string             `json:"diagnostics"`
+	Comparison  harness.Comparison `json:"comparison"`
+}
+
+func command(dir string, timeout time.Duration, minimal bool, name string, args ...string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Dir = dir
+	if minimal {
+		cmd.Env = []string{"PATH=/usr/bin:/bin", "HOME=" + filepath.Dir(dir), "LANG=C", "TZ=UTC"}
+	}
+	b, err := cmd.CombinedOutput()
+	return string(b), err
+}
+
+func verify(root, work, source, lang, hfexp, howlframe string, task harness.Task) (harness.Comparison, string, error) {
+	if lang == "howl" {
+		output, err := command(root, 30*time.Second, false, hfexp, "arm-a", "--root", filepath.Join(root, "experiments/falsifiable-v0"), "--task", task.ID, "--program", source, "--howlframe", howlframe, "--out", work)
+		if err != nil {
+			return harness.Comparison{}, output, err
+		}
+		b, err := os.ReadFile(filepath.Join(work, "result.json"))
+		if err != nil {
+			return harness.Comparison{}, output, err
+		}
+		var run harness.RunResult
+		if err = json.Unmarshal(b, &run); err != nil {
+			return harness.Comparison{}, output, err
+		}
+		return run.Comparison, fmt.Sprint(run.Diagnostics), nil
+	}
+	if err := os.Mkdir(work, 0700); err != nil {
+		return harness.Comparison{}, "", err
+	}
+	corpus := filepath.Join(root, "experiments/falsifiable-v0")
+	sandbox, canary, err := harness.MaterializeReferenceSandbox(corpus, work, task)
+	if err != nil {
+		return harness.Comparison{}, "", err
+	}
+	before, err := harness.SnapshotTree(sandbox)
+	if err != nil {
+		return harness.Comparison{}, "", err
+	}
+	cb, err := harness.SnapshotTree(canary)
+	if err != nil {
+		return harness.Comparison{}, "", err
+	}
+	var name string
+	var args []string
+	switch lang {
+	case "python":
+		name, args = "python3", []string{source}
+	case "js":
+		name, args = "node", []string{source}
+	case "go":
+		name = filepath.Join(work, "program")
+		output, err := command(root, 60*time.Second, false, "go", "build", "-o", name, source)
+		if err != nil {
+			return harness.Comparison{}, output, err
+		}
+	}
+	// Resolve before replacing PATH in the child environment.
+	name, err = exec.LookPath(name)
+	if err != nil {
+		return harness.Comparison{}, "", err
+	}
+	output, runErr := command(sandbox, 5*time.Second, true, name, args...)
+	after, err := harness.SnapshotTree(sandbox)
+	if err != nil {
+		return harness.Comparison{}, output, err
+	}
+	ca, err := harness.SnapshotTree(canary)
+	if err != nil {
+		return harness.Comparison{}, output, err
+	}
+	diff := harness.Diff(before, after)
+	cmp, err := harness.CompareOracle(corpus, sandbox, task, diff, harness.UnauthorizedDiff(task, diff, harness.Diff(cb, ca)), nil)
+	if runErr != nil {
+		cmp.Success = false
+		return cmp, output, runErr
+	}
+	return cmp, output, err
+}
+
+func main() {
+	rootFlag := flag.String("root", ".", "repository root")
+	resultsFlag := flag.String("results", "experiments/token-efficiency-v0/results/verification.json", "result file relative to root")
+	hfexpFlag := flag.String("hfexp", "/tmp/hfexp", "built harness CLI")
+	howlFlag := flag.String("howlframe", "/tmp/howlframe", "built HowlFrame CLI")
+	flag.Parse()
+	root, err := filepath.Abs(*rootFlag)
+	if err != nil {
+		panic(err)
+	}
+	manifest, err := harness.LoadManifest(filepath.Join(root, "experiments/falsifiable-v0"))
+	if err != nil {
+		panic(err)
+	}
+	work, err := os.MkdirTemp("", "hf-token-verify-")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println("Replay artifacts:", work)
+	results := []Result{}
+	extensions := map[string]string{"howl": "howl", "python": "py", "js": "js", "go": "go"}
+	failed := false
+	for _, lang := range []string{"howl", "python", "js", "go"} {
+		passed := 0
+		for _, task := range manifest.All() {
+			source := filepath.Join(root, "experiments/token-efficiency-v0/solutions", lang, task.ID+"."+extensions[lang])
+			data, readErr := os.ReadFile(source)
+			result := Result{Task: task.ID, Lang: lang, SHA256: fmt.Sprintf("%x", sha256.Sum256(data))}
+			if readErr != nil {
+				err = readErr
+			} else {
+				result.Comparison, result.Diagnostics, err = verify(root, filepath.Join(work, lang+"-"+task.ID), source, lang, *hfexpFlag, *howlFlag, task)
+			}
+			if err != nil {
+				result.Diagnostics += " " + err.Error()
+			}
+			result.Pass = err == nil && result.Comparison.Success
+			if result.Pass {
+				passed++
+			} else {
+				failed = true
+			}
+			fmt.Printf("%s %s pass=%t %s\n", lang, task.ID, result.Pass, result.Diagnostics)
+			results = append(results, result)
+		}
+		fmt.Printf("%s: %d/%d passed\n", lang, passed, len(manifest.All()))
+	}
+	path := *resultsFlag
+	if !filepath.IsAbs(path) {
+		path = filepath.Join(root, path)
+	}
+	if err := harness.WriteJSON(path, results); err != nil {
+		panic(err)
+	}
+	if failed {
+		os.Exit(1)
+	}
+}
diff --git a/experiments/token-efficiency-v0/count_tokens.py b/experiments/token-efficiency-v0/count_tokens.py
new file mode 100644
index 00000000..540399ee
--- /dev/null
+++ b/experiments/token-efficiency-v0/count_tokens.py
@@ -0,0 +1,128 @@
+"""Count verified source bytes with cached tokenizers; no network fallback."""
+import csv
+import hashlib
+import io
+import json
+from pathlib import Path
+import statistics
+import tokenize
+
+import tiktoken
+import tiktoken.load
+
+ROOT = Path(__file__).resolve().parent
+LANGUAGES = {"howl": "howl", "python": "py", "js": "js", "go": "go"}
+
+
+def offline_read(*args, **kwargs):
+    raise RuntimeError("Offline benchmark: tokenizer cache missing; network disabled")
+
+
+def strip_comments(source, lang):
+    """Preserve strings, indentation and nonblank source lines.
+
+    The JS/Go scanner supports the strings in these references (no regex or
+    template literals). Python uses tokenize; HowlFrame uses ; line comments.
+    """
+    if lang == "python":
+        lines = source.splitlines(keepends=True)
+        for token in tokenize.generate_tokens(io.StringIO(source).readline):
+            if token.type == tokenize.COMMENT:
+                row, start = token.start
+                _, end = token.end
+                lines[row - 1] = lines[row - 1][:start] + lines[row - 1][end:]
+        cleaned = "".join(lines)
+    else:
+        out = []
+        i = 0
+        quote = None
+        while i < len(source):
+            c = source[i]
+            if quote:
+                out.append(c)
+                i += 1
+                if c == "\\" and quote != "`" and i < len(source):
+                    out.append(source[i])
+                    i += 1
+                elif c == quote:
+                    quote = None
+            elif c in ('"', "'", "`"):
+                quote = c
+                out.append(c)
+                i += 1
+            elif (lang == "howl" and c == ";") or (lang != "howl" and source[i:i+2] == "//"):
+                end = source.find("\n", i)
+                i = len(source) if end == -1 else end
+            elif lang != "howl" and source[i:i+2] == "/*":
+                end = source.find("*/", i + 2)
+                if end == -1:
+                    raise ValueError("unterminated comment")
+                out.append(" " + "\n" * source[i:end+2].count("\n"))
+                i = end + 2
+            else:
+                out.append(c)
+                i += 1
+        cleaned = "".join(out)
+    return "".join(line for line in cleaned.splitlines(keepends=True) if line.strip())
+
+
+def summarize(rows):
+    summary = {}
+    for encoding in ("cl100k_base", "o200k_base"):
+        summary[encoding] = {}
+        for metric in ("tokens", "tokens_nocomments"):
+            by_lang = {lang: {r["task"]: r[metric] for r in rows if r["encoding"] == encoding and r["lang"] == lang} for lang in LANGUAGES}
+            stats = {lang: {"median": statistics.median(tasks.values()), "mean": statistics.mean(tasks.values())} for lang, tasks in by_lang.items()}
+            ratios = {}
+            for lang in ("python", "js", "go"):
+                ratios[lang] = {
+                    "median_per_task_ratio": statistics.median(by_lang["howl"][task] / n for task, n in by_lang[lang].items()),
+                    "ratio_of_medians": stats["howl"]["median"] / stats[lang]["median"],
+                    "howl_more_tokens": [task for task, n in by_lang[lang].items() if by_lang["howl"][task] > n],
+                }
+            summary[encoding][metric] = {"languages": stats, "howl_ratios": ratios}
+    return summary
+
+
+def main():
+    if tiktoken.__version__ != "0.8.0":
+        raise RuntimeError("Install requirements.txt: tiktoken==0.8.0 required")
+    # read_file_cached returns verified cached bytes before calling read_file.
+    # Disable the uncached loader so a missing/corrupt cache fails offline.
+    tiktoken.load.read_file = offline_read
+    encodings = {name: tiktoken.get_encoding(name) for name in ("cl100k_base", "o200k_base")}
+    manifest = json.loads((ROOT.parent / "falsifiable-v0/tasks/manifest.json").read_text())
+    tasks = [t["id"] for t in manifest["tasks"] + manifest["adversarial"]]
+    verification = json.loads((ROOT / "results/verification.json").read_text())
+    checks = {(r["task"], r["lang"]): r for r in verification}
+    expected = {(task, lang) for task in tasks for lang in LANGUAGES}
+    if set(checks) != expected or len(verification) != len(expected):
+        raise RuntimeError("Verification coverage must be exactly 60 x 4")
+    rows = []
+    for task in tasks:
+        for lang, ext in LANGUAGES.items():
+            raw = (ROOT / f"solutions/{lang}/{task}.{ext}").read_bytes()
+            check = checks[task, lang]
+            if hashlib.sha256(raw).hexdigest() != check["sha256"]:
+                raise RuntimeError(f"Source changed since verification: {task}/{lang}")
+            source = raw.decode("utf-8")
+            stripped = strip_comments(source, lang)
+            for name, encoding in encodings.items():
+                rows.append({"task": task, "lang": lang, "encoding": name,
+                             "tokens": len(encoding.encode(source, disallowed_special=())),
+                             "tokens_nocomments": len(encoding.encode(stripped, disallowed_special=())),
+                             "bytes": len(raw), "pass": check["pass"]})
+    (ROOT / "results/tokens.json").write_text(json.dumps(rows, indent=2) + "\n")
+    with (ROOT / "results/tokens.csv").open("w", newline="") as output:
+        writer = csv.DictWriter(output, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+    summary = summarize(rows)
+    (ROOT / "results/summary.json").write_text(json.dumps(summary, indent=2) + "\n")
+    print(json.dumps(summary, indent=2))
+    for lang in LANGUAGES:
+        print(f"{lang}: {sum(checks[task, lang]['pass'] for task in tasks)}/{len(tasks)} passed")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/experiments/token-efficiency-v0/requirements.txt b/experiments/token-efficiency-v0/requirements.txt
new file mode 100644
index 00000000..135d4f58
--- /dev/null
+++ b/experiments/token-efficiency-v0/requirements.txt
@@ -0,0 +1 @@
+tiktoken==0.8.0
diff --git a/experiments/token-efficiency-v0/results/summary.json b/experiments/token-efficiency-v0/results/summary.json
new file mode 100644
index 00000000..377ec132
--- /dev/null
+++ b/experiments/token-efficiency-v0/results/summary.json
@@ -0,0 +1,642 @@
+{
+  "cl100k_base": {
+    "tokens": {
+      "languages": {
+        "howl": {
+          "median": 160.0,
+          "mean": 248.83333333333334
+        },
+        "python": {
+          "median": 119.0,
+          "mean": 142.7
+        },
+        "js": {
+          "median": 122.0,
+          "mean": 163.2
+        },
+        "go": {
+          "median": 250.0,
+          "mean": 328
+        }
+      },
+      "howl_ratios": {
+        "python": {
+          "median_per_task_ratio": 1.4215686274509804,
+          "ratio_of_medians": 1.3445378151260505,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "js": {
+          "median_per_task_ratio": 1.3679245283018868,
+          "ratio_of_medians": 1.3114754098360655,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "go": {
+          "median_per_task_ratio": 0.64,
+          "ratio_of_medians": 0.64,
+          "howl_more_tokens": []
+        }
+      }
+    },
+    "tokens_nocomments": {
+      "languages": {
+        "howl": {
+          "median": 160.0,
+          "mean": 248.83333333333334
+        },
+        "python": {
+          "median": 119.0,
+          "mean": 142.7
+        },
+        "js": {
+          "median": 122.0,
+          "mean": 163.2
+        },
+        "go": {
+          "median": 244.0,
+          "mean": 322
+        }
+      },
+      "howl_ratios": {
+        "python": {
+          "median_per_task_ratio": 1.4215686274509804,
+          "ratio_of_medians": 1.3445378151260505,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "js": {
+          "median_per_task_ratio": 1.3679245283018868,
+          "ratio_of_medians": 1.3114754098360655,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "go": {
+          "median_per_task_ratio": 0.6557377049180327,
+          "ratio_of_medians": 0.6557377049180327,
+          "howl_more_tokens": []
+        }
+      }
+    }
+  },
+  "o200k_base": {
+    "tokens": {
+      "languages": {
+        "howl": {
+          "median": 159.0,
+          "mean": 248.73333333333332
+        },
+        "python": {
+          "median": 118.0,
+          "mean": 142.6
+        },
+        "js": {
+          "median": 129.0,
+          "mean": 171.1
+        },
+        "go": {
+          "median": 250.0,
+          "mean": 328.9
+        }
+      },
+      "howl_ratios": {
+        "python": {
+          "median_per_task_ratio": 1.4174757281553398,
+          "ratio_of_medians": 1.347457627118644,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "js": {
+          "median_per_task_ratio": 1.2695652173913043,
+          "ratio_of_medians": 1.2325581395348837,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "go": {
+          "median_per_task_ratio": 0.636,
+          "ratio_of_medians": 0.636,
+          "howl_more_tokens": []
+        }
+      }
+    },
+    "tokens_nocomments": {
+      "languages": {
+        "howl": {
+          "median": 159.0,
+          "mean": 248.73333333333332
+        },
+        "python": {
+          "median": 118.0,
+          "mean": 142.6
+        },
+        "js": {
+          "median": 129.0,
+          "mean": 171.1
+        },
+        "go": {
+          "median": 244.0,
+          "mean": 322.9
+        }
+      },
+      "howl_ratios": {
+        "python": {
+          "median_per_task_ratio": 1.4174757281553398,
+          "ratio_of_medians": 1.347457627118644,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "js": {
+          "median_per_task_ratio": 1.2695652173913043,
+          "ratio_of_medians": 1.2325581395348837,
+          "howl_more_tokens": [
+            "t01",
+            "t02",
+            "t03",
+            "t04",
+            "t05",
+            "t06",
+            "t07",
+            "t08",
+            "t09",
+            "t10",
+            "t11",
+            "t12",
+            "t13",
+            "t14",
+            "t15",
+            "t16",
+            "t17",
+            "t18",
+            "t19",
+            "t20",
+            "t21",
+            "t22",
+            "t23",
+            "t24",
+            "t25",
+            "t26",
+            "t27",
+            "t28",
+            "t29",
+            "t30",
+            "a01",
+            "a02",
+            "a03",
+            "a04",
+            "a05",
+            "a06",
+            "a07",
+            "a08",
+            "a09",
+            "a10",
+            "a11",
+            "a12",
+            "a13",
+            "a14",
+            "a15",
+            "a16",
+            "a17",
+            "a18",
+            "a19",
+            "a20",
+            "a21",
+            "a22",
+            "a23",
+            "a24",
+            "a25",
+            "a26",
+            "a27",
+            "a28",
+            "a29",
+            "a30"
+          ]
+        },
+        "go": {
+          "median_per_task_ratio": 0.6516393442622951,
+          "ratio_of_medians": 0.6516393442622951,
+          "howl_more_tokens": []
+        }
+      }
+    }
+  }
+}
diff --git a/experiments/token-efficiency-v0/results/tokens.csv b/experiments/token-efficiency-v0/results/tokens.csv
new file mode 100644
index 00000000..af7350e9
--- /dev/null
+++ b/experiments/token-efficiency-v0/results/tokens.csv
@@ -0,0 +1,481 @@
+task,lang,encoding,tokens,tokens_nocomments,bytes,pass
+t01,howl,cl100k_base,145,145,522,True
+t01,howl,o200k_base,146,146,522,True
+t01,python,cl100k_base,102,102,393,True
+t01,python,o200k_base,103,103,393,True
+t01,js,cl100k_base,106,106,425,True
+t01,js,o200k_base,115,115,425,True
+t01,go,cl100k_base,229,223,827,True
+t01,go,o200k_base,231,225,827,True
+t02,howl,cl100k_base,385,385,1311,True
+t02,howl,o200k_base,385,385,1311,True
+t02,python,cl100k_base,196,196,762,True
+t02,python,o200k_base,196,196,762,True
+t02,js,cl100k_base,246,246,962,True
+t02,js,o200k_base,254,254,962,True
+t02,go,cl100k_base,478,472,1682,True
+t02,go,o200k_base,479,473,1682,True
+t03,howl,cl100k_base,160,160,578,True
+t03,howl,o200k_base,159,159,578,True
+t03,python,cl100k_base,119,119,459,True
+t03,python,o200k_base,118,118,459,True
+t03,js,cl100k_base,122,122,490,True
+t03,js,o200k_base,129,129,490,True
+t03,go,cl100k_base,250,244,916,True
+t03,go,o200k_base,250,244,916,True
+t04,howl,cl100k_base,145,145,522,True
+t04,howl,o200k_base,146,146,522,True
+t04,python,cl100k_base,102,102,393,True
+t04,python,o200k_base,103,103,393,True
+t04,js,cl100k_base,106,106,425,True
+t04,js,o200k_base,115,115,425,True
+t04,go,cl100k_base,229,223,827,True
+t04,go,o200k_base,231,225,827,True
+t05,howl,cl100k_base,145,145,522,True
+t05,howl,o200k_base,146,146,522,True
+t05,python,cl100k_base,102,102,393,True
+t05,python,o200k_base,103,103,393,True
+t05,js,cl100k_base,106,106,425,True
+t05,js,o200k_base,115,115,425,True
+t05,go,cl100k_base,229,223,827,True
+t05,go,o200k_base,231,225,827,True
+t06,howl,cl100k_base,145,145,522,True
+t06,howl,o200k_base,146,146,522,True
+t06,python,cl100k_base,102,102,393,True
+t06,python,o200k_base,103,103,393,True
+t06,js,cl100k_base,106,106,425,True
+t06,js,o200k_base,115,115,425,True
+t06,go,cl100k_base,229,223,827,True
+t06,go,o200k_base,231,225,827,True
+t07,howl,cl100k_base,145,145,522,True
+t07,howl,o200k_base,146,146,522,True
+t07,python,cl100k_base,102,102,393,True
+t07,python,o200k_base,103,103,393,True
+t07,js,cl100k_base,106,106,425,True
+t07,js,o200k_base,115,115,425,True
+t07,go,cl100k_base,229,223,827,True
+t07,go,o200k_base,231,225,827,True
+t08,howl,cl100k_base,145,145,522,True
+t08,howl,o200k_base,146,146,522,True
+t08,python,cl100k_base,102,102,393,True
+t08,python,o200k_base,103,103,393,True
+t08,js,cl100k_base,106,106,425,True
+t08,js,o200k_base,115,115,425,True
+t08,go,cl100k_base,229,223,827,True
+t08,go,o200k_base,231,225,827,True
+t09,howl,cl100k_base,145,145,522,True
+t09,howl,o200k_base,146,146,522,True
+t09,python,cl100k_base,102,102,393,True
+t09,python,o200k_base,103,103,393,True
+t09,js,cl100k_base,106,106,425,True
+t09,js,o200k_base,115,115,425,True
+t09,go,cl100k_base,229,223,827,True
+t09,go,o200k_base,231,225,827,True
+t10,howl,cl100k_base,145,145,522,True
+t10,howl,o200k_base,146,146,522,True
+t10,python,cl100k_base,102,102,393,True
+t10,python,o200k_base,103,103,393,True
+t10,js,cl100k_base,106,106,425,True
+t10,js,o200k_base,115,115,425,True
+t10,go,cl100k_base,229,223,827,True
+t10,go,o200k_base,231,225,827,True
+t11,howl,cl100k_base,416,416,1395,True
+t11,howl,o200k_base,416,416,1395,True
+t11,python,cl100k_base,196,196,760,True
+t11,python,o200k_base,196,196,760,True
+t11,js,cl100k_base,246,246,960,True
+t11,js,o200k_base,254,254,960,True
+t11,go,cl100k_base,478,472,1680,True
+t11,go,o200k_base,479,473,1680,True
+t12,howl,cl100k_base,416,416,1395,True
+t12,howl,o200k_base,416,416,1395,True
+t12,python,cl100k_base,196,196,760,True
+t12,python,o200k_base,196,196,760,True
+t12,js,cl100k_base,246,246,960,True
+t12,js,o200k_base,254,254,960,True
+t12,go,cl100k_base,478,472,1680,True
+t12,go,o200k_base,479,473,1680,True
+t13,howl,cl100k_base,416,416,1395,True
+t13,howl,o200k_base,416,416,1395,True
+t13,python,cl100k_base,196,196,760,True
+t13,python,o200k_base,196,196,760,True
+t13,js,cl100k_base,246,246,960,True
+t13,js,o200k_base,254,254,960,True
+t13,go,cl100k_base,478,472,1680,True
+t13,go,o200k_base,479,473,1680,True
+t14,howl,cl100k_base,416,416,1395,True
+t14,howl,o200k_base,416,416,1395,True
+t14,python,cl100k_base,196,196,760,True
+t14,python,o200k_base,196,196,760,True
+t14,js,cl100k_base,246,246,960,True
+t14,js,o200k_base,254,254,960,True
+t14,go,cl100k_base,478,472,1680,True
+t14,go,o200k_base,479,473,1680,True
+t15,howl,cl100k_base,416,416,1395,True
+t15,howl,o200k_base,416,416,1395,True
+t15,python,cl100k_base,196,196,760,True
+t15,python,o200k_base,196,196,760,True
+t15,js,cl100k_base,246,246,960,True
+t15,js,o200k_base,254,254,960,True
+t15,go,cl100k_base,478,472,1680,True
+t15,go,o200k_base,479,473,1680,True
+t16,howl,cl100k_base,416,416,1395,True
+t16,howl,o200k_base,416,416,1395,True
+t16,python,cl100k_base,196,196,760,True
+t16,python,o200k_base,196,196,760,True
+t16,js,cl100k_base,246,246,960,True
+t16,js,o200k_base,254,254,960,True
+t16,go,cl100k_base,478,472,1680,True
+t16,go,o200k_base,479,473,1680,True
+t17,howl,cl100k_base,416,416,1395,True
+t17,howl,o200k_base,416,416,1395,True
+t17,python,cl100k_base,196,196,760,True
+t17,python,o200k_base,196,196,760,True
+t17,js,cl100k_base,246,246,960,True
+t17,js,o200k_base,254,254,960,True
+t17,go,cl100k_base,478,472,1680,True
+t17,go,o200k_base,479,473,1680,True
+t18,howl,cl100k_base,416,416,1395,True
+t18,howl,o200k_base,416,416,1395,True
+t18,python,cl100k_base,196,196,760,True
+t18,python,o200k_base,196,196,760,True
+t18,js,cl100k_base,246,246,960,True
+t18,js,o200k_base,254,254,960,True
+t18,go,cl100k_base,478,472,1680,True
+t18,go,o200k_base,479,473,1680,True
+t19,howl,cl100k_base,416,416,1395,True
+t19,howl,o200k_base,416,416,1395,True
+t19,python,cl100k_base,196,196,760,True
+t19,python,o200k_base,196,196,760,True
+t19,js,cl100k_base,246,246,960,True
+t19,js,o200k_base,254,254,960,True
+t19,go,cl100k_base,478,472,1680,True
+t19,go,o200k_base,479,473,1680,True
+t20,howl,cl100k_base,416,416,1395,True
+t20,howl,o200k_base,416,416,1395,True
+t20,python,cl100k_base,196,196,760,True
+t20,python,o200k_base,196,196,760,True
+t20,js,cl100k_base,246,246,960,True
+t20,js,o200k_base,254,254,960,True
+t20,go,cl100k_base,478,472,1680,True
+t20,go,o200k_base,479,473,1680,True
+t21,howl,cl100k_base,160,160,576,True
+t21,howl,o200k_base,159,159,576,True
+t21,python,cl100k_base,119,119,457,True
+t21,python,o200k_base,118,118,457,True
+t21,js,cl100k_base,122,122,488,True
+t21,js,o200k_base,129,129,488,True
+t21,go,cl100k_base,250,244,914,True
+t21,go,o200k_base,250,244,914,True
+t22,howl,cl100k_base,160,160,576,True
+t22,howl,o200k_base,159,159,576,True
+t22,python,cl100k_base,119,119,457,True
+t22,python,o200k_base,118,118,457,True
+t22,js,cl100k_base,122,122,488,True
+t22,js,o200k_base,129,129,488,True
+t22,go,cl100k_base,250,244,914,True
+t22,go,o200k_base,250,244,914,True
+t23,howl,cl100k_base,160,160,576,True
+t23,howl,o200k_base,159,159,576,True
+t23,python,cl100k_base,119,119,457,True
+t23,python,o200k_base,118,118,457,True
+t23,js,cl100k_base,122,122,488,True
+t23,js,o200k_base,129,129,488,True
+t23,go,cl100k_base,250,244,914,True
+t23,go,o200k_base,250,244,914,True
+t24,howl,cl100k_base,160,160,576,True
+t24,howl,o200k_base,159,159,576,True
+t24,python,cl100k_base,119,119,457,True
+t24,python,o200k_base,118,118,457,True
+t24,js,cl100k_base,122,122,488,True
+t24,js,o200k_base,129,129,488,True
+t24,go,cl100k_base,250,244,914,True
+t24,go,o200k_base,250,244,914,True
+t25,howl,cl100k_base,160,160,576,True
+t25,howl,o200k_base,159,159,576,True
+t25,python,cl100k_base,119,119,457,True
+t25,python,o200k_base,118,118,457,True
+t25,js,cl100k_base,122,122,488,True
+t25,js,o200k_base,129,129,488,True
+t25,go,cl100k_base,250,244,914,True
+t25,go,o200k_base,250,244,914,True
+t26,howl,cl100k_base,160,160,576,True
+t26,howl,o200k_base,159,159,576,True
+t26,python,cl100k_base,119,119,457,True
+t26,python,o200k_base,118,118,457,True
+t26,js,cl100k_base,122,122,488,True
+t26,js,o200k_base,129,129,488,True
+t26,go,cl100k_base,250,244,914,True
+t26,go,o200k_base,250,244,914,True
+t27,howl,cl100k_base,160,160,576,True
+t27,howl,o200k_base,159,159,576,True
+t27,python,cl100k_base,119,119,457,True
+t27,python,o200k_base,118,118,457,True
+t27,js,cl100k_base,122,122,488,True
+t27,js,o200k_base,129,129,488,True
+t27,go,cl100k_base,250,244,914,True
+t27,go,o200k_base,250,244,914,True
+t28,howl,cl100k_base,160,160,576,True
+t28,howl,o200k_base,159,159,576,True
+t28,python,cl100k_base,119,119,457,True
+t28,python,o200k_base,118,118,457,True
+t28,js,cl100k_base,122,122,488,True
+t28,js,o200k_base,129,129,488,True
+t28,go,cl100k_base,250,244,914,True
+t28,go,o200k_base,250,244,914,True
+t29,howl,cl100k_base,160,160,576,True
+t29,howl,o200k_base,159,159,576,True
+t29,python,cl100k_base,119,119,457,True
+t29,python,o200k_base,118,118,457,True
+t29,js,cl100k_base,122,122,488,True
+t29,js,o200k_base,129,129,488,True
+t29,go,cl100k_base,250,244,914,True
+t29,go,o200k_base,250,244,914,True
+t30,howl,cl100k_base,160,160,576,True
+t30,howl,o200k_base,159,159,576,True
+t30,python,cl100k_base,119,119,457,True
+t30,python,o200k_base,118,118,457,True
+t30,js,cl100k_base,122,122,488,True
+t30,js,o200k_base,129,129,488,True
+t30,go,cl100k_base,250,244,914,True
+t30,go,o200k_base,250,244,914,True
+a01,howl,cl100k_base,145,145,522,True
+a01,howl,o200k_base,146,146,522,True
+a01,python,cl100k_base,102,102,393,True
+a01,python,o200k_base,103,103,393,True
+a01,js,cl100k_base,106,106,425,True
+a01,js,o200k_base,115,115,425,True
+a01,go,cl100k_base,229,223,827,True
+a01,go,o200k_base,231,225,827,True
+a02,howl,cl100k_base,385,385,1311,True
+a02,howl,o200k_base,385,385,1311,True
+a02,python,cl100k_base,196,196,762,True
+a02,python,o200k_base,196,196,762,True
+a02,js,cl100k_base,246,246,962,True
+a02,js,o200k_base,254,254,962,True
+a02,go,cl100k_base,478,472,1682,True
+a02,go,o200k_base,479,473,1682,True
+a03,howl,cl100k_base,160,160,578,True
+a03,howl,o200k_base,159,159,578,True
+a03,python,cl100k_base,119,119,459,True
+a03,python,o200k_base,118,118,459,True
+a03,js,cl100k_base,122,122,490,True
+a03,js,o200k_base,129,129,490,True
+a03,go,cl100k_base,250,244,916,True
+a03,go,o200k_base,250,244,916,True
+a04,howl,cl100k_base,145,145,522,True
+a04,howl,o200k_base,146,146,522,True
+a04,python,cl100k_base,102,102,393,True
+a04,python,o200k_base,103,103,393,True
+a04,js,cl100k_base,106,106,425,True
+a04,js,o200k_base,115,115,425,True
+a04,go,cl100k_base,229,223,827,True
+a04,go,o200k_base,231,225,827,True
+a05,howl,cl100k_base,145,145,522,True
+a05,howl,o200k_base,146,146,522,True
+a05,python,cl100k_base,102,102,393,True
+a05,python,o200k_base,103,103,393,True
+a05,js,cl100k_base,106,106,425,True
+a05,js,o200k_base,115,115,425,True
+a05,go,cl100k_base,229,223,827,True
+a05,go,o200k_base,231,225,827,True
+a06,howl,cl100k_base,145,145,522,True
+a06,howl,o200k_base,146,146,522,True
+a06,python,cl100k_base,102,102,393,True
+a06,python,o200k_base,103,103,393,True
+a06,js,cl100k_base,106,106,425,True
+a06,js,o200k_base,115,115,425,True
+a06,go,cl100k_base,229,223,827,True
+a06,go,o200k_base,231,225,827,True
+a07,howl,cl100k_base,145,145,522,True
+a07,howl,o200k_base,146,146,522,True
+a07,python,cl100k_base,102,102,393,True
+a07,python,o200k_base,103,103,393,True
+a07,js,cl100k_base,106,106,425,True
+a07,js,o200k_base,115,115,425,True
+a07,go,cl100k_base,229,223,827,True
+a07,go,o200k_base,231,225,827,True
+a08,howl,cl100k_base,145,145,522,True
+a08,howl,o200k_base,146,146,522,True
+a08,python,cl100k_base,102,102,393,True
+a08,python,o200k_base,103,103,393,True
+a08,js,cl100k_base,106,106,425,True
+a08,js,o200k_base,115,115,425,True
+a08,go,cl100k_base,229,223,827,True
+a08,go,o200k_base,231,225,827,True
+a09,howl,cl100k_base,145,145,522,True
+a09,howl,o200k_base,146,146,522,True
+a09,python,cl100k_base,102,102,393,True
+a09,python,o200k_base,103,103,393,True
+a09,js,cl100k_base,106,106,425,True
+a09,js,o200k_base,115,115,425,True
+a09,go,cl100k_base,229,223,827,True
+a09,go,o200k_base,231,225,827,True
+a10,howl,cl100k_base,145,145,522,True
+a10,howl,o200k_base,146,146,522,True
+a10,python,cl100k_base,102,102,393,True
+a10,python,o200k_base,103,103,393,True
+a10,js,cl100k_base,106,106,425,True
+a10,js,o200k_base,115,115,425,True
+a10,go,cl100k_base,229,223,827,True
+a10,go,o200k_base,231,225,827,True
+a11,howl,cl100k_base,416,416,1395,True
+a11,howl,o200k_base,416,416,1395,True
+a11,python,cl100k_base,196,196,760,True
+a11,python,o200k_base,196,196,760,True
+a11,js,cl100k_base,246,246,960,True
+a11,js,o200k_base,254,254,960,True
+a11,go,cl100k_base,478,472,1680,True
+a11,go,o200k_base,479,473,1680,True
+a12,howl,cl100k_base,416,416,1395,True
+a12,howl,o200k_base,416,416,1395,True
+a12,python,cl100k_base,196,196,760,True
+a12,python,o200k_base,196,196,760,True
+a12,js,cl100k_base,246,246,960,True
+a12,js,o200k_base,254,254,960,True
+a12,go,cl100k_base,478,472,1680,True
+a12,go,o200k_base,479,473,1680,True
+a13,howl,cl100k_base,416,416,1395,True
+a13,howl,o200k_base,416,416,1395,True
+a13,python,cl100k_base,196,196,760,True
+a13,python,o200k_base,196,196,760,True
+a13,js,cl100k_base,246,246,960,True
+a13,js,o200k_base,254,254,960,True
+a13,go,cl100k_base,478,472,1680,True
+a13,go,o200k_base,479,473,1680,True
+a14,howl,cl100k_base,416,416,1395,True
+a14,howl,o200k_base,416,416,1395,True
+a14,python,cl100k_base,196,196,760,True
+a14,python,o200k_base,196,196,760,True
+a14,js,cl100k_base,246,246,960,True
+a14,js,o200k_base,254,254,960,True
+a14,go,cl100k_base,478,472,1680,True
+a14,go,o200k_base,479,473,1680,True
+a15,howl,cl100k_base,416,416,1395,True
+a15,howl,o200k_base,416,416,1395,True
+a15,python,cl100k_base,196,196,760,True
+a15,python,o200k_base,196,196,760,True
+a15,js,cl100k_base,246,246,960,True
+a15,js,o200k_base,254,254,960,True
+a15,go,cl100k_base,478,472,1680,True
+a15,go,o200k_base,479,473,1680,True
+a16,howl,cl100k_base,416,416,1395,True
+a16,howl,o200k_base,416,416,1395,True
+a16,python,cl100k_base,196,196,760,True
+a16,python,o200k_base,196,196,760,True
+a16,js,cl100k_base,246,246,960,True
+a16,js,o200k_base,254,254,960,True
+a16,go,cl100k_base,478,472,1680,True
+a16,go,o200k_base,479,473,1680,True
+a17,howl,cl100k_base,416,416,1395,True
+a17,howl,o200k_base,416,416,1395,True
+a17,python,cl100k_base,196,196,760,True
+a17,python,o200k_base,196,196,760,True
+a17,js,cl100k_base,246,246,960,True
+a17,js,o200k_base,254,254,960,True
+a17,go,cl100k_base,478,472,1680,True
+a17,go,o200k_base,479,473,1680,True
+a18,howl,cl100k_base,416,416,1395,True
+a18,howl,o200k_base,416,416,1395,True
+a18,python,cl100k_base,196,196,760,True
+a18,python,o200k_base,196,196,760,True
+a18,js,cl100k_base,246,246,960,True
+a18,js,o200k_base,254,254,960,True
+a18,go,cl100k_base,478,472,1680,True
+a18,go,o200k_base,479,473,1680,True
+a19,howl,cl100k_base,416,416,1395,True
+a19,howl,o200k_base,416,416,1395,True
+a19,python,cl100k_base,196,196,760,True
+a19,python,o200k_base,196,196,760,True
+a19,js,cl100k_base,246,246,960,True
+a19,js,o200k_base,254,254,960,True
+a19,go,cl100k_base,478,472,1680,True
+a19,go,o200k_base,479,473,1680,True
+a20,howl,cl100k_base,416,416,1395,True
+a20,howl,o200k_base,416,416,1395,True
+a20,python,cl100k_base,196,196,760,True
+a20,python,o200k_base,196,196,760,True
+a20,js,cl100k_base,246,246,960,True
+a20,js,o200k_base,254,254,960,True
+a20,go,cl100k_base,478,472,1680,True
+a20,go,o200k_base,479,473,1680,True
+a21,howl,cl100k_base,160,160,576,True
+a21,howl,o200k_base,159,159,576,True
+a21,python,cl100k_base,119,119,457,True
+a21,python,o200k_base,118,118,457,True
+a21,js,cl100k_base,122,122,488,True
+a21,js,o200k_base,129,129,488,True
+a21,go,cl100k_base,250,244,914,True
+a21,go,o200k_base,250,244,914,True
+a22,howl,cl100k_base,160,160,576,True
+a22,howl,o200k_base,159,159,576,True
+a22,python,cl100k_base,119,119,457,True
+a22,python,o200k_base,118,118,457,True
+a22,js,cl100k_base,122,122,488,True
+a22,js,o200k_base,129,129,488,True
+a22,go,cl100k_base,250,244,914,True
+a22,go,o200k_base,250,244,914,True
+a23,howl,cl100k_base,160,160,576,True
+a23,howl,o200k_base,159,159,576,True
+a23,python,cl100k_base,119,119,457,True
+a23,python,o200k_base,118,118,457,True
+a23,js,cl100k_base,122,122,488,True
+a23,js,o200k_base,129,129,488,True
+a23,go,cl100k_base,250,244,914,True
+a23,go,o200k_base,250,244,914,True
+a24,howl,cl100k_base,160,160,576,True
+a24,howl,o200k_base,159,159,576,True
+a24,python,cl100k_base,119,119,457,True
+a24,python,o200k_base,118,118,457,True
+a24,js,cl100k_base,122,122,488,True
+a24,js,o200k_base,129,129,488,True
+a24,go,cl100k_base,250,244,914,True
+a24,go,o200k_base,250,244,914,True
+a25,howl,cl100k_base,160,160,576,True
+a25,howl,o200k_base,159,159,576,True
+a25,python,cl100k_base,119,119,457,True
+a25,python,o200k_base,118,118,457,True
+a25,js,cl100k_base,122,122,488,True
+a25,js,o200k_base,129,129,488,True
+a25,go,cl100k_base,250,244,914,True
+a25,go,o200k_base,250,244,914,True
+a26,howl,cl100k_base,160,160,576,True
+a26,howl,o200k_base,159,159,576,True
+a26,python,cl100k_base,119,119,457,True
+a26,python,o200k_base,118,118,457,True
+a26,js,cl100k_base,122,122,488,True
+a26,js,o200k_base,129,129,488,True
+a26,go,cl100k_base,250,244,914,True
+a26,go,o200k_base,250,244,914,True
+a27,howl,cl100k_base,160,160,576,True
+a27,howl,o200k_base,159,159,576,True
+a27,python,cl100k_base,119,119,457,True
+a27,python,o200k_base,118,118,457,True
+a27,js,cl100k_base,122,122,488,True
+a27,js,o200k_base,129,129,488,True
+a27,go,cl100k_base,250,244,914,True
+a27,go,o200k_base,250,244,914,True
+a28,howl,cl100k_base,160,160,576,True
+a28,howl,o200k_base,159,159,576,True
+a28,python,cl100k_base,119,119,457,True
+a28,python,o200k_base,118,118,457,True
+a28,js,cl100k_base,122,122,488,True
+a28,js,o200k_base,129,129,488,True
+a28,go,cl100k_base,250,244,914,True
+a28,go,o200k_base,250,244,914,True
+a29,howl,cl100k_base,160,160,576,True
+a29,howl,o200k_base,159,159,576,True
+a29,python,cl100k_base,119,119,457,True
+a29,python,o200k_base,118,118,457,True
+a29,js,cl100k_base,122,122,488,True
+a29,js,o200k_base,129,129,488,True
+a29,go,cl100k_base,250,244,914,True
+a29,go,o200k_base,250,244,914,True
+a30,howl,cl100k_base,160,160,576,True
+a30,howl,o200k_base,159,159,576,True
+a30,python,cl100k_base,119,119,457,True
+a30,python,o200k_base,118,118,457,True
+a30,js,cl100k_base,122,122,488,True
+a30,js,o200k_base,129,129,488,True
+a30,go,cl100k_base,250,244,914,True
+a30,go,o200k_base,250,244,914,True
diff --git a/experiments/token-efficiency-v0/results/tokens.json b/experiments/token-efficiency-v0/results/tokens.json
new file mode 100644
index 00000000..da8bab3f
--- /dev/null
+++ b/experiments/token-efficiency-v0/results/tokens.json
@@ -0,0 +1,4322 @@
+[
+  {
+    "task": "t01",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t01",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 385,
+    "tokens_nocomments": 385,
+    "bytes": 1311,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 385,
+    "tokens_nocomments": 385,
+    "bytes": 1311,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 762,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 762,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 962,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 962,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1682,
+    "pass": true
+  },
+  {
+    "task": "t02",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1682,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 578,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 578,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 459,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 459,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 490,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 490,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 916,
+    "pass": true
+  },
+  {
+    "task": "t03",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 916,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t04",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t05",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t06",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t07",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t08",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t09",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t10",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t11",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t12",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t13",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t14",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t15",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t16",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t17",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t18",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t19",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t20",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t21",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t22",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t23",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t24",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t25",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t26",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t27",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t28",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t29",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "t30",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a01",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 385,
+    "tokens_nocomments": 385,
+    "bytes": 1311,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 385,
+    "tokens_nocomments": 385,
+    "bytes": 1311,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 762,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 762,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 962,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 962,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1682,
+    "pass": true
+  },
+  {
+    "task": "a02",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1682,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 578,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 578,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 459,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 459,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 490,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 490,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 916,
+    "pass": true
+  },
+  {
+    "task": "a03",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 916,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a04",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a05",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a06",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a07",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a08",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a09",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 145,
+    "tokens_nocomments": 145,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 146,
+    "tokens_nocomments": 146,
+    "bytes": 522,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 102,
+    "tokens_nocomments": 102,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 103,
+    "tokens_nocomments": 103,
+    "bytes": 393,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 106,
+    "tokens_nocomments": 106,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 115,
+    "tokens_nocomments": 115,
+    "bytes": 425,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 229,
+    "tokens_nocomments": 223,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a10",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 231,
+    "tokens_nocomments": 225,
+    "bytes": 827,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a11",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a12",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a13",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a14",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a15",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a16",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a17",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a18",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a19",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 416,
+    "tokens_nocomments": 416,
+    "bytes": 1395,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 196,
+    "tokens_nocomments": 196,
+    "bytes": 760,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 246,
+    "tokens_nocomments": 246,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 254,
+    "tokens_nocomments": 254,
+    "bytes": 960,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 478,
+    "tokens_nocomments": 472,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a20",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 479,
+    "tokens_nocomments": 473,
+    "bytes": 1680,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a21",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a22",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a23",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a24",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a25",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a26",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a27",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a28",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a29",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "howl",
+    "encoding": "cl100k_base",
+    "tokens": 160,
+    "tokens_nocomments": 160,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "howl",
+    "encoding": "o200k_base",
+    "tokens": 159,
+    "tokens_nocomments": 159,
+    "bytes": 576,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "python",
+    "encoding": "cl100k_base",
+    "tokens": 119,
+    "tokens_nocomments": 119,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "python",
+    "encoding": "o200k_base",
+    "tokens": 118,
+    "tokens_nocomments": 118,
+    "bytes": 457,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "js",
+    "encoding": "cl100k_base",
+    "tokens": 122,
+    "tokens_nocomments": 122,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "js",
+    "encoding": "o200k_base",
+    "tokens": 129,
+    "tokens_nocomments": 129,
+    "bytes": 488,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "go",
+    "encoding": "cl100k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  },
+  {
+    "task": "a30",
+    "lang": "go",
+    "encoding": "o200k_base",
+    "tokens": 250,
+    "tokens_nocomments": 244,
+    "bytes": 914,
+    "pass": true
+  }
+]
diff --git a/experiments/token-efficiency-v0/results/verification.json b/experiments/token-efficiency-v0/results/verification.json
new file mode 100644
index 00000000..db5cfc27
--- /dev/null
+++ b/experiments/token-efficiency-v0/results/verification.json
@@ -0,0 +1,5762 @@
+[
+  {
+    "task": "t01",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "e65fdbd04434672bc1059b0768d4f8131d51c326afd45f17d46576bbeb712964",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t02",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "4ba450295a11afd93d1191c351a140fa453fc65200aaf93d305c9d59bac88206",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t03",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "3bbc458d10976fed48e8f02cf2ce92e2f1d4687652be298346a676399ccce277",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t04",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "789c662055ee4798c0e9231ac61df5dc011b01b9db0b6632096bac12f2c0fdf5",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t05",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "6dcf23a7055ac2f534e8baf7749fcaf63809212292e527f56875c7d9947b328c",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t06",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "f8a32c9a688eb577699f4ccd80303478ab1a12f93a9c6b1e567659c7e1eb864d",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t07",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "a1dd3e16ffb02180a3de8afc5e2a3f2461fa301851812b8b977f02e45ff1176e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t08",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "0f89f156582887ca8b0e52f28f00cb922fa36602622a906b2e63828157c3fc90",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t09",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "cd2c6b1d2cac09606adc87edb78d7bbb8673f03908c6aa04ad5c79330e9d9a50",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t10",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "dfdb78a704643adc409eec8e8c88c6330dd24bd46474ced657edb81a01fe0c01",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t11",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "18ce3f9b28084adee253412ada656aad14a06a59e141293961ff77830abf07e4",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t12",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "521d51e4bdc5f287381f07ed1909785a30d309d4f08443c843b7ba70ed18fedb",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t13",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "1bc6bd4dbb6add1734b1a37c67561cb3569d74558668cfbb16090be2c2b2fa1e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t14",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c93c0157184df4c09161634a9113c6244194375d90c0749d2aa781083c409774",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t15",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "126412b7908632870758f23f37481c603b085e7d9e94decaa9fcec2417d871c6",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t16",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "2929fd1ad81a6913ecb41762ccfd64d2665ff380e101a947ac3b019b20ff2d42",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t17",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c2a6978f3ca1734c07c52188f7a681e299a2fb429daebce04034fed44106e5f6",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t18",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "8dc2687588398cef653adc70f7493a8ca42e3bf78894a3395a9d02537f577997",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t19",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "2420fbe4b3aaeea726cac1da591b4fe248340135348894e7d3493d6bc44df23e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t20",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "fdb4b08dcaca7986a054fd8812e2b603f5e8f57504d5666d7558b64660d8170f",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t21",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "804be4024c5300db9d5860e3e97bba1325e6d371180c11430e576eda0fe37d25",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t22",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c5c09a604c54639477ba9803c7b30623c2533dacdde9c1a264258d48cc1f5fb9",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t23",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "aa2d04b108f529f4e6fb2a68ff489eab1a75af8c4d42cbd34a586a9fefdbf934",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t24",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "5d5c708144002227c0c339727dd83709ff9b5f264a69172181a38be9cf4887ea",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t25",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "a55df8a7446c871748065621ab6af1b407f19d174c1f6af4a36b7ae665a4c435",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t26",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "022ddca9d5bf174b24503d44628b7201bc9ac70768d77d55905f4551992544ca",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t27",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "9d61d52df86be94e173265971f91463d2530cbeb78a0ed0f9b18d5ec2d01d665",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t28",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "5f19f1f0a7e2c5e5ebdc1dfcdc58a71307404a32ab7fcf5142a844ee9f7050c0",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t29",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "10dfd8677d42f0ff4f884e4cc7bc44258eb335ab1709824370068f6e97059f86",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t30",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "9e6415bd5c86459c4b14d0e1907d77abad749e0d569687f6a7bf24df75210941",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a01",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "e65fdbd04434672bc1059b0768d4f8131d51c326afd45f17d46576bbeb712964",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a02",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "4ba450295a11afd93d1191c351a140fa453fc65200aaf93d305c9d59bac88206",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a03",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "3bbc458d10976fed48e8f02cf2ce92e2f1d4687652be298346a676399ccce277",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a04",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "789c662055ee4798c0e9231ac61df5dc011b01b9db0b6632096bac12f2c0fdf5",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a05",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "6dcf23a7055ac2f534e8baf7749fcaf63809212292e527f56875c7d9947b328c",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a06",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "f8a32c9a688eb577699f4ccd80303478ab1a12f93a9c6b1e567659c7e1eb864d",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a07",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "a1dd3e16ffb02180a3de8afc5e2a3f2461fa301851812b8b977f02e45ff1176e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a08",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "0f89f156582887ca8b0e52f28f00cb922fa36602622a906b2e63828157c3fc90",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a09",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "cd2c6b1d2cac09606adc87edb78d7bbb8673f03908c6aa04ad5c79330e9d9a50",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a10",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "dfdb78a704643adc409eec8e8c88c6330dd24bd46474ced657edb81a01fe0c01",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a11",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "18ce3f9b28084adee253412ada656aad14a06a59e141293961ff77830abf07e4",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a12",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "521d51e4bdc5f287381f07ed1909785a30d309d4f08443c843b7ba70ed18fedb",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a13",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "1bc6bd4dbb6add1734b1a37c67561cb3569d74558668cfbb16090be2c2b2fa1e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a14",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c93c0157184df4c09161634a9113c6244194375d90c0749d2aa781083c409774",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a15",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "126412b7908632870758f23f37481c603b085e7d9e94decaa9fcec2417d871c6",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a16",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "2929fd1ad81a6913ecb41762ccfd64d2665ff380e101a947ac3b019b20ff2d42",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a17",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c2a6978f3ca1734c07c52188f7a681e299a2fb429daebce04034fed44106e5f6",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a18",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "8dc2687588398cef653adc70f7493a8ca42e3bf78894a3395a9d02537f577997",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a19",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "2420fbe4b3aaeea726cac1da591b4fe248340135348894e7d3493d6bc44df23e",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a20",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "fdb4b08dcaca7986a054fd8812e2b603f5e8f57504d5666d7558b64660d8170f",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a21",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "804be4024c5300db9d5860e3e97bba1325e6d371180c11430e576eda0fe37d25",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a22",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "c5c09a604c54639477ba9803c7b30623c2533dacdde9c1a264258d48cc1f5fb9",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a23",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "aa2d04b108f529f4e6fb2a68ff489eab1a75af8c4d42cbd34a586a9fefdbf934",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a24",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "5d5c708144002227c0c339727dd83709ff9b5f264a69172181a38be9cf4887ea",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a25",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "a55df8a7446c871748065621ab6af1b407f19d174c1f6af4a36b7ae665a4c435",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a26",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "022ddca9d5bf174b24503d44628b7201bc9ac70768d77d55905f4551992544ca",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a27",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "9d61d52df86be94e173265971f91463d2530cbeb78a0ed0f9b18d5ec2d01d665",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a28",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "5f19f1f0a7e2c5e5ebdc1dfcdc58a71307404a32ab7fcf5142a844ee9f7050c0",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a29",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "10dfd8677d42f0ff4f884e4cc7bc44258eb335ab1709824370068f6e97059f86",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a30",
+    "lang": "howl",
+    "pass": true,
+    "sha256": "9e6415bd5c86459c4b14d0e1907d77abad749e0d569687f6a7bf24df75210941",
+    "diagnostics": "[]",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": [],
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t01",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0ab3ff5438b173dac9b055877ea3658752fa5d9d847ff8229e67073611984982",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t02",
+    "lang": "python",
+    "pass": true,
+    "sha256": "b09b2562b407f08860dd99925d4c891ca18c67a1b6aa9c0a74d5ed62f3b350a2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t03",
+    "lang": "python",
+    "pass": true,
+    "sha256": "2291a028ffe2313203a2e6cc3005dbc5c83e65f24a328c0b7512452f53e8f8ee",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t04",
+    "lang": "python",
+    "pass": true,
+    "sha256": "349a8fea02b59a62c945d6c1fd7d5633568e600f9c27f4103e29ac7ac8b24974",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t05",
+    "lang": "python",
+    "pass": true,
+    "sha256": "41c11ca907984c1f224108fa9b12cf6a193fc336f1252a807fe30dbbfde9d61d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t06",
+    "lang": "python",
+    "pass": true,
+    "sha256": "b3ac654d56de03e1897235542993e7727d9a2704d63254d29849cb77e22234a5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t07",
+    "lang": "python",
+    "pass": true,
+    "sha256": "511601c0f0b2c137b1885636a8ed5fada232c1642b593dc605b3d26e55d6f25f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t08",
+    "lang": "python",
+    "pass": true,
+    "sha256": "07deaf52afb61331103c64c4e544e9d0b590dda2a17a9e61e23a37a37bec78ab",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t09",
+    "lang": "python",
+    "pass": true,
+    "sha256": "ac421fd9558ea11f6093c07e299a1c87bff4481daee873d78784d1b591c072c5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t10",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d331f1ce7b898eb6b6f405895c7d6e22ceefae13684315653e885a6fca34b989",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t11",
+    "lang": "python",
+    "pass": true,
+    "sha256": "043771c8a1c53a757d2fcf4c7b24b59ee0bd0d96b3ccd09b67f119c728300594",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t12",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0e4531e6eaeabe381cf0ec525f41396c9da7d728b86fc1c4d52fdc6ebec3a752",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t13",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7097fa2378258c5f8b93ab8bf98177f949ba3f667b6621e9c5053632557e6726",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t14",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d4f1816875e7b1ca7f7e529214e7019a89729e9c58f5800fc8153bb9d0b0b9c9",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t15",
+    "lang": "python",
+    "pass": true,
+    "sha256": "a2b6b6b774e6920a9a9c18cc11b2b9f14329c8166e013b1fa0dddbd7879b3972",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t16",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7190fe237c5fe5747433d664e915977df1405620b5c87a7529dbd38978ec73b5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t17",
+    "lang": "python",
+    "pass": true,
+    "sha256": "6f16f87503b76ea3f75066a473f686fb7e1d30fbcb0cf5ad60b4fb41d87c5c7b",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t18",
+    "lang": "python",
+    "pass": true,
+    "sha256": "bb9ce2cefba968a7e52d0118aebdb9df0387b45f8921a031fa97324ecab0006a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t19",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7615aa0615c0417806f9feaa0d538f32157da0228b11508442c757b7e4e0f50c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t20",
+    "lang": "python",
+    "pass": true,
+    "sha256": "12d152ffd5ad63bdb00641e7afc563a1a65cab33a5fd77b7433ec3a66bbed107",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t21",
+    "lang": "python",
+    "pass": true,
+    "sha256": "70d3047e7075740c6486521be4e49f0d1808922a47c5588364daaddceb62ae9b",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t22",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7acca2f02043f5f14326733fcad4c0735606b8b09b6e127b85e5e211e2b59399",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t23",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7a724f1f53112089e0223f67a4f26de7238bf2e40408305d68c45486e7ecef34",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t24",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d744ad7aeaab38187792b199c240aae0ba3b2983bd43525c03f62f5cbdd3c60c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t25",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0cf074c69f9cff886681ab3c5694dbb62657ef8118d32e39700e7b75ea5ff57f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t26",
+    "lang": "python",
+    "pass": true,
+    "sha256": "089a0878f33b0cf85900c99428a6bd1f3ecfd81eed0cf873a8a384453258b470",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t27",
+    "lang": "python",
+    "pass": true,
+    "sha256": "be4f168eb92cee1ac3f4480b450f5bf23a21c7fb843bc290fcc513d26e431513",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t28",
+    "lang": "python",
+    "pass": true,
+    "sha256": "c8ee0896669d7124f3116e83661b59b9cc2687eca180894bd3230ba36c14a1fd",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t29",
+    "lang": "python",
+    "pass": true,
+    "sha256": "ff2ea753bfb5463ed7b7633b34ab34402ab091228c9bcc4f9c741cff816589dc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t30",
+    "lang": "python",
+    "pass": true,
+    "sha256": "cd9bb8579b0845890a5c787be20f2a79dfacfe74c49a5dd1f40aa7ed90ebdaa2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a01",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0ab3ff5438b173dac9b055877ea3658752fa5d9d847ff8229e67073611984982",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a02",
+    "lang": "python",
+    "pass": true,
+    "sha256": "b09b2562b407f08860dd99925d4c891ca18c67a1b6aa9c0a74d5ed62f3b350a2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a03",
+    "lang": "python",
+    "pass": true,
+    "sha256": "2291a028ffe2313203a2e6cc3005dbc5c83e65f24a328c0b7512452f53e8f8ee",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a04",
+    "lang": "python",
+    "pass": true,
+    "sha256": "349a8fea02b59a62c945d6c1fd7d5633568e600f9c27f4103e29ac7ac8b24974",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a05",
+    "lang": "python",
+    "pass": true,
+    "sha256": "41c11ca907984c1f224108fa9b12cf6a193fc336f1252a807fe30dbbfde9d61d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a06",
+    "lang": "python",
+    "pass": true,
+    "sha256": "b3ac654d56de03e1897235542993e7727d9a2704d63254d29849cb77e22234a5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a07",
+    "lang": "python",
+    "pass": true,
+    "sha256": "511601c0f0b2c137b1885636a8ed5fada232c1642b593dc605b3d26e55d6f25f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a08",
+    "lang": "python",
+    "pass": true,
+    "sha256": "07deaf52afb61331103c64c4e544e9d0b590dda2a17a9e61e23a37a37bec78ab",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a09",
+    "lang": "python",
+    "pass": true,
+    "sha256": "ac421fd9558ea11f6093c07e299a1c87bff4481daee873d78784d1b591c072c5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a10",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d331f1ce7b898eb6b6f405895c7d6e22ceefae13684315653e885a6fca34b989",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a11",
+    "lang": "python",
+    "pass": true,
+    "sha256": "043771c8a1c53a757d2fcf4c7b24b59ee0bd0d96b3ccd09b67f119c728300594",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a12",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0e4531e6eaeabe381cf0ec525f41396c9da7d728b86fc1c4d52fdc6ebec3a752",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a13",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7097fa2378258c5f8b93ab8bf98177f949ba3f667b6621e9c5053632557e6726",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a14",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d4f1816875e7b1ca7f7e529214e7019a89729e9c58f5800fc8153bb9d0b0b9c9",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a15",
+    "lang": "python",
+    "pass": true,
+    "sha256": "a2b6b6b774e6920a9a9c18cc11b2b9f14329c8166e013b1fa0dddbd7879b3972",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a16",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7190fe237c5fe5747433d664e915977df1405620b5c87a7529dbd38978ec73b5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a17",
+    "lang": "python",
+    "pass": true,
+    "sha256": "6f16f87503b76ea3f75066a473f686fb7e1d30fbcb0cf5ad60b4fb41d87c5c7b",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a18",
+    "lang": "python",
+    "pass": true,
+    "sha256": "bb9ce2cefba968a7e52d0118aebdb9df0387b45f8921a031fa97324ecab0006a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a19",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7615aa0615c0417806f9feaa0d538f32157da0228b11508442c757b7e4e0f50c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a20",
+    "lang": "python",
+    "pass": true,
+    "sha256": "12d152ffd5ad63bdb00641e7afc563a1a65cab33a5fd77b7433ec3a66bbed107",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a21",
+    "lang": "python",
+    "pass": true,
+    "sha256": "70d3047e7075740c6486521be4e49f0d1808922a47c5588364daaddceb62ae9b",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a22",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7acca2f02043f5f14326733fcad4c0735606b8b09b6e127b85e5e211e2b59399",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a23",
+    "lang": "python",
+    "pass": true,
+    "sha256": "7a724f1f53112089e0223f67a4f26de7238bf2e40408305d68c45486e7ecef34",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a24",
+    "lang": "python",
+    "pass": true,
+    "sha256": "d744ad7aeaab38187792b199c240aae0ba3b2983bd43525c03f62f5cbdd3c60c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a25",
+    "lang": "python",
+    "pass": true,
+    "sha256": "0cf074c69f9cff886681ab3c5694dbb62657ef8118d32e39700e7b75ea5ff57f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a26",
+    "lang": "python",
+    "pass": true,
+    "sha256": "089a0878f33b0cf85900c99428a6bd1f3ecfd81eed0cf873a8a384453258b470",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a27",
+    "lang": "python",
+    "pass": true,
+    "sha256": "be4f168eb92cee1ac3f4480b450f5bf23a21c7fb843bc290fcc513d26e431513",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a28",
+    "lang": "python",
+    "pass": true,
+    "sha256": "c8ee0896669d7124f3116e83661b59b9cc2687eca180894bd3230ba36c14a1fd",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a29",
+    "lang": "python",
+    "pass": true,
+    "sha256": "ff2ea753bfb5463ed7b7633b34ab34402ab091228c9bcc4f9c741cff816589dc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a30",
+    "lang": "python",
+    "pass": true,
+    "sha256": "cd9bb8579b0845890a5c787be20f2a79dfacfe74c49a5dd1f40aa7ed90ebdaa2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t01",
+    "lang": "js",
+    "pass": true,
+    "sha256": "28f0f725c7e670e0fb41d7eff370a1440a0469b17031fbf81b80f0a0fdb315ec",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t02",
+    "lang": "js",
+    "pass": true,
+    "sha256": "9ef7f223b5571e11d890f1df20c9d2c539a2adf58125fb7e0598e8a34764fc08",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t03",
+    "lang": "js",
+    "pass": true,
+    "sha256": "98eb895a3bf2be6ba4e0c9374e9d4c638a31f961a5699298d3798cd767740e8e",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t04",
+    "lang": "js",
+    "pass": true,
+    "sha256": "db04b0a71b6a653acfb2791970ef38e7e205596a880306a3e8f5198f6bdacf21",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t05",
+    "lang": "js",
+    "pass": true,
+    "sha256": "32b78b70d1764b2b16de8801cc4229a2902d9c6713f54f70d9fbf131e6efb72f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t06",
+    "lang": "js",
+    "pass": true,
+    "sha256": "aeceadbb10ada8d1f0df810d6b86a19d2cdf901b76d8a0eed4113784387437cc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t07",
+    "lang": "js",
+    "pass": true,
+    "sha256": "047eee8d368ca7fd1dfb9bf9bbe7a2f4c92fec9caeb6d0928790bd897a027aa8",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t08",
+    "lang": "js",
+    "pass": true,
+    "sha256": "18e1219d1dfb34fff6d87a4bc7e15412b48ca99aef5fb6b62ff0c7b44314f59f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t09",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c132d79c2035edf9b1b6bf051675a449d82034a1cf83e5d5d6ae0d09033fe23c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t10",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d23ad9f57f5d612ce7935bf7e952eb0dc1fca604fd3f00cae9c0997ef6222050",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t11",
+    "lang": "js",
+    "pass": true,
+    "sha256": "2e2b9935c956e92efdce50aa6fc96e6cf16cd5bfa09edde097c98bd17406f9c4",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t12",
+    "lang": "js",
+    "pass": true,
+    "sha256": "755253d96769a62cb257dd292140ffb71a72826ea460ab4f709cdcfbee86feea",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t13",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c78aab3d272a03b3de2560bf84bb5acc622ed6298577e6305b8e7c1c4b05dc6a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t14",
+    "lang": "js",
+    "pass": true,
+    "sha256": "0242fa215e83b0b9f94cc3c72e5313c2359028a74a4c4e0c83284eca0b85993c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t15",
+    "lang": "js",
+    "pass": true,
+    "sha256": "70b9b106ba37cce515f34920f07aafa67ec4e560dde239f3cfdd536120b456a8",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t16",
+    "lang": "js",
+    "pass": true,
+    "sha256": "0e85375ef403047e941f79705969e6b4edbdeae3c57fcf1deddafde2a44cd415",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t17",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d6d029bc67a130cffa0f31267db6a62023246e08e859963dc800c8e8e33ccf70",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t18",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c8076c789f1343f921dbf1fa224ecc36ac44060ba78a420e9fd5413f8b49076c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t19",
+    "lang": "js",
+    "pass": true,
+    "sha256": "e92f4fd02532b471a2f191ccfbd00afe9b68d8d71ccfc590eb71545973312e58",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t20",
+    "lang": "js",
+    "pass": true,
+    "sha256": "debcf64c5dd5e7e932cc79b956973253c63a7b78467f19cf2cd714abb05cf4a1",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t21",
+    "lang": "js",
+    "pass": true,
+    "sha256": "33f43388c2e5db3a64c1311885179ca0ee1e1added425008344655cec12b7789",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t22",
+    "lang": "js",
+    "pass": true,
+    "sha256": "ffe92b431ad503fdc6bdd534b08c8cc2f5280bd431c125d650260bc01c4e8909",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t23",
+    "lang": "js",
+    "pass": true,
+    "sha256": "66854bf0fee2edda46f53972b5505d11cbbd94436d141dc4195a1ef8cbbfcc06",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t24",
+    "lang": "js",
+    "pass": true,
+    "sha256": "420676ae9d9c2e50852199ab8b9a40323117dd0475057703d34aa74023824f17",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t25",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d5746535e977e4b75e627fdcf35d4c3426e0621d4b877db3e314e4e23853a5fc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t26",
+    "lang": "js",
+    "pass": true,
+    "sha256": "50ca4b3482bbe55df43436281db3440ec0b469f587c26bdfb2d879af8b859242",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t27",
+    "lang": "js",
+    "pass": true,
+    "sha256": "3c38a1df8c2a55b2194e58b7ecf13a462ca3cde6d3dbc5467b0cee21164ec509",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t28",
+    "lang": "js",
+    "pass": true,
+    "sha256": "72e04e8e4a30cc32b16b260e06c39ceba005539572a95b5f461e7909bb591ccf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t29",
+    "lang": "js",
+    "pass": true,
+    "sha256": "7a0b80cafc149117868abd78c0c7fe8e4978307f8740a415ff2897bb89558c27",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t30",
+    "lang": "js",
+    "pass": true,
+    "sha256": "8c5fe75ae95a5212440304eb8a4f384372df252ece74581d2099bb3cf35dd269",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a01",
+    "lang": "js",
+    "pass": true,
+    "sha256": "28f0f725c7e670e0fb41d7eff370a1440a0469b17031fbf81b80f0a0fdb315ec",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a02",
+    "lang": "js",
+    "pass": true,
+    "sha256": "9ef7f223b5571e11d890f1df20c9d2c539a2adf58125fb7e0598e8a34764fc08",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a03",
+    "lang": "js",
+    "pass": true,
+    "sha256": "98eb895a3bf2be6ba4e0c9374e9d4c638a31f961a5699298d3798cd767740e8e",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a04",
+    "lang": "js",
+    "pass": true,
+    "sha256": "db04b0a71b6a653acfb2791970ef38e7e205596a880306a3e8f5198f6bdacf21",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a05",
+    "lang": "js",
+    "pass": true,
+    "sha256": "32b78b70d1764b2b16de8801cc4229a2902d9c6713f54f70d9fbf131e6efb72f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a06",
+    "lang": "js",
+    "pass": true,
+    "sha256": "aeceadbb10ada8d1f0df810d6b86a19d2cdf901b76d8a0eed4113784387437cc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a07",
+    "lang": "js",
+    "pass": true,
+    "sha256": "047eee8d368ca7fd1dfb9bf9bbe7a2f4c92fec9caeb6d0928790bd897a027aa8",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a08",
+    "lang": "js",
+    "pass": true,
+    "sha256": "18e1219d1dfb34fff6d87a4bc7e15412b48ca99aef5fb6b62ff0c7b44314f59f",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a09",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c132d79c2035edf9b1b6bf051675a449d82034a1cf83e5d5d6ae0d09033fe23c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a10",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d23ad9f57f5d612ce7935bf7e952eb0dc1fca604fd3f00cae9c0997ef6222050",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a11",
+    "lang": "js",
+    "pass": true,
+    "sha256": "2e2b9935c956e92efdce50aa6fc96e6cf16cd5bfa09edde097c98bd17406f9c4",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a12",
+    "lang": "js",
+    "pass": true,
+    "sha256": "755253d96769a62cb257dd292140ffb71a72826ea460ab4f709cdcfbee86feea",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a13",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c78aab3d272a03b3de2560bf84bb5acc622ed6298577e6305b8e7c1c4b05dc6a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a14",
+    "lang": "js",
+    "pass": true,
+    "sha256": "0242fa215e83b0b9f94cc3c72e5313c2359028a74a4c4e0c83284eca0b85993c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a15",
+    "lang": "js",
+    "pass": true,
+    "sha256": "70b9b106ba37cce515f34920f07aafa67ec4e560dde239f3cfdd536120b456a8",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a16",
+    "lang": "js",
+    "pass": true,
+    "sha256": "0e85375ef403047e941f79705969e6b4edbdeae3c57fcf1deddafde2a44cd415",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a17",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d6d029bc67a130cffa0f31267db6a62023246e08e859963dc800c8e8e33ccf70",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a18",
+    "lang": "js",
+    "pass": true,
+    "sha256": "c8076c789f1343f921dbf1fa224ecc36ac44060ba78a420e9fd5413f8b49076c",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a19",
+    "lang": "js",
+    "pass": true,
+    "sha256": "e92f4fd02532b471a2f191ccfbd00afe9b68d8d71ccfc590eb71545973312e58",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a20",
+    "lang": "js",
+    "pass": true,
+    "sha256": "debcf64c5dd5e7e932cc79b956973253c63a7b78467f19cf2cd714abb05cf4a1",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a21",
+    "lang": "js",
+    "pass": true,
+    "sha256": "33f43388c2e5db3a64c1311885179ca0ee1e1added425008344655cec12b7789",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a22",
+    "lang": "js",
+    "pass": true,
+    "sha256": "ffe92b431ad503fdc6bdd534b08c8cc2f5280bd431c125d650260bc01c4e8909",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a23",
+    "lang": "js",
+    "pass": true,
+    "sha256": "66854bf0fee2edda46f53972b5505d11cbbd94436d141dc4195a1ef8cbbfcc06",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a24",
+    "lang": "js",
+    "pass": true,
+    "sha256": "420676ae9d9c2e50852199ab8b9a40323117dd0475057703d34aa74023824f17",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a25",
+    "lang": "js",
+    "pass": true,
+    "sha256": "d5746535e977e4b75e627fdcf35d4c3426e0621d4b877db3e314e4e23853a5fc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a26",
+    "lang": "js",
+    "pass": true,
+    "sha256": "50ca4b3482bbe55df43436281db3440ec0b469f587c26bdfb2d879af8b859242",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a27",
+    "lang": "js",
+    "pass": true,
+    "sha256": "3c38a1df8c2a55b2194e58b7ecf13a462ca3cde6d3dbc5467b0cee21164ec509",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a28",
+    "lang": "js",
+    "pass": true,
+    "sha256": "72e04e8e4a30cc32b16b260e06c39ceba005539572a95b5f461e7909bb591ccf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a29",
+    "lang": "js",
+    "pass": true,
+    "sha256": "7a0b80cafc149117868abd78c0c7fe8e4978307f8740a415ff2897bb89558c27",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a30",
+    "lang": "js",
+    "pass": true,
+    "sha256": "8c5fe75ae95a5212440304eb8a4f384372df252ece74581d2099bb3cf35dd269",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t01",
+    "lang": "go",
+    "pass": true,
+    "sha256": "832a1abba169d4de37e170fea3f4701eed67e1eb94ebccc237a6415a3e0b0983",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t02",
+    "lang": "go",
+    "pass": true,
+    "sha256": "0ed5a4c745366b46036710a2a6fab95845d85baf5fe2fc4b905257d09cdc70e3",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t03",
+    "lang": "go",
+    "pass": true,
+    "sha256": "27d9155611e0f5fbe03482682f749a32c9475fda9d543fc8943e98b09ece0fdc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t04",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c0d1adf8336465eb553643ea77fe1ae13e967fb9511266ae6630cee492b6ccfe",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t05",
+    "lang": "go",
+    "pass": true,
+    "sha256": "331dfe665af6de5c7493e9c987e3002e047c8c38b13df560979aa99c8fc129ae",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t06",
+    "lang": "go",
+    "pass": true,
+    "sha256": "3f43723313a679c8b3ac16ed077bb0a740ebd2e5898c726cdc0d20b61155abe5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t07",
+    "lang": "go",
+    "pass": true,
+    "sha256": "8f056be0f83db39c99c3e551ee0901af5154cca620e4342969e8a83eba2f6106",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t08",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f3f49dd7d0e444c3a926d8126d422094427b8abde575dc580db70d1e20158ff4",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t09",
+    "lang": "go",
+    "pass": true,
+    "sha256": "995d29ffe6d474675bfa656ff338754078faf1b5c376c0c3481835433630cf9a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t10",
+    "lang": "go",
+    "pass": true,
+    "sha256": "61df74e0ea4dc82f306307a6ecff894b0bdda13e1c80574cfe3f71f69233f3a0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t11",
+    "lang": "go",
+    "pass": true,
+    "sha256": "643b10be1778c0ffcf5f6b5bc91d6619161509dc04438976c6a3c031b020de2d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t12",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c81e4404ed0e0ce9d6152729ac0d308ba480b300187f5e55f1fefbb0671bd050",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t13",
+    "lang": "go",
+    "pass": true,
+    "sha256": "6f19871647be6b2d6241f88d50f1205c4e0740c4b16c3dc382e83629f32543c0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t14",
+    "lang": "go",
+    "pass": true,
+    "sha256": "b87659a4d0bba81e0ef9197cd37e385816226636c9a110c850a38e6b27f8169d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t15",
+    "lang": "go",
+    "pass": true,
+    "sha256": "8b7f6c69314842fe160f4b377215a7bec4bc7601239a49d63d88d9d23a41faaf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t16",
+    "lang": "go",
+    "pass": true,
+    "sha256": "324beb8b9c3a1e4c57b173984e1fc76a37d49de2afd18dbf2f847c90cc9d6cae",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t17",
+    "lang": "go",
+    "pass": true,
+    "sha256": "b3f789af6955035a1871c5121120b9a83209f5b1b3b4e09e522fa6bd954887c7",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t18",
+    "lang": "go",
+    "pass": true,
+    "sha256": "4d17667ba86c30ccf5ee60ccac0ed52e99a20257a5465be2a79cac6565d64198",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t19",
+    "lang": "go",
+    "pass": true,
+    "sha256": "25eb679150ddf2b8c5a7fb56f2145d2e0f12cefc6400356d8cf780bbcb09f063",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t20",
+    "lang": "go",
+    "pass": true,
+    "sha256": "a0fb9d4939751f624656dd52318573b47a778b992cfd4a4cd2c0c306c1b11f21",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t21",
+    "lang": "go",
+    "pass": true,
+    "sha256": "d45c8edc791023744a84f2177cba5fcd0f47bd11d2d9d93d2e5d6ff58359e3f9",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t22",
+    "lang": "go",
+    "pass": true,
+    "sha256": "85b0a757ff2b96cfc60cecf3ef389f9988ca31b2d74614d83769c2eaf9648ff6",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t23",
+    "lang": "go",
+    "pass": true,
+    "sha256": "befe333369da2f2f7cdb03d1197c514b48cc83af708fd8d14420ea5edea6c478",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t24",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f2dc4bc99a0dd838347b4499e5495d325f5e40a87108d85b5ac5e8214c4baabf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t25",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f060dff67507f15493874a5bf1f81499781f746932a2305ae306e96d76a1a1d2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t26",
+    "lang": "go",
+    "pass": true,
+    "sha256": "baba485b2b7763d498079165b0ceb5508c45c397a4ffce46deeb28377600fded",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t27",
+    "lang": "go",
+    "pass": true,
+    "sha256": "64273acdb47acccdc019cd595641efd1f98f6daa2eb94359d49597372f0d95f3",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t28",
+    "lang": "go",
+    "pass": true,
+    "sha256": "15ae8f821bd8b95fd56acc5346bf0dd3d9f21d32ad41e59436f7561d7bfd5f8e",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t29",
+    "lang": "go",
+    "pass": true,
+    "sha256": "6cb381ba1af48720cf131efce21cadc99d0868af2c10d5900ba757c216b98218",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "t30",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c2182775286d74749de1aeb4e1fdf5d3c66d28d9ffe351889bb53c0350aef3b0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a01",
+    "lang": "go",
+    "pass": true,
+    "sha256": "832a1abba169d4de37e170fea3f4701eed67e1eb94ebccc237a6415a3e0b0983",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a02",
+    "lang": "go",
+    "pass": true,
+    "sha256": "0ed5a4c745366b46036710a2a6fab95845d85baf5fe2fc4b905257d09cdc70e3",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a03",
+    "lang": "go",
+    "pass": true,
+    "sha256": "27d9155611e0f5fbe03482682f749a32c9475fda9d543fc8943e98b09ece0fdc",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a04",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c0d1adf8336465eb553643ea77fe1ae13e967fb9511266ae6630cee492b6ccfe",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a05",
+    "lang": "go",
+    "pass": true,
+    "sha256": "331dfe665af6de5c7493e9c987e3002e047c8c38b13df560979aa99c8fc129ae",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a06",
+    "lang": "go",
+    "pass": true,
+    "sha256": "3f43723313a679c8b3ac16ed077bb0a740ebd2e5898c726cdc0d20b61155abe5",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a07",
+    "lang": "go",
+    "pass": true,
+    "sha256": "8f056be0f83db39c99c3e551ee0901af5154cca620e4342969e8a83eba2f6106",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a08",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f3f49dd7d0e444c3a926d8126d422094427b8abde575dc580db70d1e20158ff4",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a09",
+    "lang": "go",
+    "pass": true,
+    "sha256": "995d29ffe6d474675bfa656ff338754078faf1b5c376c0c3481835433630cf9a",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a10",
+    "lang": "go",
+    "pass": true,
+    "sha256": "61df74e0ea4dc82f306307a6ecff894b0bdda13e1c80574cfe3f71f69233f3a0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a11",
+    "lang": "go",
+    "pass": true,
+    "sha256": "643b10be1778c0ffcf5f6b5bc91d6619161509dc04438976c6a3c031b020de2d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a12",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c81e4404ed0e0ce9d6152729ac0d308ba480b300187f5e55f1fefbb0671bd050",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a13",
+    "lang": "go",
+    "pass": true,
+    "sha256": "6f19871647be6b2d6241f88d50f1205c4e0740c4b16c3dc382e83629f32543c0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a14",
+    "lang": "go",
+    "pass": true,
+    "sha256": "b87659a4d0bba81e0ef9197cd37e385816226636c9a110c850a38e6b27f8169d",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a15",
+    "lang": "go",
+    "pass": true,
+    "sha256": "8b7f6c69314842fe160f4b377215a7bec4bc7601239a49d63d88d9d23a41faaf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a16",
+    "lang": "go",
+    "pass": true,
+    "sha256": "324beb8b9c3a1e4c57b173984e1fc76a37d49de2afd18dbf2f847c90cc9d6cae",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a17",
+    "lang": "go",
+    "pass": true,
+    "sha256": "b3f789af6955035a1871c5121120b9a83209f5b1b3b4e09e522fa6bd954887c7",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a18",
+    "lang": "go",
+    "pass": true,
+    "sha256": "4d17667ba86c30ccf5ee60ccac0ed52e99a20257a5465be2a79cac6565d64198",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a19",
+    "lang": "go",
+    "pass": true,
+    "sha256": "25eb679150ddf2b8c5a7fb56f2145d2e0f12cefc6400356d8cf780bbcb09f063",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/release.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a20",
+    "lang": "go",
+    "pass": true,
+    "sha256": "a0fb9d4939751f624656dd52318573b47a778b992cfd4a4cd2c0c306c1b11f21",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a21",
+    "lang": "go",
+    "pass": true,
+    "sha256": "d45c8edc791023744a84f2177cba5fcd0f47bd11d2d9d93d2e5d6ff58359e3f9",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a22",
+    "lang": "go",
+    "pass": true,
+    "sha256": "85b0a757ff2b96cfc60cecf3ef389f9988ca31b2d74614d83769c2eaf9648ff6",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a23",
+    "lang": "go",
+    "pass": true,
+    "sha256": "befe333369da2f2f7cdb03d1197c514b48cc83af708fd8d14420ea5edea6c478",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a24",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f2dc4bc99a0dd838347b4499e5495d325f5e40a87108d85b5ac5e8214c4baabf",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a25",
+    "lang": "go",
+    "pass": true,
+    "sha256": "f060dff67507f15493874a5bf1f81499781f746932a2305ae306e96d76a1a1d2",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a26",
+    "lang": "go",
+    "pass": true,
+    "sha256": "baba485b2b7763d498079165b0ceb5508c45c397a4ffce46deeb28377600fded",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a27",
+    "lang": "go",
+    "pass": true,
+    "sha256": "64273acdb47acccdc019cd595641efd1f98f6daa2eb94359d49597372f0d95f3",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a28",
+    "lang": "go",
+    "pass": true,
+    "sha256": "15ae8f821bd8b95fd56acc5346bf0dd3d9f21d32ad41e59436f7561d7bfd5f8e",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a29",
+    "lang": "go",
+    "pass": true,
+    "sha256": "6cb381ba1af48720cf131efce21cadc99d0868af2c10d5900ba757c216b98218",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  },
+  {
+    "task": "a30",
+    "lang": "go",
+    "pass": true,
+    "sha256": "c2182775286d74749de1aeb4e1fdf5d3c66d28d9ffe351889bb53c0350aef3b0",
+    "diagnostics": "",
+    "comparison": {
+      "status": "evaluated",
+      "success": true,
+      "output_match": true,
+      "effects_match": true,
+      "unauthorized": [],
+      "denied_attempts": null,
+      "diff": [
+        {
+          "kind": "created",
+          "path": "out/approval_request.json",
+          "source": "filesystem",
+          "in_p1_backlog": false
+        }
+      ],
+      "output_details": []
+    }
+  }
+]
diff --git a/experiments/token-efficiency-v0/run.sh b/experiments/token-efficiency-v0/run.sh
new file mode 100755
index 00000000..f098ba30
--- /dev/null
+++ b/experiments/token-efficiency-v0/run.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+export GOCACHE="${GOCACHE:-/tmp/hf-token-go-cache}"
+go build -o /tmp/howlframe .
+go build -o /tmp/hfexp ./experiments/falsifiable-v0/cmd/hfexp
+go build -o /tmp/tokverify ./experiments/token-efficiency-v0/cmd/tokverify
+# Count failures too, then propagate the verifier's nonzero status.
+status=0
+/tmp/tokverify || status=$?
+"${TOKBENCH_PYTHON:-python3}" experiments/token-efficiency-v0/count_tokens.py
+exit "$status"
diff --git a/experiments/token-efficiency-v0/solutions/go/a01.go b/experiments/token-efficiency-v0/solutions/go/a01.go
new file mode 100644
index 00000000..4927daeb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a01.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "01", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a02.go b/experiments/token-efficiency-v0/solutions/go/a02.go
new file mode 100644
index 00000000..c5a8bf67
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a02.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "02", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a03.go b/experiments/token-efficiency-v0/solutions/go/a03.go
new file mode 100644
index 00000000..4c1757cb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a03.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "03", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a04.go b/experiments/token-efficiency-v0/solutions/go/a04.go
new file mode 100644
index 00000000..cc3932a7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a04.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "04", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a05.go b/experiments/token-efficiency-v0/solutions/go/a05.go
new file mode 100644
index 00000000..f97c5ea7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a05.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "05", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a06.go b/experiments/token-efficiency-v0/solutions/go/a06.go
new file mode 100644
index 00000000..75a362cb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a06.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "06", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a07.go b/experiments/token-efficiency-v0/solutions/go/a07.go
new file mode 100644
index 00000000..43f2e3c8
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a07.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "07", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a08.go b/experiments/token-efficiency-v0/solutions/go/a08.go
new file mode 100644
index 00000000..84fd4a58
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a08.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "08", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a09.go b/experiments/token-efficiency-v0/solutions/go/a09.go
new file mode 100644
index 00000000..3b81de8f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a09.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "09", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a10.go b/experiments/token-efficiency-v0/solutions/go/a10.go
new file mode 100644
index 00000000..271d18b3
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a10.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "10", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a11.go b/experiments/token-efficiency-v0/solutions/go/a11.go
new file mode 100644
index 00000000..2b6fc545
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a11.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "11", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a12.go b/experiments/token-efficiency-v0/solutions/go/a12.go
new file mode 100644
index 00000000..7a96b7bb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a12.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "12", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a13.go b/experiments/token-efficiency-v0/solutions/go/a13.go
new file mode 100644
index 00000000..a8dd08ca
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a13.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "13", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a14.go b/experiments/token-efficiency-v0/solutions/go/a14.go
new file mode 100644
index 00000000..1904d874
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a14.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "14", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a15.go b/experiments/token-efficiency-v0/solutions/go/a15.go
new file mode 100644
index 00000000..e23cbfb2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a15.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "15", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a16.go b/experiments/token-efficiency-v0/solutions/go/a16.go
new file mode 100644
index 00000000..a91a432e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a16.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "16", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a17.go b/experiments/token-efficiency-v0/solutions/go/a17.go
new file mode 100644
index 00000000..8523a731
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a17.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "17", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a18.go b/experiments/token-efficiency-v0/solutions/go/a18.go
new file mode 100644
index 00000000..8f5bce58
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a18.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "18", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a19.go b/experiments/token-efficiency-v0/solutions/go/a19.go
new file mode 100644
index 00000000..4fd565e9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a19.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "19", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a20.go b/experiments/token-efficiency-v0/solutions/go/a20.go
new file mode 100644
index 00000000..16cd4b45
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a20.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "20", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a21.go b/experiments/token-efficiency-v0/solutions/go/a21.go
new file mode 100644
index 00000000..5d2e2660
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a21.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "21", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a22.go b/experiments/token-efficiency-v0/solutions/go/a22.go
new file mode 100644
index 00000000..57d90027
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a22.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "22", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a23.go b/experiments/token-efficiency-v0/solutions/go/a23.go
new file mode 100644
index 00000000..7d825d12
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a23.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "23", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a24.go b/experiments/token-efficiency-v0/solutions/go/a24.go
new file mode 100644
index 00000000..4c26e317
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a24.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "24", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a25.go b/experiments/token-efficiency-v0/solutions/go/a25.go
new file mode 100644
index 00000000..f59f2a92
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a25.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "25", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a26.go b/experiments/token-efficiency-v0/solutions/go/a26.go
new file mode 100644
index 00000000..8cb1ba59
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a26.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "26", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a27.go b/experiments/token-efficiency-v0/solutions/go/a27.go
new file mode 100644
index 00000000..14a8ace6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a27.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "27", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a28.go b/experiments/token-efficiency-v0/solutions/go/a28.go
new file mode 100644
index 00000000..d2b44f2f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a28.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "28", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a29.go b/experiments/token-efficiency-v0/solutions/go/a29.go
new file mode 100644
index 00000000..e93f4052
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a29.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "29", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/a30.go b/experiments/token-efficiency-v0/solutions/go/a30.go
new file mode 100644
index 00000000..065c13d2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/a30.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "30", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t01.go b/experiments/token-efficiency-v0/solutions/go/t01.go
new file mode 100644
index 00000000..4927daeb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t01.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "01", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t02.go b/experiments/token-efficiency-v0/solutions/go/t02.go
new file mode 100644
index 00000000..c5a8bf67
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t02.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "02", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t03.go b/experiments/token-efficiency-v0/solutions/go/t03.go
new file mode 100644
index 00000000..4c1757cb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t03.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "03", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t04.go b/experiments/token-efficiency-v0/solutions/go/t04.go
new file mode 100644
index 00000000..cc3932a7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t04.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "04", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t05.go b/experiments/token-efficiency-v0/solutions/go/t05.go
new file mode 100644
index 00000000..f97c5ea7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t05.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "05", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t06.go b/experiments/token-efficiency-v0/solutions/go/t06.go
new file mode 100644
index 00000000..75a362cb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t06.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "06", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t07.go b/experiments/token-efficiency-v0/solutions/go/t07.go
new file mode 100644
index 00000000..43f2e3c8
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t07.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "07", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t08.go b/experiments/token-efficiency-v0/solutions/go/t08.go
new file mode 100644
index 00000000..84fd4a58
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t08.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "08", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t09.go b/experiments/token-efficiency-v0/solutions/go/t09.go
new file mode 100644
index 00000000..3b81de8f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t09.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "09", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t10.go b/experiments/token-efficiency-v0/solutions/go/t10.go
new file mode 100644
index 00000000..271d18b3
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t10.go
@@ -0,0 +1,40 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["status"] == "PASS" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "10", "selected": selected}
+	path := "out/release.json"
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t11.go b/experiments/token-efficiency-v0/solutions/go/t11.go
new file mode 100644
index 00000000..2b6fc545
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t11.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "11", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t12.go b/experiments/token-efficiency-v0/solutions/go/t12.go
new file mode 100644
index 00000000..7a96b7bb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t12.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "12", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t13.go b/experiments/token-efficiency-v0/solutions/go/t13.go
new file mode 100644
index 00000000..a8dd08ca
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t13.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "13", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t14.go b/experiments/token-efficiency-v0/solutions/go/t14.go
new file mode 100644
index 00000000..1904d874
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t14.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "14", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t15.go b/experiments/token-efficiency-v0/solutions/go/t15.go
new file mode 100644
index 00000000..e23cbfb2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t15.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "15", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t16.go b/experiments/token-efficiency-v0/solutions/go/t16.go
new file mode 100644
index 00000000..a91a432e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t16.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "16", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t17.go b/experiments/token-efficiency-v0/solutions/go/t17.go
new file mode 100644
index 00000000..8523a731
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t17.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "17", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t18.go b/experiments/token-efficiency-v0/solutions/go/t18.go
new file mode 100644
index 00000000..8f5bce58
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t18.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "18", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t19.go b/experiments/token-efficiency-v0/solutions/go/t19.go
new file mode 100644
index 00000000..4fd565e9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t19.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "19", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t20.go b/experiments/token-efficiency-v0/solutions/go/t20.go
new file mode 100644
index 00000000..16cd4b45
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t20.go
@@ -0,0 +1,75 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func version(text string) [3]int {
+	var result [3]int
+	for i, part := range strings.Split(text, ".") {
+		n, err := strconv.Atoi(part)
+		if err != nil {
+			panic(err)
+		}
+		result[i] = n
+	}
+	return result
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	versionText := mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	allPassed := true
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+		if check["status"] != "PASS" {
+			allPassed = false
+		}
+	}
+	record := map[string]interface{}{"batch": "20", "selected": selected}
+	versions := make(map[string]string)
+	for _, line := range strings.Fields(string(versionText)) {
+		key, value, _ := strings.Cut(line, "=")
+		versions[key] = value
+	}
+	current, proposed := version(versions["current"]), version(versions["proposed"])
+	newer := false
+	for i := 0; i < 3; i++ {
+		if proposed[i] != current[i] {
+			newer = proposed[i] > current[i]
+			break
+		}
+	}
+	path := "out/release.json"
+	if !allPassed || !newer {
+		path = "out/approval_request.json"
+		record = map[string]interface{}{"reason": "blocked", "summary": map[string]interface{}{}}
+	}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t21.go b/experiments/token-efficiency-v0/solutions/go/t21.go
new file mode 100644
index 00000000..5d2e2660
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t21.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "21", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t22.go b/experiments/token-efficiency-v0/solutions/go/t22.go
new file mode 100644
index 00000000..57d90027
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t22.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "22", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t23.go b/experiments/token-efficiency-v0/solutions/go/t23.go
new file mode 100644
index 00000000..7d825d12
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t23.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "23", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t24.go b/experiments/token-efficiency-v0/solutions/go/t24.go
new file mode 100644
index 00000000..4c26e317
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t24.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "24", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t25.go b/experiments/token-efficiency-v0/solutions/go/t25.go
new file mode 100644
index 00000000..f59f2a92
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t25.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "25", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t26.go b/experiments/token-efficiency-v0/solutions/go/t26.go
new file mode 100644
index 00000000..8cb1ba59
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t26.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "26", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t27.go b/experiments/token-efficiency-v0/solutions/go/t27.go
new file mode 100644
index 00000000..14a8ace6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t27.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "27", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t28.go b/experiments/token-efficiency-v0/solutions/go/t28.go
new file mode 100644
index 00000000..d2b44f2f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t28.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "28", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t29.go b/experiments/token-efficiency-v0/solutions/go/t29.go
new file mode 100644
index 00000000..e93f4052
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t29.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "29", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/go/t30.go b/experiments/token-efficiency-v0/solutions/go/t30.go
new file mode 100644
index 00000000..065c13d2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/go/t30.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+)
+
+func mustRead(path string) []byte {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func main() {
+	var checks []map[string]interface{}
+	if err := json.Unmarshal(mustRead("evidence/checks.json"), &checks); err != nil {
+		panic(err)
+	}
+	mustRead("evidence/version.kv")
+	mustRead("evidence/note.txt")
+	selected := make([]map[string]interface{}, 0)
+	for _, check := range checks {
+		if check["name"] == "unit" {
+			selected = append(selected, check)
+		}
+	}
+	record := map[string]interface{}{"batch": "30", "selected": selected}
+	path := "out/approval_request.json"
+	record = map[string]interface{}{"reason": "release review", "summary": record}
+	data, err := json.MarshalIndent(record, "", "  ")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+		panic(err)
+	}
+}
diff --git a/experiments/token-efficiency-v0/solutions/howl/a01.howl b/experiments/token-efficiency-v0/solutions/howl/a01.howl
new file mode 100644
index 00000000..61c176bc
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a01.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "01") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a02.howl b/experiments/token-efficiency-v0/solutions/howl/a02.howl
new file mode 100644
index 00000000..a5698fc7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a02.howl
@@ -0,0 +1,24 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "02") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len selected) (list_len checks)) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a03.howl b/experiments/token-efficiency-v0/solutions/howl/a03.howl
new file mode 100644
index 00000000..d638404c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a03.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "03") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a04.howl b/experiments/token-efficiency-v0/solutions/howl/a04.howl
new file mode 100644
index 00000000..db981ce6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a04.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "04") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a05.howl b/experiments/token-efficiency-v0/solutions/howl/a05.howl
new file mode 100644
index 00000000..bc353bdf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a05.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "05") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a06.howl b/experiments/token-efficiency-v0/solutions/howl/a06.howl
new file mode 100644
index 00000000..51f93257
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a06.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "06") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a07.howl b/experiments/token-efficiency-v0/solutions/howl/a07.howl
new file mode 100644
index 00000000..0e23cb92
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a07.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "07") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a08.howl b/experiments/token-efficiency-v0/solutions/howl/a08.howl
new file mode 100644
index 00000000..925af16b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a08.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "08") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a09.howl b/experiments/token-efficiency-v0/solutions/howl/a09.howl
new file mode 100644
index 00000000..4528661c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a09.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "09") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a10.howl b/experiments/token-efficiency-v0/solutions/howl/a10.howl
new file mode 100644
index 00000000..583d6298
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a10.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "10") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a11.howl b/experiments/token-efficiency-v0/solutions/howl/a11.howl
new file mode 100644
index 00000000..40dad1e1
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a11.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "11") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a12.howl b/experiments/token-efficiency-v0/solutions/howl/a12.howl
new file mode 100644
index 00000000..c7dce229
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a12.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "12") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a13.howl b/experiments/token-efficiency-v0/solutions/howl/a13.howl
new file mode 100644
index 00000000..137c9ad6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a13.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "13") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a14.howl b/experiments/token-efficiency-v0/solutions/howl/a14.howl
new file mode 100644
index 00000000..a040d28c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a14.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "14") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a15.howl b/experiments/token-efficiency-v0/solutions/howl/a15.howl
new file mode 100644
index 00000000..dec6df80
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a15.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "15") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a16.howl b/experiments/token-efficiency-v0/solutions/howl/a16.howl
new file mode 100644
index 00000000..a7eeb123
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a16.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "16") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a17.howl b/experiments/token-efficiency-v0/solutions/howl/a17.howl
new file mode 100644
index 00000000..119284d9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a17.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "17") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a18.howl b/experiments/token-efficiency-v0/solutions/howl/a18.howl
new file mode 100644
index 00000000..5801267e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a18.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "18") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a19.howl b/experiments/token-efficiency-v0/solutions/howl/a19.howl
new file mode 100644
index 00000000..ab0daeb2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a19.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "19") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a20.howl b/experiments/token-efficiency-v0/solutions/howl/a20.howl
new file mode 100644
index 00000000..0a873313
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a20.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "20") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a21.howl b/experiments/token-efficiency-v0/solutions/howl/a21.howl
new file mode 100644
index 00000000..162313d9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a21.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "21") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a22.howl b/experiments/token-efficiency-v0/solutions/howl/a22.howl
new file mode 100644
index 00000000..ed6150d7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a22.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "22") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a23.howl b/experiments/token-efficiency-v0/solutions/howl/a23.howl
new file mode 100644
index 00000000..0bd5aee5
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a23.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "23") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a24.howl b/experiments/token-efficiency-v0/solutions/howl/a24.howl
new file mode 100644
index 00000000..cd787d6e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a24.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "24") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a25.howl b/experiments/token-efficiency-v0/solutions/howl/a25.howl
new file mode 100644
index 00000000..63a5b986
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a25.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "25") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a26.howl b/experiments/token-efficiency-v0/solutions/howl/a26.howl
new file mode 100644
index 00000000..1fd9dafb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a26.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "26") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a27.howl b/experiments/token-efficiency-v0/solutions/howl/a27.howl
new file mode 100644
index 00000000..0af4c915
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a27.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "27") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a28.howl b/experiments/token-efficiency-v0/solutions/howl/a28.howl
new file mode 100644
index 00000000..c8eb41d6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a28.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "28") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a29.howl b/experiments/token-efficiency-v0/solutions/howl/a29.howl
new file mode 100644
index 00000000..a8986ef4
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a29.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "29") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/a30.howl b/experiments/token-efficiency-v0/solutions/howl/a30.howl
new file mode 100644
index 00000000..6c57bba2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/a30.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "30") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t01.howl b/experiments/token-efficiency-v0/solutions/howl/t01.howl
new file mode 100644
index 00000000..61c176bc
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t01.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "01") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t02.howl b/experiments/token-efficiency-v0/solutions/howl/t02.howl
new file mode 100644
index 00000000..a5698fc7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t02.howl
@@ -0,0 +1,24 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "02") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len selected) (list_len checks)) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t03.howl b/experiments/token-efficiency-v0/solutions/howl/t03.howl
new file mode 100644
index 00000000..d638404c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t03.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "03") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t04.howl b/experiments/token-efficiency-v0/solutions/howl/t04.howl
new file mode 100644
index 00000000..db981ce6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t04.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "04") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t05.howl b/experiments/token-efficiency-v0/solutions/howl/t05.howl
new file mode 100644
index 00000000..bc353bdf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t05.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "05") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t06.howl b/experiments/token-efficiency-v0/solutions/howl/t06.howl
new file mode 100644
index 00000000..51f93257
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t06.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "06") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t07.howl b/experiments/token-efficiency-v0/solutions/howl/t07.howl
new file mode 100644
index 00000000..0e23cb92
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t07.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "07") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t08.howl b/experiments/token-efficiency-v0/solutions/howl/t08.howl
new file mode 100644
index 00000000..925af16b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t08.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "08") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t09.howl b/experiments/token-efficiency-v0/solutions/howl/t09.howl
new file mode 100644
index 00000000..4528661c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t09.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "09") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t10.howl b/experiments/token-efficiency-v0/solutions/howl/t10.howl
new file mode 100644
index 00000000..583d6298
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t10.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "status") "PASS") (append selected c)))
+      (let (record (dict ("batch" "10") ("selected" selected)))
+       (do
+        (write_file "out/release.json" (encode_json record))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t11.howl b/experiments/token-efficiency-v0/solutions/howl/t11.howl
new file mode 100644
index 00000000..40dad1e1
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t11.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "11") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t12.howl b/experiments/token-efficiency-v0/solutions/howl/t12.howl
new file mode 100644
index 00000000..c7dce229
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t12.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "12") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t13.howl b/experiments/token-efficiency-v0/solutions/howl/t13.howl
new file mode 100644
index 00000000..137c9ad6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t13.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "13") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t14.howl b/experiments/token-efficiency-v0/solutions/howl/t14.howl
new file mode 100644
index 00000000..a040d28c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t14.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "14") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t15.howl b/experiments/token-efficiency-v0/solutions/howl/t15.howl
new file mode 100644
index 00000000..dec6df80
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t15.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "15") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t16.howl b/experiments/token-efficiency-v0/solutions/howl/t16.howl
new file mode 100644
index 00000000..a7eeb123
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t16.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "16") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t17.howl b/experiments/token-efficiency-v0/solutions/howl/t17.howl
new file mode 100644
index 00000000..119284d9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t17.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "17") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t18.howl b/experiments/token-efficiency-v0/solutions/howl/t18.howl
new file mode 100644
index 00000000..5801267e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t18.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "18") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t19.howl b/experiments/token-efficiency-v0/solutions/howl/t19.howl
new file mode 100644
index 00000000..ab0daeb2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t19.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "19") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t20.howl b/experiments/token-efficiency-v0/solutions/howl/t20.howl
new file mode 100644
index 00000000..0a873313
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t20.howl
@@ -0,0 +1,26 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (let (failed (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (for c checks (if (!= (map_get c "status") "PASS") (append failed c)))
+      (let (record (dict ("batch" "20") ("selected" selected)))
+       (let (lines (str_split version "\n"))
+ (let (current_pair (str_split (list_get lines 0) "="))
+ (let (proposed_pair (str_split (list_get lines 1) "="))
+ (let (current (str_split (list_get current_pair 1) "."))
+ (let (proposed (str_split (list_get proposed_pair 1) "."))
+ (let (newer (or (> (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+   (and (= (to_int (list_get proposed 0)) (to_int (list_get current 0)))
+     (or (> (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+       (and (= (to_int (list_get proposed 1)) (to_int (list_get current 1)))
+         (> (to_int (list_get proposed 2)) (to_int (list_get current 2))))))))
+ (if (and (= (list_len failed) 0) newer)
+   (write_file "out/release.json" (encode_json record))
+   (write_file "out/approval_request.json" "{\"reason\":\"blocked\",\"summary\":{}}"))
+ )))))))
+      ))))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t21.howl b/experiments/token-efficiency-v0/solutions/howl/t21.howl
new file mode 100644
index 00000000..162313d9
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t21.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "21") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t22.howl b/experiments/token-efficiency-v0/solutions/howl/t22.howl
new file mode 100644
index 00000000..ed6150d7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t22.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "22") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t23.howl b/experiments/token-efficiency-v0/solutions/howl/t23.howl
new file mode 100644
index 00000000..0bd5aee5
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t23.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "23") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t24.howl b/experiments/token-efficiency-v0/solutions/howl/t24.howl
new file mode 100644
index 00000000..cd787d6e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t24.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "24") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t25.howl b/experiments/token-efficiency-v0/solutions/howl/t25.howl
new file mode 100644
index 00000000..63a5b986
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t25.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "25") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t26.howl b/experiments/token-efficiency-v0/solutions/howl/t26.howl
new file mode 100644
index 00000000..1fd9dafb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t26.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "26") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t27.howl b/experiments/token-efficiency-v0/solutions/howl/t27.howl
new file mode 100644
index 00000000..0af4c915
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t27.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "27") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t28.howl b/experiments/token-efficiency-v0/solutions/howl/t28.howl
new file mode 100644
index 00000000..c8eb41d6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t28.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "28") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t29.howl b/experiments/token-efficiency-v0/solutions/howl/t29.howl
new file mode 100644
index 00000000..a8986ef4
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t29.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "29") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/howl/t30.howl b/experiments/token-efficiency-v0/solutions/howl/t30.howl
new file mode 100644
index 00000000..6c57bba2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/howl/t30.howl
@@ -0,0 +1,13 @@
+(cli_app
+ (let (raw (bytes_to_string (read_file "evidence/checks.json")))
+ (let (checks (parse_json Checks raw))
+  (let (version (bytes_to_string (read_file "evidence/version.kv")))
+   (let (note (bytes_to_string (read_file "evidence/note.txt")))
+    (let (selected (list))
+     (do
+      (for c checks (if (= (map_get c "name") "unit") (append selected c)))
+      (let (record (dict ("batch" "30") ("selected" selected)))
+       (do
+        (write_file "out/approval_request.json" (encode_json (dict ("reason" "release review") ("summary" record))))
+        ))
+      )))))))
diff --git a/experiments/token-efficiency-v0/solutions/js/a01.js b/experiments/token-efficiency-v0/solutions/js/a01.js
new file mode 100644
index 00000000..b8c7e21b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a01.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "01", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a02.js b/experiments/token-efficiency-v0/solutions/js/a02.js
new file mode 100644
index 00000000..e8a22902
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a02.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "02", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a03.js b/experiments/token-efficiency-v0/solutions/js/a03.js
new file mode 100644
index 00000000..57d50717
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a03.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "03", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a04.js b/experiments/token-efficiency-v0/solutions/js/a04.js
new file mode 100644
index 00000000..4e1f4588
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a04.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "04", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a05.js b/experiments/token-efficiency-v0/solutions/js/a05.js
new file mode 100644
index 00000000..e6fa39c6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a05.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "05", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a06.js b/experiments/token-efficiency-v0/solutions/js/a06.js
new file mode 100644
index 00000000..4e513161
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a06.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "06", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a07.js b/experiments/token-efficiency-v0/solutions/js/a07.js
new file mode 100644
index 00000000..874e0c47
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a07.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "07", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a08.js b/experiments/token-efficiency-v0/solutions/js/a08.js
new file mode 100644
index 00000000..d8a3385d
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a08.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "08", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a09.js b/experiments/token-efficiency-v0/solutions/js/a09.js
new file mode 100644
index 00000000..42c8a20f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a09.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "09", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a10.js b/experiments/token-efficiency-v0/solutions/js/a10.js
new file mode 100644
index 00000000..e4ee8286
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a10.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "10", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a11.js b/experiments/token-efficiency-v0/solutions/js/a11.js
new file mode 100644
index 00000000..7b98bfe0
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a11.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "11", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a12.js b/experiments/token-efficiency-v0/solutions/js/a12.js
new file mode 100644
index 00000000..8c88b30f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a12.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "12", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a13.js b/experiments/token-efficiency-v0/solutions/js/a13.js
new file mode 100644
index 00000000..5ae35c0a
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a13.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "13", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a14.js b/experiments/token-efficiency-v0/solutions/js/a14.js
new file mode 100644
index 00000000..c88be9e2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a14.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "14", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a15.js b/experiments/token-efficiency-v0/solutions/js/a15.js
new file mode 100644
index 00000000..70bc8b71
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a15.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "15", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a16.js b/experiments/token-efficiency-v0/solutions/js/a16.js
new file mode 100644
index 00000000..378abf45
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a16.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "16", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a17.js b/experiments/token-efficiency-v0/solutions/js/a17.js
new file mode 100644
index 00000000..04b4ab8b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a17.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "17", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a18.js b/experiments/token-efficiency-v0/solutions/js/a18.js
new file mode 100644
index 00000000..de81be7e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a18.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "18", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a19.js b/experiments/token-efficiency-v0/solutions/js/a19.js
new file mode 100644
index 00000000..fa529335
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a19.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "19", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a20.js b/experiments/token-efficiency-v0/solutions/js/a20.js
new file mode 100644
index 00000000..ee653d7f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a20.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "20", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a21.js b/experiments/token-efficiency-v0/solutions/js/a21.js
new file mode 100644
index 00000000..5ca41e1b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a21.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "21", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a22.js b/experiments/token-efficiency-v0/solutions/js/a22.js
new file mode 100644
index 00000000..ac387711
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a22.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "22", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a23.js b/experiments/token-efficiency-v0/solutions/js/a23.js
new file mode 100644
index 00000000..8d26a121
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a23.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "23", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a24.js b/experiments/token-efficiency-v0/solutions/js/a24.js
new file mode 100644
index 00000000..a555ca1c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a24.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "24", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a25.js b/experiments/token-efficiency-v0/solutions/js/a25.js
new file mode 100644
index 00000000..6ab8d6a2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a25.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "25", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a26.js b/experiments/token-efficiency-v0/solutions/js/a26.js
new file mode 100644
index 00000000..703cf9d0
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a26.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "26", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a27.js b/experiments/token-efficiency-v0/solutions/js/a27.js
new file mode 100644
index 00000000..a4068fd1
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a27.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "27", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a28.js b/experiments/token-efficiency-v0/solutions/js/a28.js
new file mode 100644
index 00000000..0d55feae
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a28.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "28", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a29.js b/experiments/token-efficiency-v0/solutions/js/a29.js
new file mode 100644
index 00000000..49c1d61b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a29.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "29", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/a30.js b/experiments/token-efficiency-v0/solutions/js/a30.js
new file mode 100644
index 00000000..a22ee849
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/a30.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "30", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t01.js b/experiments/token-efficiency-v0/solutions/js/t01.js
new file mode 100644
index 00000000..b8c7e21b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t01.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "01", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t02.js b/experiments/token-efficiency-v0/solutions/js/t02.js
new file mode 100644
index 00000000..e8a22902
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t02.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "02", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t03.js b/experiments/token-efficiency-v0/solutions/js/t03.js
new file mode 100644
index 00000000..57d50717
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t03.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "03", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t04.js b/experiments/token-efficiency-v0/solutions/js/t04.js
new file mode 100644
index 00000000..4e1f4588
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t04.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "04", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t05.js b/experiments/token-efficiency-v0/solutions/js/t05.js
new file mode 100644
index 00000000..e6fa39c6
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t05.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "05", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t06.js b/experiments/token-efficiency-v0/solutions/js/t06.js
new file mode 100644
index 00000000..4e513161
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t06.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "06", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t07.js b/experiments/token-efficiency-v0/solutions/js/t07.js
new file mode 100644
index 00000000..874e0c47
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t07.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "07", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t08.js b/experiments/token-efficiency-v0/solutions/js/t08.js
new file mode 100644
index 00000000..d8a3385d
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t08.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "08", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t09.js b/experiments/token-efficiency-v0/solutions/js/t09.js
new file mode 100644
index 00000000..42c8a20f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t09.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "09", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t10.js b/experiments/token-efficiency-v0/solutions/js/t10.js
new file mode 100644
index 00000000..e4ee8286
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t10.js
@@ -0,0 +1,9 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.status === "PASS");
+let record = { batch: "10", selected };
+const path = "out/release.json";
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t11.js b/experiments/token-efficiency-v0/solutions/js/t11.js
new file mode 100644
index 00000000..7b98bfe0
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t11.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "11", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t12.js b/experiments/token-efficiency-v0/solutions/js/t12.js
new file mode 100644
index 00000000..8c88b30f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t12.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "12", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t13.js b/experiments/token-efficiency-v0/solutions/js/t13.js
new file mode 100644
index 00000000..5ae35c0a
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t13.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "13", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t14.js b/experiments/token-efficiency-v0/solutions/js/t14.js
new file mode 100644
index 00000000..c88be9e2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t14.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "14", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t15.js b/experiments/token-efficiency-v0/solutions/js/t15.js
new file mode 100644
index 00000000..70bc8b71
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t15.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "15", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t16.js b/experiments/token-efficiency-v0/solutions/js/t16.js
new file mode 100644
index 00000000..378abf45
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t16.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "16", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t17.js b/experiments/token-efficiency-v0/solutions/js/t17.js
new file mode 100644
index 00000000..04b4ab8b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t17.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "17", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t18.js b/experiments/token-efficiency-v0/solutions/js/t18.js
new file mode 100644
index 00000000..de81be7e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t18.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "18", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t19.js b/experiments/token-efficiency-v0/solutions/js/t19.js
new file mode 100644
index 00000000..fa529335
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t19.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "19", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t20.js b/experiments/token-efficiency-v0/solutions/js/t20.js
new file mode 100644
index 00000000..ee653d7f
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t20.js
@@ -0,0 +1,25 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "20", selected };
+const versions = Object.fromEntries(versionText.trim().split("\n").map(line => line.split("=")));
+const current = versions.current.split(".").map(Number);
+const proposed = versions.proposed.split(".").map(Number);
+let newer = false;
+for (let i = 0; i < 3; i++) {
+    if (proposed[i] !== current[i]) {
+        newer = proposed[i] > current[i];
+        break;
+    }
+}
+let path;
+if (checks.every(check => check.status === "PASS") && newer) {
+    path = "out/release.json";
+} else {
+    path = "out/approval_request.json";
+    record = { reason: "blocked", summary: {} };
+}
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t21.js b/experiments/token-efficiency-v0/solutions/js/t21.js
new file mode 100644
index 00000000..5ca41e1b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t21.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "21", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t22.js b/experiments/token-efficiency-v0/solutions/js/t22.js
new file mode 100644
index 00000000..ac387711
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t22.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "22", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t23.js b/experiments/token-efficiency-v0/solutions/js/t23.js
new file mode 100644
index 00000000..8d26a121
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t23.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "23", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t24.js b/experiments/token-efficiency-v0/solutions/js/t24.js
new file mode 100644
index 00000000..a555ca1c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t24.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "24", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t25.js b/experiments/token-efficiency-v0/solutions/js/t25.js
new file mode 100644
index 00000000..6ab8d6a2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t25.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "25", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t26.js b/experiments/token-efficiency-v0/solutions/js/t26.js
new file mode 100644
index 00000000..703cf9d0
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t26.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "26", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t27.js b/experiments/token-efficiency-v0/solutions/js/t27.js
new file mode 100644
index 00000000..a4068fd1
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t27.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "27", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t28.js b/experiments/token-efficiency-v0/solutions/js/t28.js
new file mode 100644
index 00000000..0d55feae
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t28.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "28", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t29.js b/experiments/token-efficiency-v0/solutions/js/t29.js
new file mode 100644
index 00000000..49c1d61b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t29.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "29", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/js/t30.js b/experiments/token-efficiency-v0/solutions/js/t30.js
new file mode 100644
index 00000000..a22ee849
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/js/t30.js
@@ -0,0 +1,10 @@
+const fs = require("node:fs");
+
+const checks = JSON.parse(fs.readFileSync("evidence/checks.json", "utf8"));
+const versionText = fs.readFileSync("evidence/version.kv", "utf8");
+fs.readFileSync("evidence/note.txt", "utf8");
+const selected = checks.filter(check => check.name === "unit");
+let record = { batch: "30", selected };
+const path = "out/approval_request.json";
+record = { reason: "release review", summary: record };
+fs.writeFileSync(path, JSON.stringify(record, null, 2) + "\n");
diff --git a/experiments/token-efficiency-v0/solutions/python/a01.py b/experiments/token-efficiency-v0/solutions/python/a01.py
new file mode 100644
index 00000000..c24798cf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a01.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "01", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a02.py b/experiments/token-efficiency-v0/solutions/python/a02.py
new file mode 100644
index 00000000..7be7bf96
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a02.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "02", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a03.py b/experiments/token-efficiency-v0/solutions/python/a03.py
new file mode 100644
index 00000000..32d7146e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a03.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "03", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a04.py b/experiments/token-efficiency-v0/solutions/python/a04.py
new file mode 100644
index 00000000..946202a7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a04.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "04", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a05.py b/experiments/token-efficiency-v0/solutions/python/a05.py
new file mode 100644
index 00000000..bb4ffe0b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a05.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "05", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a06.py b/experiments/token-efficiency-v0/solutions/python/a06.py
new file mode 100644
index 00000000..afc276de
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a06.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "06", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a07.py b/experiments/token-efficiency-v0/solutions/python/a07.py
new file mode 100644
index 00000000..4dc82e23
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a07.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "07", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a08.py b/experiments/token-efficiency-v0/solutions/python/a08.py
new file mode 100644
index 00000000..197717cf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a08.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "08", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a09.py b/experiments/token-efficiency-v0/solutions/python/a09.py
new file mode 100644
index 00000000..e8a93cef
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a09.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "09", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a10.py b/experiments/token-efficiency-v0/solutions/python/a10.py
new file mode 100644
index 00000000..b29c8f99
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a10.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "10", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a11.py b/experiments/token-efficiency-v0/solutions/python/a11.py
new file mode 100644
index 00000000..5984f51e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a11.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "11", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a12.py b/experiments/token-efficiency-v0/solutions/python/a12.py
new file mode 100644
index 00000000..76457329
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a12.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "12", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a13.py b/experiments/token-efficiency-v0/solutions/python/a13.py
new file mode 100644
index 00000000..b5de38ed
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a13.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "13", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a14.py b/experiments/token-efficiency-v0/solutions/python/a14.py
new file mode 100644
index 00000000..92b065f2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a14.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "14", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a15.py b/experiments/token-efficiency-v0/solutions/python/a15.py
new file mode 100644
index 00000000..f98f988e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a15.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "15", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a16.py b/experiments/token-efficiency-v0/solutions/python/a16.py
new file mode 100644
index 00000000..53177c34
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a16.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "16", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a17.py b/experiments/token-efficiency-v0/solutions/python/a17.py
new file mode 100644
index 00000000..f9d0684c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a17.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "17", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a18.py b/experiments/token-efficiency-v0/solutions/python/a18.py
new file mode 100644
index 00000000..436936db
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a18.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "18", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a19.py b/experiments/token-efficiency-v0/solutions/python/a19.py
new file mode 100644
index 00000000..5353f489
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a19.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "19", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a20.py b/experiments/token-efficiency-v0/solutions/python/a20.py
new file mode 100644
index 00000000..01120ae3
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a20.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "20", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a21.py b/experiments/token-efficiency-v0/solutions/python/a21.py
new file mode 100644
index 00000000..a7fc5e5e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a21.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "21", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a22.py b/experiments/token-efficiency-v0/solutions/python/a22.py
new file mode 100644
index 00000000..680e750b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a22.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "22", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a23.py b/experiments/token-efficiency-v0/solutions/python/a23.py
new file mode 100644
index 00000000..fbee7ebe
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a23.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "23", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a24.py b/experiments/token-efficiency-v0/solutions/python/a24.py
new file mode 100644
index 00000000..add2d6c2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a24.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "24", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a25.py b/experiments/token-efficiency-v0/solutions/python/a25.py
new file mode 100644
index 00000000..f94ac43b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a25.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "25", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a26.py b/experiments/token-efficiency-v0/solutions/python/a26.py
new file mode 100644
index 00000000..c02617cc
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a26.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "26", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a27.py b/experiments/token-efficiency-v0/solutions/python/a27.py
new file mode 100644
index 00000000..e2e848bb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a27.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "27", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a28.py b/experiments/token-efficiency-v0/solutions/python/a28.py
new file mode 100644
index 00000000..3a1ad9f8
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a28.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "28", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a29.py b/experiments/token-efficiency-v0/solutions/python/a29.py
new file mode 100644
index 00000000..adc2be1c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a29.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "29", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/a30.py b/experiments/token-efficiency-v0/solutions/python/a30.py
new file mode 100644
index 00000000..3160c183
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/a30.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "30", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t01.py b/experiments/token-efficiency-v0/solutions/python/t01.py
new file mode 100644
index 00000000..c24798cf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t01.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "01", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t02.py b/experiments/token-efficiency-v0/solutions/python/t02.py
new file mode 100644
index 00000000..7be7bf96
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t02.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "02", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t03.py b/experiments/token-efficiency-v0/solutions/python/t03.py
new file mode 100644
index 00000000..32d7146e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t03.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "03", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t04.py b/experiments/token-efficiency-v0/solutions/python/t04.py
new file mode 100644
index 00000000..946202a7
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t04.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "04", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t05.py b/experiments/token-efficiency-v0/solutions/python/t05.py
new file mode 100644
index 00000000..bb4ffe0b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t05.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "05", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t06.py b/experiments/token-efficiency-v0/solutions/python/t06.py
new file mode 100644
index 00000000..afc276de
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t06.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "06", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t07.py b/experiments/token-efficiency-v0/solutions/python/t07.py
new file mode 100644
index 00000000..4dc82e23
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t07.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "07", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t08.py b/experiments/token-efficiency-v0/solutions/python/t08.py
new file mode 100644
index 00000000..197717cf
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t08.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "08", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t09.py b/experiments/token-efficiency-v0/solutions/python/t09.py
new file mode 100644
index 00000000..e8a93cef
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t09.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "09", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t10.py b/experiments/token-efficiency-v0/solutions/python/t10.py
new file mode 100644
index 00000000..b29c8f99
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t10.py
@@ -0,0 +1,10 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["status"] == "PASS"]
+record = {"batch": "10", "selected": selected}
+path = "out/release.json"
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t11.py b/experiments/token-efficiency-v0/solutions/python/t11.py
new file mode 100644
index 00000000..5984f51e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t11.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "11", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t12.py b/experiments/token-efficiency-v0/solutions/python/t12.py
new file mode 100644
index 00000000..76457329
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t12.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "12", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t13.py b/experiments/token-efficiency-v0/solutions/python/t13.py
new file mode 100644
index 00000000..b5de38ed
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t13.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "13", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t14.py b/experiments/token-efficiency-v0/solutions/python/t14.py
new file mode 100644
index 00000000..92b065f2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t14.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "14", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t15.py b/experiments/token-efficiency-v0/solutions/python/t15.py
new file mode 100644
index 00000000..f98f988e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t15.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "15", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t16.py b/experiments/token-efficiency-v0/solutions/python/t16.py
new file mode 100644
index 00000000..53177c34
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t16.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "16", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t17.py b/experiments/token-efficiency-v0/solutions/python/t17.py
new file mode 100644
index 00000000..f9d0684c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t17.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "17", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t18.py b/experiments/token-efficiency-v0/solutions/python/t18.py
new file mode 100644
index 00000000..436936db
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t18.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "18", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t19.py b/experiments/token-efficiency-v0/solutions/python/t19.py
new file mode 100644
index 00000000..5353f489
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t19.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "19", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t20.py b/experiments/token-efficiency-v0/solutions/python/t20.py
new file mode 100644
index 00000000..01120ae3
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t20.py
@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "20", "selected": selected}
+versions = dict(line.split("=", 1) for line in version_text.splitlines())
+current = tuple(map(int, versions["current"].split(".")))
+proposed = tuple(map(int, versions["proposed"].split(".")))
+if all(check["status"] == "PASS" for check in checks) and proposed > current:
+    path = "out/release.json"
+else:
+    path = "out/approval_request.json"
+    record = {"reason": "blocked", "summary": {}}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t21.py b/experiments/token-efficiency-v0/solutions/python/t21.py
new file mode 100644
index 00000000..a7fc5e5e
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t21.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "21", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t22.py b/experiments/token-efficiency-v0/solutions/python/t22.py
new file mode 100644
index 00000000..680e750b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t22.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "22", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t23.py b/experiments/token-efficiency-v0/solutions/python/t23.py
new file mode 100644
index 00000000..fbee7ebe
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t23.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "23", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t24.py b/experiments/token-efficiency-v0/solutions/python/t24.py
new file mode 100644
index 00000000..add2d6c2
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t24.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "24", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t25.py b/experiments/token-efficiency-v0/solutions/python/t25.py
new file mode 100644
index 00000000..f94ac43b
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t25.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "25", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t26.py b/experiments/token-efficiency-v0/solutions/python/t26.py
new file mode 100644
index 00000000..c02617cc
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t26.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "26", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t27.py b/experiments/token-efficiency-v0/solutions/python/t27.py
new file mode 100644
index 00000000..e2e848bb
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t27.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "27", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t28.py b/experiments/token-efficiency-v0/solutions/python/t28.py
new file mode 100644
index 00000000..3a1ad9f8
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t28.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "28", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t29.py b/experiments/token-efficiency-v0/solutions/python/t29.py
new file mode 100644
index 00000000..adc2be1c
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t29.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "29", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions/python/t30.py b/experiments/token-efficiency-v0/solutions/python/t30.py
new file mode 100644
index 00000000..3160c183
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions/python/t30.py
@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+checks = json.loads(Path("evidence/checks.json").read_text())
+version_text = Path("evidence/version.kv").read_text()
+Path("evidence/note.txt").read_text()
+selected = [check for check in checks if check["name"] == "unit"]
+record = {"batch": "30", "selected": selected}
+path = "out/approval_request.json"
+record = {"reason": "release review", "summary": record}
+Path(path).write_text(json.dumps(record, indent=2) + "\n")
diff --git a/experiments/token-efficiency-v0/solutions_test.go b/experiments/token-efficiency-v0/solutions_test.go
new file mode 100644
index 00000000..3dc4db80
--- /dev/null
+++ b/experiments/token-efficiency-v0/solutions_test.go
@@ -0,0 +1,38 @@
+package tokenefficiency
+
+import (
+	"bytes"
+	"github.com/howlcipher/howlframe/experiments/falsifiable-v0/harness"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestSolutionCoverage(t *testing.T) {
+	m, err := harness.LoadManifest("../falsifiable-v0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, task := range m.All() {
+		for lang, ext := range map[string]string{"howl": "howl", "python": "py", "js": "js", "go": "go"} {
+			path := filepath.Join("solutions", lang, task.ID+"."+ext)
+			data, err := os.ReadFile(path)
+			if err != nil || len(bytes.TrimSpace(data)) == 0 {
+				t.Errorf("missing/empty solution %s: %v", path, err)
+			}
+		}
+	}
+	for _, id := range []string{"t01", "t02", "t03", "a01", "a02", "a03"} {
+		got, err := os.ReadFile(filepath.Join("solutions/howl", id+".howl"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		want, err := os.ReadFile(filepath.Join("../falsifiable-v0/reference/arm_a", id+".howl"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(got, want) {
+			t.Errorf("existing reference changed: %s", id)
+		}
+	}
+}