[objectstack-fleet]

Requested by 田騏 · project thread
Part of #25452 (the card stays open for its after-reading: the pool after ≥ 5 merges, read by an account that can read actions/cache/*)

Clause-②: no
Metadata-protocol: none

维护者速读

• 改了什么:把 Dogfood Regression Gate 三个分片的「Save Turbo cache (main only)」接到现成的 prune-turbo-cache.mjs 后面。测试步骤的 turbo 命令加 --summarize 写运行摘要,新增的修剪步骤只留本次运行用到的任务条目,保存只在修剪答 save=true 时进行。不加脚本、不加门禁、不改恢复键、不抬池子上限。
• 为什么改:池子读数 6647111495 里,Linux-turbo-dogfood-1-main-* 每个 sha 约 3.69 GB,两份占池子 95%。整份保存会把之前每份种子都累积进来,把其他种子挤出 10 GB 池。裁决 6458731814 选 A「修剪,不删」。
• 风险与回滚:只动 .github/workflows/ci.yml 的 dogfood 作业。dogfood 只在 main 的 push/定时运行上跑,PR 上看不到效果。最坏情况是某次 push 不保存种子(没有运行摘要就是 save=false),下次继续恢复上一份种子。回滚 = revert 本 PR。
• 先看:.github/workflows/ci.yml dogfood 作业新增的「Prune the Turbo cache to this run's tasks (main only)」步骤,以及其后保存步骤的 if:;同一作业测试步骤 turbo 命令上的 --summarize。
• 两分钟验证:node scripts/ci/prune-turbo-cache.mjs --self-test,预期最后一行 prune-turbo-cache self-test: OK (25 case(s) across 5 batteries).
• 需要你做的:作为 GOVERNED_APPROVERS 审批(或亲手合并)这个 Tier H draft PR。

What changes

