A hash-chained, append-only research journal: 29,707 JSONL records in which each entry carries a SHA-256 entry_hash over its own body and a prev_hash linking it to its predecessor. The chain is independently verifiable from the file alone.

Author: Christopher Betances — catqualia.com
License: CC BY 4.0 (see LICENSE)
Language: English (record text); structured JSON in meta
Records: 29,707
Time span: 2026-08-16 03:51:13 UTC → 2026-08-19 05:27:40 UTC (3.1 days)
Verification script: verify_chain.py (in this directory)

Files

File	Bytes
`ledger.jsonl`	141,337,419
`verify_chain.py`	1,701
`README.md`, `LICENSE`	—

stat -c '%s %n' ledger.jsonl      # -> 141772491 ledger.jsonl
wc -l ledger.jsonl                # -> 29707 ledger.jsonl

Verification result

The chain verifies complete and unbroken over the published file.

python3 verify_chain.py ledger.jsonl

records parsed           : 29707
unparseable lines        : 0
genesis prev_hash == ''  : True

CHECK 1 — linkage (row[i].prev_hash == row[i-1].entry_hash)
  linkages checked       : 29706
  linkages OK            : 29706
  breaks                 : 0

CHECK 2 — content integrity (sha256 of body == entry_hash)
  records checked        : 29707
  entry_hash reproduced  : 29707
  mismatches             : 0

Result	Count
Records parsed	29,707
Unparseable lines	0
Linkage checks (rows with a predecessor)	29,706
Linkages that hold	29,706
Chain breaks	0
`entry_hash` recomputations	29,707
`entry_hash` values reproduced	29,707
Content mismatches	0

Row 0 is genesis and carries prev_hash: "", so 29,707 records yield 29,706 linkages.

What the two checks mean

CHECK 1 — linkage. row[i].prev_hash == row[i-1].entry_hash. A mismatch is a prev_hash fork: two writers finalized entries against the same tail hash, branching the chain.
CHECK 2 — content integrity. sha256(json.dumps(body, sort_keys=True, default=str)) recomputed over body = {kind, text, meta, ts, prev_hash} — every field except entry_hash itself — and compared against the recorded entry_hash. A mismatch means the record's content changed after it was written.

CHECK 1 alone cannot distinguish "the tail was rewritten" from "this record points at the wrong predecessor", which is why CHECK 2 is reported alongside it. A run in which CHECK 1 passes but CHECK 2 has not been run does not establish that no content was altered.

Method — so you can re-run it

verify_chain.py streams the file line by line and holds O(1) memory. It takes an optional path (default ledger.jsonl), plus --json for a machine-readable summary and --quiet to suppress the report. Exit code is 0 when both checks pass, 1 when either fails, 2 on a read error. The CHECK 2 recipe is not invented for the card: it is the one implemented by the ledger's own writer (_entry_body / _compute_entry_hash in the project's ledger.py).

python3 verify_chain.py ledger.jsonl            # human-readable report
python3 verify_chain.py ledger.jsonl --json     # includes kind counts
python3 verify_chain.py /path/to/other.jsonl    # verify any file in this format

Runtime on the published file: about 4 seconds.

Positive control: the verifier does detect breaks

A clean report from a verifier that cannot detect breaks is worthless, so the script was also run against the archive's pre-repair snapshot, which is known to contain three forks. It found exactly three, at the documented lines:

python3 verify_chain.py ledger.jsonl.pre-repair-20260816T043034

records parsed           : 10583
CHECK 1 — linkage
  linkages checked       : 10582
  linkages OK            : 10579
  breaks                 : 3
    ! {'line': 8035, 'issue': 'prev_hash_fork', ...}
    ! {'line': 8729, 'issue': 'prev_hash_fork', ...}
    ! {'line': 9045, 'issue': 'prev_hash_fork', ...}
CHECK 2 — content integrity
  entry_hash reproduced  : 10583
  mismatches             : 0

The three fork lines and both discrepancies match the project's own repair report. That snapshot file is not part of this dataset; it is referenced only as evidence that the verifier reports true breaks when breaks exist, and that the repair report is accurate.

History and limitation — read this before relying on the chain

The prev_hash forks above are historical. The archive records a repair with its own report:

