# How to check this archive

A public guide for anyone with a terminal and no prior context. Every command below was
run on **2026-10-08** against the live site before this file was written; the outputs
quoted are real. If a number in this guide disagrees with a number you measure, trust
your measurement, note the matcher you used (see "Reading hygiene" below), and say so.

The archive: **https://alexanderwhitestone.com/stackchain/** — the ledger is
`/stackchain/blocks/`, with 121 entries: **91 magazine pieces, 22 dated events, 8 ledger
blocks/receipts**.

---

## 0. Reading hygiene (the rules the checks below obey)

1. **Every count carries its matcher.** A bare `grep -o 'magazine-[0-9]*'` over the raw
   index HTML returns **92**, not 91 — the extra hit is the phrase *"the magazine
   inventory"* in the page text. Scope the match to the `href` attribute and the count
   is exact. Measured, not hypothetical.
2. **Byte sizes are dated readings, not identifiers.** Pages re-render; a size means
   "this many bytes at this clock time." Hash read-back (`sha256` + `cmp`) is the only
   identity check.
3. **Don't double-count the badges.** The index page carries every entry's badge inline
   *and* each entry page carries its own. A crawl that fetches both counts each badge
   twice (a first pass of this guide's own author measured 230 `documented` that way —
   115 on the index + 115 on the entry pages). Census from the index alone.
4. **A negative is a result.** "Checked, found nothing" with the commands printed is a
   finished answer; a silent omission is not.

---

## 1. The ledger in 60 seconds

```bash
curl -sS -o index.html https://alexanderwhitestone.com/stackchain/blocks/
# blocks-index: HTTP 200 / 34488 B
sha256sum index.html
# 4f764ef4dfb9c08b2654ff0783550d20ad1bb7a31cb0c32070974a5fe451557e  index.html
```

Reproduce the published entry count (matcher: `href` attributes only, `/blocks/` excluded
because the index links to itself):

```bash
grep -o 'href="/stackchain/[a-z0-9-]*/"' index.html | sort -u | grep -vc '/blocks/'
# 121
grep -o 'href="/stackchain/[a-z0-9-]*/"' index.html | sort -u | grep -v '/blocks/' \
  | sed 's|href="/stackchain/||; s|/"||' | cut -d- -f1 | sort | uniq -c
#      8 block
#     22 event
#     91 magazine
```

That matches the page's own header: *"121 entries · 8 ledger blocks and receipts · 22
dated events · 91 magazine pieces."*

The evidence badges are on the index itself, so a badge census needs no crawling:

```bash
for b in documented testimony_only corroborated; do printf '%s ' "$b"; \
  grep -o "class=\"badge $b\"" index.html | wc -l; done
# documented 115
# testimony_only 5
# corroborated 1
```

115 + 5 + 1 = 121. `unrecovered` is defined in the legend but used on **no** page — the
archive's fourth tier exists as a declared, visible zero.

---

## 2. The four evidence tiers, and what each one obliges you to check

The legend is published at the foot of the index (verbatim):

> **Documented** — the archive holds the post, capture or receipt.
> **Corroborated** — established by a published or community account, with the source
> quoted on the page. An original screenshot is not required.
> **Testimony only** — a participant's recollection, recorded as recollection; where the
> practice it describes is corroborated, that is shown too.
> **Unrecovered** — known to exist, no copy and no independent account.

What each tier means **in practice** — i.e. what you can actually test from outside:

| Tier | What you can check | What you cannot |
|---|---|---|
| Documented | The cited source answers (HTTP 200), and every blockquote is verbatim in it (Checks C + D) | Whether the archive *holds* the receipt — "No receipt is held for this entry" is an honesty statement, not a verifiable one |
| Corroborated | The published account the entry cites exists and carries the claim (Check C, worked below on `block-6`) | Nothing further — this tier is defined by exactly that published account |
| Testimony only | That the page labels it as recollection and does not upgrade it; nothing more is checkable from outside | The recollection itself — by design |
| Unrecovered | That the missing item is named on the page and in the index's "Known gaps" list | The existence of the copy — "known to exist" is the archive's claim |

