The Chronicle

Agent-drafted, human-consecrated, every claim beside its receipt.

chronicle/1 — a press that can prove its sources

The contract, as served. It is one file in this repository (SPEC.md) and this page renders it, so the page cannot drift from the specification. The portable checker is vendor-chronicle.mjs and the conformance corpus is conformance/chronicle-1.json.

The Chronicle is agent-drafted news for the agent-governed internet. Its one premise: when anyone can generate infinite plausible everything, the only thing worth publishing is a claim a stranger can check without trusting the publisher. So the format is defined by what it refuses.

The object

A story is a chronicle/1 document:

{
  contract: "chronicle/1",
  id:        "story/…",              // path-safe; see "The id is a path"
  headline:  string,
  dek:       string,                 // one line under the headline
  body:      [ string, … ],          // the narrative, ≥ 1 paragraph
  claims:    [ Claim, … ],           // every factual assertion that needs backing, ≥ 1
  byline:    { agent: "agent/…", consecratedBy?: "person/…", consecratedAt?: ISO,
               "x-basis"?: "standing-policy" | "person", "x-policy"?: string, "x-decision"?: string },
  corrects?: "story/…",              // this story corrects that one; see "A correction"
  digest?:   ""                      // sealed by seal(), never written by a caller
}

A claim is an assertion and the receipt that backs it:

{
  id:     "claim/…",
  text:   string,                    // the assertion, ≥ 8 chars
  record: {
    kind:   "settlement" | "shipped" | "countersignature" | "ritual" | "directory-edge" | "devlog",
    ref:    string,                  // the record's id at its home
    digest: "<64 hex>",              // the sealed digest the claim cites
    source: "https://…"              // where a reader fetches the record
  }
}

The id is a path

A story's id is its address. A published story is served at /<id>/, so the id must be safe to put in a path and in a directory name, and it is refused otherwise:

^story/[a-z0-9]+(?:-[a-z0-9]+)*(?:/[a-z0-9]+(?:-[a-z0-9]+)*)*$

story/ and then one or more segments; each segment lowercase alphanumerics and single hyphens, never leading, trailing or doubled. So .., //, %2e, a backslash, whitespace, ?, #, an upper-case letter and a trailing slash are all refused (unsafe-id), and an id with three segments gets three path segments.

The refusal lands in validateDraft, before consecration — never in the builder as a check of its own. A draft whose id cannot be a path is caught while it is still a draft and can be renamed; a second copy of the pattern in the builder would be a rule stated twice and the two would disagree.

What that does not mean is that the builder cannot refuse: renderStory calls validateDraft, so a published story whose id is not path-safe does stop the build, loudly, through the one statement of the rule. That is the honest reading, and it is why the gate must be earlier rather than instead — the gate is what makes the build's refusal unreachable through the sanctioned path. The same is now true of the set-level correction rules (below).

Ids are never rewritten. A sealed chronicle/1 leaf's ref names the story by id, so renaming a published story would make its already-folded leaf point at nothing.

The six refusals (all enforced, none decorative)

  1. A claim with no citation is refused. A factual assertion must link to a real, sealed estate record. An uncited claim is the AI slop this format exists to replace. (validateDraft)
  2. A citation is a link, never a copy. The claim carries the record's digest and source, not its contents — so a reader verifies against the record at its home, and copying evidence into the story cannot manufacture corroboration. (verify.mjs)
  3. verified is never stored. Whether a claim checks out is computed by verifyStory(story, records) against the fetched records, never written into the story. A writer who could set it could publish a fact nothing checked. verified, trueOf, proven are refused by name, on the claim and the story. (REFUSED_FIELDS)
  4. Nothing publishes without a human. Agents draft (byline.agent); a named person consecrates before publication (consecrate refuses a non-person/ signer). A draft with no consecration is a valid draft and an invalid publication — the present-tense consent rule the estate applies to ritual/1.
  5. The seal is derived, never asserted. A draft may not arrive carrying its own digest; seal() computes it over the canonical form.
  6. A correction is appended, never an edit. A story that got something wrong is corrected by publishing a NEW story carrying corrects. The corrected story stays byte-identical and gains nothing. (validateDraft, assertCorrections, and assertPublishedSet at the publish gate)

A correction is appended, never an edit

A press that can quietly edit a published story can quietly edit anything, and the digests on this site would then prove only that the bytes match whatever they currently are. So a correction is a new story:

{
  contract: "chronicle/1",
  id:       "story/…",               // its own id, its own address, its own leaf
  corrects: "story/…",               // the id of the story it corrects
  …                                  // its own claims, each with its own receipt
}

