The host jobs build their driver with line tables alone, and the seal's red since 2026-10-05 is accounted for

[Japabu]

Head 7f991fbad. Fixes the red on main: nightly's host has failed at its last step, the seal of the host cache, on every scheduled run since 2026-10-05.

What stood red, and for how long

run	date	image	seal line
37190643147 (d47b383cf)	2026-10-04	20260927.320.1	16897 files, 7605844073 B of the 8000000000 B an entry may hold; saved 1,813,819,887 B
37292450697 (f260e0b98)	2026-10-05	20260927.320.1	8540783725 B in 18591 files under the cache's paths, above the 8000000000 B
37444133685 (f260e0b98)	2026-10-06		red the same way
37601225884 (f260e0b98)	2026-10-07	20261004.327.1	8182940473 B in 17350 files under the cache's paths, above the 8000000000 B

Three scheduled runs, found on 2026-10-07 by a review of another pull request. Nothing reported it: the scheduled nightly is a check of no pull request and no merge group, and no role's prompt reads it. Filed as issues/a-red-nightly-on-main-is-reported-to-nobody.md.

The brief said every host check since ran cold because no entry exists. The entry of 2026-10-04 exists and is restored; the readers discard it. Runs 37646740767 and 37687777630 each say Cache restored from key: host-sealed-Linux-X64-37190643147 (1,813,819,887 B) and then d47b383cf…'s entry, built on Linux X64 ubuntu24 20260927.320.1, deleted: the run is cold, since they ran on 20261004.327.1. GitHub served both images on 2026-10-07 (the table above, and runs 37685714260 and 37693139619 on the older one hours after 37601225884 on the newer), so a fresh entry does not end this: filed as issues/a-host-reader-on-another-runner-image-downloads-the-entry-and-discards-it.md.

Root cause

#722 (c4ab2b1e1, os-release) added gix to the build system. Units compiled per step, counted from the logs of 37190643147 and 37601225884:

step	2026-10-04	2026-10-07
the driver's own build (target/ci-driver)	111	203
the build system (target/debug)	115	207
clippy, warnings denied	320	414

The build system's dependency closure is built twice, once for the driver and once for the step that tests it, in two targets by design (src/cicache.rs's header).

What is under the paths, and what a reader reads

Diagnostic run 37693139619 (branch commit 14f49933c, since replaced; its patch is in the first comment) lifted LIMIT, sealed, listed every file under the paths with its size, compressed each directory with tar | zstd -T0, then replayed two readers over the sealed tree with every file's access time reset: A with nothing changed, B with every Cargo.toml changed so every path crate rebuilt. It ran on image 20260927.320.1.

Seal: 18712 files, 8608140775 B. Compressed whole: 2,020,684,970 B.

directory	bytes	compressed	read by A or B
target/debug	3,909,175,987	965,258,324	test binaries 2,549,630,832 of 2,708,603,504 (A runs them); libraries and metadata 686,115,791 of 961,369,725 (B links them)
target/ci-driver	1,757,640,523	436,269,662	below
userland/target/x86_64-unknown-linux-gnu	951,246,596	260,655,237	libraries and metadata 581,164,209 of 631,256,523
userland/target/debug	378,489,954	89,961,462
userland/target/x86_64-pc-windows-msvc	171,769,938	56,756,954	metadata 166,379,925 of 170,333,161
userland/target/aarch64-apple-darwin	148,562,396	50,337,291	metadata 141,603,434 of 147,019,327
~/.cargo/registry/cache, index, git/db	157,454,383	125,760,696	index and git read; registry/cache not, because the replay kept ~/.cargo/registry/src, which a real reader does not have and unpacks from it

Reader times in that run: cold steps 16 min 40 s after a 2 min 47 s driver build; reader A 5 min 11 s; reader B 11 min 30 s; the driver's own rebuild 2.07 s in both, from its incremental state. So the driver's target is reused and stays in the entry.

What a reader does not use is in target/ci-driver. It is built by the workflow's cargo run before carry() runs, so it alone carried full debuginfo:

• its 167 libraries that target/debug also holds once: 738,377,910 B, against 322,227,512 B there with line tables alone;
• its binary: 262,085,512 B, against 78,170,512 B for the same binary in target/debug, and counted under two names (a hard link);
• its incremental state, 409,998,048 B, and build scripts carry the same debuginfo.