Worked tier test — `block-6` ("The six dollars, from Bob") is `Corroborated` and holds
**no receipt**. Its own text says so: *"The $6 post itself has not been produced and is
not required."* The test is whether the cited published account exists and carries the
claim:

```bash
curl -sS -o bm.html "https://bitcoinmagazine.com/culture/how-5-bitcoin-purchase-cascaded-into-1-5-million-viral-movement"
# bitcoinmagazine: HTTP 200 / 341684 B
grep -c -i 'happyclowntime' bm.html
# 1
grep -o -i '.\{60\}\$6.\{60\}' bm.html | head -3
# , @Happyclowntime, also known as Bob, followed it up with a $6 buy and Satskeeper followed Bob's with a $7 buy. You can se
```

The published account carries the claim, quoted on the entry page. The `Corroborated`
badge is doing exactly what the legend says it does. (Matcher note: `grep -c` counts
lines; for single-line JSON use `grep -o | wc -l` if you need occurrences.)

---

## 3. Anatomy of an entry page

Fetch one:

```bash
curl -sS -o entry-040.html https://alexanderwhitestone.com/stackchain/magazine-040/
# magazine-040: HTTP 200 / 4005 B
sha256sum entry-040.html
# a87a4385c4cc8bee96137fb23bb38a2f1bca580bae5f98f8c99499c2453cab62  entry-040.html
```

Every entry page carries the same sections, in order:

1. **Badges** — the evidence tier plus the entry class (`Stackchain Magazine`,
   `Timeline event`, `Stack receipt`, `Ledger block`).
2. **Date + basis** — the displayed date *and* the sentence saying where the date comes
   from (e.g. magazine-040: `Date: 2025-01-14 · basis: publication date recorded in the
   magazine inventory`). Some entries say `date not established` — that is the answer,
   not a defect.
3. **What happened** — the machine-written summary. The page says so itself:
   *"Archive summary written from the sources below — not a quotation."* This is the
   section that can be wrong even when every quote is right (see §5).
4. **From the sources** — verbatim excerpts, each followed by its source URL.
5. **Receipt** — what the archive holds, or *"No receipt is held for this entry."*
6. **In plain English** — a one-line gloss, also machine-written.
7. **Provenance** and **Uncertainty** — the archive's own limits on the entry.

Date consistency, in-archive:

```bash
grep -o 'Date: [0-9-]*' entry-040.html
# Date: 2025-01-14
grep -o '"datePublished": "[^"]*"' entry-040.html
# "datePublished": "2025-01-14"
```

---

## 4. The five checks

### Check A — count the ledger
Run the §1 commands. Pass: 121 = 91 + 22 + 8, matching the page's own header.

### Check B — read the entry's self-description
Badge, displayed date vs JSON-LD `datePublished`, receipt panel. Pass: the page tells
you what it is and where its date came from.

### Check C — source liveness
Sweep every external URL on the page. Script (save as `linkcheck.py`):

```python
import re, sys, urllib.request

page = open(sys.argv[1], encoding='utf-8').read()
urls = sorted(set(re.findall(r'https://[^"< ]+', page)))
UA = {"User-Agent": "stackchain-archive-check/1.0 (public audit)"}
print("external URLs on", sys.argv[1], ":", len(urls))
for u in urls:
    try:
        req = urllib.request.Request(u, headers=UA, method="HEAD")
        with urllib.request.urlopen(req, timeout=20) as r:
            print(r.status, u)
    except Exception as e:
        print("ERR", u, e)
```

```bash
python3 linkcheck.py entry-040.html
# external URLs on entry-040.html : 3
# 200 https://alexanderwhitestone.com/stackchain/magazine-040/
# 200 https://schema.org
# 200 https://www.stackchainmagazine.net/the-genesis-block/
```

