Structure

Most sessions are linear: each message, call or result follows the previous one. ASR requires no pointers for linear sessions and marks the exceptions explicitly: a rewind record when the source records a rewind event, branchesFrom at a real branch point in a source that stores a tree, and heads when the current leaf is not the last record.

Order

Records are ordered by seq (ASR-014). Order is observation order, not context order: a permission decision, a usage report or a file change can sit between two messages without being part of the conversation.

Context-participating and audit-only records

ASR-350 The context-participating record types are exactly message, tool_call, tool_result and compaction. Every other type, including vendor types, is audit-only. Audit-only records are facts about the session. They are never the context predecessor of another record. ASR-351 Structural refs and the branch_summary exception follow the reference-resolution table. A resolved structural target MUST be a context-participating record.

Nodes and revisions

The structure is built over nodes. A node is the revision chain of a context-participating record (see Missing data and revisions): its position is the seq of the chain’s first record, and its content is the chain’s latest revision. A record ID or entity ref resolves to the node containing the record or chain it names. ASR-352 A superseding record is not a new node: it takes the position of the chain it belongs to. A superseding record MUST have the same type and the same entity key as the record it supersedes. It MUST have the same branchesFrom, unless it is a marked rewrite: a record with assembly.mode: "rewrite", which the source wrote again under a new native ID with a marker naming the record it replaces (OpenClaw’s supersedesEntryId). A marked rewrite MAY have a different branchesFrom, which then applies to the whole chain (see Implicit predecessor). OpenClaw rewrites part of a transcript (to shorten a tool result, or after an edit) by writing the affected entries again at the end, each with a new ID and a pointer to the entry it replaces. The registry maps each rewritten entry to the entity of the first entry in its chain, so the rewrite is a revision, and the rewritten entry may hang from a different native parent.

{
  "type": "message",
  "seq": 30,
  "id": "r30",
  "messageId": "c4d5e6f7",
  "role": "user",
  "origin": "prompt",
  "content": [
    {"type": "text", "text": "Move the dentist to Thursday at 3."}
  ]
}

{
  "type": "message",
  "seq": 41,
  "id": "r41",
  "supersedes": "r30",
  "assembly": {"mode": "rewrite", "sourceIds": ["9a8b7c6d"]},
  "messageId": "c4d5e6f7",
  "role": "user",
  "origin": "prompt",
  "content": [
    {"type": "text", "text": "Move the dentist to Thursday at 4."}
  ]
}

These records come from an OpenClaw session in which the user edited a message. OpenClaw wrote the message again as entry 9a8b7c6d, pointing to entry c4d5e6f7; the revision keeps the first entry’s ID as its messageId. The path index of a node on a path is its zero-based position in that path.

Implicit predecessor

The predecessor of a node is computed from the first record of its chain, r. Let b be the branchesFrom of the chain’s latest marked rewrite, if the chain has one; otherwise b is the branchesFrom of r, if any.

If b is present:
1. {"record": <ref>}: the predecessor is the node the ref resolves to.
2. {"record": null}: the predecessor is START (the node begins a new path with an empty context).
3. {"state": "unknown"}: the predecessor is UNKNOWN.
Otherwise, scan the stream backwards from r (records with lower seq), ignoring superseding records:
1. On reaching the first record of a context-participating chain m, the predecessor is m’s node.
2. On reaching a rewind record w, the predecessor is the node w.to resolves to, or START if w.to is null.
3. On passing a gap record, or a malformed line (ASR-009), record a gap marker on the edge into r’s node and continue scanning.
4. On reaching the start of the stream, the predecessor is START.

ASR-353 Readers MUST compute predecessors exactly as above.

`rewind`

A rewind records that the source moved the conversation back to an earlier point: a user rewind, an edit of an earlier prompt, a retry, or a rollback of turns. Records after the rewind continue from its target. Records between the target and the rewind stay in the stream as an abandoned branch.

{
  "type": "rewind",
  "seq": 64,
  "id": "r64",
  "ts": "2026-10-26T14:12:40.003Z",
  "to": "r55",
  "reason": "user_rewind",
  "restoreRequested": true
}

Field	Type	Req	Meaning
`to`	Ref or null	yes	The last record that remains in the context after the rewind. `null` rewinds to an empty context.
`reason`	string, open	yes	`user_rewind`, `edit`, `retry`, `rollback` or `other`.
`restoreRequested`	boolean	no	Whether restoration of files was requested along with the rewind.