Three forks, all prev_hash_fork, at lines 8035, 8729 and 9045.
Cause, per that report: concurrent unlocked appends. Two writers read the same tail hash, both finalized against it, and the kernel serialized the writes.
For each, the recorded entry_hash matched a recomputation from its recorded prev_hash; only prev_hash disagreed with the predecessor. No line was missing, truncated or content-edited. Zero entries were quarantined.
The fix was flock + fsync on tail-read and append; the repair re-chained the forks and wrote atomically via a temp file plus os.replace.
The pre-repair file was preserved byte-for-byte as ledger.jsonl.pre-repair-20260816T043034 (10,583 records, 51,556,937 bytes).
The report states 14,473 records at repair time, with chain_ok=true.

The limitation this creates. The published ledger.jsonl contains 29,707 records — 15,234 more than the 14,473 the report records at repair time — and it verifies end to end with zero breaks. But because the repair rewrote prev_hash and entry_hash for the affected records and re-chained everything after them, the three historical forks are not detectable from the published file. Its internally consistent chain is a statement about the file as it stands, not proof that it was never repaired. Anyone relying on the chain as tamper-evidence should note that CHECK 1 and CHECK 2 confirm the file is self-consistent; they do not by themselves establish that the history was never rewritten. The repair is disclosed here, and the pre-repair snapshot is the evidence for it. Both facts are reported rather than one alone.

Verified count for this section:

wc -l ledger.jsonl                                        # -> 29707
stat -c%s ledger.jsonl.pre-repair-20260816T043034         # -> 51556937 (source archive; not in this dataset)

Record schema

Six fields, in this order:

Field	Type	Description
`entry_hash`	string	SHA-256 hex over the record body
`kind`	string	record category (see below)
`meta`	object	structured payload; schema varies by `kind`
`prev_hash`	string	predecessor's `entry_hash`; `""` on the genesis record
`text`	string	one-line human-readable summary
`ts`	number	Unix epoch seconds (float)

`kind` distribution

Counted over the published file (python3 verify_chain.py ledger.jsonl --json):

`kind`	Records	Share
`kill`	28,435	95.7%
`calibration`	912	3.1%
`campaign`	301	1.0%
`null`	35	0.1%
`claim`	24	0.1%
Total	29,707	100%

python3 verify_chain.py ledger.jsonl --json | python3 -c "
import json,sys; d=json.load(sys.stdin); print(d['kind_counts'])"

The writer reserves a sixth kind, escape, which does not occur in this file. The distribution is highly skewed: four kinds account for under 5% of records.

What `text` contains

Short one-line summaries. Measured lengths:

Statistic	Characters
Min	32
Median	66
Mean	68.4
Max	190

29,311 records are under 100 characters; 396 are 100–499. The text field is a label, not a log line — all structure lives in meta. Examples, one per kind:

`kind`	`text`
`kill`	`certified post_critical: compliance+detachment certified; λ₂ Δ=0.0`
`kill`	`meowpiler necropolis: shellcode killed by {'NX': True, 'ASLR': True, 'PIE': False, 'canary': False}`
`calibration`	`scheduler precision on stub://fee-truncation-target: {...}`
`campaign`	`campaign ebdcc5b13e9587c2 closed`
`null`	`certified null after 60 attempts: ledger refuses post_critical certification without both evidence hashes`
`claim`	`mirage_wifi_bfi: synthetic BFI identification attack/defense module exercised with tamper-evident audit`

What `meta` contains

meta is a JSON object whose schema varies by kind. There are eight distinct key sets across the five kinds — calibration alone has three:

`kind`	Keys	Records
`kill`	`finding_id`, `notes`, `quadruple`, `remediation`, `verdict`	28,433
`kill`	`escape`, `reason`, `source`, `ts`	2
`calibration`	`campaign_id`, `i`, `worker`	576
`calibration`	`campaign`, `scheduler`	301
`calibration`	`held`	35
`campaign`	`domain`, `excluded`, `features`, `findings`, `fuzz`, `hebbian`, `rounds`, `scope`, `target`	296
`campaign`	`excluded`, `features`, `findings`, `fuzz`, `hebbian`, `rounds`, `target`	5
`null`	`attempts`, `claim`, `evidence`	35
`claim`	`detection_rate`, `module`, `tamper_test_ok`	24
		29,707

Field semantics, as far as the content states them:

kill (the dominant shape) — verdict is post_critical on all 28,433 and remediation is the empty string on all of them. quadruple holds nested certification structure: a campaign id plus a divergence object carrying compliance and detachment sub-objects with passed/failed index lists and an evidence_hash (SHA-256 hex). notes is a list of short strings. finding_id is 16 hex characters. This is the lab's certification machinery.
kill, genesis shape (2 records) — escape, reason, source (meowpiler/state/necropolis) and a null ts. This shape is why meta is not schema-stable even within a single kind.
campaign — a per-round summary: counts (rounds, findings, features, excluded), a fuzz object with crashes, divergences and per-operator reward/pick maps keyed by operator name (boundary_epsilon, category_ghost, contradiction_injection, ordering_flip, threshold_shift, type_substitution), and a hebbian object. 296 records add domain (8 values: generic, matching_engine, llm_serving, wms, scada_5g, ads, medical, web) and scope (the string owned on all of them); 5 omit both.
calibration — three shapes: concurrency-gate writer events (campaign_id, i, worker); scheduler precision probes (campaign id plus a scheduler object with n, mean_interval_s, std_s, max_s, busy_threshold_s); and ouroboros scheduler probes (held, a boolean).
null — a falsification record: the claim that was tested, the number of attempts, and an evidence object with a bypassed list.
claim — a module exercise record: module, detection_rate, tamper_test_ok.

Not determined from the content

What the campaign identifiers denote; the meaning of quadruple, hebbian, λ₂ and the divergence/compliance/detachment fields beyond their literal structure; what post_critical certifies; what meowpiler/state/necropolis is; whether the 29,707 records are complete relative to the campaign's actual history. No schema definition, data dictionary or code accompanies the ledger beyond verify_chain.py.

Content note

This ledger originates from an offensive-security simulation lab. Records are short structured summaries of internal simulation campaigns: certification outcomes, scheduler calibration statistics, falsification attempts, and per-round campaign summaries. Record text is 32–190 characters and names no third party.

Verified against the published file:

No URLs in text fields. 0 distinct, 0 total.
No IPv4 addresses in text fields. 0 distinct, 0 total.
No public domain names in text fields. 0 distinct, 0 total.
Every value of meta.target in the 301 campaign records is an internal lab file path or synthetic stub: domains/matching_engine.py, domains/llm_serving.py, domains/wms.py, domains/scada_5g.py, domains/ads.py, domains/medical.py, domains/web.py, <<TREES>>/93_wealth_machine/backtesting_engine.py, and stub://fee-truncation-target.
meta.scope is owned on all 296 records that carry it.

python3 - <<'PY'
import json, re
url = re.compile(r'https?://[^\s"\']+'); ip = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
dom = re.compile(r'\b[a-z0-9][a-z0-9-]{1,40}\.(?:com|net|org|gov|edu|io|co|ru|cn)\b')
u = i = d = 0
for line in open('ledger.jsonl', encoding='utf-8', errors='replace'):
    t = json.loads(line).get('text') or ''
    u += len(url.findall(t)); i += len(ip.findall(t)); d += len(dom.findall(t))
print('urls', u, 'ips', i, 'domains', d)     # -> urls 0 ips 0 domains 0
PY

No third-party targeting material or operational attack detail aimed at any external party was found in the published file. The text fields describe defensive and lab-internal certification outcomes; the one exploit-adjacent example present (shellcode killed by {'NX': True, 'ASLR': True, ...}) describes an exploit technique being blocked by mitigations inside a local simulator, and is a one-line summary with no target and no procedure.

What was deliberately excluded

The source directory also contained material that is not published here and is not part of this dataset: a weapon registry, a third-party targeting document, an exploits/ directory, and target lists. Those files are neither included nor referenced. Only ledger.jsonl, verify_chain.py, this card and LICENSE are published.

This note is a factual description of what the file contains and what was withheld. It is not a claim that every record has been individually audited: the automated checks above cover URLs, IPs, domain-shaped tokens and meta.target, and several records of each kind were read directly. A reader with a different threat model should apply their own filters.

Attribution

Betances, Christopher. Mirage Engine Campaign Ledger. catqualia.com, 2026.
Licensed under CC BY 4.0.

If you build on the verification result, cite it as: chain verified over 29,707 records with 0 linkage breaks and 29,707/29,707 entry_hash values reproduced, using verify_chain.py; three historical prev_hash forks disclosed in the archive's repair report as having been repaired before publication.

Downloads last month: 28

Total file size:

141 MB

You need to agree to share your contact information to access this dataset

Mirage Engine Campaign Ledger