docs/reference/plumbing.md · gabriel/muse

**Exit codes:** 0 done · 1 commit not in store (with `--verify`), invalid branch or commit ID, or `--delete` on non-existent ref · 3 file write failure

418

419

---

420

421

422

### `commit-graph` — emit the commit DAG

423

424

```

425

muse plumbing commit-graph [--tip <id>] [--stop-at <id>] [-n <max>] [-c] [-1] [-a] [-f json|text]

426

```

427

428

Performs a BFS walk from a tip commit (defaulting to HEAD), following both

429

`parent_commit_id` and `parent2_commit_id` pointers. Returns every reachable

430

commit as a JSON array. Useful for building visualisations, computing

431

reachability sets, or finding the commits on a branch since it diverged from

another.

**Flags**

|---|---|---|---|

| `--tip` | — | HEAD | Commit to start from |

439

| `--stop-at` | — | — | Stop BFS at this commit (exclusive) |

440

| `--max` | `-n` | 10 000 | Maximum commits to traverse |

441

| `--count` | `-c` | off | Emit only the integer count, not the full node list |

442

| `--first-parent` | `-1` | off | Follow only first-parent links — linear history, no merge parents |

443

| `--ancestry-path` | `-a` | off | With `--stop-at`: restrict to commits on the direct path between tip and stop-at (capped at 100 000 visited commits to guard against unbounded BFS) |

**Output — JSON**

```json

{

"tip": "a3f2...c8d1",

"count": 42,

"truncated": false,

"commits": [

{

"commit_id": "a3f2...c8d1",

456

"parent_commit_id": "ff01...23ab",

457

"parent2_commit_id": null,

458

"message": "Add verse melody",

459

"branch": "main",

460

"committed_at": "2026-03-18T12:00:00+00:00",

461

"snapshot_id": "b7e4...f912",

"author": "gabriel"

}

]

}

```

`truncated` is `true` when the graph was cut off by `--max`.

469

470

**Output — `--count`**

471

472

```json

473

{"tip": "a3f2...c8d1", "count": 42}

474

```

475

476

`--count` suppresses the `commits` array entirely, making it suitable for fast

477

cardinality checks without loading commit metadata.

**Examples**

Commits on a feature branch since it diverged from `main`:

482

483

```sh

484

BASE=$(muse plumbing merge-base feat/x main -f text)

485

muse plumbing commit-graph --tip feat/x --stop-at "$BASE" -f text

486

```

487

488

Count commits in a feature branch:

489

490

```sh

491

muse plumbing commit-graph \

492

--tip $(muse plumbing rev-parse feat/x -f text) \

493

--stop-at $(muse plumbing merge-base feat/x dev -f text) \

--count

```

Linear history only (skip merge parents):

498

499

```sh

500

muse plumbing commit-graph --first-parent -f text

501

```

502

503

**Exit codes:** 0 graph emitted · 1 tip commit not found, `--ancestry-path` without `--stop-at`, or bad `--format`

---

### `pack-objects` — bundle commits for transport

509

510

```

511

muse plumbing pack-objects <want>... [--have <id>...]

512

```

513

514

Collects a set of commits — and all their referenced snapshots and objects —

515

into a single JSON `PackBundle` written to `stdout`. Pass `--have` to tell

516

the packer which commits the receiver already has; objects reachable only from

517

`--have` ancestors are excluded, minimising transfer size.

518

519

`<want>` may be a full commit ID or `HEAD`.

**Flags**

| Flag | Short | Description |

524

|---|---|---|

525

| `--have` | — | Commits the receiver already has (repeat for multiple) |

526

527

**Output** — a JSON `PackBundle` object (pipe to a file or `unpack-objects`)

```json

{

"commits": [...],

"snapshots": [...],

"objects": [{"object_id": "...", "content_b64": "..."}],

534

"branch_heads": {"main": "a3f2...c8d1"}

}

```

`objects` entries are base64-encoded so the bundle is safe for any JSON-capable

539

transport (HTTP body, agent message, file).

540

541

**Exit codes:** 0 pack written · 1 a wanted commit not found or HEAD has no commits · 3 I/O error reading from the local store

---

### `unpack-objects` — apply a bundle to the local store

547

548

```

549

cat pack.json | muse plumbing unpack-objects [-f json|text]

550

muse plumbing pack-objects HEAD | muse plumbing unpack-objects

551

```