ASR-354 A rewind MUST contain to and reason. ASR-355 to MUST name the last record that remains. A converter for a source whose rewind names the first removed item (for example a rewind “to” a message that is itself deleted) MUST map it to that item’s predecessor, or to null if it has none. ASR-356 to follows the reference-resolution table. A non-null target MUST be context-participating and have a lower seq. A rewind MUST NOT carry supersedes and MUST NOT be superseded. ASR-357 File restoration is a separate fact. restoreRequested records the request. Observed results of a restoration MUST be recorded as file_change records with cause: {"restore": <ref to the rewind>}, including files the restoration skipped (with status: "skipped") when the source records them.

`branchesFrom`

branchesFrom marks a real branch point in a source that stores the conversation as a tree without rewind events. It names the record’s actual predecessor.

{
  "type": "message",
  "seq": 90,
  "id": "r90",
  "branchesFrom": {"record": "r60"},
  "messageId": "9a0b7c1d-3e2f-4a65-8b9c-0d1e2f3a4b5c",
  "role": "user",
  "author": "human",
  "origin": "prompt",
  "content": [
    {"type": "text", "text": "Fix it without changing the public API."}
  ]
}

Form	Meaning
`{"record": <ref>}`	The predecessor is the referenced record.
`{"record": null}`	The record starts a new path from an empty context (for example an edit of the first prompt).
`{"state": "unknown"}`	The source shows that the record does not follow its implicit predecessor, but its real predecessor cannot be established.

ASR-358 branchesFrom MUST contain exactly one of record or state, and MUST appear only on context-participating records. state MUST be unknown. A record ref follows the reference-resolution table; its target MUST have a lower seq. ASR-359 A producer MUST NOT write branchesFrom when the record’s predecessor is its implicit predecessor. ASR-360 When the source shows a branch but the predecessor cannot be established, the producer MUST write {"state": "unknown"} and MUST NOT invent an edge.

The mechanical-sibling rule

Several harnesses store messages as a tree with parent pointers: Claude Code (uuid/parentUuid), Pi (id/parentId), OpenHands (parent_id), Devin (parent_node_id), Qwen Code. In these trees most sibling sets are mechanical: parallel tool calls, one response split across several native records, attachments written concurrently, retries after an error. Only a minority are real branches, where an earlier point was resumed and later content abandoned. Copying parent pointers verbatim produces branches that do not exist; ignoring them loses real rewinds. Every converter of a tree-stored source applies the rule below, so that two converters produce the same structure from the same file.

Inputs

For the agent’s native format, its registry entry names:

the native parent of a native record: the field that points to its context predecessor, and any documented logical-parent field used where the native parent is intentionally empty (for example a compaction boundary);
the response key: the field that identifies one model response, shared by all native records of that response;
which native records are injected, failed, or not context-participating.

A native unit is one native record. When one native record maps to several ASR context-participating records (for example a text block and a tool call), those records form one unit: they are linear among themselves in seq order, and only the unit’s first record is subject to the rule. The unit’s attachment point is its last ASR record: native children of the unit attach after it. For an ASR record x, rk(x) is its response key: the native response key for model output, the response key of its paired tool_call for a tool_result, and none otherwise. x is injected when it is a message with author harness or hook, or origin injected, memory, retrieval or notice. x is a failed attempt when it is an assistant message with status error or interrupted.

Rule

Process native units in observation order. Keep the tip T: the attachment point of the most recently placed unit, initially START. The current path is the active path ending at T. For each unit u with first ASR record r:

Resolve the parent. Let q be the native parent of u. If q names a native record that is not mapped to a context-participating record, replace q by that record’s own native parent, repeatedly. If the native parent is empty and the registry documents a logical parent for this record, use it.
No parent. If q is empty: if T is START, r is linear; otherwise write branchesFrom: {"record": null}. Go to step 7.
Unknown parent. If q names a record that cannot be found in the source, write branchesFrom: {"state": "unknown"}. Go to step 7.
Let p be the attachment point of the unit q names. Linear. If p is T, r is linear. Go to step 7.
Off-path parent. If p is not on the current path, write branchesFrom: {"record": <id of p>}. Go to step 7.
Displaced segment. Let S be the nodes on the current path after p, up to and including T. S is mechanical for u when u’s first record r is injected, or every node s in S satisfies at least one of:
- M1 (same response): rk(s) is defined and equals rk(p) or rk(r);
- M2 (injected): s is injected;
- M3 (failed attempt): s is a failed attempt.
If S is mechanical, r is linear. Otherwise write branchesFrom: {"record": <id of p>}.
Set T to u’s attachment point.