Ruling 6458731814 (#26957, letter A): "prune, do not drop", each seed-save step "wired behind scripts/ci/prune-turbo-cache.mjs --site … exactly as Test Core … [is] today, so a seed holds only the task entries its own run used". "⛔ The pool limit is not raised here" stands.

One file, .github/workflows/ci.yml, job dogfood (Dogfood Regression Gate (N/3)), +23 / -2:

• Test step ("Boot example apps and exercise real user flows"): pnpm turbo run test --filter=@objectstack/dogfood --log-order=stream gains --summarize, so the run writes .turbo/runs/ (one JSON file per run). The job had no run summary before: neither of its two turbo invocations (the closure build and the test run) passed --summarize, and the job sets no TURBO_RUN_SUMMARY.
• New step "Prune the Turbo cache to this run's tasks (main only)", id: prune-turbo-cache, if: always() && github.event_name == 'push': node scripts/ci/prune-turbo-cache.mjs --site 'Dogfood Regression Gate (N/3)' --cache .turbo/cache --run-summaries .turbo/runs. These are Test Core's step and condition, without --extra-summaries (next bullet).
• Save step "Save Turbo cache (main only)": if: ANDs steps.prune-turbo-cache.outputs.save == 'true'. The path and key are unchanged.
• Unchanged: the restore step and its keys, upgrade-harness-optin.yml (its restore at L96), the job's if:, its timeout, and the two attestation steps, which stay last and unconditioned.

Why one summary is enough, and why there is no --extra-summaries: the test run plans the whole ^build closure and replays it, so its summary names every closure build task. Measured at base f2a9007e93 with turbo run build --filter=@objectstack/dogfood --dry=json against OS_TEST_SHARD=1/3 turbo run test --filter=@objectstack/dogfood --dry=json: 71 shared tasks, 71 hash-identical, 0 differing. The only closure node missing from the test plan is @objectstack/dogfood#build, which has no command and no cache entry. Test Core needs --extra-summaries only because its closure summary is moved out of .turbo/runs/ by the remote-cache assertion, and the dogfood job runs no such assertion.

No --site registry, self-test or gate lists sites. git grep prune-turbo-cache outside the workflows finds only the script itself and two ui/scripts/__tests__ files about the ui jobs. So, as with #27067, nothing else needs to change.

Tests

Local seed-size estimate (closure only), at 4f58391 = base + this diff

The setup stands in for CI. A private --cache-dir was seeded with a copy of this container's shared .turbo/cache (260 MB, 1059 files) as the "restored seed". Then the job's closure command ran (--concurrency=2): Tasks: 69 successful, 69 total, Cached: 2 cached, 6m39s, on a shared 4-vCPU box. Then came the test step exactly as this PR spells it, but with an out-of-range OS_TEST_SHARD=9/3, so vitest refused at once. That run reported 69 cached, 70 total, Failed: @objectstack/dogfood#test, and wrote its summary anyway, so a red test step still leaves a summary to prune by. Then the prune ran exactly as the new step does:

prune-turbo-cache: Dogfood Regression Gate (1/3): kept 69 task entries named by 1 run summary (70 task hash(es); 1 have no entry -- a failed task, or one turbo does not cache).
prune-turbo-cache: Dogfood Regression Gate (1/3): dropped 1053 file(s) the run did not use: 304.3 MB -> 35.7 MB on disk.
save=true

• Before: 304.3 MB. After: 35.7 MB (207 files = 69 entries x 3).
• The local "before" is not CI's. CI restores the accumulated ~3.69 GB seed, and the first push run after this lands prunes that down to the same closure, as Test Core's first run did (2912.4 MB -> 0.8 MB).
• The scope is the closure only. A real dogfood#test entry (outputs: [], a log archive) adds a small amount: NOT MEASURED, because a full dogfood shard was not run here.
• Estimate: about 36 MB per shard seed, about 0.11 GB for the three shards of one merge.
• --summarize moves no hash: the summary's 69 build hashes equal the dry-run plan taken without it (69 identical, 0 differing).

• Upgrade-harness closure (upgrade-harness-optin.yml restores turbo-dogfood-1-main-* and builds --filter=@objectstack/dogfood): every one of the 69 closure tasks that has a command still has its .tar.zst in the pruned seed (69 of 69, 0 missing).
• node scripts/ci/prune-turbo-cache.mjs --self-test (script unchanged): prune-turbo-cache self-test: OK (25 case(s) across 5 batteries)., exit 0.
• The dogfood job's steps, parsed with the yaml package: ... 8 Upload stall diagnostic reports, 9 Prune the Turbo cache to this run's tasks (main only) (id=prune-turbo-cache, if="always() && github.event_name == 'push'"), 10 Save Turbo cache (main only) (if="always() && github.event_name == 'push' && steps.prune-turbo-cache.outputs.save == 'true'"), 11 Attest this shard ran and passed, 12 Publish this shard's attestation.
• No ablation, because this is workflow config and not tested behaviour.

Acceptance notes

• Before (pool reading 6647111495, main at 474c030b13):
  • First read: 10,925,870,698 B in 27 entries. Second read: 7,745,686,441 B in 16 entries.
  • The two Linux-turbo-dogfood-1-main-* seeds are 3,685,866,556 B and 3,687,370,253 B, together 7.37 GB, or 95.2 % of the second read. *-turbo-* keys overall are 99.8 %.
• Writer correction: the reading names upgrade-harness-optin.yml:96 as the source, but that step is actions/cache/restore and never saves. The writer is this job's save step: github.job is dogfood, so its key is Linux-turbo-dogfood-SHARD-main-SHA. The harness only restores shard 1's seed.
• After: owed after at least 5 merges to main. It is a maintainer pool reading (actions/cache/usage plus the full actions/caches listing, in the shares of 6647111495), because the seat token gets 403 on actions/cache/*. Until then, the first push run's three prune-turbo-cache: Dogfood Regression Gate (N/3): … lines are the measured post-prune seed size.
• Not exercised on this PR: the dogfood job does not run on pull_request or merge_group (THE TWO SPEEDS), so this PR's own CI cannot exercise the new step. The first run is the first push run on main after merge.

Verification

Derived gates (node scripts/pm/dispatch-gates.mjs --commands --repo objectstack-ai/objectstack), run on 2a737765df (this branch after merging origin/main ff12aed37; the derived list was byte-identical before the merge). Each exit code was captured before any pipe.

53 derived commands: 53 exit 0, plus the --ran line

• 18 direct node gates (closing-keyword parity, comment-mask corpus, self-test-wired, self-test-workflow-commands, step-collectors, whole-set-label-write, assert-turbo-remote-cache / plan-test-core-shards / prune-turbo-cache / scheduled-full-run self-tests, drift-comment, ci-failure self-test, dts-emitted self-test): exit 0.
• 35 pnpm check:*, including check:ci-filter-parity, check:required-contexts, check:shard-attestation, check:stall-guard-budget, check:stall-guard-headroom, check:workflow-status-functions, check:workflow-step-name-quoting, check:agent-test-spelling, check:aggregator-roster, check:nul-bytes, check:pm-dispatch-gates (fast tier, 340 s) and check:type-check-debt (under the verify lock, re-measure 366 s, 0 raw tsc errors): exit 0.
• check:dual-build-cjs-loads first exited 3 (PREREQUISITE NOT MET: 7 packages outside the dogfood closure had no dist/). It was re-run after check:type-check-debt built every package and then exited 0: 116 require entry points across 71 packages load.

Run reconciliation — 53 derived, 53 run, 0 NOT-MEASURED, 0 UNRUN.
✓ dispatch-gates --ran: 53 derived famil(ies) accounted for — 53 run, 0 NOT-MEASURED (a DERIVED zero — all 53 recorded an exit code and none of them is 3).

actionlint is not derived and not installed, so it was not run. CI's Lint & Repo Gates runs the workflow lints.

Session: https://claude.ai/code/session_017ihL2ebbZkr2QAEG1x7UC8

🤖 Generated with Claude Code

[objectstack-fleet]

domain:devx#2 · marchtian · session_017ihL2ebbZkr2QAEG1x7UC8

Contract review

Served-tier: CONTRACT_REVIEW_TIER
Head-sha: 2a737765dfeb0e95a52ee6ef6a84597759e2b0a0
Local-runs: none
Scope: .github/workflows/ci.yml + scripts/ci/prune-turbo-cache.mjs, .github/workflows/upgrade-harness-optin.yml, .github/workflows/ci.yml (Test Core and Build Core prune wiring, the precedent), turbo.json (build / test task graph), scripts/ci/report-test-leftovers.mjs (the .turbo/ classifier), ruling 6458731814 on #26957, pool reading 6647111495 on #25452

Inputs read: card #25452 body and all 25 comments; PR #30241 body, file list (one file, .github/workflows/ci.yml, +23 / -2) and git diff origin/main...2a737765df (merge-base ff12aed37b); the head's check-runs. The PR body's account was not the evidence: every claim below was read off the tree at 2a737765df and origin/main.

Check-runs on 2a737765df at the time of writing: 64 runs, all completed — 49 success, 15 skipped, 0 failure. Among the successes: Governed Surface Queue Guard, PR-body guards, Check Changeset, Lint · CI release and engine gates (the workflow lints), Lint · repo and tooling gates (check:shard-attestation, check:workflow-status-functions, check:workflow-step-name-quoting), Lint · scoped · tooling self-tests, Build Core, Test Core (1/8), Build Docs, Dogfood Regression Gate (the gate, concluding over zero expected attestations). Skipped, as THE TWO SPEEDS says they must be on pull_request: the three Dogfood Regression Gate (N/3) matrix legs, Dogfood Verify CLI, Temporal Conformance, UI Published Artifacts, both opt-in harnesses. So the changed job itself is not exercised by this PR's CI; the static gates over it are, and are green. Its first exercise is the first push run on main after merge.

① Derived judgments

The diff is three edits inside the dogfood job, nothing outside it (git diff --stat: one file; both hunks fall inside jobs.dogfood.steps). Each behaviour change it implies, named:

1. --summarize on the test step (pnpm turbo run test --filter=@objectstack/dogfood --summarize --log-order=stream). RIGHT, and it moves nothing that is hashed or keyed. A turbo run flag is not a task-hash input: turbo.json hashes inputs, declared env, globalEnv (OS_SKIP_DTS only) and dependency hashes; Test Core's own test legs already carry --summarize (ci.yml L1331, L1402) and its comment at L1446 records it as costing nothing at runtime, and the job's own comment measured the closure's build hashes identical with and without run-level flags. The Actions cache key is runner.os-turbo-github.job-matrix.shard-github.ref_name-github.sha and the diff does not touch it. Step outcomes: the summary lands in .turbo/runs/, which is NOT in the save path (.turbo/cache) and is not uploaded by any dogfood step; the "Report what the dogfood tests left" pair classifies .turbo/ as turbo-state (report-test-leftovers.mjs rule at L132-134) and is report-only; the completeness guard reads $RUNNER_TEMP/dogfood.log, the same check-test-completeness.mjs Test Core runs over a --summarize log. Flag placement --summarize --log-order=stream is Test Core's spelling verbatim, so --summarize's optional value cannot swallow the next flag.
2. The new prune step: id: prune-turbo-cache, if: always() && github.event_name == 'push', node scripts/ci/prune-turbo-cache.mjs --site 'Dogfood Regression Gate (N/3)' --cache .turbo/cache --run-summaries .turbo/runs. RIGHT. The if: is Test Core's and Build Core's verbatim (L1748-1755, L3104-3110): it runs on a red or cancelled job (always()), on push only, so schedule and workflow_dispatch full-battery runs still save nothing, as before. The inputs are the ones the script requires (--site, --cache, --run-summaries; parseArgs exits 3 only when one is missing or malformed, which is static). .turbo/runs holds exactly the test step's summary: neither the closure build (L2494, no --summarize) nor setup-workspace writes one, and the job sets no TURBO_RUN_SUMMARY (grep of the head: TURBO_RUN_SUMMARY appears only in the two ui jobs at L3490, L4064).
3. The save gate: if: always() && github.event_name == 'push' && steps.prune-turbo-cache.outputs.save == 'true'. RIGHT, Test Core's and Build Core's expression verbatim. The script appends save=true|false to GITHUB_OUTPUT on every run-time path; a skipped or crashed prune leaves the output empty, which the string compare reads as false, so the failure direction is "no save", never "save unpruned". The path and key of the save are unchanged.
4. What a save=false run does to the newest seed: nothing. prune() returns save: false and touches no file when .turbo/runs holds no readable summary (the test step was cancelled, killed by the stall guard, or never ran because the closure build failed) or when .turbo/cache is absent; the save step is skipped; the restore's prefix keys (turbo-dogfood-N-main-, then turbo-dogfood-) keep resolving to the last seed that WAS saved. Before this PR such a run saved the whole restored seed plus whatever it had added, which is the accumulation path the pool reading shows (two Linux-turbo-dogfood-1-main-* seeds of 3.69 GB each, 95 % of the pool). RIGHT.
5. A run whose test step FAILS writes its summary anyway (turbo writes the run summary at run end with execution.failed counted; the dev reproduced this with an out-of-range shard, and the script's own header documents the "a failed task" case in its kept-line), so save=true and the seed carries the closure plus no entry for the failed dogfood#test (turbo caches no failed task). That is Test Core's "keep the seed fresh even when a test fails" behaviour (L1757-1760) and is RIGHT.

② Semver level

The diff publishes nothing: one workflow file, no package, no spec surface, no skill, no ADR. skip-changeset is correct and Check Changeset is green. Clause-②: no on the PR body is right for a CI-only diff: nothing a consumer imports is widened, narrowed or declared. No (narrowing) arm is owed. Metadata-protocol: none is consistent.

③ Boundary flags

(a) No --extra-summaries. ANSWERED, sound, for every shard and for a red or cancelled test step. The argument has two legs and both hold in the tree. First, set identity: turbo.json gives test dependsOn: ["^build"] and build dependsOn: ["^build"] with no @objectstack/dogfood#test or #build override (the overrides present are docs#build, skills#build, console#build:dist, spec#gen:migration-registry, spec#build, core#build, organizations#build, plugin-auth#build, create-objectstack#build, each still ^build or a leaf and each reached identically from both roots). So turbo run test --filter=@objectstack/dogfood plans dogfood#test plus the transitive ^build closure, and turbo run build --filter=@objectstack/dogfood plans dogfood#build plus the same transitive ^build closure. The one node the test plan lacks is dogfood#build, which packages/qa/dogfood/package.json gives no build script (scripts: typecheck, test only), so it executes nothing and turbo writes no entry for it. Second, hash identity: the only env the test step adds is OS_TEST_SHARD (declared on the test task alone, so it enters dogfood#test's hash and no build hash) and VITEST_MAX_WORKERS (globalPassThroughEnv, never hashed); neither step sets OS_SKIP_DTS, the one globalEnv; NODE_OPTIONS is set identically on both; the TURBO_* remote-cache variables are turbo configuration, not hash inputs. So every shard's test summary names the closure build tasks under the hashes the closure step wrote them with, which is also what the job's standing comment measured (66 of 66 identical) and the dev re-measured (71 of 71). Test Core's --extra-summaries leg exists because its closure summary is physically moved out of .turbo/runs/ by assert-turbo-remote-cache.mjs --move-summary-to and because its test tasks for cli and metadata depend on their OWN build, which its PKG^... closure filter leaves out; the dogfood job runs no such assertion and has no own-build dependency. On a red test step the summary is still written and names the closure (judgment ①.5). On a cancelled or stall-killed test step there is no summary and the script says save=false and prunes nothing (judgment ①.4), so the extra leg could never have rescued anything: with run.summaries.length === 0 the script returns before extraSummaries is read (the nothing to seed battery pins exactly this: "no run summary: do not save, even with an extra summary present"). Sound.

(b) The pruned seed must still serve upgrade-harness-optin.yml's closure. ANSWERED, it does, including tasks the test step does not plan, because there are none with an entry. The harness restores turbo-dogfood-1-main-SHA, then the turbo-dogfood-1-main- and turbo-dogfood- prefixes (L94-99, unchanged by this PR), and runs pnpm turbo run build --filter=@objectstack/dogfood --concurrency=4 (L102). That plan is the closure of (a) plus the command-less dogfood#build root. Every closure task with a command is named by shard 1's test summary under the same hash (a), so its three files survive the prune; the root writes no entry under either plan. The harness runs on a pull_request with no TURBO_TOKEN and no TURBO_* env at all, so this seed is its ONLY cache; that is the reason ruling 6458731814 chose prune over drop, and this PR keeps the seed where restore-only would have made the harness cold (66-task closure). Changed packages on a harness PR miss as they always did. The other turbo-* readers in ci.yml do not read this seed: dogfood-verify falls back to turbo-dogfood-verify- and turbo-build-core- (L2656-2663), temporal-conformance to turbo-build-core-, ui-published-artifacts to turbo-build-core- and turbo-ui-deps-.

(c) Fixes #25452 vs Part of #25452. The seat is right to change it, and it should before landing. The card's Acceptance owes an after-reading taken after at least 5 merges to main, and ruling 6458731814 and the triage history (6487355419, 6508650688) keep step 3, the pool reading, as the card's remaining step; Fixes would close the card at merge with that step undone. Part of #N is a recognised, non-closing shape in this repo (check-closing-target-claim.mjs L89: "a Part of #N target is not a closing keyword", and the Part-of closing-keyword guard in pr-body-guards.yml is built on it), so the PR-body guards accept it. This is a PR-body matter, not a tree finding, so it does not bear on the verdict; it is listed as a should-fix for the seat below.

④ Design judgment

hits file: .github/workflows/ci.yml, job dogfood. The change is read against the script it wires (prune-turbo-cache.mjs on main), the precedent it copies (Test Core L1736-1766, Build Core L3099-3118), the restore it must keep serving (upgrade-harness-optin.yml L90-102), and the ruling and the card.

Against the ruling and the card. Ruling 6458731814 letter A names the Build Core, Type Check and pack-smoke seeds, which #27067 already landed; the dogfood seed surfaced only in pool reading 6647111495. The PR applies A's principle to it — "each seed-save step is wired behind scripts/ci/prune-turbo-cache.mjs --site … exactly as Test Core … so a seed holds only the task entries its own run used" — and that is also the card's own change 2(b) verbatim ("prune .turbo/cache to the run's own hashes before save, to cut the per-shard size"). The pool reading's suggestion (save only on opt-in runs, or restore-only) is the drop path the ruling refused for the reason in (b): the harness has no remote-cache token. A: prune, not drop — HOLDS. No new script (the script is unchanged, git grep prune-turbo-cache outside the workflows finds only itself and two ui test files about the ui jobs), no new gate, no new --site registry to update (none exists), pool limit not raised, restore keys untouched in both workflows — HOLDS. The pool reading's attribution of the 3.69 GB writer to upgrade-harness-optin.yml:96 is wrong in the way the dev says: that step is actions/cache/restore@v6 and never saves; the writer is this job's save (github.job is dogfood, so the key is Linux-turbo-dogfood-SHARD-main-SHA). The PR prunes the real writer.

Attempts to break it:

• A shard whose test step is skipped (the closure build reds). The leftovers report and completeness guard run on always() and exit 0; the stall-report upload runs on failure(); the prune runs (always(), push), finds no .turbo/runs, prints NOT SAVED and save=false, exit 0; the save is skipped; the attestation pair does not run because the job is already red, exactly as today. No seed is written, the previous one stays newest. Holds.
• A cancelled run. always() steps run on cancellation. If turbo had not yet written its summary, save=false, no save (before this PR a cancelled push run saved the whole seed — the header comment at L81-83 records that this is how cancelled runs still wrote seeds). If it had, save=true and a pruned seed is saved. Either outcome is bounded and correct. Holds.
• The attestation pair. "Attest this shard ran and passed" and "Publish this shard's attestation" are still the job's last two steps and carry no if: and no continue-on-error: (head L2607-2621); the prune and save are inserted ABOVE them. check:shard-attestation pins this statically and is green in Lint · repo and tooling gates on this head. The prune has no continue-on-error, so a non-zero exit would red the shard before the attestation — the same exposure Test Core and Build Core accepted, and prune()'s documented run-time paths all exit 0 (exit 3 is reserved for malformed arguments, which the wiring does not produce). Holds.
• Concurrency between the three shards' saves. Each shard saves under its own key (-${{ matrix.shard }}- with github.sha), fail-fast: false; no two shards or two push runs ever write one key (the header's concurrency note at L84-88 makes the same point for Test Core). The job-level turbo-dogfood- fallback on restore can hand a shard another shard's seed, and the prune then drops the other shard's dogfood#test entry and keeps the shared closure; that is the behaviour the seat accepted on ci: prune each Test Core Turbo seed to its own run's tasks before saving it #25523 and it only shrinks seeds further. Holds.
• always() semantics. always() && github.event_name == 'push' && steps.prune-turbo-cache.outputs.save == 'true' evaluates on success, failure and cancellation, and is false off push or when the prune did not say save=true; check:workflow-status-functions is green. Holds.
• First run after landing. Shard N restores the newest turbo-dogfood-N-main-* (3.69 GB on shard 1), the prune drops every entry outside the run's closure and test task, and saves the remainder; the dev's closure-only estimate is about 36 MB per shard plus the dogfood#test log archive, against the 2.41 GB to 0.8-48 MB transition Test Core measured on its first run. The pool effect is about 0.1 GB per merge instead of about 11 GB. Holds; the measured post-prune lines are owed on the first push run, as the ruling asks.

Findings:

• Must-fix: none.
• Should-fix (PR body, not tree): change Fixes #25452 to Part of #25452 before landing, per ③(c), so the card stays open for its step 3 after-reading.
• Should-fix (follow-through, not this diff): record the first push run's three prune-turbo-cache: Dogfood Regression Gate (N/3): … lines on the PR or the card, as ruling 6458731814 asks for each pruned seed; the seed-size figure in the PR body is a closure-only local estimate and says so.

Note, not a finding: the save step still has no timeout-minutes or continue-on-error, like Test Core's and Build Core's and unlike the ui jobs' (turbo-cache-save-bound.test.ts covers the ui jobs only). This PR shrinks the upload from about 3.69 GB to tens of MB, so it reduces rather than adds the objectui#6577 exposure; bounding the core saves is a separate card if anyone wants it.

Implemented-by: claude/issue-25452-dogfood-seed-prune
Reviewed-by: session_017ihL2ebbZkr2QAEG1x7UC8

VERDICT: PASS

[objectstack-fleet]

domain:devx#2 · marchtian · session_017ihL2ebbZkr2QAEG1x7UC8

席位核对 — ACCEPT · domain:devx#2 · Head-sha 2a737765dfeb0e95a52ee6ef6a84597759e2b0a0 · 2026-11-05T03:15Z

• Shape: one file, .github/workflows/ci.yml, dogfood job only, +23/−2 (read from the diff): --summarize on the test step's turbo command, a new Prune the Turbo cache to this run's tasks (main only) step running scripts/ci/prune-turbo-cache.mjs --site 'Dogfood Regression Gate (N/3)', and the save gated on its save output, the same expressions as Test Core and Build Core. Restore keys, upgrade-harness-optin.yml and the attestation pair (last, unconditioned) are unchanged.
• Against the ruling (6458731814, A: prune, not drop): no new script, no new gate, no site registry, the pool limit is not raised. The seed stays, because the upgrade harness is a PR run with no remote-cache token and this seed is its only cache.
• Premise and estimate: pool reading 6647111495 (hotlong, at 474c030b13): turbo-dogfood-1-main-<sha> ≈ 3.69 GB per sha, two live = 95% of the pool. The writer is this job's save step (ci.yml), not upgrade-harness-optin.yml:96, which only restores. Dev's local closure-only estimate (report 6648534124): 304.3 MB → 35.7 MB after prune, all 69 harness closure tasks kept.
• Contract review (Tier H, .github/workflows/**): Fable PASS 6648691312, no must-fix. Should-fix 1 (Fixes → Part of #25452, since the card still owes its after-reading) is applied to the PR body. Should-fix 2 (record the first push run's three prune-turbo-cache: lines) is the seat's follow-through after merge.
• Gates: every check-run on the head is success (49) or skipped (15); check-expected-skips OK, all 15 skips in main's roster. The dogfood legs skip on pull_request by design, so the changed job first runs on the first push to main. Local dispatch-gates --commands 53/53 exit 0, --ran reconciled.
• Out of scope: Skills-docs: n/a, Clause-②: no, Metadata-protocol: none. The core save steps carry no timeout-minutes (reviewer note, not this card).
• Landing: skip-changeset. Tier H: ready, reviewers os-zhuang and hotlong requested, needs-user-decision; the seat lands it through the merge queue after an authorized approval.