552

553

Reads a `PackBundle` JSON document from `stdin` and writes its commits,

554

snapshots, and objects into `.muse/`. Idempotent: objects already present in

555

the store are silently skipped. Partial packs from interrupted transfers are

safe to re-apply.

**Flags**

|---|---|---|---|

**Output — JSON (default)**

```json

{

"commits_written": 12,

569

"snapshots_written": 12,

570

"objects_written": 47,

"objects_skipped": 3

}

```

**Output — `--format text`**

576

577

```

578

Wrote 12 commits, 12 snapshots, 47 objects (3 skipped).

579

```

580

581

**Exit codes:** 0 unpacked (all objects stored) · 1 invalid JSON from stdin or bad `--format` · 3 write failure

---

### `ls-remote` — list refs on a remote

587

588

```

589

muse plumbing ls-remote [<remote-or-url>] [-f json|text]

590

```

591

592

Contacts a remote and lists every branch HEAD without altering local state.

593

The `<remote-or-url>` argument is either a remote name configured with

594

`muse remote add` (defaults to `origin`) or a full `https://` URL.

**Flags**

|---|---|---|---|

**Output — `--format text` (default)**

603

604

One line per branch, tab-separated. The default branch is marked with ` *`.

```

a3f2...c8d1 main *

b7e4...f912 feat/experiment

609

```

610

611

**Output — `--format json`**

```json

{

"repo_id": "550e8400-e29b-41d4-a716-446655440000",

616

"domain": "midi",

617

"default_branch": "main",

618

"branches": {

619

"main": "a3f2...c8d1",

620

"feat/experiment": "b7e4...f912"

}

}

```

**Exit codes:** 0 remote contacted · 1 remote not configured, URL invalid, or bad `--format` · 3 transport error (network, HTTP error)

---

## Composability Patterns

630

631

### Export a history range

632

633

```sh

634

# All commits on feat/x that are not on main

635

BASE=$(muse plumbing rev-parse main -f text)

636

TIP=$(muse plumbing rev-parse feat/x -f text)

637

muse plumbing commit-graph --tip "$TIP" --stop-at "$BASE" -f text

638

```

639

640

### Ship commits between two machines

641

642

```sh

643

# On the sender — pack everything the receiver doesn't have

644

HAVE=$(muse plumbing ls-remote origin --format text | awk '{print "--have " $1}' | tr '\n' ' ')

645

muse plumbing pack-objects HEAD $HAVE > bundle.json

646

647

# On the receiver

648

cat bundle.json | muse plumbing unpack-objects

649

muse plumbing update-ref main <commit-id>

650

```

651

652

### Verify a stored object

653

654

```sh

655

ID=$(muse plumbing hash-object tracks/drums.mid -f text)

656

muse plumbing cat-object "$ID" -f info

657

```

658

659

### Inspect what changed in the last commit

660

661

```sh

662

muse plumbing read-commit $(muse plumbing rev-parse HEAD -f text) | \

663

python3 -c "import sys, json; d=json.load(sys.stdin); print(d['message'])"

664

```

665

666

### Script a bare commit (advanced)

667

668

```sh

669

# 1. Hash and store the files

670

OID=$(muse plumbing hash-object -w tracks/drums.mid -f text)

671

672

# 2. Build a snapshot manifest and write it (via muse commit is easier,

673

# but for full control use commit-tree after writing the snapshot)

674

SNAP=$(muse plumbing rev-parse HEAD -f text | \

675

xargs -I{} muse plumbing read-commit {} | \

676

python3 -c "import sys,json; print(json.load(sys.stdin)['snapshot_id'])")

677

678

# 3. Create a commit on top of HEAD

679

PARENT=$(muse plumbing rev-parse HEAD -f text)

680

NEW=$(muse plumbing commit-tree -s "$SNAP" -p "$PARENT" -m "scripted commit" | \

681

python3 -c "import sys,json; print(json.load(sys.stdin)['commit_id'])")

682

683

# 4. Advance the branch

684

muse plumbing update-ref main "$NEW"

```

---

### `merge-base` — find the common ancestor of two commits

691

692

Find the lowest common ancestor of two commits — the point at which two

branches diverged.

```sh

muse plumbing merge-base <commit-a> <commit-b> [-f json|text]

```