ASR-361 A converter of a tree-stored source MUST determine branchesFrom exactly by this rule, using the fields the agent’s registry entry names. ASR-362 A converter MUST NOT use content similarity, timestamps or file positions other than observation order to decide whether a sibling is mechanical. Under this rule a regeneration of a complete response (a new response to the same prompt, after the previous response was complete) is a real branch: the earlier response left the context. An automatic retry after a failed attempt is mechanical.

Worked example

Native records of a tree-stored source, in file order (seq = line × 10):

Line	Native ID	Native parent	Content	Response key	ASR records
1	u1	—	user prompt	—	`r10` message
2	a1	u1	text, then tool use T1	X	`r20` message, `r21` tool_call T1
3	a2	a1	tool use T2	X	`r30` tool_call T2
4	t1	a1	result of T1	(X)	`r40` tool_result
5	t2	t1	result of T2	(X)	`r50` tool_result
6	a3	t2	text	Y	`r60` message
7	u2	a3	user prompt	—	`r70` message
8	a4	u2	text	Z	`r80` message
9	u2b	a3	edited user prompt	—	`r90` message
10	a5	u2b	text	W	`r100` message

r30: parent a1 maps to attachment point r21, which is T: linear.
r40: parent a1 maps to r21, but T is r30. S = [r30]; rk(r30) = X = rk(r21): mechanical (M1), linear.
r50, r60, r70, r80: each parent is T: linear.
r90: parent a3 maps to r60; T is r80. S = [r70, r80]; r70 is a human prompt with no response key: not mechanical. r90 gets branchesFrom: {"record": "r60"}.
r100: linear.

The active path from the default head r100 is r10, r20, r21, r30, r40, r50, r60, r90, r100. It keeps the second tool call r30, which the native tree leaves on a dead-end branch even though the model saw it. r70 and r80 are an abandoned branch.

Heads

A head is a leaf from which an active path is followed. session_info.heads lists the current heads; the first is the primary head. Multiple heads represent concurrent lanes or a forest (Pi lanes, Devin message forests). The default head is the predecessor that a context-participating record appended at the end of the stream would have: apply the implicit-predecessor scan from the end of the stream. If the stream ends with a rewind, the default head is the rewind’s target. ASR-363 Effective heads are the non-empty session_info.heads value, or the default head when that value is empty or absent. Readers MUST use the primary head when showing one path. A null first element means the source explicitly selects no primary head; this is neither START nor an unknown head. In that case readers MUST show no default path and MUST NOT promote another lane head. A non-null native head whose target is missing remains unknown: retain its native evidence and use the existing gap or audit fallback. ASR-364 A producer whose source names a current leaf (Claude Code’s last-prompt.leafUuid, Pi’s leaf, OpenHands leaf_event_id, Devin’s main_chain_id) that differs from the default head MUST write session_info.heads, and MUST write a new value whenever it changes.

Active path

ACTIVE-PATH(stream, head):
 1. If head is START, return [].
 2. path ← []; n ← the node head resolves to; seen ← {}.
 3. Loop:
    a. If n ∈ seen: report a cycle; the stream is invalid; stop.
    b. Add n to seen. Prepend n to path.
    c. Prepend, in order, the gap markers recorded on the edge into n.
    d. p ← predecessor(n).
    e. If p is UNKNOWN: prepend an unknown-predecessor marker; exit the loop.
    f. If p is START: exit the loop.
    g. n ← p.
 4. If the session's lineage.inherits.mode is "referenced", prepend an
    inherited-context marker naming inherits.from and inherits.throughId
    or inherits.throughOrdinal.
 5. Return path.

ASR-365 Readers MUST compute active paths with ACTIVE-PATH. ASR-366 A stream in which following predecessors revisits a node is invalid. Readers MUST report it and MUST NOT loop. ASR-367 Records not on the active path remain audit facts. Consumers computing usage, cost, file changes or VCS actions for a session MUST include records that are off the active path. Commits, costs and network effects on abandoned branches still happened.