The change

• ci.yml and nightly.yml: the host job's env: gives CARGO_PROFILE_DEV_DEBUG: line-tables-only. The driver's build and every step inherit it.
• src/ci.rs: carry() no longer sets it, so there is one declaration; the test that asserted carry() set it asserts only what carry() still does.
• .claude/agents/reviewer.md, Caches: "the one variable an env: gives either" becomes the two. The implementer was not briefed to edit a prompt; the orchestrator gave the edit his go at review (root CLAUDE.md: an agent updates the step its own change renames). Without the edit the prompt is false of the workflows it describes; the orchestrator decides whether it stands.
• LIMIT is unchanged at 8,000,000,000 B. Its reason holds on re-measurement: at the lowest Linux ratio measured (4.01; the two new ones are 4.19 and 4.26) it stores at most 1,994,138,951 B, and two entries beside main's four toolchain layers (912,484,904 B on 2026-10-07) are 4.9 GB of the 10 GB.
• No seal code changed, so no seal test was added.

Rejected: dropping target/ci-driver from the entry (a reader would pay the 2 to 3 minute cold driver build each run); debug = "line-tables-only" in the root [profile.dev] (its comment keeps debug on for LLDB); raising LIMIT alone (the content was not all reused).

Outside bounds, as read

• GitHub Docs, "Dependency caching reference", Usage limits and eviction policy: entries not accessed in over 7 days are removed; "By default, the limit is 10 GB per repository"; past it, caches are deleted "in order of last access date, from oldest to most recent".
• actions/toolkit packages/cache/src/cache.ts: an archive over 10 * 1024 * 1024 * 1024 B is not saved.
• gh api repos/ToyOSOrg/ToyOS/actions/cache/usage on 2026-10-07: 10,948,823,786 B in 25 entries, already past 10 GB: one host entry, main's four layers, and twenty sysroot layers of about 420 MB from pull requests and merge groups. Recorded in issues/the-host-caches-limit-reaches-the-10-gb-only-through-one-measured-ratio.md, with the hard links the seal counts twice (521,656,664 B in the diagnostic run) and the files every read rewrites.

What #746 must do

Its dispatch (run 37685714260, 88bcbf4d3) sealed 9348536345 B in 20064 files on image 20260927.320.1; main plus the diagnostic sealed 8,608,140,775 B on the same image the same evening: 740,395,570 B and 1,352 files more. In its log one step grew: "the apps for linux" compiles 282 units against main's 47, and "userland/*" 225 against 285; every other step is within 2 units. That log has no bytes per directory.

So #746's merge must: keep CARGO_PROFILE_DEV_DEBUG in both workflows' env: (review round 1 found the merge with db55db96a writes no conflict on these lines), and keep carry() without it; then dispatch nightly.yml on its branch and show a seal line under LIMIT. This change took 944,362,661 B off main's tree (below). If it takes the same off #746's, whose driver builds the same 203 units, that tree seals 8,404,173,684 B, 404,173,684 B over: it stays red until the apps-for-linux step shares its units with the userland step again, as it does on main in userland/target/x86_64-unknown-linux-gnu. That projection is arithmetic, not a run of #746.

Gates

ci.yml on this head, run 37713267864 (image 20260927.320.1): host success — Cache restored from key: host-sealed-Linux-X64-37190643147, built from d47b383cf…: 203 of 2501 sources dated as built, [ci] Host: 78 step(s), all green; toolchain / build and guest / suite success. It is cargo run -- --ci host on Linux at this head and the first run of ci.yml's changed job.

Nothing was built or tested locally: the owner reserved the development machine's compute while this was written, so no cargo command ran, and the src/ci.rs edit was made by reading. Every result below is run 37699848749's, nightly.yml dispatched on 7f991fbad, read from gh run view 37699848749 --job 113060424069 --log.

gate	result
run 37699848749	conclusion success: host, toolchain / build, tcg / suite, portability-linux, portability-macos success; release skipped off main
its host job, cargo run -- --ci seal	step success, exit 0; [ci] Seal: 80 step(s), all green; no RED line in the log; the save skipped off main
the seal's tests	in that job's "the build system" step: the ten cicache::tests::* and ci::tests::a_step_of_a_job_that_carries_the_cache_builds_in_its_own_target, each ... ok
cargo run -- --ci host	not run locally (restriction above). On Linux its steps are the seal job's 80 less the first and last; on macOS portability-macos ran it, success
a mutation that reds the seal's tests	not run: no seal code changed, and nothing could be built locally

