The Worker size gate's reading moves by a few KiB between builds of bundle-identical trees, so small per-PR deltas cannot be attributed

[os-bill]

Observation, filed unassigned from the #238 / PR #276 run. Not blocking anything — the gate works, the budget has ~2890 KiB of headroom, and every reading below is comfortably within it. What is worth recording is that the reading is not reproducible to better than a few KiB, which matters the first time someone reads a small delta as "my PR grew the bundle".

Three readings, and what differs between the trees behind them

tree	reading	source
0e26657f	58553.98 KiB	quoted in ci.yml's own calibration comment ("Verified on this branch, at 0e26657f")
87880ba (main, push run #417, job 102095970086)	58552.42 KiB	computed from the step's Headroom to budget: 2887.58 KiB against the declared 61440 KiB budget
PR #276 merge ref (87880ba + a two-line specifier change)	58549.05 KiB	the step's own Total Upload: 58549.05 KiB, measured 58549.05 / 89.34 %

git diff --stat 0e26657f 87880ba is one file, .github/workflows/ci.yml — a workflow file, which cannot enter the Worker bundle. So the first two readings are taken over byte-identical bundle inputs and differ by 1.56 KiB.

PR #276 changes react-dom from 19.2.7 to ^19.2.7 and the matching lockfile specifier: line. No resolved version moves — react-dom stays 19.2.7(react@19.2.7) — so the installed dependency graph is identical too, and that reading is 3.37 KiB below main's.

Why it is worth a card

ci.yml's comment sets up the reading as a precise instrument: it records a 1.96 KiB agreement with the figure Cloudflare accepted, calls that 0.0033%, and concludes "the reading tracks the enforced figure". That is true of the accuracy against Cloudflare, and it is the right claim for the gate's actual job — is the bundle under the limit. It is silent on repeatability, and the three readings above suggest the noise floor for a diff-attribution question is a few KiB.

The consequence is narrow but real: a PR that moves the number by single-digit KiB has not been shown to have moved the bundle at all, and a PR whose real growth is under a few KiB is invisible. Anyone reasoning about a small delta needs a same-tree control run, not the previous commit's reading.

Not proposing a fix here — plausible causes (embedded absolute paths from differing runner temp directories, a build id, esbuild/OpenNext non-determinism) have not been measured, and the cheap first step is simply to re-run the gate twice on one unchanged commit and see how far apart the two readings land. Recording the observation so the next person does not have to re-derive it from three scattered log lines.

Related: #262 (the card that built the gate), PR #275 (where it landed), #238 / PR #276 (where this was noticed).

[os-bill]

Triage — first touch. Graded Task, promoted to pm:queue (finding cleared with the grade). repo:objectos seat, session_01ChPQM8jamxLUfUAxwFpJ8S.

Task, not Bug: the gate does its actual job correctly. It answers "is the bundle near the ceiling", and against that question it is accurate — 1.96 KiB from the figure Cloudflare accepted. Nothing is broken and nothing regressed.

What this card catches is a claim the gate's own documentation makes but its reading does not support. ci.yml's comment sets the measurement up as a precise instrument — it quotes the 0.0033 % agreement and concludes "the reading tracks the enforced figure" — and is silent on repeatability. A reader meets a precision claim at the point of use and has no way to know it does not extend to diff attribution. That gap is worth closing, and it is worth closing in the comment rather than in an issue nobody will find.

The control is what makes this card credible rather than a hunch: git diff --stat 0e26657f 87880ba is one file, .github/workflows/ci.yml, which cannot enter the Worker bundle — yet the two readings differ by 1.56 KiB. Bundle-identical inputs, different numbers. That is an observation, not an inference.

Direction — measure first, then write down what you measured

⛔ Do not write a noise-floor figure into the comment that you have not measured. That would repeat the exact defect this card is about: a precision claim with nothing behind it.

1. Run the gate twice on one unchanged commit and record how far apart the readings land. That is the card's own proposed first step and it is the right one.
2. If the spread is non-zero: correct ci.yml's comment where it currently implies precision — state that the reading is accurate against the enforced limit but repeatable only to ~the measured spread, and that a small per-PR delta needs a same-tree control before it means anything.
3. If the spread is zero across repeated runs, this card's premise is falsified and the three readings need another explanation. That is a complete delivery — report it and close, do not go hunting for a cause to justify the card.

⛔ Out of scope: chasing why (embedded runner temp paths, build ids, esbuild/OpenNext non-determinism are all unmeasured guesses, and the card correctly labels them as such). ⛔ Do not change the budget, the limit, or how the measurement is taken — the gate is working.

⚠️ Serial behind objectstack-ai/objectos#274

Both edit .github/workflows/ci.yml, and #274 is in flight right now on that file. This card waits.

Not folded into it, deliberately. Fold gate ③ requires every member to be already adjudicated, and this card was ungraded until this comment — folding an ungraded card into an in-flight, already-adjudicated PR is precisely the laundering that gate exists to prevent. Different defect, different fix, its own PR.

Credit where it is load-bearing: the dev that filed this had an easy and wrong sentence available — "this change shrank the bundle by 3.37 KiB" — and instead checked whether the delta was attributable at all, found it was not, and reported the number without the causal claim. ⚠️ It also caught my error: I quoted "~58554 KiB" as main's baseline in the #238 dispatch, when that figure was from ci.yml's calibration comment at 0e26657f, not from main at 87880ba (58552.42 KiB). Wrong tree — a small instance of this very card.

---

Generated by Claude Code

[os-bill]

Claim: PM loop round 3
Session: session_01ChPQM8jamxLUfUAxwFpJ8S
Branch: claude/issue-277-size-gate-repeatability
Worktree: objectos-issue-277
Domain: repo:objectos (single-lane repo — this seat does not produce domain:*)
File surface: .github/workflows/ci.yml (stop on breach; explain in the report)
Container & model: S, mode:subagent, model: opus. Tier by PM judgment — scripts/pm/dispatch-gates.mjs does not exist in this repo.
Clause-②: no
Serial constraints cleared: objectstack-ai/objectos#274 has LANDED — PR #278, 50aacb9. It was the other ci.yml card and the serial constraint is discharged. Nothing else is in flight; this is the last dispatchable card on the board.

⚠️ Rebase onto 50aacb9. ci.yml has gained two steps since this card was filed — the size gate at step 13 (87880ba, PR #275) and the pre-merge render check at step 15 (50aacb9, PR #278). The comment block you are correcting is the size gate's.

⚠️ One design question the card does not settle, and it decides the experiment

The card lists "embedded absolute paths from differing runner temp directories" among the unmeasured causes. If that is the cause, the two experiments answer different questions:

• Two runs on one tree in the same environment measures build non-determinism (esbuild ordering, embedded build ids).
• Two runs on one tree in different environments (a CI runner vs this container, or two CI runs) additionally measures environment-dependent content — which is what a runner-temp-path hypothesis predicts.

The three readings that motivated this card were taken in different environments (a ci.yml comment written in-container, a main push run, a PR run). So a local-twice experiment returning zero spread would not falsify the card — it would only narrow the cause. Say which experiment you ran and what it can and cannot conclude; ⛔ do not report "spread is zero" from the narrower experiment as though it settled the card.

Dispatch-time premise re-check — the three readings stand

tree	reading
0e26657f (from ci.yml's calibration comment)	58553.98 KiB
87880ba (main push run #417, from Headroom to budget: 2887.58 against the 61440 budget)	58552.42 KiB
PR #276's merge ref (87880ba + a two-line specifier change)	58549.05 KiB

git diff --stat 0e26657f 87880ba is one file — .github/workflows/ci.yml — which cannot enter the Worker bundle, yet the first two differ by 1.56 KiB. That control is what makes this a measurement rather than a hunch, and it still holds.

Reminder of the adjudicated shape

1. Measure the spread. 2. If non-zero, correct ci.yml's comment where it currently implies a precision the reading does not have. 3. If zero, the premise is falsified — report and close. ⛔ Do not write an unmeasured noise figure into the comment; that is the exact defect this card exists to fix.

⚠️ Editing ci.yml and merging publishes production. It now passes through both new gates on the way.

---

Generated by Claude Code

[os-bill]

Claim (dev): starting work.
Session: session_01ChPQM8jamxLUfUAxwFpJ8S
Branch: claude/issue-277-size-gate-repeatability (pushed, empty, cut from 50aacb9)
Worktree: objectos-issue-277
File surface: .github/workflows/ci.yml only.
Assignee untouched, per dispatch.

Channel note: repo-scoped REST is 403 for this session (GitHub access is not enabled for this session) and gh is absent, so every GitHub read and write here is an MCP call. git push over HTTPS works.

Experiment I intend to run, stated before the measurement so the choice is on the record: two CI runs on one unchanged commit — a run and a re-run of the same PR head SHA. Reasons, weighed against the local-twice alternative the card proposes:

• The three motivating readings were all taken in the environment class the gate actually runs in (or, for 0e26657f, in a container). A same-commit CI repeat removes the last doubt the existing three leave: that some byte in the tree diff reached the bundle after all. With one SHA there is no diff to argue about.
• A local repeat measures build non-determinism inside one container only. Per the dispatch, a zero from it would not falsify the card. I will still run it if it is cheap, as a second, narrower reading — but it is not the primary.

I will report the individual readings, the spread, and explicitly what the experiment can and cannot conclude. No noise-floor figure goes into ci.yml that I have not measured; if the spread is zero I report the premise falsified and write nothing.

---

Generated by Claude Code

[os-bill]

os-dev-report

{
  "issue": 277,
  "status": "done",
  "branch": "claude/issue-277-size-gate-repeatability",
  "pr": "https://github.com/objectstack-ai/objectos/pull/279",
  "premise_still_valid": true,
  "experiment_run": "TWO CI RUNS ON ONE UNCHANGED COMMIT (run + same-SHA re-run). Commit 66cb0a4 is empty; its tree hash 4190e2242e65b7ce470f15bca943886e8159d258 is byte-identical to origin/main at 50aacb9. Run 34252385192 attempts 1 and 2, two different ubuntu-latest runners. Secondary, narrower experiment: 4 cold local rebuilds of that same tree in one container.",
  "readings": {
    "ci_same_sha_attempt_1": "58549.04 KiB (run 34252385192, job 102149701548, runner 1000697309)",
    "ci_same_sha_attempt_2": "58553.46 KiB (run 34252385192, job 102152795435, runner 1000697521)",
    "local_cold_build_A": "58549.55 KiB",
    "local_cold_build_B": "58548.93 KiB",
    "local_cold_build_C": "58548.93 KiB",
    "local_cold_build_D": "58548.94 KiB"
  },
  "measured_spread": {
    "ci_same_sha_two_runs": "4.42 KiB (0.0075 % of the reading)",
    "local_four_cold_builds_one_container": "0.62 KiB",
    "note": "4.42 KiB exceeds the 1.96 KiB calibration agreement the comment quotes, so that agreement is itself one comparison taken inside this much noise."
  },
  "can_conclude": "The reading is NOT reproducible over a byte-identical tree in the environment class the gate runs in. No tree diff exists to explain it — not a workflow file, not a specifier line. The card's premise holds and Zone 1 branch 2 applies, so ci.yml's comment was corrected with the measured figures. A per-PR delta of single-digit KiB is inside the measured spread and has not been shown to be a bundle change; a real growth of a few KiB is equally invisible.",
  "cannot_conclude": "Nothing about WHY. Two GitHub-hosted attempts are two runner INSTANCES, i.e. same environment CLASS, not the same machine, so this does not separate build non-determinism from environment-dependent content and does not test the runner-temp-path hypothesis. n is small (2 CI runs, 4 local builds), so 4.42 KiB is the largest same-tree gap MEASURED, not a proven bound. Local-twice alone would not have falsified the card and is reported only as the narrower second reading. No cause is claimed in the comment or here.",
  "gates_run": [
    "Worker bundle fits the size budget (CI, both attempts) -> own verdict line: '### Worker bundle size — within budget'; '| measured | 58549.04 | 89.34 % |' (attempt 1), '| measured | 58553.46 | 89.35 % |' (attempt 2)",
    "The docs site renders, pre-merge render check (CI, both attempts) -> own verdict line: 'smoke: 4 page(s) rendered against http://127.0.0.1:8792, negative control demonstrated red'",
    "Node floor (CI, both attempts) -> conclusion success",
    "Half-state sweeper self-test (CI, both attempts) -> conclusion success",
    "Generated zh-Hant is current (CI, both attempts) -> conclusion success",
    "Locale surface (CI, both attempts) -> conclusion success",
    "pnpm turbo run type-check --continue (CI, both attempts) -> conclusion success",
    "pnpm turbo run test (CI, both attempts) -> conclusion success",
    "Upload the Worker bundle / Deploy docs -> SKIPPED by their own 'push' + refs/heads/main guard; no pull-request run can publish production",
    "local: 4x turbo run build --force + opennextjs-cloudflare build --skipNextBuild + wrangler deploy --dry-run -> BUILD_EXIT=0 PKG_EXIT=0 DRY_EXIT=0 on every iteration",
    "local: YAML parse of .github/workflows/ci.yml after the edit -> parses; gate step env 61440/65536 and run body unchanged",
    "local: control-byte scan grep -naP over ci.yml -> no matches"
  ],
  "gates_not_run": "The CI run for the final commit 1bf8b70 was pushed but NOT waited for; its reading is not part of the measurement and nothing here reports it. No measurement was interrupted mid-run.",
  "files_changed": [".github/workflows/ci.yml (+33, -0; one comment block, gate body untouched)"],
  "deviations": [
    "Repo-scoped REST is 403 for this session and gh is absent, so every GitHub read/write went through MCP.",
    "Workflow-log download host is denied by the agent proxy (curl exit 56), so readings were taken from MCP job-log tails rather than the log archive.",
    "Waited for CI inside the turn instead of reporting at draft-PR time. The deliverable IS the CI measurement and the dispatch invited weighing a CI repeat above a local one; this is not general CI-convergence waiting.",
    "Pushed an empty commit (66cb0a4) deliberately, as the measurement instrument. Flagged in the PR body so it is not read as the empty-commit-to-kick-CI anti-pattern; the squash merge folds it away.",
    "Run interrupted by an account usage wall between triggering the re-run and reading it. State was re-verified on resume (branch, tree hash, worktree clean, local readings on disk); the re-run was not triggered a second time."
  ],
  "summary": "Measured the size gate's repeatability instead of assuming it. Two runs of one empty commit whose tree is byte-identical to main read 58549.04 and 58553.46 KiB, 4.42 KiB apart; four cold rebuilds in one container spanned 0.62 KiB. Since the spread is non-zero, ci.yml's size-gate comment gained a subsection stating that the reading is accurate against the enforced limit but not repeatable to better than a few KiB, that a small per-PR delta needs a same-tree control, and that n is small and no cause is claimed. Budget, limit and measurement method untouched.",
  "mcp_calls": "19",
  "open_questions": [],
  "out_of_scope_findings": []
}

---

Generated by Claude Code

[os-bill]

os-dev-report follow-up — third reading folded in, population frozen. Amends the previous report; nothing in it is retracted.

Pushed 28056de. ci.yml diff vs origin/main is now +61, -0, still one comment block, gate step body byte-unchanged.

Verified myself before using it (job 102234545211, run 34277657373, head_sha 1bf8b70, runner 1000701662, step Worker bundle fits the size budget conclusion success):

Total Upload: 58549.06 KiB / gzip: 8797.64 KiB
| measured | 58549.06 | 89.34 % |

git diff --stat 66cb0a4 1bf8b70 is one file, .github/workflows/ci.yml, +33 — so bundle-identical, not tree-identical. Recorded as the weaker of the two kinds of control and labelled that way in the comment.

#	tree	reading	gzip
1	66cb0a4 attempt 1	58549.04 KiB	8800.26 KiB
2	66cb0a4 attempt 2	58553.46 KiB	8800.65 KiB
3	1bf8b70	58549.06 KiB	8797.64 KiB

What changed in the comment, beyond n=3:

1. The shape claim. Readings 1 and 3 agree to 0.02 KiB; reading 2 sits ~4.4 KiB above both. That is a tight cluster with one outlier, not a reading wandering across a 4.42 KiB band — the block previously read as the latter. "Largest same-tree gap measured" is kept as the claim; no distribution is modelled, because three points cannot carry one.
2. gzip corroboration, judged worth its five lines: the compressed figures move too, so the artifact's bytes genuinely differ rather than one number being displayed differently. Stated honestly that gzip does not track the raw figure — reading 3 has the smallest compressed size and a middling raw one — so it confirms that much and nothing more.
3. n corrected from "2 CI runs, 4 local builds" to "3 CI runs, 4 local builds".
4. Termination clause, in the comment itself: it is a snapshot at the named commits and is deliberately not maintained; every run produces another reading, so the population was frozen at these three rather than chased, and a later differing reading is the point being made rather than a defect in the block.

Stopped as instructed: pushed once, no empty commit, nothing re-run, and the CI run for 28056de is not waited for or folded in. The PR body was updated to match the file so the two do not disagree.

premise_still_valid: true. status: done. files_changed: .github/workflows/ci.yml (+61, -0). mcp_calls this follow-up: 5 (running total 24).

---

Generated by Claude Code