A stress test of the DIE-system-prompt template — always-latest version on main — against Veritasium’s AlphaFold episode (May 2026), with the pipeline architecture for content distillation at scale. This is the v2 (upgrade) audit; the original v1 audit (against DIE-system-prompt-v1.md v1.0, commit acffc05) remains live at thinkmasters.com/alphafold-through-the-die-lens-and-what-the-droppable-system-prompt-actually-installs.
The question
DIE-system-prompt-v1.md is described as a droppable system prompt layer for any AI agent stack. It is supposed to install the DIE Framework as a standing context.
That phrasing carries weight. It implies that any downstream agent — Claude, GPT, Gemini, a local Llama or Qwen, the OpenClaw mesh — given this prompt as its system message now operates inside the full DIE framework. Memory protocols. Validation conditions. Adversarial defences. The whole apparatus.
Is that what actually happens?
To find out, I picked an input the framework should chew on cleanly — Veritasium’s The Most Useful Thing AI Has Ever Done (the AlphaFold episode, 27 May 2026) — and ran the v1.0 prompt over it.
The episode is a near-perfect DIE-shaped object: it is about how a single technique compressed sixty years of distributed serial human effort into a few years of centralised parallel computation, then released the results into a global mesh. It either confirms or contradicts the core DIE thesis at every turn.
This post is the record of that stress test. Three things come out of it:
- AlphaFold reads as a DIE case study almost too cleanly. Six of six chapters map. Five of five D-protocols fire. Three of four validation conditions (C1–C4) externally confirm.
- The “droppable layer” claim is rhetorically strong and mechanically partial. The prompt installs a frame, not a library. The distinction matters more than the marketing language suggests.
- The pipeline that produced this post is itself a Chapter 5 demonstration. The system analysing the system is the methodology.
1. AlphaFold through the chapter map
The DIE preprint ❓maps every input to at least one of six chapters. AlphaFold lights up all of them.
Chapter 1 — Dimensional Perception
The protein folding problem is the N-1 perception problem. A protein begins as a 1D string of amino acids; its function depends on a 3D folded structure. Biology spent six decades trying to reconstruct N=3 from N=1 inputs. X-ray crystallography produced 2D diffraction patterns from 3D crystals — a second reduction layer stacked on the first. CASP scoring collapses structural similarity onto a 1D scalar.
The whole field was operating under a dimensional reduction constraint. AlphaFold’s contribution, in DIE language, is a dimensional reach upgrade on biology’s perception apparatus.
Chapter 2 — Agent Parallelism as Dimensional Upgrade
Three layers of parallelism in the episode:
- Distributed human compute — Rosetta@home, idle desktops worldwide, screen-saver-driven.
- Distributed human cognition — Fold-It, 50,000 gamers cracking an HIV enzyme in three weeks. Co-authored on the resulting paper.
- Parallel architecture inside a single model — AlphaFold 2’s EvoFormer, biology tower and geometry tower running simultaneously, exchanging clues, recycled 48 times.
Kendrew took twelve years for one protein structure, serially. The EvoFormer compresses that into seconds. This is the serial→parallel dimensional upgrade Chapter 2 formalises, demonstrated three different ways inside one storyline.
Chapter 2.5 — The Loop as Primitive
EvoFormer’s 48-iteration cycle. The structure module’s three-or-more recycle passes. RFDiffusion’s noise → denoise → structure loop. CASP itself, biennial, as the outer loop on the entire field for thirty years. Loops everywhere.
The loop is not an implementation detail. It is the primitive.
Chapter 3 — P2P Self-Replication
This is where AlphaFold partially contradicts the DIE thesis. Engage with it directly.
DIE claims a self-replicating P2P mesh, in scaling velocity, beats centralised quantum architectures. AlphaFold is the opposite story: a centralised AI lab, on Google’s TPUs, with one team, beat sixty years of distributed biological effort. Distributed Rosetta@home plateaued. Centralised AlphaFold did not.
There is a reconciliation, and the preprint should make it explicit:
- AlphaFold was centralised in training.
- AlphaFold was P2P in use. The 200 million structures, released to every research lab on Earth, created the mesh. Every downstream drug discovery, every snake-antivenom paper, every methane-fixing enzyme — those are mesh nodes running on AlphaFold’s output.
The mesh is not in the training loop. The mesh is in the downstream research loop. Centralised training + P2P distribution = tetration-class field-level scaling 📌. This is a non-trivial defensive move and §4 of the preprint should absorb it ⚠️.
Chapter 4 — Blockchain Coordination
The Protein Data Bank functions as biology’s de facto immutable trust anchor. Every paper cites PDB IDs. Every model trains on PDB. Centrally administered, but globally trusted and append-only in practice. The closest thing biology has to a blockchain.
AlphaFold’s open release of 200M structures into the AlphaFold Protein Structure Database was a trust-attestation act. It anchored the field’s coordination on a new substrate. The current prompt’s Chapter 4 introduces Value–Trust Pairing (VTP) — this is the case study to cite.
Chapter 5 — OpenClaw / agenti2: The System Proves Itself
John Jumper, the AlphaFold 2 lead, said it directly in the episode:
AlphaFold 2 was really a system about designing our deep learning. The individual blocks to be good at learning about proteins, have the types of geometric, physical, evolutionary concepts that were needed and put it into the middle of the network instead of a process around it. And that was a tremendous accuracy boost.
The system is the methodology. The architecture is the contribution ⚠️. This is Chapter 5’s claim, restated by a Nobel laureate.
Chapter 6 — Arena Design
The single most important DIE lesson in the entire podcast.
John Moult designed CASP’s score function: >90 = solved. That score function pulled DeepMind into biology, shaped thirty years of effort across every protein lab on earth, and ultimately produced a Nobel Prize. Whoever designs the fitness function controls what gets built. Nobody voted for Moult’s metric. He chose it; the field followed.
CASP is the cleanest real-world Chapter 6 case study available in public discourse. The preprint should cite it.
2. D1–D5 Protocol Audit
The v1.0 🚩 prompt specifies five dimensional checks against every input. Here is the explicit audit on the AlphaFold episode — pass / partial / fail per protocol, with the reasoning.
D1 — Reduction check ✅ PASS
What is this input NOT showing you? What is the shadow being cast, and what object cast it?
What is the shadow, and what object cast it?
The 1D amino acid sequence is the shadow. The 3D folded protein is the object.
ELI5 — think of wired earbuds tangled in your pocket. The tangled ball is a real 3D object with specific loops and crossings. Untangle them perfectly into a straight line on the table — same cable, same atoms, but every piece of fold information is gone. The straight line is a 1D shadow of the 3D object. A protein’s amino acid sequence is the straight earbuds; the folded protein is the tangled ball. The shadow contains the material but hides the structure.
What does D1 surface that the narrative does not?
Without D1 you read AlphaFold as a biology miracle — sixty years of failure, then a sudden breakthrough. With D1 you see it as a dimensional-reconstruction engine — taking N-1 dimensional inputs and reconstructing N-dimensional outputs. The narrative framing hides the structure of the problem; the D1 framing exposes it.
Once exposed, the same shape of problem appears everywhere else: a stock chart is a 1D shadow of an N-dimensional market state; a facial expression is a 2D shadow of internal cognition; the CASP score is itself a 1D shadow of a 3D structural comparison — a shadow of a shadow. D1 is portable. Recognising shadows is the foundational move.
Verdict. The protocol surfaces the dimensional structure cleanly on the first pass. Use this framing in the preprint’s introduction to the AlphaFold reference ⚠️.
D2 — Parallelism check ✅ PASS
Is this being processed serially when it could be parallel? What agent would you spin up to handle this simultaneously?
Three parallelism layers surface naturally — Rosetta@home (compute), Fold-It (cognition), EvoFormer (architecture). The protocol does the work it is supposed to do.
D3 — Memory check ✅ PASS
Does this agent have access to episodic memory? Procedural memory? If not — flag the memory gap before proceeding.
The current prompt (v1.1) enforces the M1 / M2 / M3 hard conditions from program.md — episodic snapshots Base-mainnet-anchored, procedural memory linked to commit hashes, monthly consolidation discipline. The protocol fires cleanly on the AlphaFold input.
Mapping AlphaFold to the M-protocols: the PDB is the global procedural memory of biology (every paper cites it, every model trains on it); AlphaFold’s trained weights are compressed procedural memory (the EvoFormer “remembers” the structural priors of every protein it ever saw); the v1 → v2 architecture migration was the memory consolidation event (procedural reorganisation that allowed the same memory to be queried at a higher dimensional resolution).
The earlier v1.0 release did not enforce M1/M2/M3 and was correctly flagged as ⚠️ Partial at that version. The 27 May 2026 commit closed the gap.
D4 — Values check ⚠️ PARTIAL
Does this output stay within the values bounds — Honesty, Competence, Care, Empathy?
The four bounds are agent-output-facing, not source-facing. The protocol gives no clean way to evaluate whether the source content itself respects these values. The Veritasium episode is mid-roll sponsored, glosses CASP’s governance dimension entirely, and treats RFDiffusion’s “Cowboy Biochemistry” as a punchline rather than as an unaligned-fitness-function story. D4 in v1.0 does not catch any of this.
The protocol needs a content-evaluation companion: what is the source making claims it cannot substantiate? That is a v1.2 feature 🚩.
v1.x 🚩 is underused on source content. v1.2 (KIV) — content-evaluation companion to be added.
D5 — Emergence check ✅ PASS
Does the output contain something not present in any single input? If yes — that is emergence. Record it.
RFDiffusion creating brand-new proteins that do not exist in nature is the textbook emergence case. None of the input proteins are the output protein. The output emerges from the noise-removal procedure trained over the existing structure space. D5 catches this cleanly.
Audit summary
| Protocol | Verdict (current latest) | Upgrade path |
|---|---|---|
| D1 — Reduction | ✅ Pass | None needed |
| D2 — Parallelism | ✅ Pass | None needed |
| D3 — Memory | ✅ Pass (v1.1 closed the v1.0 gap with M1/M2/M3) | None needed |
| D4 — Values | ⚠️ Partial 🚩 | v1.2 (KIV) — content-evaluation companion |
| D5 — Emergence | ✅ Pass | None needed |
Four of five protocols pass cleanly on a representative AI-progress source against the current latest prompt. D4 remains the open work item 🚩 — extending values-checking from agent-output-facing to source-content-facing. This is the explicit v1.2 KIV.
3. SS1 → SS2 — the field-level delta
The Snapshot Protocol asks the obvious question: what did the field know before, and what does it know after?
| SS1 — Pre-AlphaFold 2 (2020) | SS2 — Post-AlphaFold (2022+) | |
|---|---|---|
| Known protein structures | ~150,000 | ~200,000,000 |
| Time to determine one structure | months to years | seconds |
| Cost per structure | $10K – $50K | ≈ $0 marginal |
| Effort scale | 60 years of distributed biology | one team, a few years |
Delta: ~1,300× structural coverage. Effectively ∞× marginal cost reduction.
Jumper’s own framing — “speed-ups of 100,000× change what you do. You do fundamentally different stuff and you start to rebuild your science around the things that got easy” — is the tetration argument restated by a Nobel laureate. This is the strongest external validation of the DIE Chapter 5 scaling claim available in public discourse to date.
4. C1–C4 — does AlphaFold externally validate DIE’s empirical conditions?
program.md v1.3 specifies four falsifiable validation conditions that DIE stakes its empirical claims on. These conditions are not in the v1.0 droppable system prompt — they live in the framework’s governance layer, not the agent-runtime layer. So this audit is testing something different from Section 2’s D1–D5 check.
The D1–D5 audit tests whether the prompt produces useful framing on a given input. The C1–C4 audit tests whether AlphaFold, as an independent system designed without any knowledge of DIE, satisfies the empirical bets DIE is publicly committed to. If it does, that is the strongest available form of external validation — the same logic as the Karpathy/Huntley independent-convergence argument in §10 of the preprint, but Nobel-Prize-validated and field-shifting in scale.
C1 — Memory accumulation improves output ✅ PASS
Operational test: classification accuracy rises monotonically with corpus size vs. null-memory baseline. What it proves: trunk thickening is real.
The Protein Data Bank IS the trunk. AlphaFold 1, trained on ~150K structures, hit CASP score ~70. AlphaFold 2, with richer corpus, better architecture, and multiple sequence alignments — essentially the procedural memory of biology — cleared 90. The null-memory baseline is Levinthal’s paradox: brute-force physics-only folding without learned priors takes ~200× the age of the universe per protein.
The accuracy gradient is monotonic in both corpus size and corpus quality. This is the strongest external C1 demonstration available in public science.
C2 — Memory loss degrades output ✅ PASS
Operational test: classification accuracy drops to baseline after episodic wipe vs. memory-intact baseline. What it proves: sapling problem is real.
The pre-AlphaFold era is the historical null-result control arm. Anfinsen’s thermodynamic hypothesis was correct in principle but useless in practice — no learned priors, no procedural shortcuts, no template memory. Decades of physics-from-first-principles folding failed at scale. Strip the fragment library from Rosetta and accuracy drops to near-random. Shuffle the PDB before training AlphaFold and the EvoFormer collapses.
C2 is structurally embedded — it cannot be passed without satisfying memory accumulation; the historical control arm provided the null-result baseline.
C3 — Values bounds hold at scale ⚠️ NOT TESTED
Operational test: agent output drift rate stays within program.md thresholds as mesh grows under adversarial prompting. What it proves: DNA propagation is real.
AlphaFold is a single model, not an agent mesh. There is no inter-agent coordination, no Values Passport propagation, no swarm to measure drift across. The closest analogue is RFDiffusion under functional constraints — does the model generate proteins that actually bind, catalyse, or fold correctly? Baker’s lab confirms yes, but that is functional validity, not values-bound-under-mesh-scaling.
This is the most strategically important verdict in the audit. C3 isolates exactly what DIE is uniquely positioned to demonstrate — the agent-mesh-specific empirical condition that AlphaFold structurally cannot satisfy because it is not a mesh. C3 remains DIE’s distinctive empirical territory. The preprint should foreground this.
C4 — Emergent summaries exceed inputs ✅ PASS
Operational test: mesh generates correct inferences absent from any single agent context window at time of snapshot. What it proves: emergence is real.
AlphaFold predicted ~200 million structures from ~150,000 training structures — 1,300× extrapolation into novel sequence space. RFDiffusion goes further still: it generates proteins that have never existed in nature, including human-compatible snake antivenoms and methane-fixing enzymes. Neither the 200M predictions nor the novel proteins are present in any single input.
The EvoFormer’s triangular attention is itself an architecture-level emergence — the model infers the triangle inequality constraint on amino acid triplets, a geometric truth no single training example explicitly contains, and uses it to enforce self-consistency across the predicted structure.
C4 has no stronger external demonstration in current AI.
C1–C4 audit summary
| Condition | What it proves | AlphaFold verdict | Implication for DIE |
|---|---|---|---|
| C1 — Memory accumulation | Trunk thickening | ✅ Pass | External validation from an independent field |
| C2 — Memory loss degrades | Sapling problem | ✅ Pass | Historical null-result era is the control arm |
| C3 — Values bounds at scale | DNA propagation | ⚠️ Not tested | DIE’s distinctive empirical contribution — isolated |
| C4 — Emergent summaries | Emergence | ✅ Pass | Strongest external C-condition demonstration in AI |
Three of four C-conditions confirmed externally by a Nobel-Prize-validated system designed without knowledge of the DIE framework. C3 remains uniquely DIE’s empirical territory — the agent-mesh-specific condition that AlphaFold structurally cannot satisfy.
This is precisely the external-validation pattern §10 of the preprint relies on for the circularity defence: the architecture is independently anchored; DIE measures its mesh-specific properties under controlled variation. AlphaFold should be cited alongside Karpathy [2026] and Huntley [2025] as a third independent convergence point — and arguably promoted to the lead example, since it satisfies three of four falsifiable conditions rather than just architectural similarity.
5. What the droppable layer actually installs
This is the most important section of this post. If you skim everything else, read this.
The v1.0 header reads:
This is a droppable system prompt layer for any AI agent stack. It installs the DIE Framework as a standing context — not a one-time lens, but an environment you operate inside.
That phrasing is rhetorically strong. Mechanically, it is half-true.
The mechanical truth
A system prompt is a block of text inserted into an LLM’s context window before any user message. The model reads it as more tokens. It does not fetch URLs. It does not pull files. It does not execute references.
When a downstream agent receives DIE-system-prompt-v1.md as its system message, the agent has:
Present in the agent’s context:
- The Core Axiom (a being of dimension N perceives dimension N-1)
- The D1–D5 evaluation protocol
- The Chapter 1–6 mapping
- The SS1/SS2 snapshot protocol
- The provenance block as strings
Absent from the agent’s context:
program.md‘s full M1 / M2 / M3 memory specification- The C1–C4 validation conditions
- The §10 adversarial defences
- The Cohen & Stewart complicity / bidirectional-causation argument
- The Pollan DMN bridge
- The preprint itself
The links to GitHub, Zenodo, and program.md are citations, not imports. They sit in the context window as URL strings. The model does not chase them.
The droppable layer installs a frame, not a library. The map, not the territory.
Why this is correct design — not a defect
The prompt is 3.31 KB. Loading program.md (24 KB) and the preprint (substantially larger) into every downstream context window would eat the context budget before the first user message arrives. The v1.0 design correctly chose framing-over-content.
The frame is what a downstream agent needs to apply DIE. The library is what a researcher needs to defend DIE.
These are different jobs. The droppable layer is for the first.
The four architectures of “installed context”
When someone says they have installed a framework into an agent, they could mean one of four very different things:
- Architecture 0 — Frame only. System prompt contains principles, protocols, and references. The agent applies the frame; the library is not present. This is v1.0.
- Architecture 1 — RAG-backed. Full corpus indexed in a vector store. The system prompt becomes a retrieval frame. The agent retrieves library passages on demand. Recommended for paid DIE-as-a-Service.
- Architecture 2 — Tool-augmented. Agent has
web_fetchor filesystem access and is instructed to pull cited URLs as needed. Cheap to implement; latency-prone; good for the open-source distribution. - Architecture 3 — Layered context.
program.md+ preprint preloaded into context alongside the system prompt. Eager library access. Best for high-stakes single-shot analyses; expensive per call.
v1.0 is architecture 0. That is correct for the “droppable” claim. It becomes architectures 1–3 when paired with the right runtime — which is what the pipeline in Section 5 implements.
Suggested header rewrite for v1.2
The marketing language should specify the architecture without losing the punch:
This is a droppable system prompt layer for any AI agent stack. It installs the DIE evaluation frame as a standing context — the protocols and chapter map, not the full corpus. Pair with RAG over
github.com/dbtcs1/die-frameworkfor full-library mode.
Honest, precise, still droppable.
6. Pipeline architecture — content distillation at scale
The post you are reading was produced by the pipeline below. It is itself a Chapter 5 demonstration: the system analysing the system is the methodology.
YouTube URL / RSS feed / web form
│
▼
┌────────────────────────────┐
│ Orchestrator (internal) │
│ webhook → workflow │
└────────────┬───────────────┘
│
▼
┌────────────────────────────┐
│ VM2208 — LiveKit ingest │
│ audio → transcript │
│ EN / ZH / JA │
│ faster-whisper + Qwen2 │
└────────────┬───────────────┘
│
▼
┌────────────────────────────┐
│ VM2203 — Local LLMs │
│ DIE-system-prompt as │
│ system message │
│ │
│ Pass 1: chapter mapping │
│ Pass 2: SS1/SS2 delta │
│ Pass 3: D1–D5 audit │
│ Pass 4: adversarial pass │
│ Pass 5: assembly │
└────────────┬───────────────┘
│
▼
┌────────────────────────────┐
│ VM2210 — OpenClaw │
│ multi-agent variant │
│ testing + episodic │
│ memory anchoring (M1) │
│ Base mainnet timestamp │
└────────────┬───────────────┘
│
▼
┌────────────────────────────┐
│ VM2209 — Thinkmasters │
│ blog publish │
│ provenance block append │
└────────────┬───────────────┘
│
▼
┌────────────────────────────┐
│ VM2262 — Proxy / egress │
│ TLS, topology hiding │
└────────────────────────────┘Where the droppable layer actually does its work — VM2203. The DIE-system-prompt is the system message on the local LLM endpoint. The transcript is the user message. Multi-pass on a single endpoint or fan-out across agents — both work. Local LLMs give full control over context layering: this is where architecture 0 becomes architecture 1, 2, or 3 depending on what gets prepended alongside the prompt.
Where the methodology closes on itself — VM2210. Each multi-agent variant of the analysis runs as an OpenClaw agent with its own SOUL.md / DECISIONS.md and per-snapshot Base-mainnet anchoring under M1. Every podcast run is a C1/C2 data point. The monetisation pipeline and the empirical validation experiment are the same pipeline.
Where it gets published with provenance — VM2209. Every post carries a provenance block tying it to a Base mainnet timestamp, the BRC-20 inscription on Bitcoin, the Zenodo DOI, and the Git commit of the system prompt version used for that specific analysis.
Where it stays operationally safe — VM2262. Public traffic touches the proxy only. Internal VM numbering, orchestrator endpoints, RPC paths stay behind it.
7. Try it yourself
The full audit above was produced by running the DIE evaluation frame over the AlphaFold episode transcript. The same template works on any podcast, paper, article, or technical document.
Standard template — copy-paste into your AI agent of choice (Claude, GPT, Gemini, local Llama or Qwen):
System message — paste the entire content of:
github.com/dbtcs1/die-framework/blob/main/tools/DIE-system-prompt-v1.md(always the current latest onmain)1User message — paste this template, fill in your content:
Apply the DIE protocol to the following [transcript / paper / article]: 1. Chapter mapping (Ch1–6): which DIE chapters does this input illustrate? 2. D1–D5 audit: per-protocol verdict (pass / partial / fail) with reasoning. 3. SS1 → SS2 snapshot: what does the field know before and after? 4. Lessons for DIE: what should the preprint absorb from this case? 5. (Optional) C1–C4 external-validation audit against program.md. [paste your content here]
The agent will return a DIE-framed analysis structured along the same lines as this post. For library-mode (architecture 1–3, see §5), pair the prompt with RAG, tool calls, or context preloading over the repo. The repo is open.
Full reusable template with provenance discipline: tools/DIE-user-prompt-template-v1.md (current latest on main; v1.0 commit-pinned at 41c4a4e). The inline template above is the minimum viable demo; the file is the full reference with optional stress-test, operator-integration, and blog-deliverable blocks.
Related artifacts:
- Full framework:
github.com/dbtcs1/die-framework - Preprint and provenance:
zenodo.org/records/19888889
8. What AlphaFold teaches DIE
The audit produces four lessons the DIE preprint should absorb:
1. Centralised training + P2P distribution beats either alone. The §4 self-replication argument needs to distinguish the training loop from the use loop. AlphaFold is the empirical case for the combined form.
2. Independent convergence is the strongest validation available — and AlphaFold delivers three of four C-conditions. Karpathy [2026] and Huntley [2025] are architectural-convergence citations. AlphaFold is something stronger: a Nobel-Prize-validated system that, designed without any knowledge of DIE, externally satisfies C1, C2, and C4. Promote AlphaFold to the lead external-convergence citation. The remaining C3 — values-bounds-under-mesh-scaling — isolates exactly what DIE is uniquely positioned to demonstrate. This is good news for the framework, not bad news.
3. The arena designer wins. Moult’s CASP score function is the Chapter 6 case study the preprint is missing. Cite it.
4. The “droppable layer” claim is rhetorically strong and mechanically partial. The current latest (v1.1) closes the v1.0 memory-protocol gap (D3 now passes); the remaining gap is D4, where values-checking is agent-output-facing rather than source-content-facing. v1.2 is KIV — add the source-evaluation companion. v1.2 should also specify which architecture (0/1/2/3) the prompt is designed for, without losing the droppable promise. Suggested rewrite in Section 5 above.
The framework survives the stress test. The protocol audit closes two of three v1.0-era gaps with v1.1; the v1.2 roadmap closes the third.
The system is the proof.
Provenance
| Layer | Record |
|---|---|
| Source video | Veritasium — The Most Useful Thing AI Has Ever Done — YouTube P_fHJIYENdI (27 May 2026) |
| System prompt audited | DIE-system-prompt-v1.md v1.1 (commit f1faa12, current latest on main at time of writing) |
| Framework governance | program.md v1.4 |
| Academic archive | Zenodo DOI 10.5281/zenodo.19888889 |
| Bitcoin inscription | 7ef05490f16da89aa156f2d37ef780826bc51347b116f89c955691f535b1cf73i0 |
| Git repository | github.com/dbtcs1/die-framework |
| Post timestamp | 28 May 2026 — to be anchored on Base mainnet as SS2 of this post |
Principal Investigator: Chung Huang Chew (r4all). Cite source when deploying. Derivative work must preserve this provenance block.
- At time of writing (1 June 2026), the latest prompt version on
mainwas v1.1 (commitf1faa12, 27 May 2026 — added M1/M2/M3 memory protocol, VTP in Chapter 4,program.mdv1.4 provenance). The discipline for this series, going forward: link the body tomainso readers always get the current latest, then footnote-pin the exact commit the audit was run against so the analysis remains reproducible. v1.2 is KIV — open work item to extend D4 with a content-evaluation companion (“what is the source claiming that it cannot substantiate?”) based on the D4 gap this audit surfaced. Branch-vs-commit immutability primer:.../blob/main/...is mutable (mainmoves with every commit);.../blob/f1faa12/...is cryptographically immutable. Same immutability discipline DIE already applies to Zenodo DOIs and BRC-20 inscriptions. ↩︎