The seal, on runner image 20260927.320.1 each time:

main, run 37292450697 (f260e0b98):  8540783725 B in 18591 files under the cache's paths, above the 8000000000 B an entry may hold
main + diagnostic, run 37693139619: 18712 files, 8608140775 B of the 80000000000 B an entry may hold   (limit lifted to list the tree)
this head, run 37699848749:         18712 files, 7663778114 B of the 8000000000 B an entry may hold; sealed: 2501 sources, built on Linux X64 ubuntu24 20260927.320.1, every target dated as built

and main's latest failing line, run 37601225884 on image 20261004.327.1: 8182940473 B in 17350 files under the cache's paths, above the 8000000000 B an entry may hold.

• Measured saving, same image and same file count: 8,608,140,775 − 7,663,778,114 = 944,362,661 B.
• Measured margin: 336,221,886 B under the limit on image 20260927.320.1.
• The other image: before this change the same commit f260e0b98 sealed 357,843,252 B less on 20261004.327.1 than on 20260927.320.1 (8,182,940,473 against 8,540,783,725), so the logs say that image seals smaller, not larger. This head has not been sealed on it.
• Job time: host ran 20 min 26 s (23:02:01Z to 23:22:27Z), its seal step 20 min 15 s, of which the driver's cold build was 2 min 24 s. main's failing host took 20 min 13 s on the same image (run 37292450697) and 13 min 0 s on the newer one (run 37601225884).

Unsure of

• The margin is 4.2 % of the limit. The next dependency the build system takes can use it up, and the red that follows is still reported to nobody until issues/a-red-nightly-on-main-is-reported-to-nobody.md is closed.
• No reader has been run against an entry of this head: the save is main's alone. The reader's times above are the diagnostic's replay, made before this change.
• Whether a host reader between this landing and the next nightly loses anything: no entry on either image matches today, and every reader runs cold.

🤖 Generated with Claude Code

https://claude.ai/code/session_01RvnWQFcMuGqTHYhvSnTe8A

[Japabu]

The diagnostic commit 14f49933c that run 37693139619 ran, since replaced on the branch. It never lands. The table of bytes read was made from its L0, L1 and L2 lines: a file counts as read by a reader when its access time moved and its modification time did not.

commit 14f49933c0a8bf4113f64b0f9ac33c1ed175e593
Author: japabu <japa.busse@gmail.com>
Date:   Wed Oct 7 23:58:42 2026 +0200

    DIAGNOSTIC, never lands: list the host cache and replay a reader
    
    Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
    Claude-Session: https://claude.ai/code/session_01RvnWQFcMuGqTHYhvSnTe8A

diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index b26634d85..0e54c5c68 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -1,28 +1,18 @@
 name: nightly
 
-# Every job's logic is `cargo run -- --ci <job>` (src/ci.rs); this file says
-# where each one runs.
+# DIAGNOSTIC, never lands: what is under the host cache's paths, and what a
+# reader reads of it.
 
 on:
-  schedule:
-    - cron: '0 3 * * *'
   workflow_dispatch:
 
-concurrency:
-  group: nightly-${{ github.ref }}
-  cancel-in-progress: false
-
 permissions:
   contents: read
 
 jobs:
-  # The host cache's writer restores nothing, and `seal` is green only once
-  # src/cicache.rs has sealed the tree the save stores.
   host:
     runs-on: ubuntu-24.04
-    timeout-minutes: 90
-    # The driver's own target, and no step's: it says this job carries the
-    # host cache (src/cicache.rs).
+    timeout-minutes: 120
     env:
       CARGO_TARGET_DIR: target/ci-driver
     steps:
@@ -32,95 +22,46 @@ jobs:
 
       - run: cargo run -- --ci seal
 