Context view

The context view applies compactions to the active path and drops entries the model did not see. Rewinds are already reflected in the active path. Each entry of the view has a path index: a node’s index in the active path, or, for a compaction summary, the index of its insertion point. Entries are kept in order of path index; entries with the same index stay in insertion order.

CONTEXT-VIEW(stream, head):
 1. P ← ACTIVE-PATH(stream, head).
 2. V ← one entry per item of P, in order: node entries for nodes, and the
    markers unchanged.
 3. For each compaction node c in P, in path order:
    a. If c's latest revision has a status and it is not "completed",
       remove c's entry from V and continue with the next compaction.
    b. Determine R, the entries c replaces, among the entries of V that
       precede c's entry:
       - replaces.throughId = t: every entry whose path index is at most
         the index of t's node. If keptFromId = k, exclude every entry
         whose path index is at least the index of k's node.
       - replaces.ids: every node entry whose node one of the refs resolves
         to, and the summary entry of every compaction node a ref resolves
         to. Refs that resolve to no entry of V are ignored.
       - replaces.state = "unknown": R is empty.
    c. Remove the entries in R, and c's own entry, from V.
    d. Determine the insertion index x:
       - insertAt.afterId = null: before the first context entry;
       - insertAt.afterId = a: just after the index of a's node;
       - insertAt.beforeId = b: just before the index of b's node;
       - otherwise, if R is not empty: the smallest path index in R;
       - otherwise: the index of c.
    e. If replaces.state is "unknown", insert an unknown-replacement
       marker naming c at x.
    f. For each entry of c's retains, in order, insert a retained entry
       for the node its ref resolves to at x, with the entry's capture.
    g. If c has a summary or opaque content, insert a summary entry for c
       at x, after the entries inserted in steps e and f.
 4. Remove every node entry whose latest revision is a message with
    audience "user" or status "withdrawn", or a tool_call with
    requestedBy "code" or with parentCallId, and every node entry of a
    tool_result paired with such a call.
 5. Return V.

Step 4 leaves out calls that a program made (a code-mode cell running commands): their input and output reached the program, and the model saw only the result of the call that ran the program. Entries inserted at the same index stay in insertion order, so a compaction’s retained entries come before its summary. A retained entry stands for the record as the source carried it into the new context; when its capture is truncated, the model saw a shortened copy. A compaction whose replaced range is unknown leaves the earlier entries in the view, after an unknown-replacement marker: the view then shows more than the model may have had, and a reader must say so. When an inherited-context marker names a parent whose stream is available, a reader MAY replace the marker with the parent’s context view at the inherited point, labeling those entries as inherited. ASR-368 Readers MUST compute context views with CONTEXT-VIEW. Applying a compaction that has no status does not mean that the source reported it as completed. ASR-369 The context view is derived from the recorded evidence and does not prove what the model’s actual request contained. Readers MUST NOT present it as the exact request. Where the source recorded the request, the request is in inference.context (see Inference), and ASR-333 says when it is exact. Resolving every emitted retains ref does not establish an exact reconstruction: the shortened content, injected instructions and the order in which they were combined may be missing. Preserve the full native replacement checkpoint and declare structural fidelity loss when those facts are not represented.

`compaction`

A compaction records that the source replaced part of the model’s context: by a summary, by pruning or masking entries, by an opaque provider-native state, by a reset, or by inserting the summary of an abandoned branch. The new context can also carry some earlier records forward (Codex keeps a list of earlier user messages). A compaction summary is never a message.

{
  "type": "compaction",
  "seq": 120,
  "id": "r120",
  "ts": "2026-10-26T14:44:02.731Z",
  "compactionId": "cmp_7",
  "kind": "summary",
  "trigger": "auto",
  "summary": [
    {
      "type": "text",
      "text": "Earlier: fixed parse_empty by returning an empty list; tests pass; commit 8e2f4a6 on main."
    }
  ],
  "replaces": {"throughId": "r118"},
  "insertAt": {"afterId": "r111"},
  "keptFromId": "r112",
  "tokens": {"before": 182000, "after": 21000},
  "historyRetained": true
}

{
  "type": "compaction",
  "seq": 233,
  "id": "r233",
  "compactionId": "cond_4",
  "idSource": "derived",
  "kind": "prune",
  "replaces": {"ids": ["r141", "r142", "r150"]},
  "insertAt": {"afterId": "r140"},
  "summary": [
    {"type": "text", "text": "Removed three large directory listings."}
  ]
}

