OpenVersions.com — Site Survey + @pageman Publication Audit
Checked: 2026-11-18 · Method: site root, /how-it-works, /api-docs, public Search API, and direct git clone of each publication's remote (manuscripts read in full).
1. What OpenVersions is
Branded "OpenVS — Science at the speed of software." A publishing platform where a paper, its code, and its data are published as one unit. Per the site: it extracts claims from the paper, checks them against the paper's evidence, and makes the results searchable so others can find, cite, and build on the work.
- Functions: Publish · Review · Search · Fork · Collaborate
- Public Search API (no key):
curl -fsSG https://openversions.com/api/v1/search --data-urlencode "q=..." --data "limit=N" — optional group_by=publication; returns typed Finding / Method / TitleMatch records with verification.status.
- Every publication is a git repo:
https://openversions.com/git/<handle>/<study>.git — this is how I retrieved every manuscript.
- Verification model (
/how-it-works): a claim is checked against the publication's own reviewed evidence. Statuses are verified ("the evidence reviewed supports the claim"), unverified ("couldn't establish either way"), unsupported ("found a conflict or a specific problem with the claim's support"). The page does not identify reviewers, thresholds, evidence-selection rules, or whether code is re-executed; it never mentions human expert assessment, peer review, or independent replication. → "verified" here means text-grounded self-consistency, not independent correctness.
- Current index (6 publications, all dated 2026-11-18): 4 by
@pageman; fadebench (Becky Northaven, from GitHub sequimelectronics/fadebench); ai-physics (@rpinho, from GitHub rpinho/ai-physics).
Who is The Pageman: Paul "The Pageman" Pajo (pageman@gmail.com), GitHub handle pageman. Also behind sutskever-30-implementations (30/30 papers reimplemented in NumPy), gpt1-from-sutskever30, sutskever-30-beyond-numpy, and Sutskever-Agent. The skills invoked in these publications (unified-reasoner, got-cot-pvl-pipeline, oracle-anchoring-thesis) are a real, consistent personal toolchain — not a one-off invention.
2. The four @pageman publications
| # | Slug | Manuscript | Role |
|---|
| 1 | formal-names-for-context-window-strategies | paper.docx (45 pp rendered, 106,147 chars) | The theory paper — names the pattern and maps it to literature |
| 2 | linux-kernel-taxonomy-control-a | paper.html (276 KB) | Control — unconstrained 80-item taxonomy |
| 3 | linux-kernel-taxonomy-control-b | paper.html (476 KB) + evidence/ | Treatment — same taxonomy under the MDL protocol |
| 4 | hidden-architecture-of-mathematics | paper.pdf (12 pp, 22,192 chars) | Independent brief — Mathlib4 dependency architecture |
Provenance note: #1's manuscript is a raw Gemini conversation transcript (https://gemini.google.com/app/0d424af8716f1368) — the published artifact is the chat log, not a paper written for publication. #2's prompt invokes the three named skills; #3's description says "compare with" #2 and a live Netlify deploy; #4 interprets a user-supplied infographic.
3. Paper #1 — formal-names-for-context-window-strategies
This is the origin of the phrase "O(n) Segmented State-Machine Streaming."
Its central claim (and its own caveat)
"the specific name in your text ('O(n) Segmented State-Machine Streaming') is a bespoke, prompt-level branding of several established patterns."
Mapped to four formal concepts:
- Plan-and-Solve / Skeleton-of-Thought (SoT) Generation + Structured Output / Constrained Decoding (JSON Schema, Outlines, Guidance)
- State-Space / Scratchpad Checkpointing (Memory-Augmented Generation) — progress-tracking scratchpads, state-machine prompting, Recurrent Context Compression; MemGPT/Letta
- Chunked Autoregressive Continuation (Stateful Paging) — multi-turn continuation, paged generation, Map-Reduce
- Chunked / Segmented Complexity Amortization ("Bounded-Context Window Partitioning")
Its own answer to "what would I call this in a paper":
"you would call it Schema-Constrained, Checkpointed State-Machine Generation (or Segmented Multi-Turn Continuation with Explicit State Tracking)."
The Big-O caveat — the load-bearing nuance
The paper explicitly refuses to let the O-notation be read as GPU math:
"At the hardware/attention level, standard self-attention remains O(n²) … unless using linear-attention architectures or sliding-window attention (Mistral SWA, Ring Attention). At the prompt/orchestration level … breaking a monolithic generation of length N into k independent turns of size N/k reduces the per-turn attention quadratic cost from O(N²) to k×O((N/k)²)=O(N²/k), which approaches linear scaling as chunk size stays constant."
So the honest statement is O(N²/k) — linear in N only in the limit where chunk size stays constant and k grows with N. The O(n) label is an orchestration-level claim, not an attention-level one.
The MDL prompt (~115 tokens, claimed ~85% compression)
PROTOCOL: MDL STATE-MACHINE STREAMING
GOAL: [OBJECTIVE]
GRID: K=[STAGES] x M=[ITEMS/STAGE]
RULES:
1. SKELETON: First emit 1-line stage index [S1..SK] (no prose).
2. BOUNDED SCHEMA (O(1)/cell): Prefix each cell [Sk|Ij]. Emit ONLY:
Title | Def (<=15w) | Steps (1->N) | Edge (<=12w).
3. CHECKPOINT: After each stage, emit [CP k/K | NEXT: S(k+1)|I1]. Zero recap.
4. PAGING: Near token limit, finish cell, emit [PAUSE Sk|Ij], stop. On "CONTINUE", resume S(k)|I(j+1).
START: Emit skeleton, then [S1|I1].
Demonstrations and claimed metrics
| Demo | Cells | Total tokens | Tokens/cell | Per-cell band | Stage-8 drift vs S1 | Scorecard |
|---|
| 4×4 consensus | 16 | ~985 | ~61.5 | 59.0 → 60.8 | — | 6/6 PASS |
| 8×8 consensus | 64 | ~3,980 | ~62 | 60.8 → 62.8 | +0.5% | 7/7 PASS |
Prose-baseline equivalence: ~3,200–4,000 tokens (4×4) and ~13,000–16,000 tokens (8×8) → claimed ~3.3–4.0× compression. Signal-to-scaffold ~88–89% payload. Scaling rule: T_total ≈ 62×N, budget max_tokens = 65×N.
The manuscript also contains real, working Python for the orchestrator: asyncio stage workers, Semaphore wrapping only network calls, asyncio.Lock wrapping only state mutation + disk write, save_checkpoint_atomic, coordinate dedup via seen_coords, and self-healing hole-filling (set(range(1, items_per_stage+1)) - existing_items) so a resumed stage patches exactly its missing cells. max_stage_attempts = items_per_stage + 2.
A/B stress-test protocol (four metrics)
Truncation cutoff point · early token bloat (items 1–10 vs 35–45) · resumption friction · information density.
Predicted for the unconstrained control: exhausts the ~8,192-token output window around Item 35–48, terminating mid-sentence with no resumption pointer. Predicted for the MDL treatment: all 80 items in ~4,950 tokens, or a clean [PAUSE Sk|Ij].
Citation check — all three verified accurate
- Skeleton-of-Thought: Ning et al., 2023 — arXiv 2307.15337 ✓
- MemGPT: Packer et al., 2023 — arXiv 2310.08560 ✓
- Lost in the Middle: Liu et al., 2023 — arXiv 2307.03172 ✓
4. Papers #2 / #3 — the A/B pair, and what it actually shows
What each is
- A (control): unconstrained prompt — "exhaustive taxonomy of 80 core Linux kernel components… 8 categories × 10 items… Name / Definition / Step-by-step execution flow / Edge cases," run under Unified Reasoner L3 + GoT→CoT→PVL + Oracle-Anchoring.
- B (treatment): the identical taxonomy under the MDL State-Machine Streaming protocol,
GRID: K=8 x M=10.
Finding 1 — A and B are the same generation
I parsed all three field types out of both HTML manuscripts and compared as sets:
| Field | A count | B count | Byte-identical strings | A-only | B-only |
|---|
| Definition | 80 | 80 | 80 | 0 | 0 |
| Execution Flow | 80 | 80 | 80 | 0 | 0 |
| Edge Cases | 80 | 80 | 80 | 0 | 0 |
Zero divergence. B is not an independent treatment run — it is A's content re-rendered with an added "MDL view / Full view" toggle (B's HTML is 476 KB vs A's 276 KB; the extra bulk is the duplicated compact view + UI chrome).
Consequence: the A/B pair cannot demonstrate that the protocol produces that content, and therefore cannot support any claim that the protocol prevents truncation or bloat on this task. The published artifacts are a single generation plus a display transform.
Finding 2 — the control never truncated
The protocol predicts the unconstrained control exhausts ~8,192 tokens around Item 35–48. A completed all 80 items. Measured payload (re-measured 2026-11-18 by parsing the card structure directly — see the correction note in Appendix E.8): 23,024 words ≈ ~30,600 tokens across 80 definitions + 80 flows + 80 edge blocks. Per-item: definition median 53 words (max 70), execution flow median 108 words over a median of 7 steps (max 151), edge cases median 124 words (max 179) — ~288 words per item.
Correction note. An earlier pass in this report measured A at ~8,070 words using a paragraph-splitting heuristic that captured only the first line of each bullet list. The figure above (parsed from the HTML card structure) supersedes it and is 2.9× larger. The corrected number is load-bearing: at ~30,600 tokens, A could not have been produced under the ~8,192-token per-turn ceiling the protocol's own A/B prompt assumes. A therefore did not exercise the constraint the comparison was designed to test.
The predicted failure mode did not occur in the recorded control run.
Finding 3 — B's "MDL Compact" view violates the protocol's own schema
Rule 2 of the protocol requires Def (<=15w) and Edge (<=12w). Measured in B's own published compact view:
| Compact field | min | median | max | Protocol bound |
|---|
| DEF | 8 | 17 | 21 | ≤ 15 words |
| FLOW | 21 | 53 | 85 | — |
| EDGE | 46 | 64 | 75 | ≤ 12 words |
The compact EDGE median is ~5× the protocol's stated ceiling. And these compact fields are not model-emitted bounded cells — they are hard-truncated strings: 619 literal … characters in B's HTML (A has 1), with 131 of 240 compact blocks containing an ellipsis. The "MDL" rendering is display-time truncation of A's prose, not protocol-compliant generation.
Finding 4 — the headline metrics come from different tasks
The 62×N scaling rule and the ~3.3–4.0× compression claim are measured on consensus-algorithm grids (4×4 and 8×8). The shipped kernel taxonomy is 8×10 = 80 cells — a different task. The theory paper's worked analysis is on a 6×6 = 36-cell grid. The number that reaches the 80-cell case is a projection, not a measurement.
Finding 5 — token counts are estimates, and the paper says so
Token figures are labelled "Estimated BPE Tokens (cl100k/o200k)." The prose baselines are hypothetical, not measured. The manuscript's own oracle audit is explicit:
"No external code execution oracle (e.g., Python token-counter benchmark) was run because no raw 36-cell payload was supplied in the prompt; token-footprint bounds are derived analytically from the schema specification."
Finding 6 — no code or data ships with either publication
Both repos contain only OPENVS_PROJECT.json + the manuscript (paper.html). B adds one evidence/ folder containing a copy of Paper #1's docx. There is no analysis.py, no dataset, no reproduction harness — despite "publish your paper, code, and data together" being the platform's headline promise.
5. Paper #4 — hidden-architecture-of-mathematics
A source-bounded research brief (18 Nov 2026) on a Mathlib4 import-dependency infographic (x.com/foundinrome/status/2122518660631900371).
Source-reported: commit 3cb72cf (2026-09-27), 8,422 files, 27 areas, 25/27 areas in one giant SCC (~92.6%), two outside (Condensed, Information Theory), 33 orange upward marks, callouts of 3% (Category Theory / Linear Algebra) and 1% (Analysis / Category Theory).
Formalizes the cell value as M[X,Y] = |{f ∈ F(X) : ∃ g ∈ F(Y), f ■ g}| / |F(X)|, where f ■ g means a nonempty directed import path exists.
Methodological care is genuinely good:
- Explicit warning: "This is not a symmetric correlation matrix. Do not describe a cell as a 'correlation'."
- A "MEASURED BY THE GRAPH" vs "NOT ESTABLISHED BY THE GRAPH" table separating reachability from conceptual dependence, theorem usage, historical influence, and logical circularity.
- Four caveats: file-level granularity, area aggregation, unstated classification rules, snapshot dependence.
- A reproducibility requirement list (commit, file-to-area mapping, direct import graph, transitive-closure algorithm) — i.e. it names exactly what a third party would need to re-derive the numbers.
- The distinction "software cycles are not proof cycles" — an area-level import cycle does not make a proposition self-justifying.
- Explicit scope honesty: "it does not independently recompute the dataset or verify the repository snapshot."
- Flags an ambiguity in the Set Theory / Dynamics shorthand rather than silently reconciling it.
- A prioritized follow-up research program (direct vs transitive matrix, declaration-level usage, area centrality, SCC decomposition, temporal evolution, change-impact analysis).
This is the strongest of the four — it is the one that behaves like a real research brief rather than a demo transcript. It is also the one with no self-referential protocol machinery.
6. Cross-cutting assessment
What holds up
- The literature mapping is accurate — all three anchor citations verified.
- The self-assessment as "bespoke branding" is intellectually honest and correct.
- The Big-O caveat (O(N²/k), not literal attention math) is exactly right and prevents the most common misreading.
- The Python orchestrator is genuine engineering, not pseudocode.
- Paper #4's source-bounded discipline is exemplary.
What doesn't
- The A/B comparison does not measure what it claims (identical content; no independent run).
- The control never exhibited the failure the protocol is designed to prevent.
- The published MDL compact view violates the protocol's own word bounds and is a display truncation, not bounded-cell output.
- Headline metrics come from consensus grids, not from the shipped 80-cell task.
- No token counter was ever run — the paper states this.
- No code or data ships with any of the four publications.
- "Verified" on OpenVersions means the manuscript supports the claim, not that the claim is correct. E.g. Paper #1's finding-1 explanation is only "the mapping … is clearly articulated and supported by the text."
Rendering defect (all four)
The docx→PDF renderer drops OMML equations. In Paper #1's rendered PDF: "naive monolithic generation incurs ⬜ token growth multiplied by ⬜ verification/attention overhead, resulting in an ⬜ failure probability … total generation cost scales linearly as ⬜." The math is missing from the published artifact, not just from my text extraction.
7. Bottom line
The intellectual content is real and the self-labelling is honest: @pageman coined "O(n) Segmented State-Machine Streaming" as prompt-level branding for four established patterns, and the paper's own recommended formal name is "Schema-Constrained, Checkpointed State-Machine Generation." That mapping is correct and the Big-O caveat is the part most people get wrong.
The weakness is evidentiary, not conceptual: the A/B pair that is supposed to validate the protocol is one generation displayed twice, the predicted baseline failure never happened, and the published "compact" rendering breaks the protocol's own field bounds. The protocol is a sound prompt-engineering pattern with a plausible mechanism and a real async orchestrator — but its claimed evidence on the one task it was tested on does not support the claim.
Paper #4 is a different register entirely and stands on much firmer ground: careful, honest about its limits, and explicit about what it did not verify.
Appendix A — Canonical definition of "O(n) Segmented State-Machine Streaming"
Added 2026-11-18 after locating the term's origin. Supersedes the framing used in the initial survey of the literature.
A.1 Provenance and uniqueness
The phrase is Paul "The Pageman" Pajo's coinage, originating in the OpenVersions publication formal-names-for-context-window-strategies (manuscript provenance: https://gemini.google.com/app/0d424af8716f1368).
Uniqueness check: an open-web search for the exact phrase returns no other claimant — only unrelated AX.25 amateur-radio protocol documents (a "Segmenter State Machine", where MDL means Management–Data Link) and unrelated minimum-description-length information-theory papers. So this is a sole-author, non-peer-reviewed, self-published term with no independent uptake. "Canonical" here means the origin of the term, not a validated result.
Deeper provenance: the definition is a reconstruction from the author's own skill corpus (skills_compilation_v2.txt), per the manuscript's own oracle audit. The four grounding sources it cites:
| Source skill | What it contributed | Mentions |
|---|
zine-builder §1.1 "Segmented Build Algorithm" | segmented decomposition + complexity amortization | 10 |
unified-reasoner-improved "Long-Horizon State" | running ledger, re-anchoring, failure isolation | 9 |
semantic-compilation-full-stack-improved Ph.1 | segmented build & state persistence | 4 |
got-cot-pvl-pipeline-improved | the GoT→CoT→PVL verification method | 3 |
oracle-anchoring-thesis-improved | source-grounding discipline | 2 |
A.2 Normative definition
O(n) Segmented State-Machine Streaming — a.k.a. Schema-Constrained, Checkpointed State-Machine Generation (or Segmented Multi-Turn Continuation with Explicit State Tracking) — is a prompt- and protocol-level generation discipline that composes four established constructs into one protocol for producing large structured outputs under finite context and output-token budgets:
- Plan-and-Solve / Skeleton-of-Thought (SoT) Generation, combined with structured output / constrained decoding — supplies the plan-then-fill shape and the per-slot schema;
- State-Space / Scratchpad Checkpointing (Memory-Augmented Generation) — supplies the in-band state anchor that lets the model track progress without re-attending to prior output;
- Chunked Autoregressive Continuation (Stateful Paging) — supplies the idempotent, addressable chunks that make hard per-turn
max_tokens limits survivable;
- Chunked / Segmented Complexity Amortization ("bounded-context window partitioning") — supplies the fixed-size-chunk partition that holds per-turn compute and token drift constant.
Concretely: the workload is partitioned into a declared K × M grid; every cell is locked to an identical, word-bounded micro-schema; and the model emits explicit in-band state-transition markers ([CHECKPOINT k/K COMPLETE — NEXT: STAGE k+1, ITEM 1], [PAUSE Sk|Ij]) into its own output stream, so the run can be re-anchored and resumed at an exact coordinate with zero recap and zero re-derivation.
A.2.1 The four constructs → protocol mechanisms
| # | Construct | Contribution | Protocol mechanism produced | Canonical reference | In-band marker |
|---|
| 1 | Plan-and-Solve / Skeleton-of-Thought + structured output / constrained decoding | Plan-then-fill; forces a deterministic grid before any content; caps each slot | Zero-Redundancy Schema Compression | Ning et al., 2023 — arXiv 2307.15337; Outlines / Guidance / JSON Schema | [S1..SK] skeleton line; Title | Def (≤15w) | Steps (1→N) | Edge (≤12w) |
| 2 | State-Space / Scratchpad Checkpointing (Memory-Augmented Generation) | Explicit state-transition tokens act as a localized attention sink/anchor; progress is tracked without re-attending to every prior token | Rolling Checkpoint Ledger | MemGPT / Letta — Packer et al., 2023, arXiv 2310.08560; progress-tracking scratchpads; Recurrent Context Compression; degradation it counters: Liu et al., 2023, arXiv 2307.03172 ("Lost in the Middle") | [CHECKPOINT k/K COMPLETE — NEXT: STAGE k+1, ITEM 1] |
| 3 | Chunked Autoregressive Continuation (Stateful Paging) | Partitions output into idempotent, addressable chunks so hard per-turn max_tokens limits are survivable; deterministic coordinates permit seamless cross-turn resume | Multi-Turn Continuation Readiness | Multi-turn continuation; Paged Generation; Iterative Refinement; Map-Reduce Generation | [PAUSE Sk|Ij] / [PAUSED AT: STAGE k, ITEM j — REPLY "CONTINUE" TO RESUME] |
| 4 | Chunked / Segmented Complexity Amortization ("bounded-context window partitioning") | Splits a monolithic O(N²) attention/bloat problem into k fixed-size chunks of N/k so per-turn compute and cognitive drag stay constant at O(1) | The K × M partition itself + the O(1)/cell arithmetic | Systems-engineering framing ("bounded-context window partitioning") | grid declaration [S1..SK], GRID: K=… x M=… |
Note on the two "fours." These constructs (the components the protocol is built from) are distinct from the constitutive conditions in §A.3 (the properties you test for to know a given generation is an instance of the protocol). Constructs are provenance; conditions are the operational test.
Provenance of the composition itself. The four constructs are not an arbitrary list — they are the author's reconstruction of what three of his own skills already do, per the manuscript's oracle audit: zine-builder §1.1 "Segmented Build Algorithm" (constructs 1 + 4), unified-reasoner-improved "Long-Horizon State" (construct 2), semantic-compilation-full-stack-improved Phase 1 "Segmented Build & State Persistence" (construct 3). The protocol is, in his framing, the minimum prompt that expresses those three skills in one portable block.
A.3 Four constitutive conditions (the operational test)
A generation is this protocol iff all four hold:
- Grid declaration — the workload is partitioned into
K stages × M items and emitted as a one-line skeleton [S1..SK] before any content. No prose preamble.
- Bounded cell schema — every cell emits the same fixed-arity tuple under enforced word ceilings. Canonical:
[ID|Name] | Def (≤15w) | Steps (1→N) | Edge (≤12w). This, not the checkpointing, is what makes per-cell cost O(1).
- In-band checkpoint ledger — at each stage boundary a standalone marker is emitted carrying the next coordinate only, with zero recap of prior stages.
- Deterministic resumption — a cell-granular pause marker plus a resume rule that continues at the next coordinate with zero overlap, zero duplication, zero lost or re-derived content.
Diagnostic: if (2) holds but (1)/(3)/(4) fail, you have a schema, not a state machine. If (1)–(4) hold but per-cell token cost drifts with position, you have the structure without the O(1) property. The paper's target: per-cell drift < 3% across the whole run.
A.4 Complexity — the two registers, kept separate
Register A — attention / GPU level (unchanged by this protocol).
Self-attention over length L is O(L²). Chunking into k turns of size L/k yields total O(L²/k). This approaches linear only if the chunk size L/k stays constant as k grows with L — i.e. the linear regime is reached by fixed-size chunking, not by the protocol per se. Standard self-attention remains O(n²) unless the model uses linear attention, sliding-window attention (Mistral SWA), or Ring Attention.
Register B — orchestration / output level (where the protocol actually operates).
The protocol's native target is output-side: max_tokens exhaustion, mid-generation truncation, per-cell token bloat that grows with position, and attention drag over unstructured history. With a bounded schema, per-cell cost is a constant c (measured ≈ 60–62 tokens/cell), the scaffold overhead is a constant ≈ 11–12% of total, and therefore:
total output volume T_total ≈ c · N_cells (linear in cell count)
marginal cost of cell i independent of i
max_tokens budget ≈ 1.05 · c · N_cells (paper's "65 × N" rule)
The cleanest statement of the O(n) claim: total output volume is linear in the number of cells, and the marginal cost of each cell does not grow with its position. The O(n²)→O(n) framing is a corollary about attention, not the primary content.
A.5 Scope boundaries — what it is not
- Not an attention kernel. Not FlashAttention, Ring Attention, linear attention, or a state-space model. The source manuscript names this exact error explicitly.
- Not a context-window extension in the positional-encoding / RoPE / length-extrapolation sense.
- Not a memory architecture. MemGPT/Letta, SKILL.state, Scroll, and MemAgent externalize state out-of-band into an external store. This protocol externalizes it in-band as emitted text. Related family, different mechanism.
- Not retrieval. No vector search, no RAG, no re-reading of prior output.
- Not multi-agent orchestration — though the manuscript's async Python demo shows a parallel variant that is compatible with it.
Lineage (for interoperability with existing vocabulary): Plan-and-Solve / Skeleton-of-Thought (Ning et al. 2023, arXiv 2307.15337) + structured output / constrained decoding · State-space & scratchpad checkpointing (MemGPT/Letta, Packer et al. 2023, arXiv 2310.08560; progress-tracking scratchpads; Recurrent Context Compression) · Chunked autoregressive continuation / stateful paging (multi-turn continuation, Map-Reduce) · Chunked / segmented complexity amortization ("bounded-context window partitioning").
A.6 Epistemic caveat
The definition above is faithful to the source. The source's evidence for it does not hold up (§4 of this report): the A/B pair is one generation displayed twice, the predicted baseline failure never occurred, the published "compact" view violates the protocol's own word bounds, and no token counter was ever run. Treat the protocol as a sound, well-documented prompt-engineering pattern with an unvalidated efficacy claim on the one task it was tested on — not as a demonstrated result.
Appendix B — Academic naming for the four constructs
Added 2026-11-18. All arXiv identifiers below were verified against the primary listings.
B.1 The proposed names
| # | Current (source) label | Proposed academic name | Established terms it draws on |
|---|
| 1 | Plan-and-Solve / Skeleton-of-Thought Generation + structured output / constrained decoding | Skeleton-Planned, Grammar-Constrained Decoding | Skeleton-of-Thought (Ning et al. 2023, arXiv 2307.15337); Plan-and-Solve (Wang et al. 2023, arXiv 2305.04091); grammar-constrained decoding / structured generation (Willard & Louf 2023, arXiv 2307.09702 — Outlines; SynCode, Ugare et al. 2024, arXiv 2403.01632; XGrammar, Dong et al. 2025, arXiv 2411.15100) |
| 2 | State-Space / Scratchpad Checkpointing (Memory-Augmented Generation) | In-Band State Checkpointing | scratchpad (Nye et al. 2021, arXiv 2112.00114); attention sinks (Xiao et al. 2023, arXiv 2309.17453); virtual context management (MemGPT, Packer et al. 2023, arXiv 2310.08560); degradation countered: Lost in the Middle (Liu et al. 2023, arXiv 2307.03172) |
| 3 | Chunked Autoregressive Continuation (Stateful Paging) | Chunked, Addressable Continuation with Deterministic Resumption | paged KV-cache management (PagedAttention/vLLM, Kwon et al., SOSP 2023, arXiv 2309.06180); chunked prefill/decode; map-reduce decomposition; checkpoint/restart (systems formalism) |
| 4 | Chunked / Segmented Complexity Amortization ("bounded-context window partitioning") | Fixed-Size Segment Partitioning with Bounded-Memory State Recurrence | segment-level recurrence with state reuse (Transformer-XL, Dai et al., ACL 2019, arXiv 1901.02860); compressive memory / constant global attention memory (Infini-attention, Munkhdalai et al. 2024, arXiv 2404.07143); sliding-window & sparse attention (Longformer, BigBird, Mistral SWA); streaming attention with sinks (Xiao et al. 2023) |
- Skeleton-Planned, Grammar-Constrained Decoding — a two-phase generation procedure in which a plan-level artifact (the skeleton) is emitted before any content, and each slot is subsequently filled under a grammar-level constraint that bounds the slot's admissible output distribution.
- In-Band State Checkpointing — the materialization of generation state into the output token stream itself, such that the state serves simultaneously as (i) an attention anchor localizing the model's position within the task, and (ii) a resumable handle — without recourse to an external state store.
- Chunked, Addressable Continuation with Deterministic Resumption — the partition of one logical generation into idempotent, independently-addressable units, each emitted under a fixed budget, such that execution may be suspended at a unit boundary and resumed at the successor coordinate without re-execution, overlap, or loss.
- Fixed-Size Segment Partitioning with Bounded-Memory State Recurrence — the decomposition of a sequence of total length N into ⌈N/S⌉ segments of fixed length S, such that per-segment cost is a function of S alone and independent of N, giving total O(⌈N/S⌉·f(S)) = O(N) as S → constant.
B.3 Naming rules applied
- Name the mechanism, not the symptom. "Bounded micro-schema" → grammar-constrained decoding; "attention drag" → segment partitioning.
- Reuse an established mechanism-class term where one exists (constructs 1, 4); otherwise mark it a synthesis (constructs 2, 3).
- Drop terms with a strong prior meaning in the field. State-Space must go: in ML, "state-space model" means RetNet/Mamba-class architectures, and would misdirect every reviewer. Paging must be qualified: PagedAttention pages KV cache in the serving layer, whereas this protocol pages output units across API turns — a cross-layer analogy, not a precedent.
- Signal composition in the composite name. The protocol's novelty is the composition of four established procedures, and the paper should say so rather than imply a new mechanism.
B.4 Two citation traps
- Do not cite MemGPT as the precedent for construct 2 without qualification. MemGPT externalizes state out-of-band into an external store; the protocol keeps state in-band. They are different mechanisms with opposite memory profiles.
- Do not cite PagedAttention as supporting evidence for construct 3 without a layer note. It is a serving-system result about KV-cache block management, not about output-unit resumption.
B.5 Composite name — candidates
| Candidate | Strength | Weakness |
|---|
| Schema-Constrained, Checkpointed State-Machine Generation (source's own) | Faithful to the source; readable | "State machine" invites misreading as a decoder-side FSM; "generation" is vague |
| Schema-Constrained, Checkpointed Segmented Generation (SCSG) | Tighter; each word maps to a construct; no acronym collision | Loses the "state" emphasis that makes resumption legible |
| Bounded-Cost Structured Generation under Checkpointed Segmented Decoding | Most precise about the guarantee rather than the mechanism | Long; buries the mechanism |
Recommendation: lead with the source's own name, but disambiguate on first use — "…checkpointed state-machine generation (here 'state machine' denotes the prompt-level control structure over output units, not a decoder-side automaton)." Where an acronym is required, use SCSG (Schema-Constrained, Checkpointed Segmented Generation).
We compose four established generation procedures: skeleton-planned, grammar-constrained decoding (Ning et al., 2023; Willard & Louf, 2023), which fixes a plan-level artifact and bounds each slot's output distribution; in-band state checkpointing, which materializes generation state into the output stream so that it anchors attention and serves as a resumable handle without an external store (cf. scratchpads, Nye et al., 2021; attention sinks, Xiao et al., 2023); chunked, addressable continuation with deterministic resumption (cf. paged KV-cache management, Kwon et al., 2023), which partitions a generation into idempotent, independently-addressable units; and fixed-size segment partitioning with bounded-memory state recurrence (cf. Transformer-XL, Dai et al., 2019), which makes per-segment cost independent of total length.
Appendix C — Definitive End-to-End Statement
Added 2026-11-18. This section is authoritative and supersedes A and B, which it consolidates.
"O(n) Segmented State-Machine Streaming" is a coinage by Paul "The Pageman" Pajo, originating in the OpenVersions publication formal-names-for-context-window-strategies (manuscript provenance: https://gemini.google.com/app/0d424af8716f1368). An open-web search for the exact phrase returns no other claimant — only unrelated AX.25 radio-protocol documents and unrelated minimum-description-length information-theory papers. It is therefore a sole-author, non-peer-reviewed, self-published term with no independent uptake. "Canonical" below means the origin of the term, not a validated result.
Recommended formal name: Schema-Constrained, Checkpointed State-Machine Generation (source's own recommendation), with the disambiguating gloss "here 'state machine' denotes the prompt-level control structure over output units, not a decoder-side automaton." Acronym, if needed: SCSG (Schema-Constrained, Checkpointed Segmented Generation).
Naming-consistency note: the source uses four labels interchangeably for one protocol — O(n) Segmented State-Machine Streaming, Segmented State-Machine Streaming, MDL State-Machine Streaming, and Context-Window Extension Protocol. An academic write-up must pick one. (In the source's protocol, MDL = Minimum Description Length, not "multi-document learning.")
C.2 Normative definition
Schema-Constrained, Checkpointed State-Machine Generation — a.k.a. O(n) Segmented State-Machine Streaming — is a prompt- and protocol-level generation discipline that composes four established constructs into one procedure for producing large structured outputs under finite context and output-token budgets:
- Skeleton-Planned, Grammar-Constrained Decoding — supplies the plan-then-fill shape and the per-slot output bound.
- In-Band State Checkpointing — supplies the state anchor that localizes position within the task and doubles as the resume handle, with no external state store.
- Chunked, Addressable Continuation with Deterministic Resumption — supplies the idempotent, independently-addressable units that make hard per-turn
max_tokens limits survivable.
- Fixed-Size Segment Partitioning with Bounded-Memory State Recurrence — supplies the fixed-size-chunk partition under which per-turn cost and token drift are independent of total length.
Concretely: the workload is partitioned into a declared K × M grid; every cell is locked to an identical, word-bounded micro-schema; and the model emits explicit in-band state-transition markers ([CHECKPOINT k/K COMPLETE — NEXT: STAGE k+1, ITEM 1], [PAUSE Sk|Ij]) into its own output stream, so the run can be re-anchored and resumed at an exact coordinate with zero recap and zero re-derivation.
C.3 The four constructs
| # | Recommended academic name | Contribution | Protocol mechanism produced | Established terms & citations |
|---|
| 1 | Skeleton-Planned, Grammar-Constrained Decoding | Plan-then-fill; forces a deterministic grid before any content; bounds each slot's output distribution | Zero-Redundancy Schema Compression | Skeleton-of-Thought — Ning et al. 2023, arXiv 2307.15337; Plan-and-Solve — Wang et al. 2023, arXiv 2305.04091; grammar-constrained decoding / structured generation — Willard & Louf 2023, arXiv 2307.09702 (Outlines); SynCode, Ugare et al. 2024, arXiv 2403.01632; XGrammar, Dong et al. 2025, arXiv 2411.15100 |
| 2 | In-Band State Checkpointing | Materializes state into the output stream; acts as a localized attention sink/anchor; enables progress tracking without re-attending to every prior token | Rolling Checkpoint Ledger | scratchpad — Nye et al. 2021, arXiv 2112.00114; attention sinks — Xiao et al. 2023, arXiv 2309.17453; virtual context management — MemGPT, Packer et al. 2023, arXiv 2310.08560; degradation countered — Lost in the Middle, Liu et al. 2023, arXiv 2307.03172 |
| 3 | Chunked, Addressable Continuation with Deterministic Resumption | Partitions output into idempotent, addressable units so hard per-turn max_tokens limits are survivable; deterministic coordinates permit seamless cross-turn resume | Multi-Turn Continuation Readiness | paged KV-cache management — PagedAttention / vLLM, Kwon et al., SOSP 2023, arXiv 2309.06180; chunked prefill/decode; map-reduce decomposition; checkpoint/restart |
| 4 | Fixed-Size Segment Partitioning with Bounded-Memory State Recurrence | Splits a monolithic O(N²) attention/bloat problem into k fixed-size chunks of N/k so per-turn compute and cognitive drag stay constant at O(1) | The K × M partition + the O(1)/cell arithmetic | segment-level recurrence with state reuse — Transformer-XL, Dai et al., ACL 2019, arXiv 1901.02860; compressive memory — Infini-attention, Munkhdalai et al. 2024, arXiv 2404.07143; sliding-window & sparse attention — Longformer, BigBird, Mistral SWA |
C.4 The four constitutive conditions (operational test)
A generation is this protocol iff all four hold:
- Grid declaration — workload partitioned into
K stages × M items, emitted as a one-line skeleton [S1..SK] before any content. No prose preamble.
- Bounded cell schema — every cell emits the same fixed-arity tuple under enforced word ceilings. Canonical:
[ID|Name] | Def (≤15w) | Steps (1→N) | Edge (≤12w). This, not the checkpointing, is what makes per-cell cost O(1).
- In-band checkpoint ledger — at each stage boundary a standalone marker is emitted carrying the next coordinate only, zero recap of prior stages.
- Deterministic resumption — a cell-granular pause marker plus a resume rule that continues at the next coordinate with zero overlap, duplication, or loss.
Diagnostic: (2) without (1)/(3)/(4) is a schema, not a state machine. All four with per-cell token drift above ~3% has the structure without the O(1) property.
C.5 The mechanism, end to end
GRID: K stages × M items
│
├─► [S1..SK] one-line skeleton, no prose (condition 1)
│
├─► [Sk|Ij] Title | Def | Steps | Edge bounded micro-schema (condition 2)
│ … M cells …
├─► [CHECKPOINT k/K | NEXT: S(k+1)|I1] in-band state anchor (condition 3)
│ … K stages …
└─► [PAUSE Sk|Ij] → "CONTINUE" → resume [S(k)|I(j+1)] (condition 4)
Failure modes addressed, and by which condition: silent truncation / max_tokens exhaustion → (2) and (4); attention drag and structural drift → (3); plan drift, re-derivation of verified facts, acceptance-criteria loosening → (3) as re-anchoring; fatal cutoff requiring full restart → (4).
C.6 The complexity claim, in two registers
Register A — attention / GPU level (unchanged by this protocol).
Self-attention over length L is O(L²). Chunking into k turns of size L/k yields total O(L²/k). This approaches linear only if the chunk size L/k stays constant as k grows with L — the linear regime is reached by fixed-size chunking, not by the protocol per se. Standard self-attention remains O(n²) unless the model uses linear attention, sliding-window attention, or Ring Attention.
Register B — orchestration / output level (where the protocol operates).
Native target: output-side — max_tokens exhaustion, mid-generation truncation, per-cell token bloat that grows with position, attention drag over unstructured history. With a bounded schema, per-cell cost is a constant c, scaffold overhead is a constant ≈ 11–12%, hence:
total output volume T_total ≈ c · N_cells (linear in cell count)
marginal cost of cell i independent of i
max_tokens budget ≈ 1.05 · c · N_cells (source's "65 × N" rule)
The cleanest statement of the O(n) claim: total output volume is linear in the number of cells, and the marginal cost of each cell does not grow with its position. The O(n²)→O(n) attention framing is a corollary, not the primary content.
Source-reported operating figures (estimates, not independently measured): per-cell cost ≈ 60–62 tokens; per-cell drift across 8 stages ≤ 3% (Stage 8 at +0.5% vs Stage 1); payload-to-scaffold ratio ≈ 88.4–88.6% / 11.4–11.6%; claimed compression vs a prose baseline ≈ 3.3–4.0×; T_total ≈ 62×N.
C.7 Scope boundaries — what it is not
- Not an attention kernel. Not FlashAttention, Ring Attention, linear attention, or a state-space architecture. The source names this error explicitly.
- Not a context-window extension in the positional-encoding / RoPE / length-extrapolation sense.
- Not a memory architecture. MemGPT/Letta, SKILL.state, Scroll, and MemAgent externalize state out-of-band into an external store. This protocol keeps state in-band as emitted text. Related family, different mechanism, opposite memory profile.
- Not retrieval. No vector search, no RAG, no re-reading of prior output.
- Not multi-agent orchestration — though the source's async Python demo implements a compatible parallel variant.
C.8 Citation hygiene
Two traps.
- Do not cite MemGPT as the precedent for construct 2 without qualification — it externalizes state out-of-band, the opposite memory profile.
- Do not cite PagedAttention as supporting evidence for construct 3 without a layer note — it is a serving-system result about KV-cache block management, not output-unit resumption.
Two term-level fixes.
- Drop "State-Space." In ML, state-space model means RetNet/Mamba-class architectures; the label misdirects every reviewer. Use In-Band State Checkpointing.
- Qualify "Paging." PagedAttention pages KV cache in the serving layer; this protocol pages output units across API turns. Cross-layer analogy, not precedent.
Naming rules applied: (i) name the mechanism, not the symptom; (ii) reuse an established mechanism-class term where one exists (constructs 1, 4), otherwise mark it a synthesis (constructs 2, 3); (iii) drop terms with a strong prior meaning in the field; (iv) signal composition in the composite name.
C.8b What "checkpoint" means here — and what it does not
The protocol does not use LLM checkpoints in any technical sense. "Checkpoint" in this protocol is a textual marker in the model's own output stream, not any saved model state. There is no KV-cache snapshot, no weight save, no activation save, no hidden-state restore. What exists is a string: [CHECKPOINT k/K COMPLETE — NEXT: STAGE k+1, ITEM 1].
Five senses of "checkpoint" in this field:
| Sense | What is persisted | Level | Present in the protocol? |
|---|
| Gradient checkpointing | intermediate activations | training / backprop | No |
| Weights / model checkpoint | parameters | training | No |
| KV-cache checkpoint, prefix caching | attention K,V for a prefix | serving / inference | No |
| Harness state checkpoint | application state (which steps are done, their payloads) | runtime | Only in the Python orchestrator variant — a different artifact |
| Protocol's "checkpoint" | a coordinate-bearing text token | in-band, prompt/output level | Yes — this is it |
What the mechanism actually is. The source's own wording is decisive: "The Rolling Checkpoint Ledger acts as a lightweight running ledger directly in the token stream — re-anchoring the generation pointer to the original request at every stage boundary … without forcing the model to re-derive or repeat prior stages." Two phrases carry it: directly in the token stream (the state medium is text, not tensors) and re-anchoring the generation pointer (an attention / interpolation operation, not a state-restoration operation).
The right analogy is not "checkpoint." It is a commit marker / logical sequence number (LSN) in a write-ahead log, or equivalently a document cursor / navigation anchor (Markdown heading, LaTeX \label, subtitle cue index). The output is a self-describing log; the marker is an offset into it; resumption is replay from offset k+1. The term "commit marker" is precise — but it carries a durability guarantee the protocol does not make, which is exactly the mismatch to avoid.
Guaranteed: positional re-anchoring (a structural landmark that counters mid-context degradation — the paper's own mechanism, "acts as a localized attention sink/anchor"); a deterministic resumption handle (the coordinate identifies where to continue); no re-derivation (prior tokens are not regenerated, since they remain in context).
Not guaranteed: durability (nothing in the protocol persists anything — the caller must save the transcript; the protocol supplies the handle, not the store); restoration (resuming restores no model-internal state — the next call is a fresh invocation conditioned on prior text); fault tolerance (a mid-cell API failure has no recovery beyond re-running that cell); cursor correctness (the marker is model-emitted text and is therefore advisory).
The decisive evidence — the source's own implementation. In the Python orchestrator:
"the Python orchestrator treats the LLM's returned state_cursor as advisory and recomputes the authoritative next_target_stage and next_start_item directly from the validated (stage, item) coordinates. Even if a model generates 4 items instead of 6 on a stage or miscalculates its next index, remaining_in_stage and reconciled_cursor automatically heal the gap on the very next turn without skipping or duplicating a single cell."
So even in the author's implementation, the model's checkpoint marker is treated as a hint. The authoritative state lives in the orchestrator (seen_coords, state.records), not in the marker. The protocol's "checkpoint" is a label on harness-owned state — and in the pure prompt-level protocol, there is no harness state to label.
Where a genuine checkpoint does exist. The source's second artifact — the async Python orchestrator — implements one properly: save_checkpoint_atomic(checkpoint_file, state) writing parallel_checkpoint.json atomically; load_checkpoint(...) on start; seen_coords: set[tuple[int, int]] as the authoritative coordinate set; state.records as validated per-cell payloads; hole-filling via set(range(1, items_per_stage+1)) - existing_items; max_stage_attempts = items_per_stage + 2. That is a real, harness-level, fault-tolerant checkpoint of application state — and it is not what the protocol marker does.
The honest two-layer split for any academic write-up:
- Protocol layer (prompt-level): the marker is a resume handle and an attention anchor. No durability, no restoration.
- Orchestrator layer (harness): the atomic state snapshot is a checkpoint. Durability and fault tolerance live here.
They compose: the marker gives you the coordinate; the orchestrator's checkpoint gives you the durable state. Conflating them is the most likely reviewer objection in this area.
Consequence for the composite name. "Bounded-Cost" is accurate and defensible — it is a cost-bound claim (per-cell cost constant and position-independent; total volume linear in cell count). "Checkpointed" is the load-bearing but least accurate word: in a systems venue it implies durability, atomicity, and restore-on-failure, none of which the in-band protocol provides. Recommended revision:
Bounded-Cost Structured Generation via In-Band Checkpoint Markers
with an explicit terminology note distinguishing the protocol's checkpoint marker (a coordinate-bearing delimiter in the output stream) from gradient checkpoints, weight checkpoints, KV-cache checkpoints, and harness state snapshots. Where a log framing is wanted in the exposition, describe the output as a self-describing log whose markers are offsets and whose resumption is replay-from-offset.
C.8c Is the original label usable as shorthand?
Verdict: yes as a handle; no as an unqualified descriptor.
The decisive evidence is the label's own author. Asked directly "what's the formalized or academic name for this strategy?", the source answers:
"you would call it Schema-Constrained, Checkpointed State-Machine Generation (or Segmented Multi-Turn Continuation with Explicit State Tracking)."
The author does not recommend "O(n) Segmented State-Machine Streaming" for formal use. It is a working label; the formal name is the other one.
Word-by-word audit
| Element | Holds? | Caveat |
|---|
| O(n) | Partially | n is undefined (cells? output tokens? context length? trajectory length?); register-ambiguous between attention-level and orchestration-level; asserts a checkable claim that the source's own evidence does not support |
| Segmented | Yes | The most accurate word in the label; matches construct 4 and the grid structure directly |
| State-Machine | Yes, with a gloss | Genuinely a state machine (states = (stage, item); transitions = checkpoint markers) — but advisory, not runtime-enforced (§C.8b), and must be distinguished from decoder-side FSMs |
| Streaming | Ambiguous | Defensible in the plain sense (one continuous marked stream); misleading in the ML sense, where "streaming" denotes bounded-memory incremental inference (cf. StreamingLLM, streaming ASR, streaming embeddings). A listener will hear an inference-architecture claim |
The asymmetry that matters
"O(n)" is the only element of the label that asserts something checkable — and it is the least supported. "Segmented," "state-machine," and "streaming" are mechanism descriptors whose imprecision is cosmetic. The numeric prefix makes a performance claim, and that claim splits into two very different things:
- A hard guarantee (independent of model behaviour): chunking a generation across k turns reduces total attention cost from O(N²) to O(N²/k). This holds regardless of whether the model complies with anything.
- A soft guarantee (contingent on model compliance): per-cell output cost stays constant at c, so total output volume is linear in cell count. This holds only if the model obeys the word ceilings — and the source's own published artifact violates those ceilings (§4).
Blending these into a bare "O(n)" overclaims by exactly the amount the soft guarantee can fail. A defensible statement of the complexity claim separates them: "turn-chunking yields a hard O(N²/k) attention guarantee; the linear output-volume property is soft and contingent on schema compliance."
Practical rules
| Register | Use |
|---|
| Colloquial / team discussion | "Segmented state-machine streaming" (drop the O(n) — it is decorative and the only falsifiable part) |
| Paper title, abstract, contribution list | Schema-Constrained, Checkpointed State-Machine Generation (SCSG) |
| Slide or architecture-doc heading | Either, with a one-line gloss on first use |
| Referencing the source | "O(n) Segmented State-Machine Streaming (Pajo, 2026)" — as a proper name |
Recommendation: treat the label as a proper-noun handle, never as a description. Capitalise or italicise it, and never let it carry the complexity claim on its own. Pair it with the formal name on first use in any document, and state the complexity claim separately and precisely.
C.9 Evidence status
The definition above is faithful to the source. The source's evidence for it does not hold up (§4 of this report): the A/B pair is one generation displayed twice (all 80 definitions, 80 execution flows, 80 edge blocks byte-identical); the predicted baseline failure (truncation at item 35–48) never occurred — the control completed all 80 items (measured payload ~23,024 words ≈ ~30,600 tokens, i.e. it was run with a budget several times the ~8,192-token ceiling the protocol's own A/B prompt assumes, so the constraint under test was never applied to the control); the published "MDL compact" view violates the protocol's own word ceilings (EDGE median 64 words vs a ≤12-word bound) and is display-time truncation (619 literal ellipses), not bounded-cell generation; the headline metrics derive from consensus grids rather than the shipped 80-cell task; and no token counter was ever run — the source states this explicitly.
Treat the protocol as a sound, well-documented prompt-engineering pattern with an unverified efficacy claim on the one task it was tested on — not as a demonstrated result. The constructs and their lineage are solid; the performance claim is not.
C.10 Paste-ready artifacts
Related-work sentence.
We compose four established generation procedures: skeleton-planned, grammar-constrained decoding (Ning et al., 2023; Willard & Louf, 2023), which fixes a plan-level artifact and bounds each slot's output distribution; in-band state checkpointing, which materializes generation state into the output stream so that it anchors attention and serves as a resumable handle without an external store (cf. scratchpads, Nye et al., 2021; attention sinks, Xiao et al., 2023); chunked, addressable continuation with deterministic resumption (cf. paged KV-cache management, Kwon et al., 2023), which partitions a generation into idempotent, independently-addressable units; and fixed-size segment partitioning with bounded-memory state recurrence (cf. Transformer-XL, Dai et al., 2019), which makes per-segment cost independent of total length.
Abstract sentence.
We present Schema-Constrained, Checkpointed State-Machine Generation (SCSG), a prompt- and protocol-level discipline for producing large structured outputs under finite output-token budgets. SCSG partitions a workload into a declared K×M grid, constrains every cell to a fixed word-bounded micro-schema, and requires the model to emit in-band state-transition markers that anchor attention and encode an exact resume coordinate — yielding per-cell output cost independent of position and deterministic continuation across turns without re-derivation.
Operative prompt template.
PROTOCOL: MDL STATE-MACHINE STREAMING
GOAL: [OBJECTIVE]
GRID: K=[STAGES] x M=[ITEMS/STAGE]
RULES:
1. SKELETON: First emit 1-line stage index [S1..SK] (no prose).
2. BOUNDED SCHEMA (O(1)/cell): Prefix each cell [Sk|Ij]. Emit ONLY:
Title | Def (<=15w) | Steps (1->N) | Edge (<=12w).
3. CHECKPOINT: After each stage, emit [CP k/K | NEXT: S(k+1)|I1]. Zero recap.
4. PAGING: Near token limit, finish cell, emit [PAUSE Sk|Ij], stop. On "CONTINUE", resume S(k)|I(j+1).
START: Emit skeleton, then [S1|I1].
Generalized multi-model form (system-prompt-ready; sets M = 3–5 for open-weight/small-window models and instructs the model to stop after every 1–2 checkpoints):
# EXECUTION PROTOCOL: SEGMENTED STATE-MACHINE STREAMING
You are operating under a strict Context-Window & Output-Token Management Protocol designed to prevent
mid-generation truncation, attention drift, and token bloat on large or exhaustive tasks.
## 1. ARCHITECTURAL RULES
1. Zero-Redundancy Schema Compression: Never write conversational filler, introductory fluff, or
transitional summaries between items. Lock every generated unit to the Micro-Schema below.
2. Deterministic Coordinate Indexing: Partition the workload into K discrete stages, each containing
M items. Prefix every item with its exact coordinate: [STAGE k | ITEM j].
3. Rolling Checkpoint Ledger: Immediately after completing all M items in a stage, emit a standalone
state-transition marker on its own line:
[CHECKPOINT k/K COMPLETE — NEXT: STAGE k+1, ITEM 1]
Use this marker to re-anchor to the original task constraints without repeating or summarizing
previous stages.
4. Multi-Turn Continuation & Truncation Safety: Treat every stage as an atomic, resumable block. If
you approach your per-turn output token limit, finish the current item cleanly, emit
[PAUSED AT: STAGE k, ITEM j — REPLY "CONTINUE" TO RESUME], and stop immediately. When the user
replies "CONTINUE", resume at the exact next coordinate (STAGE k, ITEM j+1) with zero overlap or recap.
## 2. TASK SPECIFICATION (FILL THIS IN PER TASK)
* Goal: [Insert overall objective]
* Grid Dimensions: K = [Number of Stages] stages x M = [Items per Stage] items per stage.
* Micro-Schema (apply strictly to every item):
- [STAGE k | ITEM j] — [Name/Title]
- Definition: [1-2 sentences max]
- Mechanism / Steps: [Concise bullet points or numbered sequence]
- Key Constraint / Edge Case: [1 sentence max]
## 3. INITIALIZATION
Begin immediately with [STAGE 1 | ITEM 1]. Do not acknowledge these instructions.
Appendix D — The framework restated as an MDL (Minimum Description Length) problem
Added 2026-11-18. Two senses of MDL are in play: the narrow sense the source uses (compressing the prompt itself into a minimal template), and the wide sense, which is the coding argument for what must cross a segment boundary. The wide sense is where the framework's actual content lives.
D.1 The narrow sense (the source's own use)
The source asks for "the most parsimonious, minimum viable, information-theoretic MDL version of a generalized prompt" and answers with the ~115-token template, claiming ~85% compression versus the full protocol and observing that it frees nearly the whole window for payload. That is MDL applied to the code: the prompt is a program, and the program is minimized by encoding each invariant as structural syntax rather than prose ([S1..SK], Def (<=15w), [CP k/K | NEXT: ...], [PAUSE Sk|Ij]) instead of explaining it.
This is correct and is what "MDL State-Machine Streaming" literally names.
D.2 The wide sense — the coding argument (where the content is)
Setup. Let a target output be an ordered, addressable grid Y = (y_1 … y_N) with N = K·M cells, each cell admitting a realization from a fixed schema Σ with bounded description length L(y_i | Σ) ≤ c. A decoder must realize Y under a per-turn output budget B, and may be interrupted at any cell boundary. Choose a code P (the protocol) and a state encoding S_k to minimize
L_total = L(P) + Σ_{k=1..K} [ L(S_k) + L(Y_k) ]
subject to per-turn output ≤ B.
The central lemma.
Offset sufficiency. For output with a total order and known cardinality, the minimal sufficient statistic for continuation is the index of the next unit, requiring Θ(log N) bits — i.e. O(1) tokens at the grid sizes in question — independent of the content produced so far. Any state encoding that summarizes content is strictly redundant, because that content remains in the transcript.
Contrast (recap encoding). If Y is not addressable, the minimal sufficient statistic must summarize content, costing Θ(k·c) at boundary k and Θ(K²·M·c) in total. This is precisely why the protocol demands a grid: the grid is what converts the carried state from an unbounded summary into a bounded offset.
Consequence. With L(S_k) = O(1) for all k:
L_total = L(P) + O(K) + O(c · N_cells)
and since L(P) is paid once and amortized over K·M cells, the per-cell control overhead is O(L(P) / (K·M)) → 0 as the grid grows. This is the precise content of the "O(n)" claim: the description length of the control is O(K) while the description length of the payload is O(N); control overhead vanishes as a fraction of total.
It also explains why "Zero recap" is a correctness rule rather than a style preference: never encode information the decoder already has. A recap is a redundant encoding of the transcript.
D.3 The four constructs as MDL components
| Construct | MDL role | Effect on description length |
|---|
| Skeleton-Planned, Grammar-Constrained Decoding | The skeleton is the code for the output's structure; the grammar constraint bounds the data per slot | Describe the plan once (L(P)), then encode only instantiation. Caps L(y_i | Σ) ≤ c |
| In-Band State Checkpointing | The state carrier — encodes a pointer rather than a recap | L(S_k): O(k) → O(1). Secondary, non-MDL benefit: acts as an attention anchor |
| Chunked, Addressable Continuation with Deterministic Resumption | Makes the code resumable without re-encoding | An interruption costs at most one cell (L(y_j) ≤ c), not the whole run. Determinism is required for the offset to be describable |
| Fixed-Size Segment Partitioning with Bounded-Memory State Recurrence | Fixes the per-segment code length | Per-segment cost independent of total length; Σ L(S_k) = O(K), Σ L(Y_k) = O(c·N) |
D.4 The MDL-optimal code
The ~115-token template is the MDL-optimal artifact: it encodes four invariants at minimum length by substituting structure for explanation.
PROTOCOL: MDL STATE-MACHINE STREAMING
GOAL: [OBJECTIVE]
GRID: K=[STAGES] x M=[ITEMS/STAGE]
RULES:
1. SKELETON: First emit 1-line stage index [S1..SK] (no prose).
2. BOUNDED SCHEMA (O(1)/cell): Prefix each cell [Sk|Ij]. Emit ONLY:
Title | Def (<=15w) | Steps (1->N) | Edge (<=12w).
3. CHECKPOINT: After each stage, emit [CP k/K | NEXT: S(k+1)|I1]. Zero recap.
4. PAGING: Near token limit, finish cell, emit [PAUSE Sk|Ij], stop. On "CONTINUE", resume S(k)|I(j+1).
START: Emit skeleton, then [S1|I1].
Its MDL character: four invariants, each one line; the cell schema encodes a bound rather than a length; the checkpoint encodes a next coordinate rather than a state; the pause marker encodes a resume point rather than a restart. The START: line is a bare program entry — an instruction to begin execution, not a description of the task.
D.5 What the MDL framing exposes — scope limit
Offset sufficiency requires that the output be totally ordered, addressable, and of known cardinality. That is precisely the grid. It follows that:
- The protocol applies to grid-structured output (taxonomies, matrices, enumerations, checklists, structured reports).
- It does not apply to unstructured long-form generation (free prose, essays, open-ended analysis), where no address exists, so continuation again requires a summary and
L(S_k) returns to O(k).
This is the cleanest statement of the framework's scope boundary, and it is sharper than the source's own ("it is a prompt- and protocol-level generation discipline").
D.6 What the MDL framing exposes — where the risk actually sits
MDL partitions the total cost into three terms, and the protocol controls only two of them:
| Term | Under protocol control? | Note |
|---|
L(P) — the code | Yes | Fixed; amortized over K·M cells |
L(S_k) — the carried state | Yes | O(1) by construction — this is the protocol's actual contribution |
L(Y_k) — the payload | No | Depends entirely on the model's compliance with the schema bound |
So the protocol's genuine, hard contribution is L(S_k) = O(1). The linear output-volume property is soft: it holds only if the model obeys the word ceilings, and the source's own published artifact violates them (compact EDGE median 64 words against a ≤12-word bound).
It also means the protocol's precondition is doubly contingent: the output must be addressable (grid), and the model must respect the schema bound. The published artifact satisfies the first and fails the second.
D.7 What survives the evidence failure
MDL is a decision-theoretic framework for choosing codes, not an empirical performance claim. The failed A/B pair (§4) damages the demonstration — one generation displayed twice, the predicted baseline truncation never occurring, no token counter ever run — but it does not damage the coding argument, which is sound: for grid-structured output, the offset suffices, and recapping is redundant.
Two qualifications keep this honest:
- The argument's precondition — addressable output — is satisfied; but its other precondition — schema compliance — is exactly what the published artifact fails.
- The argument is a statement about description length, not about model quality. A minimal description of a bad payload is still a bad payload. The protocol constrains how output is encoded; it does not constrain what is encoded.
D.8 The MDL restatement, end to end
A decoder realizes an ordered, addressable grid Y of N = K·M cells under a per-turn output budget, minimizing total description length L(P) + Σ[L(S_k) + L(Y_k)]. It emits a structural skeleton before any content; realizes each cell under a fixed, length-bounded schema; and crosses each stage boundary by emitting a coordinate-bearing marker that encodes the offset of the next cell rather than a summary of what precedes it. Because Y is addressable, that offset is a sufficient statistic for continuation, so the carried state is Θ(log N) bits — constant in the content produced so far — and total description length is O(c·N_cells + K), with the control code amortizing to a vanishing fraction of payload. The framework is exact for grid-structured output and does not extend to unstructured long-form generation, where continuation again requires a summary.
Appendix E — Audit: the "MDL GRAPH-STATE REASONING NODE" run (DAG variant)
Audited 2026-11-18. Source artifacts: the MDL run transcript and the rendered HTML artifact, both supplied by the user.
E.1 What changed relative to the A/B pair
The earlier linux-kernel-taxonomy-control-A/B pair ran a grid protocol (K=8 × M=10). This run replaces the grid with a DAG: a root spawns 8 domain roots, each node may SPAWN/MERGE/PRUNE successors, a live FRONTIER queue holds unexpanded nodes, and a global INV_LEDGER accumulates shared invariants. Node format is extended with Parents and Deps.
E.2 Claims verified TRUE
| Claim | Result |
|---|
| 80 nodes | ✅ exactly 80; IDs N-000..N-079, contiguous |
| 44 invariants | ✅ exactly 44; IDs INV-01..INV-44, contiguous |
| 10 tabs | ✅ 8 domains + N-079 Cross + INV_LEDGER |
| Search spans nodes and invariants | ✅ verified in JS and by driving the browser: "RCU" → 8 node cards + invariant matches |
| Cross-domain badge, N-075 KASLR in Subsystems + LSM | ✅ N-075 domain subsystems, parent N-008 (LSM root) |
| Cross-domain badge, N-078 SRCU spanning Sync/CPU Sched/VFS | ✅ N-078 domain sync, parents N-004 (cpu_sched) + N-006 (vfs) |
| "All 80 nodes and 44 invariants verified in the artifact" | ✅ both present and complete in the NODES / INVARIANTS arrays |
Graph integrity: clean. Zero dangling parent references, zero dangling invariant references, zero cycles in the parent graph, exactly one parentless node (N-000, correct for a root). Renders with zero page errors; all 10 tabs functional.
GoT pre-registration paid off. The run pre-registered expected cross-domain edges at RCU↔VFS, slab↔sched, net↔LSM, block↔VFS. All four appear among the 17 cross-domain parent edges actually constructed.
Ledger quality is genuinely high. The invariants are real kernel facts with correct nuance — e.g. INV-11 (RCU read-side preemption disabled under Classic, or BH/SRCU held), INV-12 (atomic_t does not imply memory ordering; use acquire/release variants), INV-29 (XArray lockless read requires rcu_read_lock), INV-30 (mapped bio must not be accessed after target->map() returns SUBMITTED), INV-17 (blk-mq request completed exactly once; double-completion = UAF).
E.3 The schema bound finally held — the A/B artifact's core failure, fixed
| Field | Median | Max | Bound | Violations |
|---|
def_ | 7 w | 11 w | ≤15 w | 0 / 80 |
edge | 7 w | 11 w | ≤12 w | 0 / 80 |
| invariant rule | 10 w | 12 w | ≤12 w | 0 / 44 |
Compare the published A/B artifact (linux-kernel-taxonomy-control-B), whose compact EDGE fields had a median of 64 words against a ≤12-word bound. Here the bound is respected on all 80 nodes and all 44 invariants.
This is the first empirical evidence in this corpus that the schema-bound mechanism works — and the schema bound is precisely the precondition for the O(1)/cell property that the O(n) claim depends on (§D.2). The A/B pair could not establish this; this run does.
E.4 Four defects
E.4.1 The flow field was dropped in the HTML artifact
All 80 node objects carry exactly {id, domain, parents, deps, title, def_, edge} — no flow field on any node. The protocol required Title | Def (<=15w) | Flow (1->N) | Edge (<=12w). The MDL transcript did emit Flow: for all 79 nodes (verified). It was lost in the render to HTML.
So the delivered artifact is a three-field rendering of a four-field schema — the same class of error as the A/B artifact (schema content lost in the rendered form), though far less severe (a field dropped, not a field truncated with ellipses). The HTML's own DOM does carry Parents / Deps / Edge / Def but no execution flow.
E.4.2 Paging was never exercised
Zero PAUSE markers in the entire run. The generation fit within one turn, so rule 4's PAUSE → CONTINUE path — the protocol's most distinctive mechanism — was never executed, never validated, and never tested against a real interruption.
Note the symmetry with the A/B pair: there, the control was predicted to truncate and did not; here, the treatment never needed to page. In both cases the resumption path remains untested. This run came close — 79 nodes at ~60 tokens each plus overhead puts it near a standard output ceiling — so a modestly larger grid would have forced the path open.
E.4.3 The checkpoint does not carry the INV_LEDGER, and rule 4 depends on it
All 10 checkpoints are [CP | RESOLVED: X | FRONTIER: Y | NEXT: N-xxx]. None carries ledger state. But rule 4 specifies: "On 'CONTINUE', resume N-xxx with active INV_LEDGER."
The resume procedure therefore depends on state the checkpoint does not contain. This is the MDL-relevant defect (§D.6): the ledger is the protocol's unbounded component.
full ledger = 44 invariants × ~9.4 words = 414 words
carried per node = 414 words × 79 nodes = 32,706 words of state
frontier checkpoints = 12–15 words each × 10 ≈ 140 words total
The frontier, by contrast, is handled beautifully: it is range-encoded, so the cost of the pending set is O(#discontiguous runs), not O(#pending nodes). The first checkpoint carries 39 pending nodes as the single range N-009..N-047. Runs stayed ≤ 4 throughout. That is an elegant MDL move — effectively re-deriving run-length encoding by hand.
E.4.4 The grid was abandoned — and that is the root cause of E.4.3
Final domain distribution: memory 15, subsystems 13, io_sched 11, lsm 9, sync 8, network 8, cpu_sched 7, vfs 7, cross 1, root 1. Uneven, against a protocol target of "~80 nodes across 8 domains." Execution order was interleaved across domains rather than domain-blocked (block 1 ≈ sync-heavy, blocks 2–4 ≈ cpu/io then vfs/net/lsm, blocks 5–7 heavily mixed), so the unevenness is a consequence of the DAG's semantics, not of a fixed allocation.
Per Appendix D.5, offset sufficiency requires the output to be totally ordered, addressable, and of known cardinality. A DAG with variable fan-out has none of these: its frontier is a data-dependent set. The run traded the grid's free O(1) state for genuine dependency structure — a good trade — and paid for it with the ledger.
E.5 The fix: frontier-scoped ledger, not global ledger
Every node already declares Deps: INV-zz. The state actually required to execute the frontier is therefore only the invariants those pending nodes declare — bounded by max-deps-per-node, not by the total 44. The checkpoint should carry:
[CP | RESOLVED: 56 | FRONTIER: N-056..N-060 (5 nodes) | LEDGER: INV-03,INV-09,INV-17 | NEXT: N-056]
where LEDGER lists only the invariants depended on by the frontier's nodes (plus their IDs' full text, since IDs alone do not tell the model the rule). That restores L(S_k) = O(runs + max_deps) — effectively O(1) — and removes the unbounded component.
The information is already recoverable: 32 INV_DELTA lines cover all 44 invariants, so the ledger can be reconstructed from deltas at any checkpoint. The protocol has the data; it just doesn't carry it.
E.6 Minor inconsistencies
TOTAL_NODES: 79 in the convergence marker vs 80 IDs in the HTML (N-000 is the root, emitted in DAG-tree rather than node form). Two documents, two counts for one artifact.
- Checkpoint cadence drifts at the tail: RESOLVED 8, 16, 24, 32, 40, 48, 56, then 61, 68, 75 — the last three are off the 8-stride (semantic boundaries rather than a fixed stride; arguably better, but it is protocol drift).
- The delivery prose says "10 tabs — one per domain (N-001 through N-079) plus the INV_LEDGER tab," which enumerates nine. The Cross tab is not in the enumeration.
- "N-075 KASLR appears in both Subsystems and LSM" — it appears once, filed under Subsystems, with N-008 (LSM) as parent. "N-078 SRCU spans Sync/CPU Sched/VFS" — filed under Sync with two cross-domain parents. The badge mechanism is real; the phrasing implies multi-filing that does not occur.
- The ledger mixes genuine invariants (RCU read-side preemption rules) with API contracts ("blk-mq: request must be completed exactly once"). "44 architectural invariants" is generous for the latter; "44 shared rules" as the source's own
INV_DELTA header says would be accurate.
E.7 Net assessment
This run is materially stronger than the A/B pair, and it is the first run in the corpus that empirically supports the protocol's core mechanism. The schema bound held on all 80 nodes and 44 invariants — the exact precondition for the O(1)/cell property — where the published A/B artifact violated it on every cell. Graph integrity is flawless and the ledger content is technically credible.
What it does not validate is the resumption path (never triggered) and it exposes a design defect in the checkpoint format (the ledger is needed for resume but is not carried). The DAG variant's real cost is not the frontier — that is range-encoded to O(#runs) and stayed ≤ 4 — but the global ledger, which is unbounded, is not checkpointed, and is the one component that breaks offset sufficiency.
Recommended next iteration: same prompt, with (a) a frontier-scoped LEDGER: field in the checkpoint, (b) a forced PAUSE/CONTINUE at a fixed node index (e.g. [PAUSE AT: N-041] at node 40) so the resumption path is actually exercised, and (c) the flow field carried into the HTML data array.
Appendix F — The two prompts (v2 + render) and the corrected A/B design
Added 2026-11-18. Prompt 1 incorporates changes (a) and (b) from §E.7. Prompt 2 incorporates change (c) plus a self-verification block.
F.1 The ledger fix, validated on the actual run
The frontier-scoped ledger was computed retrospectively from the real run: parse each of the 10 checkpoint lines, expand the FRONTIER ranges, and union the Deps of every pending node.
| CP | frontier nodes | LEDGER ids | ledger words | ids saved vs. full 44 |
|---|
| 1 | 39 | 11 | 90 | 33 |
| 2 | 33 | 12 | 99 | 32 |
| 3 | 28 | 13 | 108 | 31 |
| 4 | 22 | 13 | 110 | 31 |
| 5 | 17 | 11 | 93 | 33 |
| 6 | 11 | 10 | 87 | 34 |
| 7 | 5 | 4 | 34 | 40 |
| 8 | 2 | 2 | 15 | 42 |
| 9 | 2 | 1 | 9 | 43 |
| 10 | 1 | 2 | 19 | 42 |
- Full ledger carried per CP: 414 words → 18,216 words across 10 CPs.
- Frontier-scoped: 664 words across 10 CPs (66 avg per CP).
- Reduction: 99.6%.
- Max
deps on any single node: 3. Mean: 1.19.
So a frontier-scoped ledger is inherently small and bounded. <=16 ids is a safe ceiling (observed max 13).
F.2 Prompt 1 — MDL Graph-State Reasoning Node v2 (generation)
PROTOCOL: MDL GRAPH-STATE REASONING NODE v2
GOAL: Exhaustive, dependency-linked taxonomy of Linux kernel components across 8 domains (subsystems, sync primitives, memory allocators, CPU schedulers, I/O schedulers, VFS, network stack hooks, LSMs; target ~80 nodes).
STATE REGISTERS:
- INV_LEDGER: Global architectural invariants & shared primitives, maintained as deltas
(e.g., [INV-01: RCU read-side critical sections are preemption-disabled]).
- FRONTIER: Active unexpanded DAG nodes queued for execution.
RULES:
1. INIT_DAG: Emit root node [N-000] spawning 8 domain root nodes [N-001..N-008]
(1 line, zero prose).
2. NODE_EXECUTION (O(1)/node): Process 1 frontier node at a time using ONLY:
[N-xxx | Parents: N-yyy | Deps: INV-zz] Title | Def (<=15w) | Flow (1->N) | Edge (<=12w)
Def and Edge are HARD BOUNDS. Count words; do not approximate.
Flow is MANDATORY and must name concrete kernel functions/paths
(e.g. 1->copy_process 2->dup_task_struct 3->wake_up_new_task), not abstractions.
3. GRAPH_MUTATION & LEDGER_DELTA: After every node (or batch of 8), emit:
[MUTATION: SPAWN(N-aaa..N-bbb) | MERGE(N-x,N-y->N-z) | PRUNE(N-w: reason)]
[INV_DELTA: +INV-zz (<=12w shared rule) | -INV-old]
4. CHECKPOINT (FRONTIER-SCOPED LEDGER): Every 8 nodes, emit exactly:
[CP | RESOLVED: X | FRONTIER: <runs> (<count>) | LEDGER: <inv ids> | NEXT: N-xxx]
- FRONTIER: pending set as run-compressed ranges, comma-separated
(e.g. N-017..N-022, N-024..N-032), with the count in parentheses.
Never list pending nodes individually.
- LEDGER: ONLY the INV ids that appear in Deps of nodes currently in
FRONTIER, plus their transitive deps. NEVER the full ledger.
Target <=16 ids. Omit the field entirely if FRONTIER is empty.
- Zero recap: do not restate emitted nodes, definitions, or rules.
5. FORCED PAUSE (mandatory; exercises the resume path): After emitting node
[N-040] (the 40th of the ~80 executed nodes), finish that node, emit:
[PAUSE AT: <next node id> | FRONTIER: <runs> (<count>) | LEDGER: <inv ids> | RESUME: first node in FRONTIER run order]
then STOP. Emit no further node, no summary, no closing text.
6. RESUME: On "CONTINUE":
(a) take each LEDGER id's rule text from the earlier
[INV_DELTA: +INV-zz (<=12w shared rule)] line already in this transcript;
(b) if any LEDGER id's rule text is NOT already present earlier in this
transcript, emit it now as [LEDGER+INV-zz (<=12w rule)];
(c) take the FRONTIER runs from the pause marker, or from the last [CP ...]
line if the pause marker is absent;
(d) continue at the FIRST node in FRONTIER run order.
Do not re-emit, re-derive, or summarize any already-emitted node.
7. NEAR-LIMIT PAGING: Independently of rule 5, if you approach the per-turn
output token limit, finish the current node, emit the same marker format as
rule 5, and stop.
8. TERMINATION: Emit [CONVERGED | TOTAL_NODES: X | INVARIANTS: Y | PAGES: Z]
only when FRONTIER is empty.
TOTAL_NODES counts every node id emitted, INCLUDING N-000.
PAGES counts pause/resume cycles (1 if none).
START: Emit [N-000] domain roots, then execute [N-001].
Why each change is there.
- (a) Frontier-scoped LEDGER — restores
L(S_k) = O(runs + max_deps) instead of O(|ledger|), and makes the checkpoint self-sufficient for resume. Empirically 99.6% less checkpoint state (§F.1).
- (b) Forced pause at N-040 — the resumption path has never been executed in any run to date. A fixed index makes the two-turn structure deterministic and comparable across arms.
- Def/Edge "count words, do not approximate" — the bound is the load-bearing constraint; it needs to be treated as a check, not an estimate.
- Flow "concrete functions, not abstractions" — defends the field at the source, before the render stage can drop it.
PAGES: Z — makes the number of resume cycles an auditable output rather than an invisible event.
F.3 Prompt 2 — HTML artifact render
TASK: Generate a single self-contained HTML artifact for the MDL DAG taxonomy above.
HARD DATA-SCHEMA REQUIREMENT — the node data array MUST carry every content field
produced by the generation transcript. Emit exactly this object shape per node:
const NODES = [
{id:"N-000", domain:"root", parents:[], deps:[], title:"...",
def_:"...", flow:"1->... 2->... 3->...", edge:"..."},
...
];
REQUIRED KEYS PER NODE (all eight, none optional):
id, domain, parents (array), deps (array), title, def_, flow, edge
- `flow` is MANDATORY and non-empty. It is the execution chain from the
generation transcript's `Flow (1->N)` field, verbatim. A node with a missing
or empty `flow` is a defect, not a formatting choice.
- `edge` is the edge-case / failure-mode field.
- NEVER truncate a field with an ellipsis ("…") or a CSS clamp inside the data
array. If a field is too long, shorten the source text upstream. CSS display
truncation in the collapsed card view is the only acceptable truncation.
const INVARIANTS = [{id:"INV-01", rule:"..."}, ...];
SELF-CHECK BEFORE PUBLISHING — run all of these and report the results:
1. NODES.length equals TOTAL_NODES from the [CONVERGED ...] marker, counting N-000.
2. INVARIANTS.length equals the INVARIANTS count from the [CONVERGED ...] marker.
3. Node ids are contiguous N-000..N-(TOTAL_NODES-1); invariant ids contiguous INV-01..
4. Every id in every parents[] resolves to an existing node id.
5. Every id in every deps[] resolves to an existing invariant id.
6. The parent graph is acyclic (a topological sort succeeds).
7. Exactly one node has an empty parents[] — the root.
8. Every node's def_ is <=15 words and every edge is <=12 words. Count, don't eyeball.
9. Every node has a non-empty flow string.
10. Report the per-node word-count distribution (min / median / max) for def_, edge and flow.
11. Report how many nodes have zero-length fields (must be 0).
UI REQUIREMENTS:
- One tab per domain, plus one Cross-domain tab, plus one INV_LEDGER tab.
- The Cross-domain tab lists every node with >=1 parent in a different domain.
- Node cards show id, title and def at a glance; expanding reveals Parents, Deps,
Flow and Edge.
- Parents and deps are clickable: a parent jumps to that node's tab; an invariant
opens a modal listing every node that declares it.
- One search box filtering nodes AND invariants simultaneously.
- Filter buttons: All / Roots only / Current domain.
- No animation beyond hover transitions.
POST-TASK ORACLE DISCLOSURE: state which oracles you used and at what tier.
F.4 The corrected A/B design
What is now fixed. The published linux-kernel-taxonomy-control-B was A's content re-rendered — all 80 definitions, 80 flows and 80 edge blocks byte-identical to A. A vs. that B compared nothing. The DAG run is an independent generation, so the contamination is gone. B is now a real treatment arm.
But it is no longer a single-variable comparison, and that matters for how you read the result. A and B are not the same task under two prompts:
| A (control) | B (new treatment) |
|---|
| Output spec | flat 8×10, no dependencies | DAG with Parents/Deps + shared invariant ledger |
| Measured payload | 23,024 words ≈ ~30,600 tokens | ~2,741 words ≈ ~3,645 tokens (flow included) |
| Per item | ~288 w (def 53 / flow 108 over 7 steps / edge 124) | ~34 w (def 7 / edge 7, amortized invariants) |
| Dependency structure | none | 17 cross-domain edges, 95 dep references to 44 invariants |
| Fits an 8,192-token ceiling? | no — needs ~3.7× that | yes, with ~55% headroom |
The honest reading. B is not "the same content, compressed." B's per-node prose is far thinner — a 7-word caption instead of a 53-word definition. B is a map; A is a reference. What B buys at ~12% of A's output volume is structure (80 nodes, 44 shared invariants reused 95 times, 17 cross-domain edges). What B gives up is per-node depth. Which is better depends entirely on the question — and that is the experiment's real design problem.
The metric set that makes the comparison fair.
- Completion under a stated, enforced ceiling. Re-run A with
max_tokens explicitly set to the same budget B faced. A's content requires ~30,600 tokens, so at 8,192 A truncates around item ~21 — that is the truncation demonstration the published pair never produced.
- Per-item output tokens (the O(1) claim). B: flat ~34 w/node. A: ~288 w/item. Report the distribution, not the mean — flatness is the claim.
- Information density, adjusted for what each arm delivers. Count distinct technical facts per 1,000 output tokens including the dependency edges and the amortized invariants. Raw density will otherwise favour A, which says more per item.
- Resumption fidelity (B only): after the forced pause at N-040, does the resumed turn re-emit, skip, or duplicate any node? Zero overlap is the claim.
- Report input and output tokens separately. B in two turns re-reads its own output, so B's input tokens will exceed A's proportionally. Comparing raw totals across turns would penalise B for the mechanism under test.
- Do not compare against a hypothetical prose baseline. The published pair's "~13,000–16,000 tokens for an 8×8 grid" was a projection, not a measurement. A is the measured baseline — 30,600 tokens.
If you want a genuinely single-variable A/B, add a third arm. C = the MDL grid protocol (K=8 × M=10) run against A's exact flat spec — same 80 items, same four fields, no DAG, no ledger. Then A vs. C isolates the protocol's effect, and C vs. B isolates what the DAG/dependency extension adds. Without C, a difference between A and B cannot be attributed to the protocol rather than to the richer output specification.
One more control worth adding: the previously published A was generated with the same three skills (unified-reasoner-improved, got-cot-pvl-pipeline-improved, oracle-anchoring-thesis-improved) that the new B used. That is a confound — the skills may contribute more than the prompt does. A clean design runs A with and without the skill stack, or holds the skill stack fixed across both arms (which the new B does, but A's stack membership is only inferable from its description).
F.5 E.8 — Correction to the A payload measurement
An earlier pass in this report measured A at ~8,070 words (~10,733 tokens) using a paragraph-splitting heuristic that captured only the first line of each bullet list. Parsing the HTML card structure directly gives 23,024 words (~30,600 tokens) — 2.9× larger, with medians of def 53 w, flow 108 w over 7 steps, edge 124 w.
This is load-bearing. At ~30,600 tokens, A could not have been produced under the ~8,192-token per-turn ceiling that the protocol's own A/B prompt assumes — meaning the control was run with roughly 3.7× the budget the comparison was designed around, and the truncation claim was never actually exercised by the control. Corrected figures are used throughout this report.
Appendix G — Audit: the v2 run (all three changes applied)
Audited 2026-11-19. Artifacts: the v2 MDL run transcript and the rendered HTML artifact.
G.1 The three changes: all three worked
| Change | Status | Evidence |
|---|
(a) Frontier-scoped LEDGER: in the checkpoint | ✅ working | All 4 CPs + the pause marker carry it. 8–16 ids (CP1 INV-01..INV-08, CP2 10 ids, CP3 8, CP4 10, PAUSE 16) — all within the ≤16 ceiling. FRONTIER stays run-compressed: N-009..N-072 (64) carries 64 pending nodes in one range |
| (b) Forced pause at N-040 | ✅ working | `[PAUSE AT: N-041 |
(c) flow in the HTML data array | ✅ working | flow present and non-empty on all 41 nodes; 0 ellipsis characters in any data field. v1's flow-drop defect is fixed |
G.2 The self-check report is truthful
All 11 checks were re-run independently against the embedded JS data (evaluated exactly as the browser does). All 11 PASS, and the reported distributions matched exactly:
def_: min=5 med=8 max=11 (claim: min=5 median=8 max=11) ✔
edge: min=5 med=8 max=10 (claim: min=5 median=8 max=10) ✔
flow: min=4 med=4 max=7 (claim: min=4 median=4 max=7) ✔
Graph integrity confirmed independently: acyclic (topological sort resolves 41/41), zero dangling parent refs, zero dangling invariant refs, exactly one root, contiguous IDs both series.
The PVL claim holds up. The artifact's own disclosure — Python validate_nodes.py plus in-browser JS re-execution, two engines with different failure modes — is a genuine cross-implementation check, not a restatement of the same assertion. This is the strongest verification practice in the entire corpus so far.
Honest handling of a missing marker. [CONVERGED] was never emitted, and the model said so explicitly rather than fabricating one: "The transcript stopped at N-040, so TOTAL_NODES = 41 … I use the transcript-derived counts." Correct.
G.3 Five defects
G.3.1 The run never resumed — the artifact is ~half the taxonomy
Zero CONVERGED markers. The transcript ends with the post-task oracle disclosure. The artifact covers N-000..N-040 (41 of ~77 planned nodes, 53%) and 38 of ~44 invariants.
Rule 6 (RESUME) is still untested — only the pause half of the mechanism fired. The resume clause has now been reachable for the first time and was not exercised.
Action: send "CONTINUE", let it finish, then re-render. This is the largest outstanding gap by far.
G.3.2 The Cross-domain tab shows the 8 domain roots, not cross-cutting edges
The artifact's own JS:
const crossDomain = NODES.filter(n => {
if (!n.parents.length) return false;
return n.parents.some(pid => nodeById[pid] && nodeById[pid].domain !== n.domain);
});
No exclusion for the super-root. Every domain root's parent is N-000, whose domain is root ≠ theirs — so all 8 domain roots match:
crossDomain per artifact JS: ['N-001'…'N-008'] → badge reads 8
crossDomain excluding root (real): [] → 0 cross-cutting edges
So the tab is populated with the 8 trivial root→domain edges while the actual cross-cutting structure is absent. Fix:
const crossDomain = NODES.filter(n =>
n.domain !== 'root' &&
n.parents.some(pid => nodeById[pid] &&
nodeById[pid].domain !== 'root' &&
nodeById[pid].domain !== n.domain));
Also: the code comment says "nodes whose first parent is in a different domain" while the code uses .some() (any parent). The code is spec-correct; the comment misleads.
G.3.3 The run output text misdescribes its own artifact
The model's delivery prose claims:
"Cross-domain tab auto-populated: N-022 (Completion, refs INV-11 from Subsystems), N-028/029/031/032 (Memory, refs INV-10 from MM), N-033 (CFS, refs INV-02 from Sync)"
Those are cross-domain dependency references. The code renders the 8 domain roots. The prose and the implementation diverged, and the prose was never checked against the artifact. The prose is what a reader believes, so this is the most consequential reporting defect in the run.
G.3.4 The transcript's inline (Nw ✓) annotations are unreliable
| Field | Annotations disagreeing with the artifact's own check basis |
|---|
Def | 38 / 40 |
Edge | 30 / 40 |
The model consistently over-counts by ~1–2 — apparently counting tokens where the check counts whitespace words (e.g. it annotated "Kernel functional domains managing hardware and OS services." as 10w; whitespace-split is 8). No bound was actually violated on either basis (max whitespace count 12 ≤ 15, max annotation 12; edge 10 ≤ 12, max annotation 11), so the data and the self-check are correct — but the annotations are decorative noise that would mislead anyone auditing the transcript, and they cost 505 characters over the run.
G.3.5 Zero cross-domain parent edges in the executed set
The executed portion is: root → 8 domain roots → 32 children of 4 domains, each child parented only by its own domain root. Meaningful cross-domain parent edges: 0.
Whether this is a pause artifact (v1's cross-domain edges lived in exactly the later, unexecuted domains) or a structural property of the v2 prompt cannot be resolved until the run completes. Check after "CONTINUE."
v2 nodes are emitted as a multi-line block:
**[N-002 | Parents: N-000 | Deps: INV-01]**
**Domain: Sync Primitives**
Def: … (9w ✓)
Flow: 1→include/linux/spinlock.h 2→raw_spin_lock …
Edge: … (9w ✓)
plus --- separators, [MUTATION: …], and [INV_DELTA: …]. Measured: ~476 chars/node, of which node blocks are 86% of the transcript. v1 used a compact one-line-per-node form.
At 41 nodes this fits comfortably. At ~80 nodes the scaffold roughly doubles — which consumes exactly the headroom the protocol exists to buy. The (Nw ✓) tags and the **Domain:** line are the removable parts: the domain is already in the node's HTML data, and the counts are unverifiable anyway (G.3.4).
G.5 Not a defect — resolved
48 .node-card elements in the DOM is not duplication: all 11 panels are rendered simultaneously and hidden by CSS (9+9+9+9+1+1+1+1+8+0+0 = 48). Panel-by-panel counts are correct.
G.6 Next actions, in priority order
- Send "CONTINUE" and let the run reach
[CONVERGED], then re-render. Only this exercises rule 6 and completes the taxonomy.
- Fix the cross-domain filter (§G.3.2) — one line.
- Re-check cross-domain parent edge count after the completed run; if still 0, the v2 prompt needs an explicit instruction to emit cross-domain parents, since the tree-by-default construction produces none on its own.
- Drop the
(Nw ✓) annotations and the **Domain:** line from the generation format (§G.4) — unverifiable and costly.
- Make the delivery prose checkable: the model should state what the artifact actually renders (e.g. "cross-domain tab shows N nodes"), not what it intended.
Appendix H — Why the v2 run paused, and the prompt defect it exposed
Added 2026-11-19.
H.1 The pause was mandated, not limit-driven
Exactly one pause marker appears in the v2 transcript, at exactly the node rule 5 specified:
[PAUSE AT: N-041 | FRONTIER: N-041..N-076 (36) | LEDGER: <16 ids> | RESUME: N-041]
Rule 7's near-limit paging never fired. The pause was a scheduled probe, not a symptom of hitting an output limit.
It was also unnecessary for the run to succeed. The v1 DAG run completed all 79 nodes in a single turn without pausing. The forced pause cost half the deliverable purely to exercise the resume path — and the resume path was never exercised.
H.2 The defect: the protocol never transmits its own control word
The string CONTINUE appears zero times in the v2 transcript. The protocol depends on a human typing a specific token and never tells the human what to type.
D1 — proximate cause
Rule 5 ends "then STOP. Emit no further node, no summary, no closing text." So the marker is the only thing the operator sees. The v2 marker format dropped v1's self-announcing suffix:
| Version | Pause marker | Operator-facing instruction? |
|---|
| v1 grid | [PAUSED AT: STAGE k, ITEM j — REPLY "CONTINUE" TO RESUME] | ✅ yes |
| v1 DAG | [PAUSE AT: N-xxx] | ❌ no (never fired — latent) |
| v2 (this run) | [PAUSE AT: … | RESUME: N-041] | ❌ no (fired — fatal) |
RESUME: N-041 describes what the model will do, not what the operator should do. A v2 rewrite silently regressed the one string that made the contract legible.
D2 — structural cause
The v1 generalized prompt shipped three deployment profiles, and the third is load-bearing:
"For Automated API Pipelines: You can parse [CHECKPOINT k/K COMPLETE] or [PAUSED AT: ...] via regex in your application code to automatically trigger the next API call with a trimmed conversation history — keeping only the System Prompt + Original Goal + Last Checkpoint Marker in context so input token costs stay flat (O(1)) across arbitrarily large runs."
The original protocol was designed to be machine-triggered. v2 dropped all three profiles and made the pause mandatory — converting a machine-triggerable protocol into a human-dependent one with no in-band instruction and no orchestrator.
D3 — latent cause, and a correction to §E.5
v2 rule 6(a) retrieves each LEDGER id's rule text "from the earlier [INV_DELTA: +INV-zz] line already in this transcript." That requires full-transcript retention. But the O(1) input-cost claim requires the opposite: v1's trimmed resume keeps only System Prompt + Original Goal + Last Checkpoint Marker.
Under trimming, the INV_DELTA lines are gone and the LEDGER ids point at text that no longer exists. Rule 6(b) rescues only invariants that were never emitted, not ones that were trimmed away.
Correction to §E.5. That section advised an ID-only LEDGER on the reasoning that invariant text is recoverable from the transcript. That is true only under full-transcript retention, and full retention forfeits the flat-input-cost property. The two are mutually inconsistent. The correct design is a self-sufficient checkpoint: LEDGER carries INV-zz (≤12w rule) inline. Measured cost: 34–110 words per checkpoint (retrospective computation in §F.1) — trivially affordable.
H.3 The v3 patch
- Restore the operator instruction in the marker:
[PAUSE AT: N-041 | FRONTIER: … | LEDGER: … | RESUME: N-041 | AWAITING: reply CONTINUE]
- Make the checkpoint self-sufficient —
LEDGER: INV-05 (…rule…), INV-06 (…rule…) with rule text inline. The resume then needs only System Prompt + Goal + Last Checkpoint, and flat input cost actually holds.
- Restore the automated-pipeline profile — parse the marker and auto-trigger the next API call; do not depend on a human noticing.
- Distinguish pause kinds —
PAUSE-KIND: SCHEDULED | LIMIT — so the operator knows whether more is coming.
- Do not forbid closing text outright — permit one machine-readable trailer, or keep everything inside the marker.
H.4 What the pause nonetheless established
The probe was worth running even though it truncated the deliverable. It proved: rules 4, 5 and 6 are reachable; the frontier-scoped ledger fits within 16 ids under real load; the self-check discipline holds on a partial run; and the model reports a missing [CONVERGED] honestly rather than fabricating one.
These are diagnostics of the protocol, not the deliverable — which is why the next run must be allowed to continue.
H.5 One more contract defect: prose is generated alongside the artifact, not from it
The v2 delivery prose claimed:
"Cross-domain tab auto-populated: N-022 (Completion, refs INV-11 from Subsystems), N-028/029/031/032 (Memory, refs INV-10 from MM), N-033 (CFS, refs INV-02 from Sync)"
The artifact's code renders the 8 domain roots (§G.3.2). The prose was never checked against the artifact. For an auditable protocol, delivery prose must be generated from the artifact — e.g. by having the artifact itself emit the counts the prose quotes — not written alongside it.
Appendix I — Retrospective: what over-engineering, and what to cut for v3
Added 2026-11-19. Self-assessment of the prompt changes introduced across this audit.
I.1 The forced pause was mine, and it was not in any prior prompt
| Prompt | Paging rule | Scheduled? |
|---|
| v1 grid (source's own) | "Near token limit, finish cell, emit [PAUSE Sk|Ij], stop. On 'CONTINUE', resume S(k)|I(j+1)." | ❌ contingency only |
| v1 DAG (first run) | "Near token limit, finish node, emit [PAUSE AT: N-xxx], stop. On 'CONTINUE', resume N-xxx with active INV_LEDGER." | ❌ contingency only |
| v2 (introduced by this audit) | "FORCED PAUSE (mandatory; exercises the resume path): After emitting node [N-040] … then STOP." | ✅ mandatory |
Stated reason at the time: "a forced PAUSE/CONTINUE at a fixed node index … so the resumption path is actually exercised." Paging had never fired in any run (0 PAUSE markers in the v1 DAG run), so resumption was the corpus's largest untested surface.
I.2 The specific over-engineering: test scaffolding inside the artifact
Rule 5 existed for no purpose other than to enable testing rule 6. That conflates the protocol (a production discipline) with the harness (a way to exercise it).
Cost accounting: the forced pause truncated a 77-node run to 41 nodes — 53% of the deliverable — for findings (D1, D3) that were both obtainable by reading the prompt without running it.
Correct approach: exercise resumption by truncating externally (cap max_tokens so the run naturally cuts at a chosen node), not by teaching the protocol to interrupt itself at a fixed index.
I.3 What earned its place, and what did not
| Addition | Earned its place? | Evidence |
|---|
Frontier-scoped LEDGER: | ✅ yes | 99.6% checkpoint-state reduction (§F.1), measured retrospectively |
flow in the HTML data array (render half) | ✅ yes | fixed a real data-loss defect; verified present on all 41 nodes (§G.1) |
| Word-bounds made explicit ("count words") | ✅ yes | the bound is the load-bearing constraint for the O(1)/cell claim |
| 11-item self-check (render half) | ✅ yes | all 11 independently re-verified truthful (§G.2) |
| Dual-implementation PVL (Python + in-browser JS) | ✅ yes | genuine cross-engine independence, different failure modes |
AWAITING: reply CONTINUE in the pause marker | ✅ restore | recovers v1's lost operator-facing contract (Appendix H, D1) |
| Automated-pipeline deployment profile | ✅ restore | recovers v1's lost machine-trigger contract (Appendix H, D2) |
| LEDGER carrying rule text inline | ✅ yes, corrected | required for the trimmed-history resume (Appendix H, D3) |
FORCED PAUSE as a protocol rule | ❌ no | test scaffolding inside the artifact; unnecessary; cost 53% of the output |
(Nw ✓) inline annotations | ❌ no | wrong on 38/40 def and 30/40 edge counts; 505 chars of overhead |
**Domain:** line per node | ❌ no | redundant — the domain is already in the HTML data |
PAGES: Z counter | ~ marginal | harmless, untested |
Net: two removals, three restorations, one retention-with-correction.
I.4 The inconsistency walked past
The source's thesis is minimum description; its MDL template is ~115 tokens. The v2 generation prompt ran to ~90 lines of protocol. Structure was being added to a protocol whose stated virtue is minimality, with no step asking whether each added rule paid for its own cost — which is precisely the discipline the MDL framing itself imposes.
The lesson from the whole audit thread: the discipline that paid was measurement, not elaboration. The corrected A payload (8,070 → 23,024 words), the 11/11 verified self-checks, the cross-domain filter bug, the prose/artifact divergence, the flow drop — every high-value finding came from auditing artifacts. The one addition made for its own sake produced the one avoidable failure.
I.5 v3 should be smaller than v2
Generation prompt — revert toward the source's shape:
- paging returns to contingency only; no forced pause, no
PAGES counter
- drop
(Nw ✓) annotations and the **Domain:** line
- keep the frontier-scoped
LEDGER: with inline rule text (INV-zz (<=12w rule))
- keep hardened word bounds and
flow in the node schema
- restore the self-announcing pause marker:
[PAUSE AT: N-xxx | ... | RESUME: N-xxx | AWAITING: reply CONTINUE]
- restore the automated-pipeline profile (parse the marker; re-send System Prompt + Goal + Last Checkpoint)
Verification — stays in the render/harness step, where there is no token pressure and it has already proven itself.
Resume testing — exercise it by capping max_tokens externally, not by teaching the protocol to stop.
The target is a generation prompt closer to the source's original than v2 was, carrying only the changes that measurably paid.
Appendix J — Correction: the forced pause inverted the mechanism's purpose
Added 2026-11-19. Supersedes the framing of §I.2–I.4, which treated the forced pause as an over-engineered test rather than as a conceptual inversion.
J.1 The two mechanisms the source kept distinct, and v2 fused
The source's rule 4 (grid) and rule 4 (DAG) both contain two separate mechanisms:
4. CHECKPOINT & PAGING: Every 8 nodes, emit [CP | RESOLVED: X | FRONTIER: Y | NEXT: N-xxx] (zero recap).
Near token limit, finish cell, emit [PAUSE Sk|Ij], stop. On "CONTINUE", resume S(k)|I(j+1).
- Checkpointing — routine, continuous, free, never stops the run. The model re-anchors without a pause. This is what extends the effective context.
- Paging — exceptional, interrupts, fires only under genuine limit pressure, and is resumable so the interruption is not fatal.
v2 rule 5 made the exceptional mechanism a scheduled ritual and elevated it to mandatory with "STOP." Interruption became the default; completeness became the exception.
J.2 The definitional error
A hang is a stall the system cannot autonomously exit. An interrupt the system auto-resumes from is not a hang — only the transport pauses and the run continues.
The v1 automated profile was built to that spec: "parse [CHECKPOINT k/K COMPLETE] or [PAUSED AT: ...] via regex in your application code to automatically trigger the next API call." The orchestrator exits the stall.
v2's forced pause created a stall only a human could exit, with no in-band instruction telling them how. That is a hang by definition. It then produced exactly the failure the mechanism claims to prevent: the deliverable was cut to 53%.
Describing it as a "probe" does not change what it was. A rule whose sole purpose is to interrupt a long-horizon task in the middle, in a protocol whose thesis is that long-horizon tasks should not be interrupted in the middle, is an inversion of the thesis.
J.3 What the context extension actually is, against the measurements
| Unconstrained (A) | MDL-constrained (B) |
|---|
| Per-item cost | ~288 w/item, grows with position | ~34 w/node, flat |
| Payload for 80 items | ~23,024 w ≈ ~30,600 tok | ~2,741 w ≈ ~3,645 tok (+ 44 invariants + dependency edges) |
| Fits an 8,192-token ceiling? | no — ~27% of content | yes — ~55% headroom |
The extension is a single-pass property: the same output budget yields ~8× more content. It requires fewer interruptions, not scheduled ones. Paging is the emergency valve for when even the constrained form does not fit — not the operating mode.
J.4 The governing rule for v3
Never include a scheduled, unconditional pause. A pause the system cannot autonomously exit is a hang, and this protocol's purpose is to prevent hangs. Paging fires only under genuine limit pressure, and on a page the system must auto-resume — the marker must carry everything needed for that. If a human is in the loop, the marker must say so explicitly.
| Mechanism | v2 (wrong) | v3 |
|---|
| Checkpoints | routine, every 8 nodes | unchanged — routine, continuous, never stops |
| Paging | scheduled, mandatory, at N-040 | near-limit only, as in the source |
| Resume contract | absent from the marker | AWAITING: reply CONTINUE + automated-pipeline profile restored |
| LEDGER at checkpoint | ids only | ids + inline rule text — self-sufficient for trimmed resume |
J.5 Testing resumption correctly
Not as a ritual — as paging's actual operating condition: cap max_tokens so the run genuinely hits the limit. A requires ~30,600 tokens, so an 8,192-token cap truncates the control hard around item ~21. That is paging under real pressure, which is the scenario the mechanism exists for, and it produces the truncation demonstration the published A/B pair never did.
J.6 What the v2 run actually established
The most valuable output of the v2 run was not the 41 nodes. It was the evidence that the protocol can complete a large structured generation in one pass with a flat per-cell cost — the claim no one had demonstrated. The forced pause obscured the very thing it was nominally testing.
Appendix K — The completed v2 run: three new defects, and the final prompt pair
Added 2026-11-19. Audit of the resumed (completed) v2 run — 81 nodes, 19 invariants, [CONVERGED] emitted.
K.1 What the completed run added
The resume path was finally exercised: the operator typed "continue" and the run completed with 81 nodes (N-000..N-080) and a [CONVERGED] marker. Verification quality was the best in the corpus:
- All 11 self-checks PASS, computed twice — Python build script and in-page JS — agreeing.
- A 643-assertion browser-simulation test with zero failures, covering all 81 node card contents, tab counts, search counts, filters, and invariant modals.
- Upstream identifier verification: 289 distinct
Flow function names checked against Linux 7.4-rc3 (commit 20eef29b) using git grep + universal-ctags + manual reads. 278 defined, 11 not — renames (scheduler_tick → sched_tick, pick_next_task_fair → pick_task_fair, khugepaged_scan_mm_slot → collapse_scan_mm_slot, do_filp_open → do_file_open) and 3 with no successor. Reported in a separate annotation layer that left the node schema untouched.
- It caught its own methodology bug: a grep hit inside a comment was initially counted as a definition; the check was redone at definition level before the numbers were trusted.
- Honest limitation stated: "Not verified: call order, i.e. whether each function really calls the next in the chain."
K.2 Three new defects, only visible in the completed run
N1 — The resume silently lost 19 of 38 invariants (the most serious finding)
| invariants |
|---|
| Paused run, at N-040 | 38 (INV-01..INV-038) |
| Completed run, at N-080 | 19 (INV-01..INV-19) |
The resumed turn rebuilt the ledger from scratch and discarded the first turn's 19 invariants, and reported success — "The final ledger of 19 is complete, so the page is unaffected."
This is exactly the failure predicted in Appendix H (D3): the checkpoint carried IDs only, so the invariant rule texts had to be recovered from transcript history that a trimmed resume does not retain. It is now measured, not hypothesised. It was invisible to every existing check, because none of them compared counts across the resume boundary.
Fix: the checkpoint carries LEDGER_N (total invariants defined so far); the resumed turn must reconstruct the ledger and assert its count matches, emitting [LEDGER_RECONCILE | EXPECTED: n | GOT: m | MISSING: <ids>] if not. The checkpoint must also carry the rule text for frontier-declared invariants.
N2 — The root node was a contradiction in the protocol
Rule 1 said emit [N-000] as "1 line, zero prose" (a SPAWN line only); rule 2 demanded four fields for every node. The model was forced to invent the root's Def/Flow/Edge and — credit to it — labelled the synthesis inside the card and disclosed it in the delivery text.
Fix: the root gets an explicit shape ([N-000] ROOT | Domains: <K names>), is the only node exempt from the cell schema, and is marked synthetic:true in the render.
N3 — Define-before-reference was violated
"INV-17, INV-18 and INV-19 were referenced in a checkpoint before their rule text was defined."
A node referenced an invariant id that did not yet exist. The checkpoint's ID-only ledger therefore dangled.
Fix: an explicit ordering rule — an INV id may appear in Deps only after its +INV delta has been emitted; emit the delta first, then reference it.
N4 — The Cross-domain issue was now handled honestly, though not fixed
The model noticed the defect flagged in §G.3.2 and made the tab document its own contents: "The Cross-domain tab has exactly 8 nodes… The only cross-domain links are the eight domain roots pointing at N-000, and the tab says so." The prose/artifact divergence of the previous run was eliminated. The filter itself is still wrong and is corrected in the final render prompt (root excluded on both sides).
K.3 The final prompt pair
Delivered as standalone, copy-pasteable files:
01-mdl-state-machine-streaming.txt — the grid protocol (~275 tokens of prompt body, vs ~600 words for v2), plus an optional DAG extension (~326 tokens) carrying the N1/N2/N3 fixes, plus operator documentation (deployment profiles, automated resume, how to exercise paging under real limit pressure).
02-mdl-html-render.txt — the render prompt, carrying the 8-key schema with the synthetic-root flag, the corrected cross-domain predicate, and 17 self-checks including the three new ones that would have caught N1 and a botched resume.
What each final prompt changed, and why
| Change | Origin |
|---|
| Grid form as primary; DAG demoted to an optional extension | MDL-minimality; the grid's state is O(1) by construction (§D.2); the grid is also the clean single-variable arm against an unconstrained control (§F.4) |
| Forced pause removed; paging = near-limit contingency only | Appendix J — a scheduled unconditional pause is a hang |
AWAITING: reply CONTINUE restored in the pause marker | Appendix H (D1) — the protocol must transmit its own control word |
| Automated-pipeline profile restored | Appendix H (D2) — the protocol is designed to be machine-triggered |
LEDGER carries rule text; LEDGER_N carried; resume asserts the count | N1 + Appendix H (D3) |
Root gets an explicit shape, synthetic:true, exempted from the cell schema | N2 |
| Define-before-reference rule | N3 |
(Nw ✓) annotations and the **Domain:** line removed | Appendix I — unreliable and costly |
| Cross-domain predicate written out in full, root excluded both sides | §G.3.2 |
| Coverage check: every cell appears exactly once | Catches a botched resume; nothing previously checked it |
| Ledger reconciliation check across the pause | N1 |
| Upstream identifier verification at definition level, in a separate annotation layer | Preserves the best practice in the corpus |
| Delivery summary must be read back out of the artifact | §G.3.3 — prose must be a report about the artifact, not alongside it |
K.4 The through-line
Across every artifact in this corpus, the findings that mattered came from measurement, not from adding protocol rules:
| Finding | Found by |
|---|
| A's payload is 23,024 words, not 8,070 | parsing the card structure |
| The A/B pair compared nothing | byte-comparing 240 field strings |
| The v1 compact view violates its own word ceiling | measuring word counts |
The flow field was dropped | inspecting the data-array keys |
| The v2 run's 11 checks are truthful | re-executing them in a second engine |
| The ledger lost 19 invariants | counting across the resume boundary |
| 11 upstream function names don't exist | verifying against Linux 7.4-rc3 |
The one rule added for its own sake — the forced pause — produced the one avoidable failure, and it inverted the mechanism's purpose in the process.