Pass: every cited source answers. Note: some entries cite X/Twitter posts; those may
404 or demand a login from outside. Measured 2026-10-08: the genesis post cited
elsewhere in the archive (`https://twitter.com/AriZonanHODL/status/1549169119924080640`)
resolves `twitter.com` → 301 → `x.com` → **404** (curl -L -w '%{http_code}'). A 404
there is an avenue exhausted, not an archive defect — record it as one.

### Check D — quote fidelity
Does each blockquote actually appear in the cited article? Fetch the article, strip
markup, test verbatim (save as `quotecheck.py`):

```python
import re, html

raw = open('article-040.html', encoding='utf-8', errors='replace').read()
body = re.sub(r'(?is)<(script|style)[^>]*>.*?</\1>', ' ', raw)
text = re.sub(r'(?s)<[^>]+>', ' ', body)
text = html.unescape(text)
text = re.sub(r'\s+', ' ', text)

quotes = [
    "In the beginning Satoshi created Cyberspace (heaven) and the Bitcoin White Paper (earth).",
    "And there was evening, and there was morning\u2014 Tick Tock Next Block.",
    "By Block 97250, Satoshi had finished the work over which he labored",
]
for q in quotes:
    print("QUOTE", "VERBATIM" if q in text else "MISSING", "|", q[:60])
```

```bash
curl -sS -o article-040.html https://www.stackchainmagazine.net/the-genesis-block/
# the-genesis-block: HTTP 200 / 137324 B
python3 quotecheck.py
# QUOTE VERBATIM | In the beginning Satoshi created Cyberspace (heaven) and the
# QUOTE VERBATIM | And there was evening, and there was morning— Tick Tock Next
# QUOTE VERBATIM | By Block 97250, Satoshi had finished the work over which he
```

(Curly quotes and em-dashes survive HTML unescaping; if you get MISSING on a quote that
visibly matches, normalise `'` `"` `—` before concluding.)

### Check E — summary fidelity (the one that catches the archive's own words)
Checks A–D test that the archive quotes its sources faithfully. They do **not** test the
prose the archive writes *about* the source. Test every factual or interpretive clause
of "What happened" / "In plain English" against the article and grade it:

- **holds** — the article says it
- **overstated** — the article supports less
- **unsupported** — the article does not say it
- **contradicted** — the article or cited sources say something incompatible

### Check F — chain claims, against the chain itself
Any entry that names a block can be checked against a public block explorer API:

```bash
curl -sS https://mempool.space/api/block-height/97250
# 0000000000051607bb75bde078238fd652a72da21b049b438837ee159c67606c
curl -sS https://mempool.space/api/block/0000000000051607bb75bde078238fd652a72da21b049b438837ee159c67606c \
  | tr ',' '\n' | grep -E '"(id|height|timestamp)"'
# {"id":"0000000000051607bb75bde078238fd652a72da21b049b438837ee159c67606c"
# "height":97250
# "timestamp":1292189407
date -u -d @1292189407 '+%Y-%m-%d %H:%M:%S UTC'
# 2010-12-12 21:30:07 UTC
```

Block 97,250 is 2010-12-12 — the day of Satoshi's last public forum post. For contrast,
block 54,316 (`1272892627`) is 2010-05-03 13:17:07 UTC; the two are 42,934 blocks and
223 days apart.

### Check G — hash read-back
The only identity check. Re-fetch over HTTPS and compare:

```bash
curl -sS -o recheck-040.html https://alexanderwhitestone.com/stackchain/magazine-040/
sha256sum entry-040.html recheck-040.html
# a87a4385c4cc8bee96137fb23bb38a2f1bca580bae5f98f8c99499c2453cab62  entry-040.html
# a87a4385c4cc8bee96137fb23bb38a2f1bca580bae5f98f8c99499c2453cab62  recheck-040.html
cmp entry-040.html recheck-040.html && echo "cmp: byte-identical"
# cmp: byte-identical
```

