kubuszok/balticporter/consumer-ci

Consumer CI — the loop

CI is not the debugger. One push per cycle, every row green locally first.

1. The loop

1. Collect EVERY failing job (JVM, JS, Native, Android, packageSrc, scalafmt, covenant gate,

the cancelled dependents). Read each log to its root cause; group by cause.

1. Classify each cause: engine (a), parameterised phase/policy (b), library rule (c), consumer

build (aliases, pins, markers), pre-existing drift. The fix goes where the cause is — almost always in Baltic Porter, never in the consumer's generated tree.

1. Fix ALL known causes; measure the lanes (iterate-lane); publish; pin; regenerate; the whole

chain locally (step 3); then push. A red CI after that returns to step 1 for ALL failures — never a one-line patch and another push.

2. What counts as cheating (each was tried, each was reverted)

• @Ignore/.ignore on a test, deleting a test, an empty suite, assert(true).
• Editing a test to the generated spelling (same.getOrElse(null), boxed Float.valueOf) —

the test is master's; the generated spelling is wrong.

• testFull → compile, a JS/Native row downgraded to compile-only, a module skipped in an alias.
• Growing .rescale/data/covenant-gate-baseline.tsv; a @nowarn, null.asInstanceOf,

.getOrElse(null) in a hand file (the scanner counts them: null-cast, get-or-else-null).

• A JVM-only dependency (jackson, ANTLR, reflection) to make a row pass.
• Patching an extension to the generated core's spelling (u_=→setU, compare→compareTo):

the fix is the derivation/fold that made the core diverge from master; then git checkout <merge-base> -- <file> puts the extension back.

3. The chain (sge; ssg is the same shape)

# Baltic Porter                          # JDK 22
git commit …; sbt --client "reload; publishLocal"      → note <hash> (the version IS the commit)
# sge                                    # JDK 25 (a real 25: see sbt2-client §6)
Edit project/plugins.sbt: both balticporter pins → <hash>-SNAPSHOT
sbt --client "reload; generatePort"
sbt --client "testCompile-jvm-3"; sbt --client "testCompile-js-3"; sbt --client "testCompile-native-3"
git commit …; sbt --client "verifyLocal"   # ci-jvm-3; test-js-3; test-native-3; records the verified commit
sbt --client "scalafmtCheckAll; scalafmtSbtCheck; sge / Compile / packageSrc"
PATH=<re-scale>/bin:$PATH .rescale/scripts/covenant-gate.sh

Each command through tee (skill sbt2-client). Rows fail in order: fix the first row's root cause before reading the next; the same cause usually explains all three.

A hook refuses git push in a consumer until target/local-verification names HEAD (changes to docs and .github/ alone are exempt). A LOCAL pin is never pushed: push the engine ONCE, wait for its snapshot release to finish, probe the pom (skill generated-code), repin to that hash, verify, push.

What CI does with it (sge): one generate job runs Baltic Porter and stores the tree in the Actions cache; compile builds each platform row once into the remote cache; every other job restores both and only links and runs; the demos build against the snapshot release.yml publishes. After a push: ONE gh run watch <id>, then read every red job before touching anything — never poll, never re-push a one-line guess, never an empty commit to retrigger (gh run rerun <id> --failed).

4. The consumer's generator and dedup

project/BalticPorterGen.scala drops a generated file whose path exists under src/main (the hand file wins). So an "inject copy" living in src/main shadows the injected file and its covenant header shows up as missing-header: delete the copy (six were), never header it. "N fatal finding(s)" downgraded to a warning by the generator are pre-existing dropped-type references the hand tree replaces; new fatal kinds are yours.

Every generator input is a fixed object, never a branch name. sge's generator read the hand-written reference tree from master; the pull request was green because master still held that tree, and the merge itself removed it — master's first CI run failed to compile with hundreds of type mismatches naming no cause. A reference tree is pinned by commit hash in the generator source (so it is part of the generated tree's cache key), and a pull request's green run proves nothing about the push run on the default branch when an input is read from that branch — after a merge, read the default branch's own run.

5. The covenant gate

re-scale enforce verify --all / enforce shortcuts --covenanted behind .rescale/scripts/covenant-gate.sh. Growth vs merge-base (a new (file, kind) pair, a raised count, rows removed with a deleted file) needs covenant-baseline-approved: <reason> in EVERY commit that edits the baseline since merge-base; an uncommitted baseline edit can never be approved. methods-removed lists the names (re-scale enforce verify --all | grep 'methods removed'); each is a spelling the generated core lost against master — a derivation question first, a header edit never.

6. What to report

Per row: the count before → after, the root cause per group, which repository fixed it, and the residues left with their owner (pre-existing drift, parked engine items) — never "green" without the three rows' test totals.