In the first example, records up to r111 are replaced, records r112 to r118 are kept, and the summary is placed between them. Two other forms occur. Codex replaces the whole context with a list of retained earlier messages, some shortened, followed by a summary or an encrypted state. T3 Code records that a compaction happened, with token counts, but not what it replaced:

{
  "type": "compaction",
  "seq": 512,
  "id": "r512",
  "ts": "2026-10-26T10:44:19.881Z",
  "compactionId": "019a3c55-1f0e-7d42-9b6a-3e8c2d1f0a57",
  "kind": "summary",
  "trigger": "auto",
  "status": "completed",
  "replaces": {"throughId": "r509"},
  "retains": [{"ref": "r5"}, {"ref": "r212", "capture": "truncated"}],
  "summary": [
    {
      "type": "text",
      "text": "Fixed parse_empty; the CLI entry point still needs the same check."
    }
  ],
  "durationMs": 8120
}

{
  "type": "compaction",
  "seq": 77,
  "id": "r77",
  "ts": "2026-10-26T19:02:44.310Z",
  "compactionId": "turn-item:provider:claudeAgent:native-item:cmp-41",
  "kind": "summary",
  "trigger": "auto",
  "reason": "beforeCacheExpires",
  "replaces": {"state": "unknown"},
  "tokens": {"before": 161000, "after": 24000},
  "capture": {"summary": {"state": "absent"}}
}

Field	Type	Req	Meaning
`compactionId`	string	yes	Native compaction ID, or a derived one.
`kind`	string, open	yes	`summary`, `prune`, `mask`, `provider_native`, `reset` or `branch_summary` (below).
`trigger`	string, open	no	`auto`, `manual` or `model` (the model asked for a new context, as with Codex’s `new_context` tool).
`reason`	native string	no	Why the source compacted, as it records it (OpenClaw’s reset reasons `daily` or `idle`; T3 Code’s `beforeCacheExpires`).
`status`	string, open	no	`completed`, `failed`, `cancelled` or `in_progress` (values from the Agent Client Protocol, or ACP). If absent, the source recorded the compaction without a status.
`summary`	ContentPart[]	no	The readable summary, when there is one.
`opaque`	object	no	`{format?, data? \| blob?}`: provider-native compacted state that cannot be read.
`replaces`	object	yes	`{throughId}` (a range), `{ids}` (a set of refs), or `{"state": "unknown"}` (the source did not record what was replaced).
`keptFromId`	Ref	no	With `throughId`: the first record of the portion kept at the end of the range.
`insertAt`	object	no	`{afterId}` or `{beforeId}`: where the summary enters the context, when the source records it.
`retains`	array	no	`[{ref, capture?}]`: earlier records carried into the new context, in order. `capture` is `full` or `truncated` (the carried copy was shortened).
`tokens`	object	no	`{before?, after?}`: context size before and after, as recorded.
`durationMs`	number	no	How long the compaction took, as the source records it.
`historyRetained`	boolean	no	`false` when the source destroyed the replaced history.

Capture state key: summary. Kinds:

Kind	Meaning
`summary`	A model-written summary replaces the range or set.
`prune`	Entries are removed from the context, with no summary or with a short note.
`mask`	Entries’ content is replaced by placeholders. A mask with a separate placeholder per entry is recorded as one compaction per entry.
`provider_native`	The provider returned compacted state as an opaque blob (`opaque`), possibly with no readable summary.
`reset`	The context was cleared.
`branch_summary`	A summary of an abandoned branch is inserted into the current path. `replaces.ids` names the branch’s records, which are off the path; the branch itself is untouched.

