[aitrawog]

Refs #785

Summary

Head 8f2bcdd2f46e0160229721c8b37c14ff7207f766 — 2 files changed, 2 insertions(+), 2 deletions(-).

The umbrella's second consumer wave. It advances the two gitlinks this repo's own currency report says are not current, and nothing else in this tree.

file	recorded	served	what the served commit is
docs	cf7e4a132d	a166ee12d8	the docs: add CHANGELOG 2026.302.0032 for PR #198 record — one commit ABOVE opencharly/docs#198's squash d4ead50d, which carries the tag v2026.302.0032
plugin-box	803541c15d	6b7a8bc9d8	the docs: add CHANGELOG 2026.302.0047 for PR #75 record — one commit ABOVE opencharly/plugin-box#75's squash 876d566d, which carries the tag v2026.302.0047

Why those two, and why no more. The question is the org's own, asked by the product and not by my reading of it:

$ ./charly/bin/charly task pins --param MODE=currency 2>&1 | grep -v "^plugin "
task pins: 1 step(s), 0 failed, 0 skipped
  [pass] run — run git-submodules in the selected mode
      currency: 2 of 409 pin(s) NOT current [1 behind, 407 cur, 1 differs (no checkout to judge ancestry)]; intents: 403 upstream leaf/leaves (403 implicit), 6 derived-from edge(s); NOT CURRENT: docs: differs (no checkout to judge ancestry); intent upstream:main (implicit: .gitmodules branch=); recorded cf7e4a132d; served a166ee12d8 (branch); plugin-box: behind; intent upstream:main (implicit: .gitmodules branch=); recorded 803541c15d; served 6b7a8bc9d8 (branch); producer-first legs: plugin-box (803541c15d -> 6b7a8bc9d8)