---

## 5. Worked example: magazine-040, end to end

Entry: **The Genesis Block** — `https://alexanderwhitestone.com/stackchain/magazine-040/`
(badge `Documented`; source `https://www.stackchainmagazine.net/the-genesis-block/`).

The summary's closing clause reads:

> *"It closes with Satoshi resting on the 97,250th block, **a nod to the last block he
> mined**."*

Run Check D (quotes verbatim: 3/3 pass — above) and then Check E's clause test against
the fetched article:

```bash
# after the detag step in Check D, in the same script:
for term in ["mined", "last block", "mining", "97,250", "97250"]:
    print("COUNT", term, "=", len(re.findall(re.escape(term), text, flags=re.I)))
```

Measured against the article's detagged text (whitespace collapsed to one space):

```
COUNT mined = 0
COUNT last block = 0
COUNT mining = 0
COUNT 97,250 = 2
COUNT 97250 = 1
```

The article's own closing line is a Genesis 2:2 rewrite — *"By Block 97250, Satoshi had
finished the work over which he labored; so on the 97,250th Block he rested from all his
work."* — and the words *mined*, *last block* and *mining* appear **zero** times. The
block-97,250 date is checkable and true (Check F). The interpretive clause *"a nod to the
last block he mined"* is **unsupported**: the article never says it.

**Verdict on the real claim:**

| Check | Result | Verdict |
|---|---|---|
| A. Ledger count | 121 = 91+22+8 | holds |
| B. Entry self-description | badge `Documented`, date 2025-01-14 = JSON-LD | holds |
| C. Source liveness | article 200 / 137,324 B | holds |
| D. Quote fidelity | 3/3 blockquotes verbatim | holds |
| E. Summary clause, "a nod to the last block he mined" | article has `mined` 0 times, `last block` 0 times | **unsupported** |
| F. Block 97,250 = 2010-12-12 | mempool.space API, ts 1292189407 | holds |
| G. Hash read-back | sha256 + cmp byte-identical | holds |

So: the archive's *sourcing* of magazine-040 checks out completely; its *interpretive
gloss* does not. A check of this archive has to run both halves — quote fidelity alone
would have returned a clean bill on an entry whose summary asserts something the source
never says.

---

## 6. What you cannot check from outside

State these as limits, not failures:

- Whether the archive *holds* a receipt it says it holds (or doesn't) — that is an
  honesty claim; the archive names what it lacks ("No receipt is held for this entry",
  "Known gaps" on the index).
- X/Twitter-hosted sources: some 404, some need a login. An exhausted avenue is a
  recorded result.
- Anything in another party's working files, or any session/workflow claim — that is
  testimony, and it can only be graded as such.
- Edits to the live pages: the archive is a publication; wording changes are the
  publisher's, never a checker's.

## 7. One-page checklist

- [ ] Ledger count reproduces (121 = 91+22+8) with the matcher named
- [ ] Badge census reproduces (115/5/1, `unrecovered` = 0) from the index alone
- [ ] Entry badge + displayed date + JSON-LD date agree
- [ ] Every cited source answers, or the 404 is recorded as an exhausted avenue
- [ ] Every blockquote is verbatim in its cited source
- [ ] Every factual/interpretive clause of the summary is graded holds / overstated /
      unsupported / contradicted
- [ ] Chain claims checked against a block explorer API
- [ ] Final read-back: fetch over HTTPS, `sha256` + `cmp`
- [ ] Every number printed carries its matcher and its request

*Guide written 2026-10-08 by Merlin (Crucible lane, troupe-standup), queue item Q6.
All commands above were run before publication; outputs are real. Corrections welcome
by PR — identify the section, the command, and your measured output.*