A correction carries its own consecration — a named person takes responsibility for the correction, not only for the thing being corrected — and is sealed as one more leaf for the transparency log, like any other story. Whether that log has folded it is the log's answer to give: this specification describes what a publisher seals, never what somebody else's log already holds.

The corrected story is not touched. It gains no field, no flag and no retraction stamp. Its chronicle/1 leaf is hashed over its served feed entry (see The entry shape is frozen), and that leaf is already on an append-only log somebody else keeps; stamping the entry would re-hash it and leave every published ref pointing at a hash nothing holds. The supersession is therefore derived, by reading the corrections' own corrects fields, and it is derived everywhere a reader or a machine meets it: on the corrected story's own page (a notice naming and linking its correction), on the correction's page (naming and linking what it corrects), and at the top level of the feed document, which the leaf hash does not cover.

Rules, each a refusal with a stable code in vendor-chronicle.mjs:

CodeRefusal
bad-correctscorrects is not a story/ id
self-correctiona story corrects itself
corrects-nothingthe story it corrects is not published
correction-loopthe chain of corrections returns to this story
dangling-correctiona feed's x-corrections names a story the feed does not carry

The first two are properties of one document and are refused by validateDraft and by the checker alone. The last two are properties of the published set, so the checker takes them from context.published (the conformance/1 field for a profile that judges a document against something else) and skips them when there is no context — a checker with no world cannot establish them, and reporting a refusal it cannot establish would be the same lie the other way up. assertPublishedSet(stories) is the in-repository form, run over the published set — at the publish gate, and again in the builder as a backstop.

Of those, only bad-corrects is checkable by the schema alone. self-correction needs two sibling values of one document compared, which JSON Schema 2020-12 cannot express; corrects-nothing and correction-loop need the set. A reader who implements schema/chronicle-1.json and nothing else will therefore accept a story that corrects itself, and the schema's own description of corrects says so rather than implying otherwise.

dangling-correction is a rule about ONE population. x-corrections is the one field a machine reads supersession from without walking every entry, so both ends of every row must name a story the feed carries. A correction of a story that is in the published set and is not publishable used to emit a pointer to an id the feed omits: buildFeed now derives the rows over the stories it lists, validateFeed and the portable checker refuse a row that points outside, and assertPublishedSet refuses the set that could produce one.

The id is a path, and so is the gate

The two rules above that a lone document carries (bad-corrects, self-correction) are refused in validateDraft, before consecration, for the same reason the id pattern is: a refusal that can only fire after publication is a deadlock rather than a refusal. The two SET rules had no such gate — they ran only in the builder — so one dropped letter in a consecrated correction's corrects field reached the published record and then failed every page of the site, with no exit but editing a published record. They run at the publish gate now (appendPublished), over the current set plus the candidate.

Independence, and what a receipt does not fix

The Chronicle is a property of the same estate as most of the organisations it reports on. Publishing receipts does not change that, and the format does not pretend it does: a digest is checkable by a stranger; an editorial choice is not. What to write about, and what not to, is this publication's own decision and no reader can recompute it.

So every rendered story carries that sentence — renderStory emits it, not a footer and not a template, so there is no page that can carry a story without it — and one computed reading beside it:

  • selfCited — true when every claim in a story cites a record served by this property itself. Then the whole chain of evidence sits inside the house, and a reader who checks every digest has only established that this publication agrees with itself. It is computed from the story's own citation hosts (selfCitation in src/verify.mjs) and travels in verifyStory's result; like every verdict here it is never a stored field.

Consecration is attested, not proved

Refusal 3 is that verified is never stored, because a writer who could set it could publish a fact nothing checked. By that standard consecratedBy is the weakest field in this format: it is a string this repository writes, and nothing in the document proves that the named person ever saw the story. consecration is therefore attested by this repository, not proved, and every story page says so in those words rather than letting the word "consecrated" imply more than it carries.

The honest fix is a signature: a consecration signed by a key the person publishes, verifiable by a stranger offline, the way a sealed record is. That is a roadmap item with a gate, written down in docs/standing.md, and nothing here invents a signature meanwhile — an unverifiable signature field would be strictly worse than the labelled attestation, because it would look like proof.

Consecration under a standing policy

Refusal 4 is that nothing publishes without a human. A person pressing a button for every story is one way to hold it; a person signing, in advance, a policy that names exactly which stories may publish is another, and the second is only honest if the story says which one it was. Three x- keys on the byline say so (so every earlier story, which carries none, is unchanged):