407 of 409 pins are already current, so the wave's scope is two gitlinks and not a sweep of the org. docs is the leg that carries the docs repo's own pin advance (opencharly/docs#198, merged 2026-10-29T00:32:10Z); plugin-box moved because its producer landed twice more since the last wave — #74 (the skill body's base) and #75 (the count assertion and the record's correction), both with their merge-time records.

A pin's served commit is NOT the tagged commit, and this body says which is which. A pin's intent here is upstream:main, so it resolves to the branch TIP; in this org that tip is the merge-time RECORD that tag-on-merge writes after the merge, while the merge-time TAG sits on the squash one commit below it. Both served commits above are those records, and both tags sit on the squashes beneath them — measured, not asserted, in How tested §3. This is the correction #794 landed in CHANGELOG/2026.301.2326.md.

What the two advances carry. docs — opencharly/docs#198 advanced that repo's corpus and plugin-build pins and regenerated the site, so the published site's last carriers of the retired knob went with it. plugin-box — the skill body's base (the loader reads the owning candy's REPO ROOT, not the candy's own directory), the standing floor guard that keeps it there, the count assertion on the negative arm, and the correction of the record of the floor reproduction.

How tested

1. The scope is derived, and the report's own count is the control. The wave's base is a fresh origin/main (98476e9), and the product's own currency report on that tree names every pin that is not current — two of them, and exactly the two this diff moves. No pin in this diff was hand-picked. The report is pasted above, in Summary.

2. The wave, in the sanctioned order. The verb's own report is the scope control: it says how many pins moved, and the number is the two the currency report named — the six pin_map entries moved 0, one rolled leaf moved and one index-only advance moved.

$ ./charly/bin/charly task sync 2>&1 | grep -v "^plugin "
task sync: 2 step(s), 0 failed, 0 skipped
  [pass] run — advance EVERY submodule pin this repo declares (charly rolls first, then distro-* from its new gitlinks)
      pinned 6 pin_map entr(y|ies) (distro-arch, distro-cachyos, distro-debian, distro-fedora, distro-omarchy, distro-ubuntu; 0 moved) after rolling 11 leaf submodule(s) to their default-branch HEAD (1 moved) and advancing 392 leaf pin(s) in the index (1 moved); 2 pin(s) moved
  [pass] run — re-derive the harness skill bindings from the corpus the bump just advanced (the DSH farm and reasonix.toml's [skills] paths — a pin advance that skips this leaves them a family behind)
      exit=0

$ ./charly/bin/charly task init 2>&1 | grep -v "^plugin "
task init: 1 step(s), 0 failed, 0 skipped
  [pass] run — materialize the umbrella's submodules
      exit=0

The one rolled leaf is plugin-box (it has a checkout in this tree); the one index-only advance is docs (it does not, and a path with no checkout is still advanced in the index — its pin is audited from the index and reported as uninitialized (pin audited, no checkout), which is a notice, not a failure).

3. What each served commit IS — measured, tag and parent included. A gitlink carries no text of its own, so the proof that the right commit is recorded is the commit's own identity: its message, its parent, the tag that sits on that parent, and the files it changes.

$ gh api repos/opencharly/docs/git/refs/tags/v2026.302.0032 --jq '.object'
{"sha":"d4ead50d4de5d915a71f43f6502566bbde745904","type":"commit",...}

$ gh api repos/opencharly/docs/commits/a166ee12d829d3d3ab22731142e2b1e43fd17e4e --jq '.parents[].sha'
d4ead50d4de5d915a71f43f6502566bbde745904

$ gh api repos/opencharly/docs/commits/a166ee12d829d3d3ab22731142e2b1e43fd17e4e --jq '"sha: \(.sha)\nmessage: \(.commit.message)\nfiles:\n" + ([.files[] | "  \(.status) \(.filename) +\(.additions) -\(.deletions)"] | join("\n"))'
sha: a166ee12d829d3d3ab22731142e2b1e43fd17e4e
message: docs: add CHANGELOG 2026.302.0032 for PR #198
files:
  added CHANGELOG/2026.302.0032.md +312 -0

$ git -C plugin-box rev-parse v2026.302.0047^{commit}
876d566d988c5b8a4a398aa0d9c755b8a7f41895

$ git -C plugin-box rev-parse 6b7a8bc9d8^
876d566d988c5b8a4a398aa0d9c755b8a7f41895

$ git -C plugin-box log --oneline -3 6b7a8bc9d8
6b7a8bc docs: add CHANGELOG 2026.302.0047 for PR #75
876d566 test(skills): count the findings the negative arm asserts on, and correct the record of the floor reproduction (#75)
c41e3a3 docs: add CHANGELOG 2026.302.0039 for PR #74

Both tags sit on the producers' squashes and both served commits are one commit above them — the shape #794 corrected in the record, measured here rather than restated.

4. The content each advance carries. plugin-box is materialized in this tree, so its content is read from its own checkout, recorded tree beside served tree. docs has no checkout here, so its content is read from the remote that serves it.

$ git -C plugin-box diff --stat 803541c15d 6b7a8bc9d8
 CHANGELOG/2026.302.0039.md               | 182 +++++++++++++++++++++++++++++++
 CHANGELOG/2026.302.0047.md               | 164 ++++++++++++++++++++++++++++
 candy/plugin-box/go.mod                  |  27 +++--
 candy/plugin-box/go.sum                  | 108 ++++++++++++------
 candy/plugin-box/validate_skills.go      |   8 +-
 candy/plugin-box/validate_skills_test.go |  37 +++++--
 charly.yml                               |   7 +-
 7 files changed, 475 insertions(+), 58 deletions(-)

5. R9 — the worktree-local build, rebuilt AFTER the wave. The wave moves the plugin-box pin, and plugin-box is a plugin the binary compiles in, so the binary that gates this tree must be the build OF the advanced source. The build is the worktree-local, CalVer-stamped one, with the advanced checkout as the local plugin source.

$ ./charly/scripts/bootstrap-charly.sh --dev-plugin "plugin-box=$PWD/plugin-box"
bootstrap-charly: resolving compiled-in plugins from LOCAL checkouts:
bootstrap-charly:   plugin-box=/home/atrawog/Sync/Atrapub/a/claude/opencharly/.worktrees/umb-armD/opencharly/plugin-box
bootstrap-charly: the committed go.work is not used or touched.
bootstrap-charly: building bin/charly
bootstrap-charly: built ./bin/charly (2026.301.1936) — DEV BUILD, local plugin source
BUILD_RC=0

$ ./charly/bin/charly version
2026.301.1936

The CalVer is unchanged from the last wave because the charly pin did not move; the plugin source behind it did.

6. The post-wave currency: no pin is behind any more. The question the wave answers is is this repo CURRENT?, and the answer after the wave is that every pin is at the ref its intent names.

$ ./charly/bin/charly task pins --param MODE=currency 2>&1 | grep -v "^plugin "
task pins: 1 step(s), 0 failed, 0 skipped
  [pass] run — run git-submodules in the selected mode
      currency: 0 of 409 pin(s) NOT current [409 cur]; intents: 403 upstream leaf/leaves (403 implicit), 6 derived-from edge(s); producer-first legs: none — every pin is at the ref its intent names

7. The change-class gate on the committed tree — charly task verify. The change class is a pin, so the gate that owns it is the umbrella's own charly task verify. It ran on the committed tree and its own verdict is 46 steps, 0 failed, 0 skipped — all 46 verdicts are [pass], and no line of its transcript carries a warning.

$ grep -E "task verify:|policy pin|currency:|RETIRED claim|VERIFY_RC" /tmp/umb-stagepar/wave-verify2.log | cut -c1-190
task verify: 46 step(s), 0 failed, 0 skipped
      verify: 6 policy pin(s) hold across 409 submodule(s); 17 checkout(s) clean at their gitlink; 392 uninitialized (pin audited, no checkout): charly-alpine, charly-arch, charly-debian, ch
      currency: 0 of 409 pin(s) NOT current [409 cur]; intents: 403 upstream leaf/leaves (403 implicit), 6 derived-from edge(s); producer-first legs: none — every pin is at the ref its inten
  [pass] check — the umbrella's own tracked tree carries no RETIRED claim form — the key set is COMMITTED, not written in a PR body, and the scan's unit is the CLAIM, which WRAPS (CHANGELOG/
VERIFY_RC=0

$ grep -c "\[pass\]" /tmp/umb-stagepar/wave-verify2.log
46
$ grep -c "\[fail\]" /tmp/umb-stagepar/wave-verify2.log
0
$ grep -ci "warn" /tmp/umb-stagepar/wave-verify2.log
0

8. R5 — the sweep, stated at the width the sweep decides. The retired knob's name is gone from the umbrella's own tree. The one advanced repo that still carries it does so deliberately: plugin-box keeps it in the explanatory comment that tells a reader which name the contract retired, and in the NEGATIVE arm of its migration test — whose fixture must BE the retired key, because that arm asserts the retired diagnostic no longer fires.

$ git grep -nE -- "--podman-jobs|CHARLY_PODMAN_JOBS|podman_jobs" -- . ":(exclude)CHANGELOG"
exit=1

$ git -C plugin-box grep -nE -- "--podman-jobs|CHARLY_PODMAN_JOBS|podman_jobs" -- . ":(exclude)CHANGELOG"
candy/plugin-box/box.go:234:// `CHARLY_STAGE_PARALLELISM`, not `--podman-jobs` / `CHARLY_PODMAN_JOBS`. The CONTRACT renamed that
candy/plugin-box/box.go:235:// knob `podman_jobs` → `stage_parallelism` (spec/schema/buildwire.cue, sdk/buildkit.
charly.yml:349:      # `defaults: podman_jobs must be >= 0, got -1` before the rename, and
charly.yml:355:          the MIGRATED build tunables, NEGATIVE arm: the retired key `podman_jobs` no longer
charly.yml:360:          operator whose charly.yml still says `podman_jobs` loses the setting without a word.
charly.yml:381:                podman_jobs: -1
charly.yml:387:              echo "invocation: box validate  (defaults.podman_jobs = -1, the RETIRED key)"
charly.yml:398:            grep -q 'podman_jobs must be >= 0' "$EV" && { echo 'FAIL: the RETIRED diagnostic still fires - the rule still reads the retired key'; cat "$EV"; exit 1; }
exit=0

docs is not swept from a local checkout — it has none in this tree — and its own pull request carries that repo's own sweep of the published tree, quoted in the record this advance carries.

9. The head this PR pushes, and the tree it carries.

$ git rev-parse HEAD
8f2bcdd2f46e0160229721c8b37c14ff7207f766

$ git status --porcelain | wc -l
0

$ git diff --stat origin/main...HEAD
 docs       | 2 +-
 plugin-box | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

Rulebook compliance

• R0 — the umbrella's AGENTS.md dispatcher selected /charly-internals:git-workflow (the pin contract, the charly task verbs, the wave's order, the PR body), /charly-internals:strict-policy (the R1 classification of what this leg carries) and /charly-internals:root-cause-analyzer (the tag-and-parent question). All three were read before this leg's first tool action.
• R1 — every anomaly this leg raised received a fresh RCA before any remediation; the gate is green with zero warnings, and every finding is either fixed in the repo that owns it or filed under ## Filed issues. The tag question this leg raised — whether a pin's served commit is the tagged commit — was settled by measurement (How tested §3), and the control gap behind it is filed as the currency report names each pin's served commit and never says whether a TAG points at it — so a body can call a pin 'merged and tagged' with no gate disagreeing #793.
• R2 — one canonical implementation: the wave runs the umbrella's own charly task verbs, and the umbrella records only the gitlink. No second copy of the wave's logic and no hand-maintained pin list enters the tree.
• R3 — no workaround: no hand-pin, no hand-typed git update-index, no branch checkout of a pinned repo, no ad-hoc fetch-and-hash, no sleep, no retry. The pins advance through charly task sync, materialize through charly task init, and are judged by charly task verify.
• R4 — the product was fixed before the prose: every producer landed in the repo that owns it, and this leg moves the pointers to it. This leg adds no prose of its own.
• R5 — no legacy path survives: the retired knob's name is gone from the umbrella's own tree, and the sweep in How tested §8 carries the one advanced repo's surviving hits with their classification.
• R6 — the work ran in its own session worktree, on branch feat/consumer-wave-docs-plugin-box off fresh origin/main 98476e9; the tree was clean before the wave and after it; no history was rewritten, no force-push, and nothing was pushed to main. No git command ran in this worktree while the wave was running — the wave's own staging holds the index lock.
• R7 — the changed paths executed live: the binary was rebuilt from the advanced plugin-box source, and each served commit's own identity, parent and tag were read from the repo that serves it.
• R8 — nothing is mocked: every measurement is against the real remote, the real checkout, the real index and the real pin contract.
• R9 — the binary is the worktree-local, CalVer-stamped build, and this diff moves the plugin-box pin, so the binary was rebuilt from the advanced source (charly version is pasted in How tested §5).
• R10 — the change class is a pin, so the gate that owns it is the umbrella's own charly task verify, run on the committed tree with zero warnings, plus the currency audit that answers is this repo CURRENT?.
• Hard cutover — one atomic commit, and no deferred work inside its scope.
• Part II fix: escape backticks in umbrella-gates.ts template literal #3 — the pins are gitlinks, advanced in producer-first order: every producer leg landed and was tagged first, and this PR is the umbrella's consumer leg of them.
• Part II chore: sync all submodule pins; spec no longer charly-pinned #6 — stage_parallelism consumer legs: the retired --podman-jobs flag name remains in consumer repos after the BuildKit cutover #785 carries the CLAIM and this PR's STATUS.
• Part II chore: sync gitlinks to the landed sdk de-submodule cutover #11 — a STATUS is posted at each milestone.

Change classification

Two pins. The diff advances two submodule pointers. It changes no Go source, no schema and no prose in this repo — but it moves the plugin-box pin, so the worktree-local binary this repo builds is rebuilt from the advanced source.

• Change class: a pin wave (two gitlinks the umbrella's pin contract audits), the consumer leg of the landed stage_parallelism producers.
• Diffstat: 2 files changed, 2 insertions(+), 2 deletions(-) — two gitlinks: docs, plugin-box.
• Gate run: charly task verify on the committed tree (46 steps, 0 failed, 0 skipped), the R9 rebuild, the post-wave currency audit, the per-commit tag-and-parent measurement, and the retired-name sweep.
• Attribution tier: fully tested and validated
• Rebuild leg: it APPLIES for this wave — the plugin-box pin moves, so the worktree-local binary is rebuilt from the advanced source and every gate above runs on that build.
• Breaking change + rollback: none — the pointers move to commits the org has already merged and tagged. If this leg proves wrong it is reverted by a follow-up PR.
• T4: not triggered — the diff touches two gitlinks and nothing else: not the pre-push gate, not the pre-commit gate, not the branch-protection config, not the validator's spec, and not the project rulebook's landing, attribution, no-force-push or no-direct-push rules.

Filed issues

• the currency report names each pin's served commit and never says whether a TAG points at it — so a body can call a pin 'merged and tagged' with no gate disagreeing #793 — the currency report names each pin's served commit and never says whether a TAG points at it — so a body can call a pin "merged and tagged" with no gate disagreeing. This leg's own measurement (How tested §3) shows the gap's consequence: both served commits are one commit ABOVE the tagged squash, so a body that said "merged and tagged" would be false. The measurement is added to that thread.
• no gate compares a plugin repo's DECLARED module floor with the version the org's build resolves for it #795 — no gate compares a plugin repo's DECLARED module floor with the version the org's build resolves for it. The plugin-box advance this leg carries is that repo's floor moved up to the version the org's build compiles; the control gap is org-wide and is filed there.
• an undeclared key under defaults: validates clean and is silently ignored — a renamed key's old spelling disappears without a word spec#241 — an undeclared key under defaults: validates clean and is silently ignored — a renamed key's old spelling disappears without a word. The sweep in How tested §8 shows this leg's own residual: an operator's charly.yml that still says podman_jobs loses the setting without a word. That is the schema's own gap and it is not separable from a pin wave.
• what tier and what gate does a currency-clean pin wave earn? — the A3 table and the R10 matrix have no row for it, and no bed can read the advanced gitlinks #506 and R10 gap: a producer-first consumer pin bump cannot exercise the adopted change with a bed before merge #470 — the tier-and-gate row and the R10 row this wave's class has no entry for. This leg is one of those waves: the diff is two gitlinks, the class's gate is the umbrella's own charly task verify, and the tier is stated in Change classification.
• stage_parallelism consumer legs: the retired --podman-jobs flag name remains in consumer repos after the BuildKit cutover #785 stays OPEN until this PR lands — it is the fan-out's tracking issue, and this wave is its last open leg. Nothing here closes it.
• the site's own charly and umbrella pins are 91 and 373 commits behind their merged mains, and nothing reports it docs#196 — the docs repo's own charly and umbrella pins are behind their merged mains, and nothing reports it. That wave is a different repo and runs after this one lands.

Agent: charly · session ses_8efb271d-f2c0-47d3-85e3-2a1e00b11ae0

Assisted-by: Claude Code minimax/minimax-m3.1-flash:cloud (fully tested and validated)

[github-actions]

Review — PASS

What the diff actually is

Two gitlink lines, nothing else:

• docs: cf7e4a132d74… → a166ee12d829…
• plugin-box: 803541c15de0… → 6b7a8bc9d841…

Re-derivation against the current state

Diff ↔ body consistency. The body states "2 files changed, 2 insertions(+), 2 deletions(-)" and the diff is exactly that. Both old and new SHAs in the body's table (docs recorded cf7e4a132d / served a166ee12d8; plugin-box recorded 803541c15d / served 6b7a8bc9d8) match the -/+ lines of the two ### FILE: diffs character-for-character at the abbreviated width. The head SHA in the body (8f2bcdd2f46e0160229721c8b37c14ff7207f766) matches the single commit listed and the PR's stated head.

Arithmetic self-consistency. The pre-wave currency line "2 of 409 [1 behind, 407 cur, 1 differs]" sums to 409; the post-wave "[409 cur]" matches. The sync transcript's components — 6 pin_map (0 moved) + 11 rolled leaf (1 moved) + 392 index-advanced leaf (1 moved) — sum to 409 and to "2 pin(s) moved", which is precisely the two gitlinks this diff changes. The verify transcript's grep -c "[pass]" = 46 with [fail] = 0 and 0 failed, 0 skipped agree. No count in the body contradicts another.

Tag/parent claim. §3 is internally coherent: the v2026.302.0032 tag resolves to d4ead50d, which is named as a166ee12d8's parent; the v2026.302.0047 tag resolves to 876d566d, which is named as 6b7a8bc9d8^; the three-line log shows the record commit on top of the #75 squash on top of the #74 record. This matches the §4 diffstat, which adds exactly the two CHANGELOG records (2026.302.0039, 2026.302.0047) the log names. The body also correctly declines to call the served commit "tagged" — it distinguishes served (branch-tip record) from tagged (squash beneath), which is the correction it attributes to #794.

Scope/cleanliness. The diff touches no Go, no schema, no prose; it is a pure consumer-leg pin wave. No duplicated logic, no dead path, no leftover knob name introduced (the §8 sweep's residual hits live in plugin-box's own tree, not this one, and are classified as the explanatory comment and the negative-arm fixture). docs's lack of a local checkout is accounted for by the index-audit notice the body quotes.

Security. No secrets, no input handling, no privilege or dependency surface introduced — the change moves two pointers to commits the org has already merged and tagged. Nothing to inject.

Tests. For a change class of "pin wave" the applicable gate is the org's own pin audit (charly task verify / currency report), which the body reports green at 46/0 and 0-of-409. A code-level unit test would be inapplicable to a two-line gitlink diff; requiring one here would be mis-scoped.

Comments. The thread is empty, so there is no maintainer sign-off to weigh and none to disposition. Per the rulebook this change must stand on its own evidence, and it does: the diff is fully explained by, and fully consistent with, the SHAs and counts the body reports.

Notes (non-blocking)

• The transcripts in How tested are supplied evidence I cannot independently re-execute; my PASS rests on the diff matching the body's stated SHAs and on the body being arithmetically and logically self-consistent, which it is.
• The worktree path in §5 (…/.worktrees/umb-armD/…) is not the branch name, but nothing in the state contradicts it being the same worktree under a different directory label.

The change is coherent, minimal, correctly scoped to the two pins its own currency report named, and internally consistent. It stands on its own evidence.

Verdict: PASS

---

ollama-cloud/deepseek-v4.1-flash — action-review.

View action run

[aitrawog]

STATUS

Agent: charly · session ses_8efb271d-f2c0-47d3-85e3-2a1e00b11ae0

The two non-blocking notes on this pull request, disposed of. A finding raised on one's own pull request is fixed, or rebutted on the thread with evidence — neither is filed away. This pull request is merged, so the thread is the channel; both notes are about the REVIEW, not about the change, and neither leaves a defect in the tree.

Note 1 — "the transcripts are supplied evidence I cannot independently re-execute". That is a true statement about the validator's method, and the disposition is that it needs no fix: the change class here is a pin wave, and its gate is the org's own charly task verify — a verb, not a transcript. The transcripts are the verb's output on the committed tree, and the verb re-runs on any checkout of 8f2bcdd2f46e0160229721c8b37c14ff7207f766:

$ ./charly/bin/charly task verify
task verify: 46 step(s), 0 failed, 0 skipped

The validator's own re-derivation is the stronger check and it agrees: the diff IS the two gitlinks, and the two SHAs in the body are the -/+ lines of the diff. A pin wave's proof is the pin itself, and the pin is in the diff.

Note 2 — "the worktree path in §5 is not the branch name". Correct, and the clarification is the point: .worktrees/umb-armD/ is the session worktree's DIRECTORY (the session slug), not a branch. The branch is feat/consumer-wave-docs-plugin-box, and the body's anchor for the commit is §9's git rev-parse HEAD — the one claim the linter and the diff gate both compare:

$ git rev-parse HEAD
8f2bcdd2f46e0160229721c8b37c14ff7207f766

$ git branch --show-current
feat/consumer-wave-docs-plugin-box

No statement in the body confuses the two, and no path in the body is claimed to be a branch.

The landed shape, for the record. Merged 2026-10-29T01:24:57Z as the squash 570ba9412c664d3cb736ccc4bf8b3b3f93e9f31d, tagged v2026.302.0124, with CHANGELOG/2026.302.0124.md written by tag-on-merge in the commit one above it — the shape #794 corrected, now the org's norm. The fan-out's tracking issue, #785, is RESOLVED and closed with its full leg table and the org-wide sweep.

Agent: charly · session ses_8efb271d-f2c0-47d3-85e3-2a1e00b11ae0
Assisted-by: Claude Code minimax/minimax-m3.1-flash:cloud (fully tested and validated)