|---|---|---|---|

Arguments accept full SHA-256 commit IDs, branch names, or `HEAD`.

**JSON output:**

```json

{

"commit_a": "<sha256>",

710

"commit_b": "<sha256>",

711

"merge_base": "<sha256>"

}

```

When no common ancestor exists, `merge_base` is `null` and `error` is set.

| Exit | Meaning |

|---|---|

| 0 | Result computed (check `merge_base` for null vs. found) |

720

| 1 | Ref cannot be resolved; bad `--format` |

721

| 3 | DAG walk failed |

---

### `snapshot-diff` — diff two snapshot manifests

727

728

Compare two snapshots and categorise every changed path as added, modified,

or deleted.

```sh

muse plumbing snapshot-diff <ref-a> <ref-b> [-f json|text] [-s]

```

|---|---|---|---|

Arguments accept snapshot IDs, commit IDs, branch names, or `HEAD`.

**JSON output:**

```json

{

"snapshot_a": "<sha256>",

747

"snapshot_b": "<sha256>",

748

"added": [{"path": "new.mid", "object_id": "<sha256>"}],

749

"modified": [{"path": "main.mid", "object_id_a": "<sha256>", "object_id_b": "<sha256>"}],

750

"deleted": [{"path": "old.mid", "object_id": "<sha256>"}],

"total_changes": 3

}

```

**Text output:**

```

A new.mid

M main.mid

D old.mid

```

| Exit | Meaning |

|---|---|

| 0 | Diff computed (zero changes is a valid result) |

766

| 1 | Ref cannot be resolved; bad `--format` |

767

| 3 | I/O error reading snapshot records |

---

### `domain-info` — inspect the active domain plugin

773

774

Inspect the domain plugin active for this repository — its name, class,

775

optional protocol capabilities, and full structural schema.

776

777

```sh

778

muse plumbing domain-info [-f json|text] [-a]

```

|---|---|---|---|

**JSON output:**

```json

{

"domain": "midi",

"plugin_class": "MidiPlugin",

792

"capabilities": {

793

"structured_merge": true,

"crdt": false,

"rerere": false

},

"schema": {

"domain": "midi", "merge_mode": "three_way",

799

"dimensions": [...], "top_level": {...}

800

},

801

"registered_domains": ["bitcoin", "code", "midi", "scaffold"]

}

```

| Exit | Meaning |

|---|---|

| 0 | Domain resolved and schema emitted |

808

| 1 | Domain not registered; bad `--format` |

809

| 3 | Plugin raised an error computing its schema |

---

### `show-ref` — list all branch refs

815

816

List all branch refs and the commit IDs they point to.

817

818

```sh

819

muse plumbing show-ref [-f json|text] [-p PATTERN] [-H] [-v REF]

```

|---|---|---|---|

| `--pattern` | `-p` | `""` | fnmatch glob to filter ref names |

826

827

| `--verify` | `-v` | `""` | Silent existence check — exit 0 if found, 1 if not |

**JSON output:**

```json

{

"refs": [

{"ref": "refs/heads/dev", "commit_id": "<sha256>"},

835

{"ref": "refs/heads/main", "commit_id": "<sha256>"}

836

],

837

"head": {"ref": "refs/heads/main", "branch": "main", "commit_id": "<sha256>"},

"count": 2

}

```

Use `--verify` in shell conditionals:

843

844

```sh

845

muse plumbing show-ref --verify refs/heads/my-branch && echo "branch exists"

```

| Exit | Meaning |

|---|---|

| 0 | Refs enumerated (or `--verify` ref exists) |

851

| 1 | `--verify` ref absent; bad `--format` |

852

| 3 | I/O error reading refs directory |

---

### `check-ignore` — test whether paths are excluded by `.museignore`

858

859

Test whether workspace paths are excluded by `.museignore` rules.

860

861

```sh

862

muse plumbing check-ignore <path>... [-f json|text] [-q] [-V]

```

|---|---|---|---|

**JSON output:**

```json

{

"domain": "midi",

"patterns_loaded": 4,

877

"results": [

878

{"path": "build/out.bin", "ignored": true, "matching_pattern": "build/"},

879

{"path": "tracks/dr.mid", "ignored": false, "matching_pattern": null}

]

}

```

Last-match-wins: a negation rule (`!important.mid`) can un-ignore a path