-      # The host cache's one writer. Only main's entries are readable from
-      # every branch.
-      - if: github.ref == 'refs/heads/main'
-        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: |
-            ~/.cargo/registry/index
-            ~/.cargo/registry/cache
-            ~/.cargo/git/db
-            target
-            userland/target
-            toyos/target
-            kernel/target
-            bootloader/target
-          key: host-sealed-${{ runner.os }}-${{ runner.arch }}-${{ github.run_id }}
-
-  toolchain:
-    uses: ./.github/workflows/toolchain.yml
-
-  # Skipped off main, where the driver refuses it by name.
-  release:
-    needs: toolchain
-    if: github.ref == 'refs/heads/main'
-    runs-on: ubuntu-24.04
-    timeout-minutes: 30
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
-
-      - uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ${{ needs.toolchain.outputs.sysroot-path }}
-          key: ${{ needs.toolchain.outputs.sysroot-key }}
-          fail-on-cache-miss: true
-
-      - env:
-          GH_TOKEN: ${{ github.token }}
-        run: cargo run -- --ci release
-
-  tcg:
-    needs: toolchain
-    if: ${{ !cancelled() }}
-    uses: ./.github/workflows/guest.yml
-    with:
-      kvm: false
-      sysroot-key: ${{ needs.toolchain.outputs.sysroot-key }}
-      sysroot-path: ${{ needs.toolchain.outputs.sysroot-path }}
-
-  # `cargo run -- --build-only` from a fresh machine. `sid` as it stands,
-  # image and archive both, and no cache — a fresh machine is the premise.
-  portability-linux:
-    runs-on: ubuntu-24.04
-    timeout-minutes: 350
-    container:
-      image: debian:sid
-    steps:
-      - name: deps
+      - if: always()
         run: |
-          for attempt in 1 2 3; do
-            apt-get update -qq > /tmp/apt.log 2>&1 \
-              && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq git curl ca-certificates \
-                   build-essential qemu-system-x86 python3 cmake >> /tmp/apt.log 2>&1 \
-              && break
-            [ "$attempt" = 3 ] && { cat /tmp/apt.log; exit 1; }
-            sleep 20
+          cd "$GITHUB_WORKSPACE"
+          E=""
+          for p in "$HOME/.cargo/registry/index" "$HOME/.cargo/registry/cache" "$HOME/.cargo/git/db" target userland/target toyos/target kernel/target bootloader/target; do
+            [ -e "$p" ] && E="$E $p"
           done
