Publish KLIK real-agent Coder390 and TURBO-Fable replacement study with all failures

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.DS_Store
+*.log
+*.synctex.gz
+*.aux
+*.out

CITATION.cff

@@ -0,0 +1,14 @@
+cff-version: 1.2.0
+message: "Cite the paper and pinned artifact revision. Results are configuration-level descriptive tests, not a global model ranking."
+title: "Fast on the Card, Slow in the Agent: A Vision and Speculation Study of Coder390 and TURBO-Fable on Apple Silicon"
+authors:
+  - family-names: Xu
+    given-names: Chengyi
+    orcid: "https://orcid.org/0009-0008-1277-6670"
+  - name: KLIK team
+version: 1.0.0
+date-released: 2026-10-09
+type: software
+url: "https://huggingface.co/datasets/ChengyiX/coder390-fable-m4max-agent-study"
+license: MIT
+abstract: "AI-assisted experimental report, sanitized evidence and measurement code for thinking-enabled local model replacement trials. Code MIT, manuscripts/data CC BY 4.0; no model weights."

LICENSE

@@ -0,0 +1,27 @@
+Artifact licensing notice
+
+Original code in code/ and tools/ is MIT, as below. Original manuscript text,
+protocol documents, generated figures, synthetic vision fixture and sanitized
+numerical evidence are CC BY 4.0: https://creativecommons.org/licenses/by/4.0/
+No model weights or third-party source trees are distributed. Referenced model
+and runtime licenses remain separate. No unrestricted rights to third-party
+checkpoints are granted by this artifact.
+
+MIT License
+Copyright (c) 2026 Chengyi Xu and KLIK team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,105 @@
+---
+license: other
+license_name: klik-research-artifact
+license_link: LICENSE
+pretty_name: Coder390 and TURBO-Fable on Apple Silicon — Real-Agent Replacement Study
+language:
+- en
+tags:
+- apple-silicon
+- local-inference
+- agent-evaluation
+- qwen
+- ornith
+- speculative-decoding
+- vision
+- reproducibility
+---
+# Fast on the Card, Slow in the Agent
+
+## A Vision and Speculation Study of Coder390 and TURBO-Fable on Apple Silicon
+
+**Chengyi Xu and KLIK team — KLIK Research, October 2026**
+
+[![Paper](https://img.shields.io/badge/paper-PDF-blue)](paper/main.pdf)
+[![Source](https://img.shields.io/badge/source-LaTeX-green)](paper/main.tex)
+[![Platform](https://img.shields.io/badge/platform-Apple%20M4%20Max-black)]()
+
+An AI-assisted experimental deployment report comparing two requested Qwen3.8-27B replacements against an installed normal/abliterated Ornith-1.5-35B-A3B pair on **Apple M4 Max, 40-core GPU, 64 GiB unified memory**.
+
+**Public hosting is not peer review or journal acceptance. No DOI is claimed. No model weights are redistributed.**
+
+## Download the paper
+
+- [Paper PDF](paper/main.pdf)
+- [LaTeX source](paper/main.tex), using the same `klik-paper.sty` style as earlier KLIK reports
+- [Numerical results](results/processed/runs.json)
+- [Pinned model/runtime provenance](results/processed/provenance.json)
+- [Vision probe results](results/processed/vision.json)
+
+## Main result: do not replace the working deployment yet
+
+Both requested candidates loaded with thinking and vision; **all seven small llama.cpp vision probes answered a known diagram correctly**. That did not establish coding-agent usability.
+
+| Model/configuration | Whole task | Final visible stream | Full final-cycle visible rate | Repair result |
+|---|---:|---:|---:|---|
+| Installed normal Ornith, thinking low | 218.08 s | 30.57 tok/s | 23.86 tok/s | Independent gate + 275 tests passed, 1 skipped |
+| Installed abliterated Ornith, thinking low | 204.68 s | 32.33 tok/s | 28.38 tok/s | Independent gate + 275 tests passed, 1 skipped |
+| Coder390, five tested configurations | ~900 s each | Unknown: no completed final answer | Unknown | Five timeouts; injected defect remained |
+| Fable, b11036 MTP4 | 889.64 s | 4.32 tok/s | 2.44 tok/s | Independent gate + 274 tests passed, 1 skipped |
+| Fable, b11538 MTP2 | 892.05 s | 8.38 tok/s | 6.22 tok/s | Independent gate + 274 tests passed, 1 skipped |
+| Fable, b11538 no speculation | 795.80 s | 6.50 tok/s | 3.15 tok/s | Independent gate + 274 tests passed, 1 skipped |
+
+The task was a **real Pi repository repair**, routed through Magpie with normal extensions and tools, in a fresh isolated clone for every run. Initial requests were approximately **25k tokens**, not blank prompts. A deliberately injected regression failed before the task; the parent checked the repaired source, independent gate, and full suite afterward.
+
+These are **configuration-level descriptive results**, not a causal ranking of model intelligence. There is one trial per configuration, different sampling and engines, and variable workstation load. Candidate cold first-turn waits of roughly **365–579 seconds** dominated the deadline. Coder390 may complete with different runtime/settings or more time; these failures are not proof that it cannot solve the task.
+
+![Task elapsed including failures](paper/figures/task-wall.png)
+
+![Visible rates for completed answers only](paper/figures/visible-rates.png)
+
+## Important compatibility findings
+
+- The publishers' headline speed measurements used **NVIDIA RTX PRO 6000 / RTX 5090**, not this Mac.
+- Coder390's static FP8 headline scores differ from its Q4 GGUF table. We did not independently rerun GPQA/MMLU/LCB.
+- Author recipe `-c 409600 -np 4` means **102400 tokens per slot**, not 409k per individual session. Native config declares262144 positions.
+- SGLang does support Apple MLX, but its inspected **in-tree DFLASH handler excludes MPS**. No unsupported SGLang+DFlash2 result is invented.
+- Native Splash admits only about208889 context tokens for Coder390 at28GiB;32GiB admits262144 startup. That is allocation readiness, **not actual256k qualification**.
+- The tested Coder390 native DFlash2 path was **text-only**, using a compatible BF16 draft, not the author's FP8 draft or requested Q8 projector. Vision proof from llama.cpp does not transfer to it.
+- The existing native importer rejected Fable's BF16 output head. No hidden requantization or unverified kernel patch was used.
+- MTP acceptance is not whole-task speed. In Fable's measured newer-build runs, no-MTP completed the whole task sooner than MTP2 despite lower final-stream speed.
+
+## Reproducibility and privacy
+
+See [REPRODUCIBILITY.md](REPRODUCIBILITY.md), [RESULTS.md](RESULTS.md), and [protocol.md](protocol.md).
+
+The public ledger is a whitelist-only export. **Private repository source, raw source-bearing transcripts, tool arguments/results, secrets and local user paths are withheld.** The original private task cannot be reproduced byte-for-byte publicly. Using your own authorized repository is a new method replication, not identical evidence.
+
+No failed run is dropped. `null` means unknown, not zero. Visible-stream rates exclude preceding reasoning/prefill; full final-cycle rates include waiting and reasoning. Neither is whole-task visible throughput. Tool-only parser bursts are not decode evidence.
+
+Selected method tests:
+
+```sh
+cd code
+python3 -m unittest test_export test_pi_measure test_public_evidence
+python3 make_figures.py
+```
+
+The tests validate export/privacy and measurement logic, not model inference. Figures and the LaTeX numerical table are regenerated from all ten public ledger rows.
+
+## Published checkpoints evaluated
+
+- [nerkyor Coder390 EfficientThink](https://huggingface.co/nerkyor/Qwen3.8-27B-Coder390-EfficientThink-Opus5.5-GPT6Astra-Grok4.7-DSV4Pro-K3-SFT-RLOO-MTP-DFlash2)
+- [DavidAU TURBO-Fable Cold-Fusion](https://huggingface.co/DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NEO-CODER-MAX-MTP-GGUF)
+- [Normal Ornith GGUF](https://huggingface.co/ornith-ai/Ornith-1.5-35B-A3B-GGUF)
+- [Separate abliterated Ornith GGUF](https://huggingface.co/PocketAiHub/Ornith-1.5-35B-A3B-Abliterated-GGUF)
+
+Full revisions, hashes, actual formats and publisher-evidence scope are in the provenance ledger. Terms such as "distilled," "uncensored," and "Heretic" describe publisher lineage, not proprietary-model identity or a guarantee of particular behavior. No harmful-generation/refusal benchmark was performed.
+
+## Outcome and disclosures
+
+Neither candidate was promoted or permanently registered in Magpie. Temporary test providers were removed and the prior service restored. Old Ornith weights were preserved. No cloud defaults or image workflow were changed. No monitors or delegated agents were used.
+
+AI tools materially assisted research, code, experiments, source comparison, analysis and drafting. No independent human manuscript review, funding/conflict attestation, contributor-role declaration or peer acceptance is asserted. Attribution follows the project owner's requested authorship.
+
+Original code is MIT; original manuscript and sanitized numerical evidence are CC BY4.0. See [LICENSE](LICENSE) for mixed-artifact terms. Referenced models/software retain their own licenses. Use [CITATION.cff](CITATION.cff) to cite this artifact and the specific published revision.

REPRODUCIBILITY.md

@@ -0,0 +1,62 @@
+# Reproducibility
+
+## Artifact contents and limits
+
+This package contains the PDF/LaTeX, generated plots/table, numerical trial ledger, hashes/provenance, a neutral known-ground-truth vision fixture, and selected measurement/export code. It does not include model weights, private repository source, full provider payloads, source-bearing chats, or credential-bearing local launch scripts.
+
+The original task ran in isolated copies of a private Klik repository at commit `45f075409a47aa8834c3b166bbb57b64194ca13a`. Withheld inputs prevent byte-identical public reproduction of this private task. The following protocol is a method-replication guide; substituting your authorized repository is a new experiment.
+
+## Download integrity
+
+Read `results/processed/provenance.json`. Use Hugging Face CLI to download the exact target/projector at the recorded revision. Verify both exact byte size and full SHA-256 before loading. Publisher availability and filenames may change; pinned commits and hashes are the evidence identity.
+
+## Runtime identity
+
+- llama.cpp b11036: recorded version0.4.1-dev, abbreviated commit911f6cdc8.
+- llama.cpp b11538: version0.6.0-dev, commit79e2e74eb; official macOS-arm64 release archive and extracted binary SHA in provenance.json.
+- Splash: commitc64a578fcfaa059023a2ca57230d4aead134b73b, local patches acceptingQ4_KGDNalpha/beta and512-rowprefill. See earlier public artifact for method context. This package does not imply that an unpatched arbitrary Splash release is equivalent.
+- SGLang: source compatibility inspected at72eab59bf6395c342a60967ec2a31761c505e151. NoSGLanginference trial was run; do not invent one from the documentation.
+
+## Configuration
+
+llama.cpp candidate: fullMetaloffload, FlashAttentionon, Q8_0K/Vcache, plain `--load-mode none`, one262144slot, `--jinja`, suppliedmmproj, thinkingon/effortlow, reasoning budget-1, temperature0.6/top_p0.95/top_k20. Run `--spec-type none` or `--spec-type draft-mtp --spec-draft-n-max N`, never combine algorithms. Common trials used GGML_METAL_NO_RESIDENCY=1; one labelled b11036MTP4 trial removed that override. Record exact installed `--help` and version, not merely an assumed flag.
+
+NativeCoder390DFlash2: architecture-compatible local BF16denseQwen draft,32GiBMetal/8GiBdiskcache/512-rowprefill, text-only262144. It does not load theQ8projector or the author'sFP8SGLangdraft. Native28GiBstartup is recorded as rejected at208889capacity; do not force it.
+
+InstalledOrnith baselines: sparse35B/3Btargets using nativeSplash/DFlash2,28GiBMetal/8GiBSSD/512rows, lowthinking, backenddefaults temperature1.0/top_p0.95. Sampling/runtime/architecture differences are explicit confounders. Do not describe this as a matched fine-tuning-only comparison.
+
+Magpie is an additional gateway hop to the local backend. Candidate providers were temporary; they were removed after every run. Existing cloud/default selection was preserved. No removed budget hook or task-specific JSON constraint was re-enabled.
+
+## Fixed task and gates
+
+`protocol.md` contains the task instruction. In your own isolated checkout, introduce a clearly disclosed cap inversion in a bounded-retry implementation. Prove the independent gate fails before model work. Verify that the installed Python module is imported from that checkout rather than a shared reference environment. The gate must cover delay counts, exponential growth, maximum caps, an over-cap initial delay, one-attempt behavior, and validation/status invariants.
+
+Give Pi ordinary tools and instructions, not an empty system prompt. Use the same task across configurations and fresh clones. Record repository revision and diffs. Parent checks should rerun independent gates/full suite even after a model timeout; final text saying "passed" is not evidence of a repair.
+
+Task deadline:900seconds from Pi invocation, not a900secondgeneration limit. Timed-out trials retain partial work and are not successes. A pending request must be cancelled and the owned test server shut down before restoring another engine. Never stop unrelated user jobs.
+
+## Vision probe
+
+Use `results/processed/vision-fixture.png` (384x256). Expected printed textVISION42; two blue circles; red rectangle. Send it as an image_url data URI with thinking low and max_completion_tokens2048. Inspect the visible answer separately from reasoning content. Correctness on one diagram is not a general vision score. The native text-only run is explicitly untested for vision.
+
+## Measurement
+
+The harness timestamps PiJSONevents with a monotonic clock. It closes stdin for one-shot tests and uses a separate process group for bounded cancellation. For completed final text, retokenize through the target tokenizer with the same special-token settings; identify its first nonempty text_delta and message_end. Final-visible streaming excludes earlier thinking/prefill. Full final-cycle rate uses turn_start to message_end and includes any setup before stream creation. Whole task includes all turns/tools/waiting. Counts for reasoning/tool syntax are not silently reused as visible text.
+
+ToolUse bursts have unknown client decodeTPS. Tiny buffered windows below0.1s are not accepted speed evidence. Unknowns are null, not zero. Record errors, retries, timeouts, failures, host memory/swap and cold/warm prefix counts.
+
+## Regenerate public outputs
+
+```sh
+cd code
+python3 -m unittest test_export test_pi_measure test_public_evidence
+python3 make_figures.py
+```
+
+Figure generation requires matplotlib; recorded publication environment and dependency versions are under results/processed/artifact-environment.json. Figures/table derive from all10publicruns. Do not replace the ledger with selected successes.
+
+The host build uses the existing LaTeX skill compile.py driver and the explicittools/xelatexadapter toTectonic--untrusted, with shell escape disabled. A conventional trusted build may use XeLaTeX/latexmk with shell escape disabled. The adapter is clearly labelled, not pretending a systemTeXdistribution is installed. Source/table/figures should be compiled together.
+
+## Privacy and licenses
+
+Export only whitelisted scalar metrics. The private comparison-reviewed file also contains tool error excerpts and local paths: do not upload it directly. Public code's fixture boundaries are synthetic; they are not private repository excerpts. No publisher gallery, third-party full source tree or model weights are bundled. SeeLICENSE for originalcode/manuscript/data terms. Public hosting is notpeerreview.

RESULTS.md

@@ -0,0 +1,14 @@
+# Results and claim boundaries
+
+- Eight candidate configurations and two installed thinking-enabled baselines.
+- Coder390:0/5completedrepairs within900s; nofinalvisible-outputTPS.
+- TURBO-Fable:3/3completedrepair/gate/fullsuite,795.80–892.05s; finalvisible4.32–8.38tok/s.
+- Ornithnormal:218.08s,30.57visible-stream/23.86final-cycle;275passed/1skipped.
+- Ornithabliterated:204.68s,32.33visible-stream/28.38final-cycle;275passed/1skipped.
+- Vision:7known-diagramprobes passed;1nativeDFlash2text-only rununtestedforvision.
+- SGLangAppleMLXexists;inspectedin-treeDFLASHrejectsMPS. NoSGLangbenchmark.
+- NativeCoder39028GiBstartuprejects262k;32GiBready. Noactual256kcandidatequalification.
+- One trial perconfiguration;differentengine/architecture/quant/sampling andhostload. No causal/globalintelligence ranking oruniversalTPSfloor.
+- Candidateprovidersremoved;productionOrnithpreserved. Alltimeouterror/failure recordsretained inpublicledger,private traceswithheld.
+
+See paper/main.pdf and results/processed/runs.json for per-run values and REPRODUCIBILITY.md for definitions.

SHA256SUMS

@@ -0,0 +1,29 @@
+f290ec11d7b0798cd47e2b074f57856ba7cdc5ef489f33134bdb3a7bb20bc56f  .gitignore
+5fa8697250627d89be3de5a2b082a76ee793f19d1f96f900f9901390b2afc466  CITATION.cff
+53a646895f362d51afbc31b430b05548c8a9afa1947529e6baeb2ffaacce7ca3  LICENSE
+29be0f41b8d4c962afa5a1ebab78f1e14a0b29519346017a43bdd46cca90816a  README.md
+a0239fa44dda85931e370fd37b825e8a287f3a6d2e1dbbceed366c16f0c67f5b  REPRODUCIBILITY.md
+fe55ac9d2571a5252bf2856c172a9827dfee5dfde26a83122aede89b80ee319f  RESULTS.md
+b1cf8c8db36eb508896b748bc1c945872cf1bba9962f5e55b703ee6bd8133ff9  code/export_results.py
+f74a94160cc7897e3479ac4266ae2aabfb0f033afe2275272def07814b17073d  code/make_figures.py
+3f63c9340acacf773d9c3b02183fe7f3b4fc59a939e5ef48537c0e9ff05d9d59  code/pi_measure.py
+bd69b491ed72c0fa76e66a7cb8e14581c19adb98e1a97e334676ee6340928ffe  code/public_evidence.py
+6403a7f4697824fda6dfcaf75de2a6c89dc70d402ce3fb87c97ce72aeda6ef8d  code/requirements.txt
+a85dd415f9120a44d05f9cef131a7b1e5b2c8f54101cc73315a97d816e151bca  code/test_export.py
+e6d3879f633fb8f6c58215803c94894babfb80f80a3382729dadc4dbb3ed10e3  code/test_pi_measure.py
+03b958c717724e8f0c17705efcce9a0206c0d528cf3d05d3924bac54326d4f24  code/test_public_evidence.py
+f6753357ec81220f112a6c031566b84affadd7365b3c4a10c5ef1d0621477649  paper/figures/task-wall.pdf
+e8f47b554e0d788247b56976732d367ff08e30c982f34dcc999a1f38b79d0c1b  paper/figures/task-wall.png
+acc1e9c3a764177eda29213dd1b8ce1ca3b9994646b5acf56907b98c454168b0  paper/figures/visible-rates.pdf
+73a8f9ebc335a4751ccbf7dd92f491721804c94cd4f328f375df8d767c49611a  paper/figures/visible-rates.png
+b35af2c949c67321489dbe6fd174c890e20197cf792a84f58ed00e5f940086cf  paper/klik-paper.sty
+134b2be87992f381575df6cf597880f2bbec58f9ddb8870549f2d11a156487bc  paper/main.pdf
+6c637023adea971d9c9f5ebb87543db4b7a05d216b77e9c0310f92d1e3cfa63a  paper/main.tex
+53030101094440be3a5a472e82f0279ebc2797902ce3f350941e7860dac55872  paper/results-table.tex
+4fa8e065458afda23c424e0cb71a2629469759637388a967f91cf21c0c333b05  protocol.md
+568b7f2788a7d53cb8bf3b8fcbfaa6349e0056db848ddd275e7d1616d201bed3  results/processed/artifact-environment.json
+4c32c0c39c69aaee7f0ef8418061487876bcf093d4b9e0b31171830f9e54b1ab  results/processed/provenance.json
+4b9beee4c1d7c467809ea89aeebc3bbb8cbd8b36713a282c5bcb3c7ccfd01b01  results/processed/runs.json
+e56d6a2dae70d53ee0c1f29584dab845f8d305562387d4e6dd836350ff109bef  results/processed/vision-fixture.png
+358d74f3bd7281f64bc707bfc03353c88420d56b551db1546afda724d1b76429  results/processed/vision.json
+2a88b28832d8267840ff67429d50e1bceff307876aee808bcd7a4b0986b49411  tools/xelatex

code/export_results.py

@@ -0,0 +1,40 @@
+"""Whitelist-only export of descriptive model/runtime trial metrics."""
+import json
+import math
+from pathlib import Path
+import re
+import sys
+
+NUMBERS=['elapsed_s','initial_input_tokens','initial_ttft_s','tool_calls','tool_errors','visible_stream_tps','visible_cycle_tps']
+FLAGS=['completed','gate_pass','full_suite_pass','repair_verified']
+
+
+def public_run(source):
+    identifier=source.get('run_id')
+    if not isinstance(identifier,str) or not re.fullmatch(r'[A-Za-z0-9_-]{1,100}',identifier):
+        raise ValueError('Invalid run identifier')
+    out={'run_id':identifier}
+    for key in NUMBERS:
+        value=source.get(key)
+        if value is not None and (type(value) not in (int,float) or not math.isfinite(value)):
+            raise ValueError('Invalid numeric metric')
+        out[key]=value
+    for key in FLAGS:
+        value=source.get(key)
+        if value is not None and type(value) is not bool:raise ValueError('Invalid boolean metric')
+        out[key]=value
+    return out
+
+
+def main():
+    source=Path(sys.argv[1]);dest=Path(sys.argv[2]);raw=json.loads(source.read_text())
+    result={'schema_version':1,'scope':'Single-run-per-configuration descriptive task measurements; failed/timeout records retained. No private source/transcript is exported.',
+            'prompt_sha256':raw['prompt_sha256'],'repository_revision':raw['repository_revision'],
+            'candidate_sampling':raw['candidate_sampling'],
+            'baseline_sampling_caveat':raw['baseline_sampling_caveat'],
+            'actual256k_candidate_proof':False,'production_replaced':False,
+            'runs':[public_run(row) for row in raw['runs']]}
+    dest.parent.mkdir(parents=True,exist_ok=True);dest.write_text(json.dumps(result,indent=2)+'\n')
+
+
+if __name__=='__main__':main()

code/make_figures.py

@@ -0,0 +1,44 @@
+"""Render paper figures and tables directly from the public numerical ledger."""
+from pathlib import Path
+import json
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+ROOT=Path(__file__).resolve().parents[1]
+rows=json.loads((ROOT/'results/processed/runs.json').read_text())['runs']
+labels={
+ 'ornith-normal-thinking-repair':'Ornith normal',
+ 'ornith-uncensored-thinking-repair':'Ornith abliterated',
+ 'coder390-none-0-repair':'Coder390: none / b11036',
+ 'coder390-mtp-4-repair':'Coder390: MTP4 / b11036',
+ 'coder390-mtp-4-wired-repair':'Coder390: MTP4 / residency',
+ 'coder390-mtp-4-b11538-repair':'Coder390: MTP4 / b11538',
+ 'coder390-dflash-0-repair':'Coder390: DFlash2 / Splash',
+ 'fable-mtp-4-repair':'Fable: MTP4 / b11036',
+ 'fable-mtp-2-b11538-repair':'Fable: MTP2 / b11538',
+ 'fable-none-0-b11538-repair':'Fable: none / b11538'}
+order=list(labels);byid={r['run_id']:r for r in rows};ordered=[byid[n] for n in order]
+plt.rcParams.update({'font.size':9,'axes.spines.top':False,'axes.spines.right':False,'pdf.fonttype':42})
+fig,ax=plt.subplots(figsize=(8.6,4.4))
+colors=['#1f4e79' if r['run_id'].startswith('ornith') else '#b7443d' if not r['completed'] else '#cb983b' for r in ordered]
+y=list(range(len(ordered)));ax.barh(y,[r['elapsed_s'] for r in ordered],color=colors)
+ax.set_yticks(y,[labels[r['run_id']] for r in ordered]);ax.invert_yaxis();ax.set_xlabel('Whole-task elapsed (seconds)');ax.set_xlim(0,1080)
+for i,r in enumerate(ordered):ax.text(r['elapsed_s']+10,i,f"{r['elapsed_s']:.0f}s"+(' · timeout' if not r['completed'] else ''),va='center',fontsize=8)
+ax.axvline(900,color='#777',linestyle='--',linewidth=.8);fig.tight_layout();fig.savefig(ROOT/'paper/figures/task-wall.pdf');fig.savefig(ROOT/'paper/figures/task-wall.png',dpi=180);plt.close(fig)
+completed=[r for r in ordered if r['completed']]
+fig,ax=plt.subplots(figsize=(8.6,3.3));positions=list(range(len(completed)));width=.36
+ax.bar([p-width/2 for p in positions],[r['visible_stream_tps'] for r in completed],width,label='Visible streaming',color='#1f4e79')
+ax.bar([p+width/2 for p in positions],[r['visible_cycle_tps'] for r in completed],width,label='Visible / full final-cycle time',color='#cb983b')
+ax.set_xticks(positions,[labels[r['run_id']].replace(': ','\n') for r in completed],fontsize=8)
+ax.set_ylabel('Visible tokens/s');ax.axhline(20,color='#777',linestyle='--',linewidth=.8);ax.legend(frameon=False);fig.tight_layout();fig.savefig(ROOT/'paper/figures/visible-rates.pdf');fig.savefig(ROOT/'paper/figures/visible-rates.png',dpi=180);plt.close(fig)
+with (ROOT/'paper/results-table.tex').open('w') as f:
+ for r in ordered:
+  elapsed=f"{r['elapsed_s']:.2f}"
+  stream=f"{r['visible_stream_tps']:.2f}" if r['visible_stream_tps'] is not None else '--'
+  cycle=f"{r['visible_cycle_tps']:.2f}" if r['visible_cycle_tps'] is not None else '--'
+  outcome='Pass' if r['repair_verified'] and r['completed'] else 'Timeout'
+  name=labels[r['run_id']].replace('/','/')
+  f.write(f'{name} & {elapsed} & {r["initial_ttft_s"]:.2f} & {stream} & {cycle} & {outcome}\\\\\n')
+with (ROOT/'paper/results-table.tex').open('a') as f:f.write('\\bottomrule\n')
+print('Rendered two figures and numerical table from all ten runs.')

code/pi_measure.py

@@ -0,0 +1,149 @@
+"""Measure timestamped Pi JSON events without conflating chunks with tokens."""
+from __future__ import annotations
+import argparse
+import json
+import os
+from pathlib import Path
+import selectors
+import signal
+import subprocess
+import time
+
+
+def summarize(rows, elapsed, returncode, timed_out):
+    turns, current = [], None
+    turn_start = None
+    tool_calls, tool_errors, compactions, retries = 0, 0, 0, 0
+    settled = False
+    for row in rows:
+        t, e = row['t_s'], row['event']
+        kind = e.get('type')
+        if kind == 'turn_start':
+            turn_start = t
+        elif kind == 'message_start' and e.get('message', {}).get('role') == 'assistant':
+            current = {'start_s': t, 'turn_start_s': turn_start, 'first_delta_s': None, 'text_chars': 0,
+                       'thinking_chars': 0, 'tool_chars': 0}
+        elif kind == 'message_update' and current is not None:
+            part = e.get('assistantMessageEvent', {})
+            delta = part.get('delta')
+            tag = part.get('type')
+            field = {'text_delta':'text_chars','thinking_delta':'thinking_chars','toolcall_delta':'tool_chars'}.get(tag)
+            if field and isinstance(delta, str) and delta:
+                if current['first_delta_s'] is None: current['first_delta_s'] = t
+                current[field] += len(delta)
+        elif kind == 'message_end' and e.get('message', {}).get('role') == 'assistant':
+            msg = e['message']
+            if current is None:
+                current = {'start_s':None, 'first_delta_s':None}
+            usage = msg.get('usage', {})
+            tokens = usage.get('output')
+            tokens = tokens if isinstance(tokens,(int,float)) and tokens > 0 else None
+            first, start = current['first_delta_s'], current['start_s']
+            decode = t-first if first is not None else None
+            duration = t-start if start is not None else None
+            cycle_start = current.get('turn_start_s')
+            cycle = t-cycle_start if cycle_start is not None else None
+            current.update(end_s=t, usage=usage, output_tokens=tokens, stop_reason=msg.get('stopReason'),
+                           inference_cycle_s=cycle,
+                           inference_cycle_tps=tokens/cycle if tokens and cycle and cycle>0 else None,
+                           request_scope='assistant stream start to end; inference_cycle includes earlier turn/preflight',
+                           ttft_s=first-start if first is not None and start is not None else None,
+                           request_s=duration, decode_s=decode,
+                           decode_tps=tokens/decode if tokens and decode is not None and decode>=.1 and msg.get('stopReason')!='toolUse' else None,
+                           request_tps=tokens/duration if tokens and duration and duration>0 else None,
+                           decode_timing_warning=('tool_parser_timing_not_backend_decode' if msg.get('stopReason')=='toolUse'
+                                                  else 'burst_or_buffered' if decode is not None and decode < .1 else None))
+            turns.append(current); current = None
+        elif kind == 'tool_execution_start': tool_calls += 1
+        elif kind == 'tool_execution_end' and e.get('isError'): tool_errors += 1
+        elif kind == 'compaction_start': compactions += 1
+        elif kind == 'auto_retry_start': retries += 1
+        elif kind == 'agent_settled': settled = True
+    all_known = bool(turns) and all(t['output_tokens'] is not None for t in turns)
+    total = sum(t['output_tokens'] for t in turns) if all_known else None
+    return {'turns':turns, 'elapsed_s':elapsed, 'returncode':returncode, 'timed_out':timed_out,
+            'tool_calls':tool_calls,'tool_errors':tool_errors,'compactions':compactions,'retries':retries,
+            'incomplete_turns':int(current is not None),
+            'total_output_tokens':total,
+            'task_generated_tps':total/elapsed if total is not None and elapsed>0 and current is None else None,
+            'visible_text_tps':None,
+            'token_scope':'provider-reported completion tokens (may include reasoning and tool syntax); not visible-text TPS',
+            'completed':settled and returncode==0 and not timed_out and current is None and bool(turns)
+                        and turns[-1]['stop_reason'] not in ('error','aborted','length')}
+
+
+def command_args(args):
+    prompt = ('@'+str(Path(args.prompt).resolve())) if args.prompt_file else Path(args.prompt).read_text()
+    return ['pi','--offline',
+            *([] if getattr(args,'enable_extensions',False) else ['--no-extensions']),
+            '--mode','json','--no-session',
+            *([] if getattr(args,'default_tools',False) else ['--tools',args.tools]),
+            '--provider',args.provider,'--model',args.model,'--thinking',args.thinking,
+            *(['--approve'] if getattr(args,'approve',False) else []),prompt,
+            *([args.task_instruction] if getattr(args,'task_instruction',None) else [])]
+
+
+def run(args):
+    output = Path(args.output).resolve()
+    output.parent.mkdir(parents=True,exist_ok=True)
+    cmd = command_args(args)
+    env = os.environ.copy()
+    env.update(NO_PROXY='127.0.0.1,localhost',no_proxy='127.0.0.1,localhost',PI_TELEMETRY='0')
+    if args.agent_dir: env['PI_CODING_AGENT_DIR'] = str(Path(args.agent_dir).resolve())
+    start = time.monotonic(); rows = []; timed_out=False
+    with output.with_suffix('.stderr').open('wb') as err, output.with_suffix('.events.jsonl').open('w') as raw:
+        proc = subprocess.Popen(cmd,cwd=args.workspace,env=env,stdin=subprocess.DEVNULL,
+                                stdout=subprocess.PIPE,stderr=err,start_new_session=True)
+        sel = selectors.DefaultSelector(); sel.register(proc.stdout,selectors.EVENT_READ); buf=b''
+        try:
+            while True:
+                if time.monotonic()-start > args.timeout:
+                    timed_out=True; os.killpg(proc.pid,signal.SIGTERM); break
+                for key,_ in sel.select(1):
+                    data=os.read(key.fd,65536)
+                    if not data: sel.unregister(key.fileobj); continue
+                    buf+=data
+                    while b'\n' in buf:
+                        line,buf=buf.split(b'\n',1)
+                        if not line: continue
+                        try: event=json.loads(line)
+                        except ValueError: event={'type':'non_json','line':line.decode(errors='replace')}
+                        row={'t_s':time.monotonic()-start,'event':event}; rows.append(row)
+                        raw.write(json.dumps(row,ensure_ascii=False)+'\n'); raw.flush()
+                        if event.get('type') in ('tool_execution_start','tool_execution_end','agent_settled'):
+                            print(f"{row['t_s']:.3f} {event['type']} {event.get('toolName','')}",flush=True)
+                        if event.get('type')=='message_end' and event.get('message',{}).get('role')=='assistant':
+                            print(f"{row['t_s']:.3f} assistant_end {event['message'].get('usage')} {event['message'].get('stopReason')}",flush=True)
+                if proc.poll() is not None and not sel.get_map(): break
+        finally:
+            sel.close()
+            try:proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:os.killpg(proc.pid,signal.SIGKILL);proc.wait()
+    result=summarize(rows,time.monotonic()-start,proc.returncode,timed_out)
+    result.update(provider=args.provider,model=args.model,workspace=str(Path(args.workspace).resolve()),
+                  thinking=args.thinking,
+                  tools=('normal Pi discovery; actual request tools require trace review'
+                         if getattr(args,'default_tools',False) else args.tools),
+                  extensions=('enabled via normal Pi discovery; actual loading requires trace review'
+                              if getattr(args,'enable_extensions',False) else 'disabled for controlled comparison'),
+                  task_quality_verified=False)
+    output.with_suffix('.summary.json').write_text(json.dumps(result,indent=2)+'\n')
+    print(json.dumps({k:v for k,v in result.items() if k!='turns'},indent=2))
+    return 0 if result['completed'] else 1
+
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser()
+    for name in ('workspace','provider','model','prompt','output'):p.add_argument('--'+name,required=True)
+    p.add_argument('--timeout',type=float,default=600)
+    p.add_argument('--thinking',default='off')
+    p.add_argument('--tools',default='read,grep,find,ls')
+    p.add_argument('--agent-dir')
+    p.add_argument('--default-tools',action='store_true',
+                   help='Do not restrict Pi tool discovery with an explicit --tools list')
+    p.add_argument('--enable-extensions',action='store_true',
+                   help='Use normal Pi extension discovery; controlled runs disable extensions by default')
+    p.add_argument('--prompt-file',action='store_true',help='Pass large prompts as Pi file attachments')
+    p.add_argument('--approve',action='store_true',help='Trust this isolated benchmark project configuration')
+    p.add_argument('--task-instruction',help='Direct user instruction after a reference-file attachment')
+    raise SystemExit(run(p.parse_args()))

code/public_evidence.py

@@ -0,0 +1,41 @@
+"""Whitelist-only metrics export. Private transcripts and source are never copied."""
+import math
+import re
+
+
+def number(value):
+    if value is None:return None
+    if type(value) not in (int,float) or not math.isfinite(value):
+        raise ValueError('Metric must be a finite number or null')
+    return value
+
+
+def flag(value):
+    if value is not None and type(value) is not bool:raise ValueError('Flag must be boolean or null')
+    return value
+
+
+def public_row(run_id,summary):
+    if not isinstance(run_id,str) or not re.fullmatch(r'[A-Za-z0-9_-]{1,100}',run_id):
+        raise ValueError('Invalid public run identifier')
+    turns=summary.get('turns',[])
+    counts=[number(t.get('usage',{}).get('input',0))+number(t.get('usage',{}).get('cacheRead',0)) for t in turns]
+    return {
+        'run_id':run_id,
+        'completed':flag(summary.get('completed')),
+        'timed_out':flag(summary.get('timed_out')),
+        'bounded_quality_pass':flag(summary.get('task_quality_verified')),
+        'elapsed_s':number(summary.get('elapsed_s')),
+        'initial_input_tokens':counts[0] if counts else None,
+        'max_input_tokens':max(counts) if counts else None,
+        'initial_cache_read_tokens':number(turns[0].get('usage',{}).get('cacheRead')) if turns else None,
+        'first_ttft_s':number(turns[0].get('ttft_s')) if turns else None,
+        'tool_calls':number(summary.get('tool_calls')),
+        'tool_errors':number(summary.get('tool_errors')),
+        'compactions':number(summary.get('compactions')),
+        'visible_final_tokens':number(summary.get('final_visible_text_tokens')),
+        'visible_stream_tps':number(summary.get('final_visible_stream_tps')),
+        'visible_cycle_tps':number(summary.get('final_visible_cycle_tps')),
+        'visible_assistant_request_tps':number(summary.get('final_visible_request_tps')),
+        'task_completion_tps_including_reasoning_and_tools':number(summary.get('task_generated_tps')),
+    }

code/requirements.txt

@@ -0,0 +1,3 @@
+matplotlib==3.10.9
+Pillow==11.3.0
+PyYAML==6.0.3

code/test_export.py

@@ -0,0 +1,27 @@
+import importlib.util
+import json
+import unittest
+from pathlib import Path
+
+class ExportTests(unittest.TestCase):
+    def module(self):
+        self.assertIsNotNone(importlib.util.find_spec('export_results'))
+        import export_results
+        return export_results
+
+    def test_whitelist_excludes_private_source_and_paths(self):
+        src={'run_id':'fixture','completed':False,'elapsed_s':900,'errors':[{'error':'PRIVATE SOURCE /Users/person SECRET'}],'workspace':'SECRET','initial_input_tokens':25000,'visible_stream_tps':None}
+        row=self.module().public_run(src)
+        self.assertNotIn('SECRET',json.dumps(row));self.assertNotIn('/Users',json.dumps(row))
+        self.assertFalse(row['completed']);self.assertIsNone(row['visible_stream_tps'])
+        self.assertEqual(row['initial_input_tokens'],25000)
+
+    def test_invalid_metric_or_identifier_rejected(self):
+        m=self.module()
+        for value in ['SECRET',float('nan'),True]:
+            with self.assertRaises(ValueError):m.public_run({'run_id':'fixture','elapsed_s':value})
+        with self.assertRaises(ValueError):m.public_run({'run_id':'/private/path'})
+
+    def test_success_not_inferred_from_tests_only(self):
+        r=self.module().public_run({'run_id':'fixture','completed':False,'gate_pass':True,'full_suite_pass':True})
+        self.assertFalse(r['completed']);self.assertIsNone(r['visible_stream_tps'])

code/test_pi_measure.py

@@ -0,0 +1,156 @@
+import unittest
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from types import SimpleNamespace
+import pi_measure
+from pi_measure import summarize
+
+
+def event(t, kind, **data):
+    return {'t_s': t, 'event': {'type': kind, **data}}
+
+
+class MeasureTests(unittest.TestCase):
+    def test_reports_prefill_and_task_time_not_just_decode(self):
+        rows = [event(0, 'message_start', message={'role':'assistant'}),
+                event(10, 'message_update', assistantMessageEvent={'type':'text_delta','delta':'abc'}),
+                event(15, 'message_end', message={'role':'assistant','usage':{'input':123,'output':100},'stopReason':'stop'}),
+                event(17, 'agent_settled')]
+        out = summarize(rows, 20, 0, False)
+        self.assertEqual(out['turns'][0]['ttft_s'], 10)
+        self.assertEqual(out['turns'][0]['decode_tps'], 20)
+        self.assertAlmostEqual(out['turns'][0]['request_tps'],100/15)
+        self.assertEqual(out['task_generated_tps'],5)
+        self.assertIsNone(out['visible_text_tps'])
+
+    def test_full_turn_timing_includes_request_preflight_before_stream_start(self):
+        rows=[event(0,'turn_start'),event(2,'message_start',message={'role':'assistant'}),
+              event(3,'message_update',assistantMessageEvent={'type':'text_delta','delta':'answer'}),
+              event(5,'message_end',message={'role':'assistant','usage':{'output':40},'stopReason':'stop'})]
+        turn=summarize(rows,6,0,False)['turns'][0]
+        self.assertEqual(turn.get('turn_start_s'),0)
+        self.assertEqual(turn.get('inference_cycle_s'),5)
+        self.assertEqual(turn.get('inference_cycle_tps'),8)
+        self.assertEqual(turn['request_s'],3)
+
+    def test_does_not_count_empty_tool_delta_as_first_token(self):
+        rows = [event(0,'message_start',message={'role':'assistant'}),
+                event(1,'message_update',assistantMessageEvent={'type':'toolcall_delta','delta':''}),
+                event(2,'message_update',assistantMessageEvent={'type':'toolcall_delta','delta':'{"path"'}),
+                event(3,'message_end',message={'role':'assistant','usage':{'output':10},'stopReason':'toolUse'})]
+        self.assertEqual(summarize(rows,4,0,False)['turns'][0]['ttft_s'],2)
+
+    def test_tool_only_chunks_do_not_prove_backend_decode_speed(self):
+        rows = [event(0,'message_start',message={'role':'assistant'}),
+                event(10,'message_update',assistantMessageEvent={'type':'toolcall_delta','delta':'{"path":"src"}'}),
+                event(10.2,'message_end',message={'role':'assistant','usage':{'output':100},'stopReason':'toolUse'})]
+        out=summarize(rows,11,0,False)
+        self.assertIsNone(out['turns'][0]['decode_tps'])
+        self.assertAlmostEqual(out['turns'][0]['request_tps'],100/10.2)
+
+    def test_one_token_length_cutoff_burst_is_not_decode_speed_evidence(self):
+        rows=[event(0,'message_start',message={'role':'assistant'}),
+              event(8,'message_update',assistantMessageEvent={'type':'thinking_delta','delta':'Now'}),
+              event(8.005,'message_end',message={'role':'assistant','usage':{'output':1,'reasoning':1},'stopReason':'length'})]
+        out=summarize(rows,8.1,0,False)
+        self.assertIsNone(out['turns'][0]['decode_tps'])
+        self.assertEqual(out['turns'][0]['decode_timing_warning'],'burst_or_buffered')
+        self.assertEqual(out['turns'][0]['output_tokens'],1)
+        self.assertFalse(out['completed'])
+
+    def test_unknown_usage_never_becomes_zero_or_chunk_token_count(self):
+        rows = [event(0,'message_start',message={'role':'assistant'}),
+                event(1,'message_update',assistantMessageEvent={'type':'text_delta','delta':'hello'}),
+                event(2,'message_end',message={'role':'assistant','stopReason':'stop'})]
+        out=summarize(rows,3,0,False)
+        self.assertIsNone(out['turns'][0]['decode_tps'])
+        self.assertIsNone(out['total_output_tokens'])
+
+    def test_timeout_or_compaction_cannot_pass(self):
+        out=summarize([event(0,'compaction_start'), event(1,'agent_settled')], 2,143,True)
+        self.assertFalse(out['completed'])
+        self.assertEqual(out['compactions'],1)
+        self.assertEqual(out['incomplete_turns'],0)
+
+    def test_runner_closes_child_stdin_when_parent_input_is_open(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp); script=root/'pi'
+            script.write_text('#!'+sys.executable+'\nimport sys,json\nfrom pathlib import Path\nsys.stdin.read()\n'
+                'Path("child-args.json").write_text(json.dumps(sys.argv[1:]))\n'
+                'events=[{"type":"message_start","message":{"role":"assistant"}},'
+                '{"type":"message_end","message":{"role":"assistant","usage":{"output":1},"stopReason":"stop"}},'
+                '{"type":"agent_settled"}]\n'
+                'for e in events: print(json.dumps(e),flush=True)\n')
+            script.chmod(0o755); (root/'prompt.txt').write_text('fixture task')
+            env={**os.environ,'PATH':str(root)+os.pathsep+os.environ['PATH']}
+            cmd=[sys.executable,str(Path(__file__).with_name('pi_measure.py')),
+                 '--workspace',tmp,'--provider','fixture','--model','fixture',
+                 '--prompt',str(root/'prompt.txt'),'--output',str(root/'result'),'--timeout','10']
+            p=subprocess.Popen(cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,env=env)
+            try:
+                p.wait(timeout=25)
+                result=json.loads((root/'result.summary.json').read_text())
+                self.assertTrue(result['completed'],'Child inherited open stdin and never began its task')
+                self.assertEqual(result['extensions'],'disabled for controlled comparison')
+                self.assertIn('--no-extensions',json.loads((root/'child-args.json').read_text()))
+                enabled=subprocess.run(cmd+['--enable-extensions'],stdin=subprocess.DEVNULL,
+                                       capture_output=True,env=env,timeout=25)
+                self.assertEqual(enabled.returncode,0,enabled.stderr.decode())
+                enabled_result=json.loads((root/'result.summary.json').read_text())
+                self.assertTrue(enabled_result['completed'])
+                self.assertEqual(enabled_result['extensions'],
+                                 'enabled via normal Pi discovery; actual loading requires trace review')
+                self.assertNotIn('--no-extensions',json.loads((root/'child-args.json').read_text()))
+            finally:
+                if p.poll() is None:p.kill();p.wait()
+                p.stdin.close();p.stdout.close();p.stderr.close()
+
+    def test_large_prompt_uses_pi_attachment_not_os_argument_payload(self):
+        self.assertTrue(hasattr(pi_measure,'command_args'),'Runner needs a file-attachment command path')
+        with tempfile.TemporaryDirectory() as tmp:
+            prompt=Path(tmp)/'corpus.txt';prompt.write_text('x'*1000000)
+            args=SimpleNamespace(tools='read,bash,edit,write',provider='local',model='model',thinking='low',prompt=str(prompt),prompt_file=True)
+            cmd=pi_measure.command_args(args)
+            self.assertEqual(cmd[-1],'@'+str(prompt.resolve()))
+            self.assertLess(sum(map(len,cmd)),10000)
+            self.assertIn('read,bash,edit,write',cmd)
+            self.assertNotIn('--approve',cmd)
+            args.approve=True
+            self.assertIn('--approve',pi_measure.command_args(args))
+            args.task_instruction='Use the current repository, not the attachment directory.'
+            self.assertEqual(pi_measure.command_args(args)[-2:],['@'+str(prompt.resolve()),args.task_instruction])
+            args.task_instruction=None
+            args.prompt_file=False; prompt.write_text('small task')
+            self.assertEqual(pi_measure.command_args(args)[-1],'small task')
+
+    def test_full_extensions_are_explicit_opt_in_without_changing_tools(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            prompt=Path(tmp)/'prompt.txt';prompt.write_text('Read the isolated checkout')
+            args=SimpleNamespace(tools='read,bash,edit,write',provider='local',model='model',
+                                 thinking='low',prompt=str(prompt),prompt_file=True)
+            controlled=pi_measure.command_args(args)
+            self.assertIn('--no-extensions',controlled)
+            args.enable_extensions=True
+            production=pi_measure.command_args(args)
+            self.assertNotIn('--no-extensions',production)
+            self.assertEqual(production,[v for v in controlled if v!='--no-extensions'])
+            args.enable_extensions=False
+            self.assertEqual(pi_measure.command_args(args),controlled)
+            args.enable_extensions=True
+            args.default_tools=True
+            discovered=pi_measure.command_args(args)
+            self.assertNotIn('--tools',discovered)
+            self.assertNotIn('read,bash,edit,write',discovered)
+            self.assertNotIn('--no-extensions',discovered)
+
+    def test_incomplete_generation_reported(self):
+        out=summarize([event(0,'message_start',message={'role':'assistant'})],5,143,True)
+        self.assertEqual(out['incomplete_turns'],1)
+        self.assertIsNone(out['task_generated_tps'])
+
+
+if __name__ == '__main__': unittest.main()

code/test_public_evidence.py

@@ -0,0 +1,29 @@
+import importlib.util
+import unittest
+import json
+
+def export(summary):
+    assert importlib.util.find_spec('public_evidence') is not None, 'Missing whitelist-only public evidence exporter'
+    return importlib.import_module('public_evidence').public_row('fixture',summary)
+
+class PublicEvidenceTests(unittest.TestCase):
+    def test_omits_private_text_paths_credentials_and_unknown_fields(self):
+        row=export({'completed':True,'elapsed_s':10.5,'workspace':'/private/secret/repo',
+                    'api_key':'SECRET','task_quality_evidence':'PRIVATE SOURCE','arbitrary':'SECRET',
+                    'turns':[{'usage':{'input':256222,'cacheRead':0},'ttft_s':5.0}],
+                    'final_visible_stream_tps':30.0})
+        encoded=json.dumps(row)
+        self.assertNotIn('SECRET',encoded);self.assertNotIn('/private',encoded);self.assertNotIn('PRIVATE SOURCE',encoded)
+        self.assertEqual(row['initial_input_tokens'],256222);self.assertEqual(row['visible_stream_tps'],30.0)
+        self.assertIsNone(row['visible_cycle_tps'])
+
+    def test_rejects_non_numeric_metrics_instead_of_exporting_arbitrary_text(self):
+        with self.assertRaises(ValueError):export({'elapsed_s':'SECRET'})
+        with self.assertRaises(ValueError):export({'elapsed_s':float('nan')})
+        with self.assertRaises(ValueError):export({'elapsed_s':True})
+
+    def test_failure_and_unknown_quality_never_become_a_pass(self):
+        row=export({'completed':False,'timed_out':True,'elapsed_s':3600,'task_quality_verified':False})
+        self.assertFalse(row['completed']);self.assertFalse(row['bounded_quality_pass'])
+        self.assertIsNone(row['visible_stream_tps']);self.assertTrue(row['timed_out'])
+        self.assertIsNone(export({})['bounded_quality_pass'])

paper/klik-paper.sty

@@ -0,0 +1,63 @@
+\NeedsTeXFormat{LaTeX2e}
+\ProvidesPackage{klik-paper}[2026/09/22 KLIK research paper style]
+
+\newif\ifklikbenchmark
+\klikbenchmarkfalse
+\DeclareOption{benchmark}{\klikbenchmarktrue}
+\ProcessOptions\relax
+
+\ifklikbenchmark\else
+  \RequirePackage[margin=0.9in,headheight=15pt]{geometry}
+  \RequirePackage{amsmath,amssymb,amsfonts}
+  \RequirePackage{booktabs}
+  \RequirePackage{tabularx}
+  \RequirePackage{graphicx}
+  \RequirePackage{enumitem}
+  \RequirePackage{float}
+  \RequirePackage[numbers,sort&compress]{natbib}
+\fi
+\RequirePackage{xcolor}
+\RequirePackage{microtype}
+\RequirePackage{fancyhdr}
+\RequirePackage{hyperref}
+
+\definecolor{klikblue}{HTML}{1F4E79}
+\definecolor{klikgray}{HTML}{5B6573}
+\hypersetup{
+  colorlinks=true,
+  linkcolor=blue!55!black,
+  citecolor=blue!55!black,
+  urlcolor=blue!65!black,
+  pdfcreator={KLIK Research},
+  pdfproducer={KLIK Research}
+}
+
+\pagestyle{fancy}
+\fancyhf{}
+\lhead{\small\textcolor{klikgray}{KLIK Research}}
+\rhead{\small\textcolor{klikgray}{\thepage}}
+\renewcommand{\headrulewidth}{0.3pt}
+\renewcommand{\footrulewidth}{0pt}
+\setlength{\headheight}{15pt}
+\setlength{\emergencystretch}{3em}
+\Urlmuskip=0mu plus 2mu\relax
+
+\ifklikbenchmark\else
+  \setlist{leftmargin=1.6em,itemsep=2pt,topsep=4pt}
+  \setlength{\parindent}{1.2em}
+  \setlength{\parskip}{0pt}
+  \renewcommand{\arraystretch}{1.08}
+  \makeatletter
+  \renewenvironment{abstract}{%
+    \small
+    \begin{center}%
+      {\bfseries\color{klikblue}\abstractname\vspace{-.4em}\vspace{0pt}}%
+    \end{center}%
+    \quotation
+  }{\endquotation}
+  \makeatother
+\fi
+\urlstyle{same}
+
+\newcommand{\klikteam}{KLIK team}
+\newcommand{\klikresearchnote}[1]{\thanks{KLIK Research. #1}}

paper/main.tex

@@ -0,0 +1,139 @@
+\documentclass[11pt]{article}
+\usepackage{klik-paper}
+\hypersetup{pdftitle={Fast on the Card, Slow in the Agent: A Vision and Speculation Study of Coder390 and TURBO-Fable on Apple Silicon},pdfauthor={Chengyi Xu and KLIK team},pdfsubject={Real-workspace local model replacement evaluation},pdfkeywords={Apple Silicon, Coder390, Fable, Ornith, MTP, DFlash2, agent evaluation}}
+\title{\textbf{Fast on the Card, Slow in the Agent:\\A Vision and Speculation Study of Coder390 and TURBO-Fable on Apple Silicon}}
+\author{Chengyi Xu and KLIK team\\\small KLIK Research}
+\date{October 2026 --- experimental deployment report}
+\begin{document}
+\maketitle
+\begin{abstract}
+Model-card speed and reasoning-efficiency claims do not establish the usability of a local coding agent. We examine two proposed replacements for a working Apple M4 Max deployment: nerkyor's Qwen3.8-27B Coder390 EfficientThink Q4 LynnStyle checkpoint and DavidAU's Qwen3.8-27B TURBO-Fable Cold-Fusion Q4\_K\_M checkpoint. Both are downloaded at pinned revisions, fully hashed, and tested with thinking enabled and their vision projectors. Seven small image-comprehension probes answer a known diagram correctly. However, actual Pi sessions routed through Magpie in fresh copies of a real software repository reveal substantially worse task latency than the installed Ornith-1.5-35B-A3B pair. All five Coder390 configurations time out near 900 seconds without repairing the injected defect. Fable completes three configurations and passes independent tests, but takes 796--892 seconds and streams its final visible answer at only 4.32--8.38 tokens/s. Thinking-enabled Ornith baselines complete in 205--218 seconds with 30.57--32.33 visible tokens/s. Candidate first-turn waits of 365--579 seconds on approximately 25,000-token agent inputs dominate the deadline. Current SGLang documentation supports Apple MLX, but the inspected in-tree DFlash handler excludes MPS; its NVIDIA recipe cannot be assumed portable. We publish the negative outcomes, vision checks, memory-admission failure and sanitized numerical evidence. These descriptive configuration tests support retaining the existing deployment, not a global intelligence ranking or a 256k-context qualification of the candidates.
+\end{abstract}
+
+\section{Introduction}
+A proposed local-model upgrade often arrives with three attractive ingredients: a stronger teacher-model lineage, shorter reasoning traces and a speculative decoder. Each can be useful. None alone answers the operational question: will this configuration complete a useful coding task through the user's actual agent, on the user's workstation, with acceptable latency and correct tools?
+
+The two candidates studied here were requested as replacements for normal and abliterated Ornith deployments. Coder390 emphasizes suppression of unproductive long reasoning through successive supervised and RLOO stages; TURBO-Fable emphasizes a multi-stage fine-tune/merge with reduced thinking and an embedded MTP head. Their publishers report strong benchmarks and NVIDIA speed~\cite{coder,fable}. We do not reproduce those benchmark claims. Instead, we conduct a narrower deployment comparison on a 64\,GiB Apple Silicon workstation with thinking, vision, an actual agent client and independent repair gates.
+
+Our contributions are: (i) a pinned, failure-preserving comparison of eight candidate configurations and two installed baselines; (ii) separate vision and coding-workflow evidence; (iii) a source-level check of an apparently portable SGLang recipe; (iv) a native memory-plan rejection rather than an inflated context promise; and (v) a public artifact that excludes private source-bearing transcripts while exposing its reproducibility limits.
+
+\section{Candidates and upstream claims}
+\subsection{Coder390 EfficientThink}
+The requested repository is nerkyor's Qwen3.8-27B Coder390 EfficientThink release, pinned at \texttt{a3a1170a0c8fcb7a5f119ce16c70e7c54ea006ff}. Its card describes successive SFT and RLOO stages on an earlier SFT/SimPO EfficientThink descendant of Qwen3.8, with teacher traces from several frontier-labelled systems. Teacher names identify the claimed data lineage; they do not mean that the local checkpoint is the named proprietary model.
+
+The publisher's headline static-FP8 measurements are 178/198 GPQA, 450/500 MMLU and 90/100 LCB, using a 100k context and a 94,208-token generation ceiling on RTX PRO 6000 hardware. Its Q4 LynnStyle GGUF table instead reports 175/198, 448/500 and 89/100. The MMLU 500-question and LCB 100-question sets are finite evaluation sets, not evidence that an independent full standard benchmark was replicated. The reported 180.3-token/s DFlash2 and 91.1-token/s MTP single-request figures use a Blackwell RTX PRO 6000 with 96\,GB and a 32k context~\cite{coder}. They are not M4 Max measurements.
+
+We use the requested Q4 LynnStyle GGUF with its embedded MTP head and the separate Q8\_0 multimodal projector. The target file is 19,620,406,592 bytes; the projector is 629,247,008 bytes. Both pass pinned full-file SHA-256 verification. The main GGUF mixes Q4\_K, Q5\_K, Q6\_K, Q8\_0, BF16 and F32 tensors, with Q4\_0 in the embedded MTP component; nominal ``Q4'' does not describe every tensor.
+
+\subsection{TURBO-Fable Cold-Fusion}
+The DavidAU target is pinned at \texttt{ceb55042229d17dcf45df52ad84698339e63d4c5}. Its card describes multi-stage fine-tuning and merging, Heretic ARA lineage, reduced reasoning-token claims and high-detail output. Its quoted approximately 75--90 tokens/s uses an RTX 5090 with Windows/LM Studio~\cite{fable}. That result does not establish Metal throughput or a same-protocol improvement over Ornith.
+
+We use its MTP Q4\_K\_M file (18,498,573,856 bytes) and its BF16 projector (931,145,920 bytes). The quantization includes a BF16 output head and Q8\_0 MTP tensors, making it different from the Coder390 mixed-precision layout. The publisher recommends at least Q4\_K\_M for tool use. All downloaded components are fully hashed. Labels such as ``uncensored'' or ``Heretic'' are provenance descriptors here; no harmful-generation or refusal-removal benchmark is performed.
+
+\subsection{Installed baselines}
+The retained baselines are normal Ornith-1.5-35B-A3B Q4\_K\_M and a separately pinned PocketAiHub abliterated Ornith Q4\_K\_M. These are sparse 35B-total/approximately-3B-active targets, whereas the proposed replacements are dense 27B targets. This architectural difference is central to hardware fit and prevents interpreting the comparison as a controlled test of fine-tuning alone. Exact repositories, revisions, file hashes and runtimes are provided in the public provenance ledger.
+
+\section{Hardware, serving systems and portability}
+The host is an Apple M4 Max with 40 GPU cores and 64\,GiB unified memory. The native planner observed macOS 27.2.0. The workstation is concurrently used, not a quiet laboratory appliance. A sampled state had roughly 17--18\,GB of swap and elevated background load; power was AC with no reported thermal or power-saving warning. Unrelated processes were not killed. We do not infer that host contention caused a particular failed task.
+
+Candidate llama.cpp runs use pinned build b11036 (commit \texttt{911f6cdc8}) or b11538 (\texttt{79e2e74eb}), with full Metal offload, Flash Attention, Q8\_0 KV, one 262,144-token slot, plain loading, the projector, temperature 0.6/top-p 0.95, thinking enabled at low effort and an unrestricted reasoning budget. Speculation is either absent or embedded MTP with two or four draft tokens. The ordinary runs set \texttt{GGML\_METAL\_NO\_RESIDENCY=1}; one labelled run enables residency. Logs confirm M4 Max offload, so the result is not assumed to be CPU-only inference.
+
+The native DFlash2 comparison uses Splash, pinned at commit\\
+\texttt{c64a578fcfaa059023a2ca57230d4aead134b73b}, with existing local Q4\_K GDN alpha/beta support and a 512-row prefill cap. It uses an architecture-compatible local dense-Qwen DFlash2 draft, not the publisher's FP8 SGLang draft. The run uses 32\,GiB Metal and an 8\,GiB SSD tier and is text-only. The baseline Ornith pair uses the installed native 28\,GiB/8\,GiB/512-row preset with DFlash2. Candidates and baselines are therefore comparisons of deployable configurations, not equivalent engines or precision paths.
+
+\subsection{Why the pasted context command is misleading}
+The publisher's \texttt{-c 409600 -np 4} command splits the pool into four slots of 102,400 tokens each~\cite{coder}. It is not a proof of a 409,600-token individual session. The downloaded Coder390 config declares 262,144 native positions. We use one slot and this truthful configured capacity without implicit RoPE scaling. No candidate request in this study approaches 256k; actual first requests are approximately 25k. Allocation and config metadata are not long-context competence evidence.
+
+\subsection{SGLang: Apple support does not imply DFlash support}
+Current SGLang documentation describes an Apple MLX runtime~\cite{sglangmetal}. It would be incorrect to dismiss SGLang as entirely unavailable on Apple Silicon. However, the inspected source at \texttt{72eab59bf6395c342a60967ec2a31761c505e151}, \texttt{speculative\_hook.py}, permits in-tree DFLASH only for CUDA, NPU or XPU and raises an error for other devices~\cite{sglangsource}. Generic MPS/MLX support therefore does not provide the requested SGLang+DFlash2 deployment. An out-of-tree platform could declare additional support, but none is installed or tested here. We do not invent a SGLang benchmark or equate MLX-format loading with these GGUF files.
+
+\subsection{Native memory admission and quantization constraints}
+At the existing 28\,GiB limit, Splash rejects Coder390's 262k startup. Its memory plan permits a maximum context of approximately 208,889 tokens, with 18,585.52\,MiB target weights, 1,207.39\,MiB draft weights and a 21,701.08\,MiB fixed runtime. Q8 KV pages occupy 1,064,960 bytes per 32 tokens. Increasing the declared allocation to 32\,GiB admits a 262,144-token startup. This is readiness, not actual near-limit processing.
+
+The existing native importer also rejects Fable's BF16 \texttt{output.weight}. We do not silently requantize the author's output head or add an unverified kernel patch. Its measured llama.cpp vision path loads, while the tested native Splash path cannot be substituted for it. Likewise, Coder390's text-only Splash result does not inherit the Q8-projector proof from llama.cpp.
+
+\section{Workload and evidence}
+\subsection{Real repository repair}
+The same fixed repair prompt is used across configurations in fresh isolated clones of a real private Klik LLM client repository, revision \texttt{45f075409a47aa8834c3b166bbb57b64194ca13a}. The test deliberately inverts a retry-delay cap from minimum to maximum; it is not represented as a discovered production bug. The independent gate fails before model work. The agent must inspect implementation and tests, add regression coverage for an initial delay exceeding the cap, restore the implementation without altering the public API or status policy, and run offline tests.
+
+Each run is an actual Pi session routed through a temporary Magpie provider for the candidate or the installed Magpie route for the baseline. Normal extensions and default tool discovery are enabled. There is no request-budget hook, task-specific JSON schema or post-generation answer repair. The agent's actions occur only in isolated clones. Parent checks examine the restored source, remaining tracked diff, independent gate and full suite.
+
+\subsection{Small vision probes}
+Before each candidate llama.cpp repair run, a hand-drawn 384$\times$256 diagram supplies known ground truth: the text \texttt{VISION 42}, two blue circles and a red rectangle. The request is image input, not generation, with thinking enabled. Seven llama.cpp configurations answer those three facts correctly and return separate reasoning content. The Splash run is explicitly text-only. One diagram per condition is a functional probe, not a broad vision benchmark, OCR score or estimate of population accuracy.
+
+\subsection{Thinking and sampling}
+Low reasoning is enabled through runtime/template controls and observed in actual responses. ``EfficientThink'' may reduce a model's output trajectory, but it does not make prefill or dense verification free. Candidate temperature 0.6 differs from baseline backend temperature 1.0, while top-p is 0.95. Request counts, initial cache state and generated tool paths vary. This non-randomized single-run-per-configuration design supports an operational decision on the tested task, not a causal estimate of model superiority. Small differences among speculation modes should not be treated as statistically established effects.
+
+\section{Metrics and timeout treatment}
+Whole-task time runs from Pi invocation through completion or the 900-second deadline; wrapper shutdown adds small measured overhead. Timeouts retain partial output and tool traces. They are right-censored observations, not completed 900-second answers. Failed gates are rerun on the final checkout state even after timeout.
+
+For a completed final answer, let $N_v$ be its visible text retokenized by the running target tokenizer, $t_v$ the first nonempty visible text delta, $t_e$ message end and $t_c$ the agent turn start. We report
+\[
+R_{\mathrm{visible}}=\frac{N_v}{t_e-t_v},\qquad
+R_{\mathrm{cycle}}=\frac{N_v}{t_e-t_c}.
+\]
+The first excludes preceding reasoning and waiting. The second includes the entire final turn. Neither is whole-task visible throughput. All tool work and prefill remain in whole-task elapsed. Initial TTFT is measured from assistant-stream start and can omit small pre-stream setup; it is not a pure kernel-only prefill duration. The relevant first-turn waits are preserved rather than subtracted as warmup.
+
+Provider-reported completion counts may include reasoning and tool syntax. Tool parsers can buffer tool calls, so a tool-only client burst is not a backend decode measurement. Characters and SSE chunks are not tokens. Candidate timeouts have no usable final visible rate; the table uses a dash, never an invented zero or extrapolated speed. Native-log decode observations are separate from client final-visible metrics.
+
+\section{Results}
+\begin{table}[H]\centering\scriptsize
+\setlength{\tabcolsep}{3pt}
+\begin{tabular}{lrrrrl}\toprule
+Configuration & Wall(s) & TTFT(s) & $R_{\rm visible}$ & $R_{\rm cycle}$ & Repair\\\midrule
+\input{results-table.tex}
+\end{tabular}
+\caption{All ten task runs. Rates are visible tokens/s only for completed final answers. Wall time includes the whole task; TTFT is the initial assistant request. ``Pass'' requires completion and parent repair/test verification. There is one run per configuration.}
+\label{tab:results}
+\end{table}
+
+\begin{figure}[H]\centering
+\includegraphics[width=\linewidth]{figures/task-wall.pdf}
+\caption{Whole-task elapsed, with Coder390 timeouts retained. The dashed line marks the nominal 900-second task deadline; shutdown produces small overruns. There is no confidence interval or pooled throughput estimate.}
+\end{figure}
+\begin{figure}[H]\centering
+\includegraphics[width=\linewidth]{figures/visible-rates.pdf}
+\caption{Only completed answers have final visible rates. Coder390 timeouts are intentionally absent from this rate chart but remain in Table~\ref{tab:results} and the wall-time chart. Final-cycle rates include waiting and reasoning.}
+\end{figure}
+
+\subsection{Thinking-enabled Ornith baselines}
+Normal Ornith completes in 218.08 seconds with 13 tools and no tool errors; its final visible rate is 30.57 tokens/s and full final-cycle rate 23.86. The abliterated target completes in 204.68 seconds with 12 tools and no errors, with 32.33 and 28.38 tokens/s respectively. Parent checks confirm the original implementation restored, new retry tests added and no unrelated tracked source changes. Both full suites report 275 passed and one skipped. Initial first-turn waits are approximately 56--58 seconds. These current baselines are not borrowed from older headline measurements.
+
+\subsection{Coder390: five timeouts}
+Coder390 fails to finish or restore the injected defect within the deadline in all five configurations: b11036 without speculation, b11036 with four-token MTP, the same with Metal residency, b11538 with four-token MTP, and native Splash/DFlash2 at 32\,GiB. Their initial requests contain 25,247--25,254 tokens. First-turn TTFT is approximately 400--579 seconds; subsequent reads, reasoning and tool processing consume the remaining deadline. Parent gates and full-suite failures confirm the defect remains at cutoff.
+
+Native logs show roughly 4--10 completion tokens/s in the examined llama.cpp segments and 6--14 in the Splash segments. These are observations, not accepted final-visible task rates. MTP acceptance is useful, but the task still does not complete. The newer build and residency experiment do not justify promoting the configuration. We do not infer that Coder390 is incapable of repairing the defect with more time, a different prompt, a different quant or another runtime.
+
+\subsection{Fable: correct repairs but poor task latency}
+Fable finishes all three tested conditions and passes the independent gate, restores the original implementation and adds over-cap regression tests. Each full suite reports 274 passed and one skipped. Its times are 889.64 seconds with four-token MTP on b11036, 892.05 with two-token MTP on b11538, and 795.80 without MTP on b11538. The two MTP runs each include one failed pre-repair pytest tool result from the TDD workflow; that is not a transport fault. The no-MTP run has no tool errors.
+
+The newer two-token MTP condition has a higher final visible rate (8.38 versus 6.50 tokens/s without MTP), but a slower complete task. Four-token MTP on the older build delivers only 4.32 final visible tokens/s. The shorter no-MTP task cannot be attributed solely to speculation: the configurations are single stochastic trials with different tool paths and first-turn waits. All are substantially slower than the current installed baseline on this workload.
+
+\section{Interpretation and limitations}
+The result is a deployment veto for these measured combinations, not an intrinsic intelligence ranking. Dense target compute, hybrid prefill kernels, quantization-specific kernels, vision buffers, cache state, host pressure, unrestricted reasoning and speculative verification may all contribute. The experiment does not isolate every factor. Quantization differs between candidates and sparse baselines; runtime differs; sampling differs. Full candidate prompt bodies and source-bearing traces are withheld because the repository is private.
+
+The candidates' vision probes pass, but that does not rescue a failed coding workflow. Speculative acceptance is not absolute speed. A 262k-ready runtime does not prove near-limit correctness or practical cold latency. No actual candidate 256k request is accepted as a result in this study; ordinary-task failures were sufficient to reject immediate replacement under the operational target. Likewise, no official GPQA/MMLU/LCB benchmark or refusal evaluation was rerun locally.
+
+A future experiment could test a validated MLX conversion, a Metal-compatible vision/draft runtime, a smaller truthful working-context preset or a different quant, with matched sampling and repeated tasks. These are research directions, not completed results. Replacing a known-working deployment solely to match a popular model name would conflate desired capability with verified usability.
+
+\section{Artifacts and deployment outcome}
+Neither candidate was permanently registered in Magpie, and temporary candidate entries were removed after each foreground run. The existing normal and abliterated Ornith profiles remained installed; the previously active abliterated service was restored. No cloud defaults, image workflow or unrelated machine was changed. No monitor or delegated agent was used. Candidate weights, projectors, source metadata and private records remain local for further investigation.
+
+The public artifact contains the PDF/LaTeX in the same KLIK style as prior reports, whitelist-only numerical records, vision fixture and answers, model/runtime provenance, measurement code/tests, figures regenerated from the ledger, and a protocol. Model weights and third-party source trees are not redistributed. Private repository source, raw chats, credentials and local machine paths are excluded. The corpus cannot therefore be reproduced byte-for-byte publicly; an authorized substitute repository is a new replication, not identical evidence.
+
+\section{Conclusion}
+On this M4 Max, with thinking and an actual full-extension coding-agent workload, the tested Coder390 and TURBO-Fable configurations do not justify replacing the working Ornith pair. Coder390's five timeouts and Fable's correct but slow repairs are as important as the successful image probes. The measured deployment decision is to retain the existing models until an alternative configuration demonstrates usable complete-task behavior. NVIDIA model-card speed, reduced reasoning-token claims and a successful health endpoint are insufficient evidence for a local upgrade.
+
+\section*{Disclosure and publication status}
+This report is AI-assisted: tools assisted research, implementation, experiments, source comparison, analysis and manuscript drafting. No independent human manuscript review, peer acceptance, funding declaration, contributor-role attestation or conflict declaration is invented. Attribution follows the project owner's requested name, Chengyi Xu and KLIK team. Public hosting is not journal acceptance or a DOI assignment. Model and runtime licenses remain separate; no model weights are published with this artifact.
+
+\begin{thebibliography}{7}
+\bibitem{coder} nerkyor. Coder390 EfficientThink model card, pinned revision a3a1170a0c8fcb7a5f119ce16c70e7c54ea006ff. Repository identity and direct link in artifact \texttt{provenance.json}.
+\bibitem{fable} DavidAU. TURBO-Fable Cold-Fusion model card, pinned revision ceb55042229d17dcf45df52ad84698339e63d4c5. Repository identity and direct link in artifact \texttt{provenance.json}.
+\bibitem{sglangmetal} SGLang. Apple Silicon with Metal documentation. \url{https://docs.sglang.io/docs/hardware-platforms/apple_metal}.
+\bibitem{sglangsource} SGLang. Speculative algorithm platform validation, inspected commit 72eab59bf6395c342a60967ec2a31761c505e151. \url{https://github.com/sgl-project/sglang}.
+\bibitem{llama} llama.cpp. Metal serving, multimodal and speculative decoding implementation. \url{https://github.com/ggml-org/llama.cpp}.
+\bibitem{splash} Splash runtime. \url{https://github.com/incoai/splash}.
+\bibitem{prior} Chengyi Xu and KLIK team. Local Agent 256K Audit. \url{https://huggingface.co/datasets/ChengyiX/local-agent-256k-audit}.
+\end{thebibliography}
+\end{document}

paper/results-table.tex

@@ -0,0 +1,11 @@
+Ornith normal & 218.08 & 57.97 & 30.57 & 23.86 & Pass\\
+Ornith abliterated & 204.68 & 55.74 & 32.33 & 28.38 & Pass\\
+Coder390: none / b11036 & 901.61 & 399.69 & -- & -- & Timeout\\
+Coder390: MTP4 / b11036 & 900.89 & 511.61 & -- & -- & Timeout\\
+Coder390: MTP4 / residency & 900.39 & 578.64 & -- & -- & Timeout\\
+Coder390: MTP4 / b11538 & 900.61 & 560.42 & -- & -- & Timeout\\
+Coder390: DFlash2 / Splash & 900.54 & 454.65 & -- & -- & Timeout\\
+Fable: MTP4 / b11036 & 889.64 & 431.99 & 4.32 & 2.44 & Pass\\
+Fable: MTP2 / b11538 & 892.05 & 545.48 & 8.38 & 6.22 & Pass\\
+Fable: none / b11538 & 795.80 & 364.57 & 6.50 & 3.15 & Pass\\
+\bottomrule

protocol.md

@@ -0,0 +1,26 @@
+# Task and evaluation protocol
+
+## Fixed user instruction
+
+> A regression in this Klik LLM client causes bounded retries to violate their configured delay cap. Investigate the real implementation and existing tests. Add a regression test, make a minimal repair without changing the public API or retryable-status policy, and run the relevant offline tests. Also cover the case where the initial delay exceeds the maximum delay. Do not read credentials, contact any external service, or alter other files unrelated to the retry policy. Finish with a concise explanation of the root cause, change, tests, and limitations. Work only in this checkout. Use the installed `.venv/bin/python -m pytest` for tests.
+
+TaskpromptSHA256:6815313e62e8d2f6e6934021ab986234eebedcc7950fa1f4be1f92ecda9c1f8c. Originalrepositoryrevision and privacy boundary are inREPRODUCIBILITY.md. This instruction can be reproduced; theprivate implementation/tests/context files are withheld.
+
+## Gate sequence
+
+1. Fresh isolated clone; import-path identity checked.
+2. Deliberately introduce the cap inversion, not a newly discovered production bug.
+3. Independent gate must fail before agent work.
+4. Actual Pi through Magpie, normalextensions/defaulttools, thinkinglow,900sdeadline.
+5. Retain everyevent locally, including failedbefore-fixpytest calls; those failures are nottransportfaults.
+6. Parent independent gate andfullsuite after completion/timeout; preserve diff andsource restoration state.
+7. Completedrun requires afinalanswer andsource/test review. Correctrepairbutnoanswerwouldremainincomplete. No inventedvisibleratefortimeout.
+8. Remove temporarygatewayroute/shutdownownedtestengine; restorepreviousservice.
+
+## Vision
+
+Known384x256handdrawnPNG:VISION42,2bluecircles,redrectangle. Everycandidate llama configuration received1probe withthinkingon. NativeSplash/DFlash2runwastext-onlyandcannotinheritvisionpass.
+
+## Comparison limits
+
+One run perconfiguration; no confidence intervals. Different runtimes, target architectures, quantizationlayouts, samplingtemperatures, caches/toolpaths andhostload areconfounders. Hardwaregate/deploymentveto isbounded toobservedconfigurations. Nooriginalmodel-benchmarkreplication,actual256kcandidateproof orrefusalbehaviorbenchmark isclaimed.

results/processed/artifact-environment.json

@@ -0,0 +1,13 @@
+{
+  "scope": "publication/measurement host tools, not unrecorded CUDA environment",
+  "python": "3.14.3",
+  "node": "v24.11.1",
+  "pi": "1.1.0",
+  "magpie_version_scope": "Installedgateway; not a pinned upstream gateway implementation",
+  "plot_dependencies": {
+    "matplotlib": "3.10.9",
+    "Pillow": "11.3.0",
+    "PyYAML": "6.0.3"
+  },
+  "tectonic": "Tectonic 0.17.0"
+}

results/processed/provenance.json

@@ -0,0 +1,92 @@
+{
+  "models": [
+    {
+      "label": "Coder390Q4LynnStyleMTP",
+      "repository": "nerkyor/Qwen3.8-27B-Coder390-EfficientThink-Opus5.5-GPT6Astra-Grok4.7-DSV4Pro-K3-SFT-RLOO-MTP-DFlash2",
+      "revision": "a3a1170a0c8fcb7a5f119ce16c70e7c54ea006ff",
+      "files": [
+        {
+          "file": "GGUF/Qwen3.8-27B-Coder390-EfficientThink-Q4LynnStyle-MTP.gguf",
+          "bytes": 19620406592,
+          "sha256": "56c7c605a59764d9f0bb645d4eb335f1574af2c9e74020386139597df0e872f5",
+          "verified": true
+        },
+        {
+          "file": "GGUF/mmproj-Qwen3.8-27B-Q8_0.gguf",
+          "bytes": 629247008,
+          "sha256": "cae9799dc9196449b0d83f716e64af89d5cf65147510462e5a629a2aa23adb32",
+          "verified": true
+        }
+      ],
+      "url": "https://huggingface.co/nerkyor/Qwen3.8-27B-Coder390-EfficientThink-Opus5.5-GPT6Astra-Grok4.7-DSV4Pro-K3-SFT-RLOO-MTP-DFlash2/tree/a3a1170a0c8fcb7a5f119ce16c70e7c54ea006ff"
+    },
+    {
+      "label": "FableQ4_K_MMTP",
+      "repository": "DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NEO-CODER-MAX-MTP-GGUF",
+      "revision": "ceb55042229d17dcf45df52ad84698339e63d4c5",
+      "files": [
+        {
+          "file": "Qwen3.8-27B-TurboFCFusion-735-882-Here-Uncen-NEO-CODER-MAX-MTP-Q4_K_M.gguf",
+          "bytes": 18498573856,
+          "sha256": "bc7a6cf2bcc78d1190aaf04d1ab1c5cb845b6ff23aa0e7d24fe0d2ea6d3a7c7c",
+          "verified": true
+        },
+        {
+          "file": "mmproj-BF16.gguf",
+          "bytes": 931145920,
+          "sha256": "b0d8d89e9c9c90e0fb8ca74742d9d9bd7cc0f966a29b6f8c14227000ea6bd89e",
+          "verified": true
+        }
+      ],
+      "url": "https://huggingface.co/DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NEO-CODER-MAX-MTP-GGUF/tree/ceb55042229d17dcf45df52ad84698339e63d4c5"
+    },
+    {
+      "label": "normalOrnith",
+      "repository": "ornith-ai/Ornith-1.5-35B-A3B-GGUF",
+      "revision": "12393612fd4f730ff5aadc23e9b8f9648aa49ceb",
+      "file": "Ornith-1.5-35B-Q4_K_M.gguf",
+      "sha256": "42739874cc2ccfdb8523b23fbe52e29b2a7555c8176737ca9ca0b5d59859d41f",
+      "scope": "Pinned retained deployment provenance; task trial uses installed native preset",
+      "url": "https://huggingface.co/ornith-ai/Ornith-1.5-35B-A3B-GGUF/tree/12393612fd4f730ff5aadc23e9b8f9648aa49ceb"
+    },
+    {
+      "label": "abliteratedOrnith",
+      "repository": "PocketAiHub/Ornith-1.5-35B-A3B-Abliterated-GGUF",
+      "revision": "78c2971382a49b442ce044fd4e17169217b0b36c",
+      "file": "Ornith-1.5-35B-A3B-Abliterated-Q4_K_M.gguf",
+      "sha256": "a07f299e83a398b5078c1cb8ab4ec96333c8ea9d10d0cb479cb073056fedd3d0",
+      "scope": "Pinned retained deployment provenance; task trial uses installed native preset",
+      "url": "https://huggingface.co/PocketAiHub/Ornith-1.5-35B-A3B-Abliterated-GGUF/tree/78c2971382a49b442ce044fd4e17169217b0b36c"
+    }
+  ],
+  "hardware": {
+    "chip": "AppleM4Max",
+    "gpu_cores": 40,
+    "unified_memory_gib": 64,
+    "macos_observed": "27.2.0",
+    "host_scope": "Concurrent real workstation; variable load and17\u201318GBswap observation, not quiet lab"
+  },
+  "runtimes": {
+    "llama_b11036": {
+      "commit": "911f6cdc8",
+      "version": "0.4.1-dev"
+    },
+    "llama_b11538": {
+      "commit": "79e2e74eb",
+      "version": "0.6.0-dev",
+      "archive_sha256": "291c46b9288975ec54771d4056911d9cb773b954afb6c5eba35dc9fa359d45f4",
+      "binary_sha256": "1bf5602a2be50097c44282a6ecc63234d94ee8f96d39fd45fed6eff4e74b6b41"
+    },
+    "splash": {
+      "commit": "c64a578fcfaa059023a2ca57230d4aead134b73b",
+      "local_patches": [
+        "Q4_KGDNalpha/betaacceptance",
+        "opt-in512-rowprefillcap"
+      ]
+    },
+    "sglang_inspected": {
+      "commit": "72eab59bf6395c342a60967ec2a31761c505e151",
+      "scope": "Primarysourcecompatibilityinspection only; noSGLanginferenceexperiment"
+    }
+  }
+}

results/processed/runs.json

@@ -0,0 +1,156 @@
+{
+  "schema_version": 1,
+  "scope": "Single-run-per-configuration descriptive task measurements; failed/timeout records retained. No private source/transcript is exported.",
+  "prompt_sha256": "6815313e62e8d2f6e6934021ab986234eebedcc7950fa1f4be1f92ecda9c1f8c",
+  "repository_revision": "45f075409a47aa8834c3b166bbb57b64194ca13a",
+  "candidate_sampling": {
+    "temperature": 0.6,
+    "top_p": 0.95,
+    "thinking": "low"
+  },
+  "baseline_sampling_caveat": "Ornith backend defaults temperature1.0/top_p0.95; not randomized precision/model-equivalence experiment. Wall/prefill gaps and failed candidate runs are not discarded.",
+  "actual256k_candidate_proof": false,
+  "production_replaced": false,
+  "runs": [
+    {
+      "run_id": "coder390-dflash-0-repair",
+      "elapsed_s": 900.5439520420041,
+      "initial_input_tokens": 25248,
+      "initial_ttft_s": 454.65274166599556,
+      "tool_calls": 7,
+      "tool_errors": 0,
+      "visible_stream_tps": null,
+      "visible_cycle_tps": null,
+      "completed": false,
+      "gate_pass": false,
+      "full_suite_pass": false,
+      "repair_verified": false
+    },
+    {
+      "run_id": "coder390-mtp-4-b11538-repair",
+      "elapsed_s": 900.6056057919923,
+      "initial_input_tokens": 25254,
+      "initial_ttft_s": 560.4180580840039,
+      "tool_calls": 4,
+      "tool_errors": 0,
+      "visible_stream_tps": null,
+      "visible_cycle_tps": null,
+      "completed": false,
+      "gate_pass": false,
+      "full_suite_pass": false,
+      "repair_verified": false
+    },
+    {
+      "run_id": "coder390-mtp-4-repair",
+      "elapsed_s": 900.8888564999943,
+      "initial_input_tokens": 25248,
+      "initial_ttft_s": 511.6134912500129,
+      "tool_calls": 6,
+      "tool_errors": 0,
+      "visible_stream_tps": null,
+      "visible_cycle_tps": null,
+      "completed": false,
+      "gate_pass": false,
+      "full_suite_pass": false,
+      "repair_verified": false
+    },
+    {
+      "run_id": "coder390-mtp-4-wired-repair",
+      "elapsed_s": 900.3876166249975,
+      "initial_input_tokens": 25250,
+      "initial_ttft_s": 578.6395830829861,
+      "tool_calls": 4,
+      "tool_errors": 0,
+      "visible_stream_tps": null,
+      "visible_cycle_tps": null,
+      "completed": false,
+      "gate_pass": false,
+      "full_suite_pass": false,
+      "repair_verified": false
+    },
+    {
+      "run_id": "coder390-none-0-repair",
+      "elapsed_s": 901.6147849999979,
+      "initial_input_tokens": 25247,
+      "initial_ttft_s": 399.6929838340002,
+      "tool_calls": 6,
+      "tool_errors": 0,
+      "visible_stream_tps": null,
+      "visible_cycle_tps": null,
+      "completed": false,
+      "gate_pass": false,
+      "full_suite_pass": false,
+      "repair_verified": false
+    },
+    {
+      "run_id": "ornith-normal-thinking-repair",
+      "elapsed_s": 218.07918445799442,
+      "initial_input_tokens": 25220,
+      "initial_ttft_s": 57.974555624998175,
+      "tool_calls": 13,
+      "tool_errors": 0,
+      "visible_stream_tps": 30.5667864536839,
+      "visible_cycle_tps": 23.863257486100046,
+      "completed": true,
+      "gate_pass": true,
+      "full_suite_pass": true,
+      "repair_verified": true
+    },
+    {
+      "run_id": "ornith-uncensored-thinking-repair",
+      "elapsed_s": 204.67863974999636,
+      "initial_input_tokens": 25222,
+      "initial_ttft_s": 55.73794937500497,
+      "tool_calls": 12,
+      "tool_errors": 0,
+      "visible_stream_tps": 32.325835061578886,
+      "visible_cycle_tps": 28.383798305340317,
+      "completed": true,
+      "gate_pass": true,
+      "full_suite_pass": true,
+      "repair_verified": true
+    },
+    {
+      "run_id": "fable-mtp-2-b11538-repair",
+      "elapsed_s": 892.0477351669979,
+      "initial_input_tokens": 25248,
+      "initial_ttft_s": 545.4822127910011,
+      "tool_calls": 10,
+      "tool_errors": 1,
+      "visible_stream_tps": 8.383198154549364,
+      "visible_cycle_tps": 6.220912677209678,
+      "completed": true,
+      "gate_pass": true,
+      "full_suite_pass": true,
+      "repair_verified": true
+    },
+    {
+      "run_id": "fable-mtp-4-repair",
+      "elapsed_s": 889.6382008749933,
+      "initial_input_tokens": 25242,
+      "initial_ttft_s": 431.99032208300196,
+      "tool_calls": 10,
+      "tool_errors": 1,
+      "visible_stream_tps": 4.32499664508571,
+      "visible_cycle_tps": 2.442347802250632,
+      "completed": true,
+      "gate_pass": true,
+      "full_suite_pass": true,
+      "repair_verified": true
+    },
+    {
+      "run_id": "fable-none-0-b11538-repair",
+      "elapsed_s": 795.797991333995,
+      "initial_input_tokens": 25247,
+      "initial_ttft_s": 364.5697842500085,
+      "tool_calls": 10,
+      "tool_errors": 0,
+      "visible_stream_tps": 6.50344451839138,
+      "visible_cycle_tps": 3.145782000635697,
+      "completed": true,
+      "gate_pass": true,
+      "full_suite_pass": true,
+      "repair_verified": true
+    }
+  ]
+}

results/processed/vision.json

@@ -0,0 +1,78 @@
+{
+  "fixture_expected": {
+    "text": "VISION 42",
+    "blue_circles": 2,
+    "rectangle": "red"
+  },
+  "runs": [
+    {
+      "run_id": "coder390-dflash-0",
+      "tested": false,
+      "correct": null,
+      "reason": "Native text-only run, projector not loaded"
+    },
+    {
+      "run_id": "coder390-mtp-4-b11538",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 18.3520681670052,
+      "visible_answer": "Text: VISION 42\nBlue circles: 2\nRectangle color: red",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "coder390-mtp-4",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 25.302896834007697,
+      "visible_answer": "Text: VISION 42\nBlue circles: 2\nRectangle color: red",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "coder390-mtp-4-wired",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 25.24740708299214,
+      "visible_answer": "Text: VISION 42\nBlue circles: 2\nRectangle color: red",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "coder390-none-0",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 6.812550208007451,
+      "visible_answer": "Text: VISION 42\nBlue circles: 2\nRectangle color: red",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "fable-mtp-2-b11538",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 13.7357887919934,
+      "visible_answer": "VISION 42; 2 blue circles; red rectangle.",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "fable-mtp-4",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 22.614452459005406,
+      "visible_answer": "Text: VISION 42\nBlue circles: 2\nRectangle color: Red",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    },
+    {
+      "run_id": "fable-none-0-b11538",
+      "tested": true,
+      "correct": true,
+      "elapsed_s": 7.312152416998288,
+      "visible_answer": "The text is \"VISION 42\". There are 2 blue circles. The rectangle is red.",
+      "reasoning_content_returned": true,
+      "scope": "Oneknown384x256fixture; notmultimodalbenchmark"
+    }
+  ]
+}

tools/xelatex

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Explicit Tectonic compatibility adapter for the skill's compile.py driver.
+Not a claim that a system XeLaTeX distribution is installed. Reject shell escape.
+"""
+import os
+import shutil
+import sys
+
+allowed={'-synctex=1','-interaction=nonstopmode','-file-line-error','-no-shell-escape'}
+files=[]
+for arg in sys.argv[1:]:
+    if arg in allowed:continue
+    if arg.startswith('-'):raise SystemExit('Unsupported compiler option: '+arg)
+    files.append(arg)
+if len(files)!=1:raise SystemExit('Expected exactly one TeX file')
+exe=shutil.which('tectonic')
+if not exe:raise SystemExit('Tectonic is required')
+print('Build backend: Tectonic via explicit compile.py compatibility adapter; shell escape disabled.',flush=True)
+os.execv(exe,[exe,'--untrusted','--keep-logs','--synctex',files[0]])