885

matched by an earlier rule.

| Exit | Meaning |

|---|---|

| 0 | Results emitted (or `--quiet` with all ignored) |

890

| 1 | `--quiet` with any non-ignored path; missing args |

891

| 3 | TOML parse error in `.museignore` |

---

### `check-attr` — query merge-strategy attributes for paths

897

898

Query merge-strategy attributes for workspace paths from `.museattributes`.

899

900

```sh

901

muse plumbing check-attr <path>... [-f json|text] [-d DIMENSION] [-A]

```

|---|---|---|---|

| `--dimension` | `-d` | `*` | Domain axis to query (e.g. `notes`, `tempo`) |

908

909

910

**JSON output (default: first-match):**

```json

{

"domain": "midi",

"rules_loaded": 3,

"dimension": "*",

"results": [

{

"path": "drums/kit.mid",

920

"dimension": "*",

921

"strategy": "ours",

922

"rule": {"path_pattern": "drums/*", "strategy": "ours", "priority": 10, ...}

}

]

}

```

When no rule matches, `strategy` is `"auto"` and `rule` is `null`.

| Exit | Meaning |

|---|---|

| 0 | Attributes resolved and emitted |

933

| 1 | Missing args; bad `--format` |

934

| 3 | TOML parse error in `.museattributes` |

---

### `verify-object` — re-hash stored objects to detect corruption

940

941

Re-hash stored objects to detect silent data corruption.

942

943

```sh

944

muse plumbing verify-object <object-id>... [-f json|text] [-q]

```

|---|---|---|---|

Objects are streamed in 64 KiB chunks — safe for very large blobs.

**JSON output:**

```json

{

"results": [

{"object_id": "<sha256>", "ok": true, "size_bytes": 4096, "error": null},

960

{"object_id": "<sha256>", "ok": false, "size_bytes": null,

961

"error": "object not found in store"}

],

"all_ok": false,

"checked": 2,

"failed": 1

}

```

Compose with `show-ref` to verify every commit in a repo:

970

971

```sh

972

muse plumbing show-ref -f json \

973

| jq -r '.refs[].commit_id' \

974

| xargs muse plumbing verify-object

```

| Exit | Meaning |

|---|---|

| 0 | All objects verified successfully |

980

| 1 | One or more objects failed; object not found; bad args |

981

| 3 | Unexpected I/O error (disk read failure) |

---

### `symbolic-ref` — read or write HEAD's symbolic reference

987

988

In Muse, HEAD is always a symbolic reference — it always points to a branch,

989

never directly to a commit. `symbolic-ref` reads which branch HEAD tracks or,

990

with `--set`, points HEAD at a different branch.

```sh

# Read mode

muse plumbing symbolic-ref HEAD [-f json|text] [--short]

995

996

# Write mode

997

muse plumbing symbolic-ref HEAD --set <branch> [-f json|text]

```

|---|---|---|---|

| `--set` | `-s` | `""` | Branch name to point HEAD at |

**JSON output (read mode):**

```json

{

"ref": "HEAD",

"symbolic_target": "refs/heads/main",

1012

"branch": "main",

1013

"commit_id": "<sha256>"

}

```

`commit_id` is `null` when the branch has no commits yet.

1018

1019

**Text output:** `refs/heads/main` (or just `main` with `--short`)

| Exit | Meaning |

|---|---|

| 0 | Ref read or written |

1024

| 1 | `--set` target branch does not exist; bad `--format` |

1025

| 3 | I/O error reading or writing HEAD |

---

### `for-each-ref` — iterate all refs with rich commit metadata

1031

1032

Enumerates every branch ref together with the full commit metadata it points to.

1033

Supports sorting by any commit field and glob-pattern filtering, making it

1034

ideal for agent pipelines that need to slice the ref list without post-processing.

1035

1036

```sh

1037

muse plumbing for-each-ref [-p <pattern>] [-s <field>] [-d] [-n <count>] [-f json|text]

```

|---|---|---|---|

| `--pattern` | `-p` | `""` | fnmatch glob on the full ref name, e.g. `refs/heads/feat/*` |

1043

| `--sort` | `-s` | `ref` | Sort field: `ref`, `branch`, `commit_id`, `author`, `committed_at`, `message` |

1044

1045