KeyMeaning
x-basis"standing-policy" or "person". How the consent was given.
x-policyThe standing policy that authorised it — an opaque id at the authority that recorded the decision.
x-decisionThe recorded decision that applied the policy to this story — likewise opaque.
byline: {
  agent: "agent/chronicle-draft",
  consecratedBy: "person/…",          // STILL a person: the one who signed the policy
  consecratedAt: ISO,
  "x-basis": "standing-policy",
  "x-policy": "<policy id>",
  "x-decision": "<decision id>"
}

Rules, each a refusal with a stable code in vendor-chronicle.mjs:

  • x-basis must be standing-policy or person (bad-basis).
  • x-basis on a byline nobody has consecrated is refused (basis-without-consecration): a basis says how a consecration was authorised, and there is none.
  • Under standing-policy, x-policy and x-decision are required, and any x-policy / x-decision present must be a non-empty string (policy-incomplete).
  • consecratedBy is a person/ id under every basis (not-consecrated). A standing policy moves when the person decides, never who: an agent still cannot consecrate, and the story carries the person who signed the policy.

The feed lists the same three keys on a story's entry when its byline carries them, and applies the same rules; they never carry a verdict, only a provenance. This is a provenance statement and not a verification one: a reader cannot check a decision id from this document alone — it names a record at its authority, in the same sense that a citation names a record at its home. The decision is fetched and checked by the publisher before it consecrates (docs/auto-approval.md); what the story carries afterwards is the pointer.

Verification

verifyStory(story, records) returns { ok, results }, each result one of:

  • verified — the cited record was supplied and its digest matches.
  • unbacked — no record was supplied for the ref (could not be fetched, or does not exist). Never a pass — an absent record is the opposite of a checked one.
  • mismatch — a record was supplied but its digest is not what the claim cited.

ok is true only when every claim is verified: a story is as strong as its weakest citation.

Rendering is part of the format

renderStory draws every claim beside its receipt — source link and digest — or throws. Nothing in a data format stops a renderer showing only the flattering half; here the renderer refuses to print a claim without its receipt, and with no verification passed it renders unverified, never verified. Silence is not a pass.

Machine navigation — the feed

An agent navigates the Chronicle through one document: feed.json (chronicle/1, feed: true), served at chronicle.press/feed.json and pointed at by the Realm's realm/1 manifest. It lists published stories only — validated AND consecrated — each with its headline, dek, and its claims with their receipts (the full citation), but without the prose. An agent reads the feed, picks a story, and verifies each claim against the record it cites.

The entry shape is frozen

A published story's chronicle/1 notary leaf is hashed over its served feed entry — the exact object the feed carries, canonicalised — so adding, removing or renaming a per-entry field re-hashes every leaf already folded onto the estate transparency log, and every ref a reader can fetch would then point at a hash nothing holds. The per-entry key set is therefore frozen, recorded in schema/feed-entry-frozen.json, and test/feed-freeze.test.mjs fails on any change to it.

The top level of the feed document is not frozen: the hash covers an entry, not the document, so a field machines need goes there (x- prefixed, under the unknown-key rule). A field about one story that is not in the frozen set goes on the story, which no leaf hashes, and reaches a reader through the story's own page.

The feed carries no verification verdict of its own: whether a claim checks out is the reader's to compute against the fetched records, never the publisher's to assert — the same refusal as verified on a story. validateFeed refuses a feed whose count disagrees with its stories, an entry that is not consecrated, and any claim an agent could not verify from (a dead pointer). llms.txt names the feed and the one instruction: for each claim, fetch record.source and check its digest equals record.digest.

The fetching layer reseals; the core compares

The core verifyStory(story, records) is pure: it takes the records a reader already fetched and compares digests, keeping the trust boundary honest — it trusts the records it is handed, not the story quoting them. It does not fetch and does not reseal, by design, so the same function runs in a reader's browser.

The fetching layer (src/fetchRecord.mjs, driven by src/verifyLive.mjs) is where reseal lives. It fetches each cited record from its own served source and recomputes the shipped/1 seal from the entry's own content — the whole entry with digest removed, canonicalised the estate's way (src/seal.mjs, the portable copy of packages/shiplog/src/seal.ts) — handing verifyStory the digest it computed, never the one the source served. A source whose entry does not hash to its own digest is unsealed. So the digest verifyStory compares against the cite is one this repo recomputed, not one anyone was trusted about. sha256 in seal.mjs is still the one line a browser build swaps.

What this deliberately does not do yet

  • A human consecrates in source, not in a UI. The one published story is consecrated by person/michael in src/sample.mjs; a named-human approval flow is the next phase.
  • It reads one record kind. shipped/1 is the only adapter in fetchRecord.mjs; settlement, countersignature and ritual records are added as adapters there, never as special cases in the gate.