-          git config --global --add safe.directory "$GITHUB_WORKSPACE"
-          curl --proto '=https' --tlsv1.2 -sSf -o "$RUNNER_TEMP/rustup-init.sh" https://sh.rustup.rs
-          sh "$RUNNER_TEMP/rustup-init.sh" -y --profile minimal --default-toolchain stable
-          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
-
-      - &checkout
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
-
-      - run: cargo run -- --build-only
-
-  portability-macos:
-    runs-on: macos-latest
-    timeout-minutes: 350
-    steps:
-      - *checkout
-      # Homebrew keeps one QEMU; `cargo run` notes it if it is not the declared one.
-      - run: |
-          brew install qemu cmake
-      - run: |
-          curl --proto '=https' --tlsv1.2 -sSf -o "$RUNNER_TEMP/rustup-init.sh" https://sh.rustup.rs
-          sh "$RUNNER_TEMP/rustup-init.sh" -y --profile minimal --default-toolchain stable
-          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
-      - run: cargo run -- --build-only
-      # The host suite's macOS arms run here alone: `ci.yml`'s `host` is Linux.
-      - run: cargo run -- --ci host
+          echo "DIAG paths:$E"
+          findmnt -T . || true
+          findmnt -T "$HOME" || true
+          df -h . || true
+          echo "DIAG-BEGIN list0"
+          find $E -type f -printf 'L0 %A@ %T@ %s %p\n'
+          echo "DIAG-END list0"
+          echo "DIAG-BEGIN zstd"
+          echo "Z all $(tar -cf - $E 2>/dev/null | zstd -T0 | wc -c)"
+          for d in "$HOME/.cargo/registry/index" "$HOME/.cargo/registry/cache" "$HOME/.cargo/git/db" target/* userland/target/* toyos/target/* target/ci-driver/debug/* target/debug/*; do
+            [ -e "$d" ] && echo "Z $d $(tar -cf - "$d" 2>/dev/null | zstd -T0 | wc -c) $(du -sb "$d" | cut -f1)"
+          done
+          echo "DIAG-END zstd"
+          cp target/ci-sources "$RUNNER_TEMP/ci-sources"
+          find $E -type f -exec touch -a -d '2000-01-01' {} +
+          probe=$(find target/debug/deps -name '*.rlib' | sed -n 1p)
+          head -c 1 "$probe" > /dev/null
+          echo "DIAG atime probe: $(stat -c '%X %n' "$probe")"
+          touch -a -d '2000-01-01' "$probe"
+
+          echo "DIAG reader A (nothing changed) starts $(date -u +%T)"
+          git ls-files -z | xargs -0 touch -c
+          cargo run -- --ci host; echo "DIAG reader A EXIT=$? ends $(date -u +%T)"
+          echo "DIAG-BEGIN list1"
+          find $E -type f -printf 'L1 %A@ %T@ %s %p\n'
+          echo "DIAG-END list1"
+
+          find $E -type f -exec touch -a -d '2000-01-01' {} +
+          cp "$RUNNER_TEMP/ci-sources" target/ci-sources
+          git ls-files -z '*Cargo.toml' ':!rust' ':!tests/testcases' | xargs -0 -n1 sh -c 'echo "# diag" >> "$0"'
+          echo "DIAG reader B (every package changed) starts $(date -u +%T)"
+          git ls-files -z | xargs -0 touch -c
+          cargo run -- --ci host; echo "DIAG reader B EXIT=$? ends $(date -u +%T)"
+          echo "DIAG-BEGIN list2"
+          find $E -type f -printf 'L2 %A@ %T@ %s %p\n'
+          echo "DIAG-END list2"
diff --git a/src/cicache.rs b/src/cicache.rs
index e35039ec7..2c8581a24 100644
--- a/src/cicache.rs
+++ b/src/cicache.rs
@@ -64,7 +64,7 @@ const PATHS: [&str; 8] = [
 
 /// The most the files under [`PATHS`] may hold, uncompressed. The repository's
 /// caches are evicted by last access past 10 GB.
-const LIMIT: u64 = 8_000_000_000;
+const LIMIT: u64 = 80_000_000_000;
 
 /// 2001-09-09T01:46:40Z: older than any build, so a file dated so is never
 /// newer than one.

[Japabu]

Review round 1 of 7f991fbad against origin/main 8506640f1 (branch base e16cb0841, three landings behind). Read only: nothing was built or run here; every figure below is from a run's log or the investigation's listings.

BLOCKER

None.

NOTE

• .claude/agents/reviewer.md:92 — a role prompt edited without a brief (root CLAUDE.md, Prose) — the clause is true of both workflows and is the least that says it, and it is what makes the cut of the -C debuginfo=line-tables-only assertion in src/ci.rs legal ("when this prompt takes its rule"); it stands only on the orchestrator's go, and the body's "I was not briefed" sentence is then resolved before it becomes main's record.
• issues/the-host-caches-limit-reaches-the-10-gb-only-through-one-measured-ratio.md:40 — 521,656,664 B is given as what the seal counts twice; run 37693139619's own lines say at least 977,318,242 B — the find listing against du -sb of the same directories: target/ci-driver 2,133,805,759 against 1,757,640,523, target/debug 4,211,395,739 against 3,909,175,987, userland/target/debug 566,708,306 against 378,489,954, userland/target/x86_64-unknown-linux-gnu 1,061,961,498 against 951,246,596. The three kinds named sum correctly; every build script's binary, stored under two names in build/ (225,531,894 listed against 117,351,174 in the driver's alone), is left out.
• issues/the-host-caches-limit-reaches-the-10-gb-only-through-one-measured-ratio.md:60 — "Two gates that red:" now heads three items, and the third is no gate.
• issues/a-host-reader-on-another-runner-image-downloads-the-entry-and-discards-it.md:17 — "the 5 a reader of its own image's entry took in run 37693139619" was a replay over the sealed tree in place: no restore, and ~/.cargo/registry/src kept. The PR's own host check is now a real one: run 37713267864 restored 1,813,819,887 B in 24 s and ran cargo run -- --ci host in 16 min 57 s against an entry 30 landings old.
• PR body, "What One workspace, one lock: the root, the kernel, the loader, userland and the SDK resolve together #746 must do" — "when it resolves the conflict on the path list": git merge-tree --write-tree 7f991fbad origin/wt/toyos-oneworkspace (db55db96a) writes a tree with no conflict; both env: lines and the shortened carry() survive untouched.
• PR body, "Gates" — the host check of this head is not in it: run 37713267864, job 113103856303, image 20260927.320.1, Cache restored from key: host-sealed-Linux-X64-37190643147, built from d47b383cf…: 203 of 2501 sources dated as built, [ci] Host: 78 step(s), all green, conclusion success; toolchain / build and guest / suite success in the same run. It is cargo run -- --ci host on Linux at this head, and the first run of ci.yml's changed job.
• PR body, the table of directories — its byte column is du -sb, which counts a hard link once, and sums to 7,474,339,777 B; the seal counted 8,608,140,775 B over the same tree. The column is not what LIMIT judges.

Growth

7 files changed, 87 insertions(+), 16 deletions(-). Production: src/ci.rs carry() −4; the two workflows +2 settings and +4 net comment lines. Tests: src/ci.rs +3 −4. Prompt +3 −3. Issues +71 −1. Accepted: the setting moves, nothing is added.

What was asked

Root cause. Measured as stated, by units: between the last green nightly (37190643147, d47b383cf) and the first red (37292450697, f260e0b98) thirty pull requests landed, and the steps that grew are the driver's build (111 to 203), the build system (115 to 207) and clippy (320 to 414); every other step together compiled 37 fewer. There is no listing of the tree before #722, so the bytes per directory of the growth are not measured, only its sum, 934,939,652 B on one image.

The fix is the cheapest part, not the growth. It removes 944,362,661 B (same image, same 18,712 files) of full debuginfo in target/ci-driver, which was there before #722 too. The gix closure is still built twice and linted once, and stays in the entry. The tree is now 57,934,041 B above the last green one: the margin was 394,155,927 B before #722 and is 336,221,886 B after this. What still carries the bytes, by run 37693139619's listing: target/debug's 240 test binaries, 2,708,603,504 B; names counted twice, at least 977,318,242 B; the driver's incremental state, 409,998,048 B before this change.

What is lost. Nothing a reader or a failing run uses. Every step already built with line tables alone; only the driver's own build changes. A panic's backtrace keeps function, file and line. Variable and type DWARF for a debugger attached to the driver on a hosted runner goes, and nothing attaches one. A developer's build is untouched: the setting exists only in two jobs' env:; portability-linux and portability-macos do not have it.

The margin. 4.2 % on image 20260927.320.1, measured on a base three landings behind main. #722 cost about 10 MB a unit across the three steps, so some 33 units of a build-system dependency use it up. On 20261004.327.1 this head is unmeasured: f260e0b98 sealed 357,843,252 B and 1,241 files less there with the same 961 compiled and 843 checked units, and nothing in the logs says why; the hosted stable is not pinned and neither log prints it. #746 is already known to pass the limit.

One source of truth or two. Two declarations and one sentence: ci.yml, nightly.yml, and the Caches clause that holds them equal, the same standing CARGO_TARGET_DIR and the path list have. Before, the steps' setting was one line of code under a test. A writer that loses it reds at the seal while the margin is thinner than the debuginfo. A reader that loses it reds nothing: the entry is restored, every unit is rebuilt, the check is green and slow. Only the review catches that.

The two issues. Both have an owner that exists and an exit a reader can check. The reader issue's first exit arm contradicts src/cicache.rs's header as it stands ("the cache key cannot carry the image"); the second arm is the one reachable without a redesign.

#746. It must rebase onto this, dispatch nightly.yml on its branch and show a seal line under LIMIT before it lands; 8,404,173,684 B is arithmetic from a run before this change. Its merge needs no hand on these lines. What this PR does not say: #746 changes the path list, which is the cache's version, so the entry the next nightly saves is unreadable from the moment #746 lands, and every host check is cold until a nightly after it seals green. If #746 lands before the next scheduled nightly, this fix is never observed on main.

What main must show for the red to count as fixed. As of this review main's latest nightly is 37601225884, failure. Fixed is:

1. the next scheduled nightly on main, at or after this merge: host success, its seal line with bytes under 8,000,000,000 and the image named, and the save step run rather than skipped, with the key host-sealed-Linux-X64-<run id> and the stored size, which joins the ratios in the limit's issue;
2. the first ci.yml host after it on that image: Cache restored from key: naming that run, built from <the merge commit>, and the driver's Finished in seconds rather than two minutes, which is the first measurement that the reader's env: matches the writer's; a reader that draws the other image and logs deleted: the run is cold shows nothing;
3. toolchain / build on main after that save still restoring its four layers: the repository's caches stood at 10,948,823,786 B before it.

LAND