| `--count` | `-n` | `0` | Limit to first N refs after sorting (0 = unlimited) |

**JSON output:**

```json

{

"refs": [

{

"ref": "refs/heads/dev",

1055

"branch": "dev",

1056

"commit_id": "<sha256>",

1057

"author": "gabriel",

1058

"message": "Add verse melody",

1059

"committed_at": "2026-01-01T00:00:00+00:00",

1060

"snapshot_id": "<sha256>"

}

],

"count": 1

}

```

**Text output:** `<commit_id> <ref> <committed_at> <author>`

1068

1069

**Example — three most recently committed branches:**

1070

1071

```sh

1072

muse plumbing for-each-ref --sort committed_at --desc --count 3

```

| Exit | Meaning |

|---|---|

| 0 | Refs emitted (list may be empty) |

1078

| 1 | Bad `--sort` field; bad `--format` |

1079

| 3 | I/O error reading refs or commit records |

---

### `name-rev` — map commit IDs to branch-relative names

1085

1086

For each supplied commit ID, performs a single multi-source BFS from all branch

1087

tips and reports the closest branch and hop distance. Results are expressed as

1088

`<branch>~N` — where N is the number of parent hops from the tip. When N is 0

1089

(the commit is the exact branch tip) the name is the bare branch name with no

`~0` suffix.

```sh

muse plumbing name-rev <commit-id>... [-n] [-u <string>] [-f json|text]

```

|---|---|---|---|

**JSON output:**

```json

{

"results": [

{

"commit_id": "<sha256>",

"name": "main~3",

"branch": "main",

"distance": 3,

"undefined": false

},

{

"commit_id": "<sha256>",

"name": null,

"branch": null,

"distance": null,

"undefined": true

}

]

}

```

**Text output:** `<sha256> main~3` (or `main~3` with `--name-only`)

1126

1127

**Performance:** A single O(total-commits) BFS from all branch tips simultaneously.

1128

Every commit is visited at most once regardless of how many input IDs are supplied.

| Exit | Meaning |

|---|---|

| 0 | All results computed (some may be `undefined`) |

1133

| 1 | Bad `--format`; no commit IDs supplied |

1134

| 3 | I/O error reading commit records |

---

### `check-ref-format` — validate branch and ref names

1140

1141

Tests one or more names against Muse's branch-naming rules — the same

1142

validation used by `muse branch` and `muse plumbing update-ref`. Use in

1143

scripts to pre-validate names before attempting to create a branch.

1144

1145

```sh

1146

muse plumbing check-ref-format <name>... [-q] [-f json|text]

```

|---|---|---|---|

**Rules enforced:** 1–255 chars; no backslash, null bytes, CR, LF, or tab;

1155

no leading/trailing dot; no consecutive dots (`..`); no leading/trailing or

consecutive slashes.

**JSON output:**

```json

{

"results": [

{"name": "feat/my-branch", "valid": true, "error": null},

1164

{"name": "bad..name", "valid": false, "error": "..."}

],

"all_valid": false

}

```

**Text output:**

```

ok feat/my-branch

FAIL bad..name → Branch name 'bad..name' contains forbidden characters

1174

```

1175

1176

**Shell conditional:**

1177

1178

```sh

1179

muse plumbing check-ref-format -q "$BRANCH" && git checkout -b "$BRANCH"

```

| Exit | Meaning |

|---|---|

| 0 | All names are valid |

1185

| 1 | One or more names are invalid; no names supplied |

---

### `verify-pack` — verify PackBundle integrity

1191

1192

Reads a PackBundle JSON from stdin or `--file` and performs three-tier integrity

1193

checking:

1194

1195

1. **Object integrity** — every object payload is base64-decoded and its SHA-256

1196

is recomputed. The digest must match the declared `object_id`.

1197

2. **Snapshot consistency** — every snapshot's manifest entries reference objects

1198

present in the bundle or already in the local store.

1199

3. **Commit consistency** — every commit's `snapshot_id` is present in the bundle

1200

or already in the local store.

1201

1202

```sh

1203

muse plumbing pack-objects main | muse plumbing verify-pack

1204

muse plumbing verify-pack --file bundle.json

```

|---|---|---|---|

| `--file` | `-i` | `""` | Path to bundle file (reads stdin when omitted) |

**JSON output:**