ASR-370 A compaction MUST contain compactionId, kind and replaces. ASR-371 replaces MUST contain exactly one of throughId (a ref), ids (an array of refs, possibly empty) or state (the value unknown). insertAt, when present, MUST contain exactly one of afterId or beforeId. afterId: null places the summary at START, even if no entry remains. beforeId is a non-null ref. keptFromId MUST appear only with throughId. Each entry of retains MUST contain ref, and its capture, when present, MUST be full or truncated. ASR-372 replaces.throughId, keptFromId, insertAt and retains follow the reference-resolution table. Non-null targets MUST have a lower seq and lie on the compaction’s own active path (the path ending at the compaction’s predecessor). The node keptFromId names MUST NOT come after the node throughId names on that path. ASR-373 A compaction summary MUST NOT be emitted as a message, and indexers MUST NOT index it as user-authored text. A converter for a source that stores the summary as a message (for example a user-role record flagged as a compaction summary) folds it into the compaction. ASR-374 A branch_summary MUST NOT erase its source branch: the summarized records stay in the stream, and producers MUST NOT emit tombstone records for them because of the summary. ASR-375 When the source destroyed the replaced history, the compaction MUST have historyRetained: false, and the producer MUST emit a gap record for the destroyed history. ASR-377 When the source records a compaction without recording what it replaced, the producer MUST write replaces: {"state": "unknown"} and MUST NOT guess a range. ASR-378 retains MUST come from a list of carried records that the source keeps. A producer MUST set capture: "truncated" on a retained entry when the source records that the carried copy was shortened (Codex retained_source.complete: false). replaces.ids covers sources whose compaction applies to individual entries: OpenHands’ forgotten event IDs, Goose messages marked invisible to the agent, pruned tool outputs.

Algorithm output for fixtures

Conformance fixtures compare active paths and context views as JSON arrays. ASR-376 An implementation that reports an active path or context view for conformance testing MUST use these entries:

Entry	Meaning
`{"id": "<record id>"}`	A node, named by the first record of its chain. Add `"rev": "<record id>"` when the latest revision is a different record.
`{"summary": "<record id>"}`	A compaction summary (context view only), named by the compaction chain’s first record, with `rev` as above.
`{"gap": "<record id>"}`	A gap marker from a `gap` record.
`{"gap": "malformed", "line": <n>}`	A gap marker from a malformed line (1-based line number).
`{"unresolvedRef": "<ref>", "status": "unresolved or ambiguous or wrong_type", "exact": false}`	A required reference could not identify its target (ASR-080).
`{"unknownPredecessor": true}`	The path continues from an unknown predecessor.
`{"unknownReplacement": "<record id>"}`	A compaction, named by its chain’s first record, replaced an unknown part of the context (context view only).
`{"retained": "<record id>", "by": "<record id>"}`	A record carried forward by a compaction (context view only): the retained node, named by its chain’s first record, and the compaction. Add `"capture": "truncated"` when the carried copy was shortened.
`{"inherited": {"session": "<SessionRef>", "throughId"?: "<ref>", "throughOrdinal"?: <n>}}`	Inherited context that is referenced, not present.

Context view of the worked example above, which has no compactions:

[
  {"id": "r10"},
  {"id": "r20"},
  {"id": "r21"},
  {"id": "r30"},
  {"id": "r40"},
  {"id": "r50"},
  {"id": "r60"},
  {"id": "r90"},
  {"id": "r100"}
]

Incomplete compaction evidence

A count alone does not identify the replaced records. Use replaces: {"state": "unknown"} and keep the native count. If any target in a recorded replacement set is unavailable, keep the complete set in native evidence and use the unknown state rather than listing only the known subset. A failed summary attempt establishes no context change. Pruning supported by separate evidence still has its own record. For a summary at the start of the context (offset zero), insertAt: {"beforeId": "first-retained"} works when that entry remains. insertAt: {"afterId": null} works when none remains. Both require evidence from the source establishing the summary’s placement.

Introduction

Format

Records

Trust

Extending and conforming

Agent registry

Order

Context-participating and audit-only records

Nodes and revisions

Implicit predecessor

`rewind`

`branchesFrom`

The mechanical-sibling rule

Inputs

Rule

Worked example

Heads

Active path

Context view

`compaction`

Algorithm output for fixtures

Incomplete compaction evidence

​Order

​Context-participating and audit-only records

​Nodes and revisions

​Implicit predecessor

​rewind

​branchesFrom

​The mechanical-sibling rule

​Inputs

​Rule

​Worked example

​Heads

​Active path

​Context view

​compaction

​Algorithm output for fixtures

​Incomplete compaction evidence

Order

Context-participating and audit-only records

Nodes and revisions

Implicit predecessor

`rewind`

`branchesFrom`

The mechanical-sibling rule

Inputs

Rule

Worked example

Heads

Active path

Context view

`compaction`

Algorithm output for fixtures

Incomplete compaction evidence