```json

{

"objects_checked": 42,

1219

"snapshots_checked": 5,

1220

"commits_checked": 5,

"all_ok": true,

"failures": []

}

```

**With failures:**

```json

{

"all_ok": false,

"failures": [

{"kind": "object", "id": "<sha256>", "error": "hash mismatch"},

1233

{"kind": "snapshot", "id": "<sha256>", "error": "missing object: ..."}

]

}

```

**Validate before upload:**

1239

1240

```sh

1241

muse plumbing pack-objects main | muse plumbing verify-pack -q \

1242

&& echo "bundle is clean — safe to push"

```

| Exit | Meaning |

|---|---|

| 0 | Bundle is fully intact |

1248

| 1 | One or more integrity failures; malformed JSON; bad args |

1249

| 3 | I/O error reading stdin or the bundle file |

---

---

## Composability Patterns — Advanced

1256

1257

### Name every commit reachable from a branch

1258

1259

```sh

1260

# Get all commit IDs on feat/x since it diverged from dev

1261

BASE=$(muse plumbing merge-base feat/x dev -f text)

1262

muse plumbing commit-graph --tip feat/x --stop-at "$BASE" -f text \

1263

| xargs muse plumbing name-rev --name-only

1264

```

1265

1266

### Audit all refs with full metadata and filter by recency

1267

1268

```sh

1269

# List all branches modified in 2026, sorted newest-first

1270

muse plumbing for-each-ref --sort committed_at --desc \

1271

| jq '.refs[] | select(.committed_at | startswith("2026"))'

1272

```

1273

1274

### Validate a branch name before creating it

1275

1276

```sh

1277

BRANCH="feat/my-feature"

1278

muse plumbing check-ref-format -q "$BRANCH" \

1279

&& echo "Name is valid — safe to branch" \

1280

|| echo "Invalid branch name"

1281

```

1282

1283

### Verify a bundle before shipping

1284

1285

```sh

1286

muse plumbing pack-objects main | tee bundle.json | muse plumbing verify-pack -q \

1287

&& echo "bundle is clean — safe to push" \

1288

|| echo "bundle has integrity failures — do not push"

1289

```

1290

1291

### Switch active branch via plumbing

1292

1293

```sh

1294

# Check where HEAD is now

1295

muse plumbing symbolic-ref HEAD -f text # → refs/heads/main

1296

# Redirect HEAD to dev

1297

muse plumbing symbolic-ref HEAD --set dev

1298

muse plumbing rev-parse HEAD -f text # → tip of dev

1299

```

1300

1301

### Find stale branches (no commits in the last 30 days)

1302

1303

```sh

1304

# Requires `date` and `jq`

1305

CUTOFF=$(date -u -v-30d +%Y-%m-%dT%H:%M:%SZ 2>/dev/null \

1306

|| date -u --date="30 days ago" +%Y-%m-%dT%H:%M:%SZ)

1307

muse plumbing for-each-ref -f json \

1308

| jq --arg c "$CUTOFF" '.refs[] | select(.committed_at < $c) | .branch'

1309

```

1310

1311

### Check which files changed between two branches

1312

1313

```sh

1314

BASE=$(muse plumbing merge-base main feat/x -f text)

1315

muse plumbing snapshot-diff "$BASE" feat/x --format text --stat

```

---

## Object ID Quick Reference

1321

1322

All IDs in Muse are 64-character lowercase hex SHA-256 digests. There are

1323

three kinds:

1324

1325

| Kind | Computed from | Used by |

1326

|---|---|---|

1327

| **Object ID** | File bytes | `hash-object`, `cat-object`, snapshot manifests |

1328

| **Snapshot ID** | Sorted `path:object_id` pairs | `read-snapshot`, `commit-tree` |

1329

| **Commit ID** | Parent IDs + snapshot ID + message + timestamp | `read-commit`, `rev-parse`, `update-ref` |

1330

1331

Every ID is deterministic and content-addressed. The same input always

1332

produces the same ID; two different inputs never produce the same ID in

practice.

---

## Exit Code Summary

| Code | Constant | Meaning |

1340

|---|---|---|

1341

| 0 | `SUCCESS` | Command completed successfully |

1342

| 1 | `USER_ERROR` | Bad input, ref not found, invalid format |

1343

| 3 | `INTERNAL_ERROR` | I/O failure, integrity check, transport error |