Skip to content

CI plans: post-#7132 operator rulings — atomic delivery, derived clamps, lens-door, observation UX contract - #7169

Merged
briansrls merged 19 commits into
mainfrom
claude/ci-audit-management-4ok4ac
Jul 24, 2026
Merged

briansrls merged 19 commits into
mainfrom
claude/ci-audit-management-4ok4ac

Conversation

@briansrls

Copy link
Copy Markdown
Contributor

Summary

Docs-only: brings the two CI plan authorities up to date with the operator rulings issued after #7132 merged, so the dispatched workers (the CI atomic-rework lane and the progress/observation lane) read current doctrine from main instead of a side channel. Seven commits, two files.

ci-two-tier-placement-redesign.md

  • §9.8 fleet-wide budget diagnosis (2026-07-24): seven observed full-corpus batch-3 walls (1344–1629s) across five branches, every sampled failure with all witnesses passing; main 12/12 green — no regression; the scalar budget is mis-denominated (workload size × host speed × per-entry creep conflated in one number).
  • Operator ruling — no interim raise; the clamp model lands with PR-1 atomically. Two signed constants per unit class: a hard per-unit max (witness: 5s — the existing fast-lane authority, never a second definition) and an expected average as the aggregate coefficient (witness: 1s; batch = overhead + units × avg). The hand-set gunbc_ci_floor_batch_wall_budget_seconds rows delete; constants change only by appended signed line.
  • Operator ruling — PR-1 is the atomic full rework ("CI entirely reworked atomically — specifically so we don't have to deal with migrations"): placement roster + gauntlet split + DiffBaseline + derived clamps + the lens-door reintroduction (ts-lens-door: floor's three seed-path compile sites through the v2 door, empty_complexity_report stamping deleted, lens_contract_complexity AuditOnly → Blocking with a planted-quadratic RED). The pre-PR probe gains a non-blocking v2-door lens audit so the door flips knowing its red set. D4 rides iff a green falsifier cadence run exists at landing.
  • Probe note: fleet-class measurement needs no special hardware — branch CI runs execute on the capped srv slots (workflow_dispatch harness).

progress-observation-design.md

  • §6b — interaction with the CI rework: model and laws unchanged; the CI renderer gains three event classes (derived-clamp refusals rendered with their arithmetic, placement dispositions, lens findings); heartbeat keys on clamp units; AttentionLevel grounds on the signed constants; one atomic PR (P0–P3 together), landing after the CI rework PR (shared emit sites — no double churn).
  • Human-legibility contract: preamble required; status line once/minute max, identity-first, human units; raw byte dumps ([floor-memory]'s current shape) are named census violations.
  • Selection prominence: the diff→runs chain is the preamble's centerpiece — per-file and per-declaration attribution (diff hunks ∩ declaration spans, change kind, then witness counts attributed honestly at selection's real grain — "via the N modules that reference these"), skip count with the falsifier audit pointer, widening named in plain language with the causing file. When decl-grain selection lands (namespace lane), the same display shrinks with zero format change.
  • Tone: arm's-length lines are plain sentences; dense key=value lives only in receipt boxes/files; real emojis from the one glyph authority (reward-animal rows kept); 🕐 for the status pulse.
  • §6c — relation to the frontend/UX lanes: shared register thesis; the glyph table's color roles re-ground on gunbc.design.* when the design-register library lands (dissolution trigger, not a blocking dependency); dashboard belt B is renderer N+1 of the same JSONL stream; gunb.ai's terminal module a future renderer of the shared schema.

Verification

Docs-only; neither file moved on main since the branch base (no conflict surface). The parked hub-file miscite fix deliberately does NOT ride this PR (it rides PR-1 per §3.3 — a token-only hub-file PR pays a full-corpus floor, priced by run 30063529282).

🤖 Generated with Claude Code

https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg


Generated by Claude Code

claude added 7 commits July 24, 2026 09:09
…ed budget

Seven observed full-corpus batch-3 walls (1344-1629s) across five branches,
every sampled failure with all witnesses passing and memory healthy; main
12/12 green through #7129's merge. A scalar wall-time budget conflates
workload size (diff-proportional by design), host speed, and per-entry cost
creep (the actual regression dial, stable ~1.57-2.0 s/entry). Interim: one
signed raise to ~1680s on main's row; durable: re-denominated budget
(overhead + units x rate[host-class]) riding PR-1's CiSpec work.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…wo-constant clamp model

Witness clamps: 5s hard max per witness (existing fast-lane authority,
unchanged) + 1s expected-average as the aggregate coefficient (batch =
overhead + units x avg; full corpus ~44min under the 55m cap). Hand-set
budget rows delete; constants signed via the existing budget_note
discipline. PR-1 is the atomic full rework (no migrations): placement
roster + gauntlet split + DiffBaseline + derived clamps + ts-lens-door
(v2-door routing, empty_complexity_report stamping deleted, complexity
lens AuditOnly -> Blocking with planted-quadratic RED). Pre-PR probe
gains the lens-audit inventory so the door flips knowing its red set.
D4 rides PR-1 iff a green cadence run exists at landing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…-tier rework

Model and laws unchanged; CI renderer contract gains three event classes
(derived-clamp refusals with their arithmetic, placement dispositions,
lens findings), heartbeat keys on clamp units, AttentionLevel grounds on
the signed constants, pain point migrates to the gauntlet context, and
P1 sequences after the atomic CI PR to avoid double-churning the floor's
emit sites.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…t, §6c frontend relation

One atomic PR (P0-P3 together, after the CI rework PR). Heartbeat:
identity-first, vitals-suffix, human units, once/minute max; raw byte
dumps are census violations — [floor-memory]'s current shape is the
named negative example. §6c: register thesis shared with the site lane;
glyph color roles re-ground on gunbc.design.* when it lands (dissolution
trigger, not dependency); dashboard belt B = renderer N+1 of the same
JSONL stream; gunb.ai terminal a future renderer of the shared schema.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…, clock pulse

Arm's-length lines are readable sentences, never key=value chains (dense
form lives in receipt boxes/files); glyphs are real emojis from the one
glyph authority with the reward-animal rows kept; the periodic status
line uses the clock, not the heart.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
… is the preamble centerpiece

Per-file attribution (touched file → selected entries/witnesses), skip
count with the falsifier audit pointer, now-vs-later placement split,
and widening named in plain language with the causing file. Same
selection authority projected per file — no new telemetry.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…the file

Under each touched file, the qualified names the diff actually touches
(hunks intersect declaration spans) with change kind, then the witness
count attributed at selection's real grain (module closure today, stated
honestly); decl-grain selection shrinks the same display when the
namespace lane lands it — the UI leads, selection catches up.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
@cursor

cursor Bot commented Jul 24, 2026

Copy link
Copy Markdown

Bugbot is not enabled for your account, so this pull request was not reviewed.

Enable Bugbot in the Cursor dashboard to get automatic reviews on future PRs.

Git-diff convention colors (green/yellow/red) as glyph-authority rows,
textual kind tag always beside color. No-ops are a closed sum — docs-policy,
uncovered (a visible coverage nudge), no-decls-touched, generated-artifact,
deletion (widens, not a no-op) — a bare unlabeled 'nothing' is a census
violation (the Option/None conflation pattern applied to UX).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
@gunbai-bot

gunbai-bot Bot commented Jul 24, 2026

Copy link
Copy Markdown
Contributor

Reviewed from the consuming side — I'm the worker on ts-obs-model (P0), PR #7168. Two concrete defects, one sequencing question, and one confirmation that the new doctrine is already actionable.

1. Duplicated ## 7. Non-goals heading (will land as-is)

The §6c block ends by re-emitting the section header that already exists below it:

+- **gunb.ai's `tools/terminal` Go module** is declined ...
+
+## 7. Non-goals
+
 ## 7. Non-goals

Net effect on main: two identical ## 7. Non-goals headings, the first with an empty body. Since this doc is markdown-ingested and the design lane is heading toward design_document.dag-style keyed deltas on containment-tree node identity, a duplicated heading is exactly the ambiguity that refuses later. Drop the added one.

2. Table row 15 contradicts the §9.8 body it points at

Row 15 of the residuals table (added in this PR):

§9.8 — interim: one signed raise to ~1680s on main; durable: re-denominated budget ... in PR-1

The §9.8 body (also added in this PR):

Operator ruling (2026-07-24): no interim raise — the clamp model lands with PR-1 atomically.

The PR summary follows the body ("no interim raise"), so the table row is the stale one. As written, a reader who trusts the scannable table lands on the opposite of the signed ruling — and a budget raise is precisely the "widen instead of refuse" move §5 forbids, so this is worth being unambiguous about rather than leaving to whoever reads which line first.

3. Sequencing — P0 is already green and provably touches no emit site

The new §6b changes my dispatched brief. What I was dispatched with (and what §6b said as merged via #7132):

Sequencing: P0 (pure .dag model + glyph authority) lands anytime — zero carrier overlap with the rework. P1's renderer wiring lands AFTER the atomic CI PR.

What this PR says:

ONE atomic PR — P0 through P3 land together, entirely, after the atomic CI rework PR (both touch the floor's emit sites ...)

The stated rationale — "both touch the floor's emit sites" — is true of P1–P3 but not of P0. P0 as built is dag/std/observation.dag (new), rows appended to std.symbols + extdeps/render/glyphs.dag, and two witness files. It touches zero emit sites, zero floor carriers, and nothing the CI rework edits; there is no double-churn to avoid because there is no shared file. It is green by execution now (21 model conjuncts + a live-tree lockstep witness).

I'll follow whichever you rule, and I'm defaulting to the new ruling (holding #7168 as draft, growing it toward P0–P3) unless you say otherwise. But the atomicity argument buys nothing for P0 specifically, and holding it means the atomic PR carries the model, three renderers, and a corpus-wide census in one review — so if the concern is reviewability rather than migration safety, landing P0 first strictly helps. Worth an explicit call either way, since "atomic" and "P0 lands anytime" are both now in-tree doctrine on different branches.

4. Already actionable in P0 — no clarification needed

Recording these so you can see they're not lost; I'm folding them in now:

  • Glyphs are real emojis from the one authority: 🚫 refused (I had ⛔), ⏳ blocked, ⏭️ skipped, ✅ done, ❌ failed, and 🕐 for the status pulse replacing ♥. Reward-animal rows kept. 🚨 lands with the P1 lens-finding class (no unused row now).
  • Change-kind coloring as rows, color never the only channel — added/modified/removed carry a text tag beside the role, so colorless contexts degrade losslessly. Lands as model + rows with a witness that no kind can be constructed without its tag.
  • No-ops are a closed sum, never a bare "nothing" — docs-policy | uncovered | no-decls-touched | generated-artifact | deletion, with uncovered deriving a visible nudge rather than a comfort, and deletion typed as not-a-no-op. This one is pure P0 construction work: with a closed sum and a total presentation assignment, a bare unlabeled "nothing" is unwritable rather than censused after the fact.
  • Human units / raw byte dumps are census violations — lands as a contract row now (P3 enforces it), so [floor-memory]'s current shape stays named as the negative example.

One note on §6c's dissolution trigger: "the glyph table's color roles re-ground on gunbc.design.* when the design-register library lands" is the right shape, and the glyph rows already carry SemanticColor role names rather than hex, so that re-grounding is a row repoint and not a rewrite.

claude added 2 commits July 24, 2026 15:31
Regen job folds into the floor as a spec row (serial chain becomes
build → ci → deploy; cold control stays a gauntlet row on main); the two
receipt gates fold into merge admission. Envelope: leaf PR 6-8 min;
whole-repo diff ~35-41 min honest wall (clamp ceiling ~44m, 55m cap),
with the cold-build and memory-pathology tails named and the shrink path
owned by store-econ/native-flip + W3.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
Operator ruling: PR-0/PR-1 split dissolved; #7162 absorbs all remaining
pieces. Build order: clamps first (self-greening — the floor reads CiSpec
from the PR tree). D4's gate restated for the growing PR: a branch
falsifier run is the deletion receipt (main-cadence green impossible
pre-merge by construction); one green cold run post-D0 triples as D0
acceptance, D4 receipt, and cold-side probe timings. D5's Env.Get mock
is its own named part, finished in-PR. Probe: worker-driven
workflow_dispatch on fleet slots, serial, >=2 hosts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
gunbai-bot Bot pushed a commit that referenced this pull request Jul 24, 2026
P0 of the progress-and-observation lane (docs/plans/progress-observation-design.md,
operator-signed 2026-07-23; §6b/§6c doctrine from #7169 folded in). Model only —
no renderer, no emit site touched.

ObservationEvent = subject (a typed containment path: run ⊃ batch ⊃ entry ⊃ module
⊃ phase) × Begin | Step{k,n} | Concluded{outcome} × measured facts. Outcomes are a
closed sum with Refused DISTINCT from Failed — the reference implementation conflates
them, which is how a deliberate refusal reads as a crash.

Grounded on existing authorities rather than minted:
- ancestry reuses std.effect_grant.path_is_prefix (one prefix relation, not a second walk)
- over-budget arithmetic calls std.temporal_effect.stall_budget_verdict
- change kind projects from std.change.KeyedDiffHunk — no second added/modified/removed enum
- glyphs extend std.symbols + extdeps.render.glyphs rows (the one table), never a fork
- module_path/source_path carry std's existing representation (std.decl_ref's), with
  convergence to QualifiedName/SourceRef declared, not assumed

Derived, never hand-set: AttentionLevel from a supplied basis (the signed clamp
constants — no threshold is invented in this module); BlockedOn from SchedulerHold,
which is held in lockstep with the seed governor's HoldReason by execution; T from the
heartbeat period the seed actually sleeps, declared a Scaffold with the measured
quiet-time distribution as its dissolve-on.

Construction over validation: the no-op sum is closed (docs-policy | uncovered |
no-decls-touched | generated-artifact | departed-path), so a bare unlabelled "nothing"
is unwritable rather than censused after the fact; uncovered derives a visible nudge,
departed-path is typed as a widen and not a no-op.

Green by execution, with discriminating REDs proven by perturbation:
- 28 model conjuncts + 6 lockstep conjuncts PASS
- orphaned law row (enforced_by names a missing declaration) → RED
- Refused/Failed collapsed onto one glyph → RED (both distinctness and collapse laws)
- glyph-table row perturbed → presentation moves → RED (single authority, by execution)

Compile-clean attributed: the closure's 47 errors are pre-existing in std/measure.dag
(46) and std/effect_grant.dag (1) — identical counts compiling those entries alone;
zero attributable to this change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
claude added 9 commits July 24, 2026 15:46
… escape; witness locks escape semantics

The ${...}-in-strings gotcha, root-caused: interpolation triggers on '{' +
identifier (the dollar is irrelevant), and a failed interpolation-body parse
escaped as a bare expression error ('expected RParen, found Colon') with no
pointer to the existing \{ escape — which works, verified by execution
(the principled shell form is "$\{VAR:-default}"; no bare-dollar
workaround needed). parse_interp_parts now wraps body-parse failures with
the interpolation context and the escape hint. Witness battery (4 claims,
green by execution) locks the escape semantics via discriminating lengths.

STAGED: stage0 regen for the 02_parse change is fail-closed BLOCKED on a
main-head breakage this work exposed — regen_stage0's v2-self-compile leg
cannot resolve name_resolution_policy_is_namespace_only from 04_env/04_sigs
(calls landed in #7093; resolution broken by the 09:0x emit-import-closure
wave). Pre-existing on the clean tree, verified by stash + --verify.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
… retract the main-breakage alert

CORRECTION: main was never broken — the regen 'breakage' was this
session's stale debug binaries (name_resolution_policy_is_namespace_only
is a native builtin registered post-#7093; a fresh build resolves it, and
main is green 12/12 through the 09:0x wave). The prior commit's STAGED
note is superseded here.

The real second defect, found by reproducing the worker's exact error
shape: parse_interp_parts' fallback arm returned SUCCESS on an unexpected
token after an interpolation expression (a fail-open — a well-formed node
handed back mid-string), letting the caller trip later with the
context-free 'expected RParen, found Colon'. The arm now refuses with the
interpolation context + literal-brace hint. Verified by execution: the
worker's shape now reports the hint; regen_stage0 --verify is
byte-clean (regen_divergence_count=0 — no legitimate interpolation in the
closure relied on the silent arm); the escaped form evaluates to
${GITHUB_BASE_REF:-origin/main} exactly; 4/4 escape witnesses PASS.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…e author

Operator ruling 2026-07-24: noticing you are implementing a workaround IS
the line-stop signal — back up, reassess, root-cause or flag for help; the
only landing states are the real fix or a declared scaffold with a named
dissolution trigger. A workaround is an unmarked scaffold; the marking is
the entire difference. Added to the recurring-failure-modes roster as
'unmarked workaround'. Receipt: the ${…}-in-strings dodge — the bare-$
respelling concealed the existing \{ escape and two real parser defects;
stopping the line surfaced all three within the hour.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…ster corrections

Root cause of the dead strikethrough (operator screenshots 2026-07-24):
inline <style> text was HTML-escaped, emitting '.node-superseded &gt; .title'
— an inert selector in every browser. Per the HTML spec's raw-text elements
(script, style), std.markup's MarkupMedium gains raw_text_tags and emits
their text raw; try_serialize_html_source refuses fail-closed when raw-text
content contains its own close sequence (same escape class as the
dispatch-button inline-script incident — the style copy was never fixed).

Page: rows render their LEAD (first ' — '/'. ' segment) with the full brief
behind a native <details> disclosure (188 blocks; zero JS). Style: .status
Width→MinWidth (the 'superseded' chip overflowed its fixed box into the
title); .roadmap/.daily-workspace gain auto side margins (centered);
dispatch-btn carries the figure-role border accent (actions carry the
accent; status stays quiet). Witnesses: 6 new page claims incl. the
unescaped-combinator check and the raw-text refusal RED; 10/10 green by
execution; markdown/jsx media unchanged (raw_text_tags: []) and main_wet
byte-stable.

Named follow-up (belt B lane): deploy refreshes files but the serve path's
artifact/process refresh is unproven — the live page lagged tree styling;
a served-page fingerprint check belongs in live_deploy.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
Three pillars with exists/missing stated honestly: P1 readability (largely
landed 2026-07-24, section-collapse residue); P2 observable dispatch — the
stateful workflow: GET /sessions projection from belt B's existing observe
half, live row states, Stop/re-dispatch verbs (absorbs the filed
ts-dispatch-redispatch), progress depth via the observation lane's stream
(renderer N+1 by contract); P3 the feel register — gunbc.design.motion
tokens + the acknowledgment law (total assignment, censused like unthemed
colors), dashboard as first consumer on existing state flips, sound a
named later axis. Doc bound to roadmap_page_for_authority.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…iple

Operator-directed exemplar: one control end to end. The story: rest →
pressed (ack on DOWN, act on UP) → requested (still, distinct — no pulse;
the keyframes wall holds) → spawned (settle beat, morphs into the
workflow-stage chip) → working (live stages from P2a, changes animate,
steady states still) → done (settle + re-arm; re-dispatch fix in scope) →
refused (blocked-travel dip + typed reason). Every edge a tokenized row,
totality censused. Root principle recorded for gunbc.design.principles:
simulate real analog behavior — every control an individual physical
instrument (car-knob rule): travel, mass, detents, mechanical state;
still-until-touched is analog honesty; sound = mechanism click, later
axis. Register inventory: hover/press rows exist; missing = transform
responses, settle_spring easing, lifecycle edges, sessions read.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
Six person-observable checkpoints; the consumption rule (no register row
lands without its consumer in the same PR); the single-line-item workflow
representation (stages as detent positions, not a progress bar; history
as belt-fact projections); everything else in Pillar 3 explicitly parked;
two PRs total with PR-A independently shippable as the anti-shelf-ware
test.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
…e bar

Operator 2026-07-24, against the P0-carve-out argument: one PR, P0-P3
entirely, after the CI rework. The controlling rationale is completeness
(only finished work merges — landed vocabulary with no renderer is the
consumed-by-nothing state the consumption rule forbids); the
shared-emit-site rationale is secondary and not load-bearing. #7168 grows
to P0-P3 rather than merging alone.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016fdkaGGLUKpLRwwqxp5sLg
@briansrls
briansrls merged commit b867e9b into main Jul 24, 2026
1 check passed
@briansrls
briansrls deleted the claude/ci-audit-management-4ok4ac branch July 24, 2026 17:56
briansrls added a commit that referenced this pull request Jul 24, 2026
…erified UX gaps, clamp basis (#7175)

The three plan docs accreted 2026-07-24 operator rulings in layers without a
supersession sweep, so each carried live contradictions; this pass makes the
newest ruling the only live text and records what the tree already proves.

roadmap-workspace-ux-plan: the END-TO-END CONTRACT is the controlling text
(P3b's requested-pulse deleted — exemplar's no-pulse holds; P2b's
status-chip overload superseded by the separate session chip; Sequencing
marked superseded — PR-A then PR-B, P1b parked). Two verified modeling gaps
recorded honestly: G1 — session terminal states have no observable source
(an exited session just disappears from tmux ls; done/red from absence
would fabricate; three options named, worktree completion receipt
recommended); the tmux read-back carries no started/last-activity (the
observation format must grow — real work, not pure projection). New
mechanical constraints pinned: the per-state transform detent table (CSS
transitions fire only on property change, so settle beats require distinct
stable transforms per state — the detent metaphor made literal), the morph
mechanism named (interpolate-size or fixed measures), disclosure-animation
mechanism named (::details-content, Chrome-target), reduced-motion as a
register axis, elapsed quantized to minutes, keyframes wall extended to the
dashboard emission, and the serve-refresh fingerprint check made a
precondition of PR-B's live walkthrough. Dead squash hash 2ba4d8f
repointed at #7169's merge.

ci-two-tier-placement-redesign: D4's routing normalized everywhere to the
section-8 restructure (rides #7162 with a branch-falsifier receipt; the
section-9.7 fast-follow and section-10 BLOCKED shapes superseded); every
stale PR-0 reference resolved to #7162; row 8 updated to LANDED via #7146;
row 15 reconciled with the tree (the stopgap raise LANDED via #7137,
1320 -> 1440 -> 1680 operator-signed — 'no interim raise' means no further
raises). Clamp additions: the signed 1s average folds in host speed AND
worker width, so the signed row must name its basis (a width/fleet change
is a deliberate re-sign, never a rediscovered fleet-wide-red episode);
cost creep gets a durable home (per-cadence s/unit receipt row on the
gauntlet); the clamp demotes but never deletes (the complexity lens asserts
structural linearity, not constants or host pathology). Issue 11
(UnlistedImportUse fork) re-flagged — still unowned.

progress-observation-design: the section-3a trace rewritten to the rulings
it predated — plain sentences, emoji-tier glyphs, clock pulse, clamp
arithmetic on the refusal, and the refusal rendered OUTSIDE the group (the
old trace violated its own RED; the landed renderer already makes that
placement unwritable by construction). The two glyph lists unified as tiers
of the one landed authority (glyphs.dag); Law 2 rendered per the tone
contract; the belt-view vs stream-view two-source composition rule named at
3d (carried by the UX plan's P2c); duplicate Non-goals heading removed.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>
briansrls added a commit that referenced this pull request Jul 25, 2026
The design_register_lift_parity witness was stale on main (roadmap_style
changed in #7169); dag/std edits in this PR surfaced it in the affected-set
corpus. NFR stale row for deleted filesystem.is_text_encoding was already
removed in a934d68.

Co-authored-by: Cursor <cursoragent@cursor.com>
briansrls added a commit that referenced this pull request Jul 25, 2026
…ing-authority cluster) (#7188)

* WIP: Extdeps/std §3-fork dedups (point-at-existing-authority cluster) — per d

* Fix §3-fork dedup follow-ups: repair rust/types parse error and dissolve CacheInterfaceProduct.

The WIP commit left rust/types.dag with a broken rust_cast_syntax declaration (regen parse panic). Restore the data decl, delete the zero-consumer integer_types/float_types lists (authority: rust.primitives), delete CacheInterfaceProduct enum in favor of CacheInterfaceId, and wire cache.dag catalog rows directly to cited facts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Regen stage0 after rust.types §3-fork dedup.

Updates extdeps_languages_rust_types.rs to match fresh regen_stage0 --verify output: remove integer_types/float_types emit, add rust_types_name_catalog_dissolve_on.

Co-authored-by: Cursor <cursoragent@cursor.com>

* WIP: Extdeps/std §3-fork dedups (point-at-existing-authority cluster) — per d

* WIP: Extdeps/std §3-fork dedups (point-at-existing-authority cluster) — per d

* Fix CI floor witnesses: re-pin roadmap_css digest after #7169.

The design_register_lift_parity witness was stale on main (roadmap_style
changed in #7169); dag/std edits in this PR surfaced it in the affected-set
corpus. NFR stale row for deleted filesystem.is_text_encoding was already
removed in a934d68.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Brian Searls <briansrls@gunb.ai>
Co-authored-by: Cursor <cursoragent@cursor.com>
cursor Bot pushed a commit that referenced this pull request Jul 25, 2026
Bring design_register_lift_parity digest re-pin (#7169), namespace-flip
aftermath, and related main landings. Keep this PR's derived FloorBatchClamp
authority over main's stopgap static 2100s batch-3 raise (#7204) — the clamp
is the mechanism that raise was awaiting.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>
briansrls added a commit that referenced this pull request Jul 25, 2026
…dmap_css re-pin, migration-debt ratchet updates)
briansrls added a commit that referenced this pull request Jul 25, 2026
…able fixes actually verified (#7177)

* Roadmap workspace Part A: make the served page provable, and the readable fixes actually verified

Three findings, each proven by execution rather than by reading.

1. The six readability witnesses shipped with #7169 had ZERO executing
   consumers. Discovery keys on the `test fn `/`test data ` prefix, and this
   file has exactly one `test fn` which bundled 13 of its 19 witnesses --
   the raw-text style serialization, chip min-width, container centering,
   <details> disclosure and dispatch-accent checks were all unreachable.
   Proof: reverting `.status` min-width back to `width` (the original defect)
   left roadmap_page_keystone_holds returning true. All 19 are now enrolled,
   and the same plant now reds.

2. READY meant "something answered /healthz", which the PRE-RESTART process
   satisfies. `gunbc serve` binds its compiled graph once at process start,
   so a deploy could green against the process it was replacing while the
   dashboard kept serving the old tree -- exactly what srv1 was doing on
   2026-07-24 (escaped `.node-superseded &gt; .title`, pre-fix chip width,
   no disclosure, no centering) with every check green. healthz now publishes
   digests for the whole served surface (both HTML pages and the modeled
   dispatch asset, not just the two text artifacts), and readiness grounds
   only when the observed fingerprint equals this tree's. The digest is taken
   over the SAME body the route serves via a shared served_page_body /
   page_render_refusal_body pair, so there is no second definition of the page
   to drift from. Three refusal causes stay type-distinct because their
   remedies differ: probe never landed, body is not JSON, body is a
   well-formed fingerprint of another tree.

3. The three rows whose lead exceeded 300 chars are re-cut, each by moving
   the ' -- ' up to just after its bold headline rather than by deleting
   content, so the body survives verbatim behind the disclosure. A typed,
   located, counted census walls the class (node id + measured length, not a
   bare Bool). Measured after: 180 rows under 100 chars, 0 at or over 300.

Cost measured before adoption rather than assumed, because readiness polls
healthz repeatedly: a live srv1 render is ~18 ms for the 223 KB roadmap page.

Co-authored-by: Cursor <cursoragent@cursor.com>

* chore: regenerate drifted generated artifacts (ci auto-heal)

* Exemplar PR-A: the dispatch button becomes a physical instrument (checkpoints 1, 2, 7a)

Register vocabulary landing WITH its consumer and its walls, per the
consumption rule. Before this the button's whole vocabulary was colour --
the edge brightens, the background flips -- which is a diagram that lights
up rather than an object that moves.

MOTION. Three responses of POSITION join the register (Lift, Depress,
Settle) and the still-until-touched law is AMENDED, as the normalized plan
directs: motion on user touch OR observed state change, ambient motion
still unwritable. Mechanically that is one MotionTrigger variant --
OnStateClass -- because a pseudo-class is the browser's and a state class
is the client program's, but both compose onto a subject by suffixing the
selector, so the coverage law, both censuses and reduced-motion keep working
with no new arms. A second BuildRule shape would have left those readers
with their old arms while the emitter grew a shape.

DETENTS. Positions are a table, pinned as data before any CSS, because a
CSS transition fires only on a property CHANGE -- an edge between two states
holding the same transform cannot beat without a keyframe (walled) or
choreography. Every transform rule is READ from that table, so no position
is written twice. detent_edge_defects is a construction check with two
type-distinct faults; its first cut compared transforms through a lookup
that returned "" for a missing state, so an edge naming two nonexistent
states compared equal-to-equal and reported a coincidence while an edge
naming one reported FINE. A typo would have gone green.

SOUND. gunbc.design.sound: a 5ms square detent tick, synthesized through
WebAudio from modeled rows, no audio files. The wall is an ENVELOPE -- the
aural sibling of the glare envelope -- refusing long decay, nonzero attack,
loud peak and out-of-band frequency, with a 400ms 880Hz sine bell as the
provably-refused negative control. The tick rides its OWN pointerdown
listener: mechanically that is when engagement happens, and it means a
WebAudio failure cannot abort the dispatch. Mute is one persisted boolean,
default sounding; it ticks on unmute and is silent on mute with no branch.

TIMING. No new duration is minted. Hover moves to reveal_deliberate (160ms
-- an approach is a reveal, and 90ms was the press clock borrowed), press
and hold stay on respond_fast, and settle_spring DERIVES its duration from
restore_gentle by reference so the mint is provably the easing alone.

Two bugs found by reading the emitted output rather than by trusting green
witnesses. First, unioning transition property NAMES produced
`transition: border-color, transform 160ms ease-out`, in which border-color
silently takes the initial 0s -- the shorthand is `prop duration easing`
per item. Second, two triggers sharing a base selector wrote two
`transition` declarations and the later won. Both are now structurally
impossible: transitions are accumulated per carrier selector as typed
(property, timing) items and emitted once, never inside a rule, with
per-edge weights riding their own selectors.

Site digests re-pinned, justified by execution rather than assertion: old
and new moodboard CSS compared as per-selector declaration SETS -- all 68
selectors identical, the 138-byte delta entirely block placement, so
computed styles are unchanged. accent_study_html and moodboard_digest did
NOT move, which is itself evidence the change is scoped to the transition
machinery.

Grammar gaps closed at the language layer instead of routed around: TsExpr
gained the NewExpression production (the alternative was
Ident{name:"new AudioContext()"}, a hand JS string smuggled through an
identifier), CssPropertyName gained Transform, and std.decimal now owns the
one fixed-point-to-decimal projection both WebAudio and the CSS scale
factors need. Travel is a scale token so no raw pixel escapes the register.

25 witnesses, all reachable from one test fn, each with a discriminating
input: planting a settle duration mint reds, and so does moving the lift
back onto the press clock.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Remodel W1a+W1b: DispatchBand dissolves the ok-trio; venom completes island-pastel at the workspace layer

Operator-signed direction (2026-07-24 review session) filed as
docs/plans/roadmap-workspace-remodel-plan.md; this is the first model slice.

W1a — DispatchBand (ok / in-progress / fail / loud) is a total match over
BeltDispatchResult, now the SINGLE ok-authority: belt_dispatch_result_ok,
belt_dispatch_ok_status_labels, and belt_dispatch_label_is_ok are projections
of the band fold (they were three spellings of one fact — the half-born-band
defect). No wire result maps to BandInProgress, so presentation cannot
fabricate progress out of an answer. Derived label→band rows + cover checker,
4 witnesses incl. a located RED (dropped row reds the cover).

W1b — SwatchSetForUse: base sets stay provenance-pure; a use that needs a hue
class the base cannot serve completes it at the consuming layer (loam-from-camel
generalized; shadowing a base name is unwritable). island_venom #8a2f23 (ACNH
scorpion tail, operator-directed) completes island-pastel for the workspace:
ivory-on-venom grades AAA by the cited WCAG kernel, venom-on-loam pins
DecorationOnly, empty/duplicate completions refuse.

Green by execution: belt, palette, component, tactile, register, site-register,
lift-parity, dispatch-presentation, sandbox, serve, page, static-site keystones.
live_deploy_readiness_witnesses is red on the pre-change baseline too
(local-environment, pre-existing). Served-surface receipt: healthz digests
byte-identical before/after across all five artifacts — model-only, zero drift.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1d+W1g: presented-state choreography, bands as paint, day/night toggle, first-press sound fix

The choreography (operator ruling: transitions are sugar over the data layer).
The wire answer lands on the data layer immediately (b.dataset.status); the
presentation holds the requested phase >= the reveal_deliberate dwell — the
160 referenced from the register row, never a hand constant — via
setTimeout(apply, max(0, t0 + dwell - now)). A 1 ms echo now reads as a
deliberate act (kills the label flash, A.5); a slow belt applies the moment it
answers. The catch path rides the same dwell and lands banded (loud), never a
bare 'error'.

Captions stop leaking the wire taxonomy (A.1): terminal text is the band's
phrase (ok keeps the session-chip morph; fail -> 'not dispatchable'; loud ->
'belt fault'), the wire label + located fields demote to the title channel,
and the label->band table in the client is DERIVED from
belt_dispatch_label_band_rows (unknown label -> loud, honest). Reserved width
re-points from the longest wire label to the longest caption — the A.4 width
driver dissolves.

Bands as paint: band_root_css emits the instrument fills as (theme x band)
vars under the same :root / [data-theme] / prefers-color-scheme grammar the
theme vars use — invite=mint, in-progress=butter, ok=aqua, fail/loud=venom,
inks loam/ivory (grades held by the palette witnesses). State rules paint
fill+ink+border from band vars; dispatch-loud lands as a marker class.
BoundaryRole leaves the dashboard archetype demand with its last paint
consumer (the both-ways demand witness forced the row to move with the
stylesheet).

Day/night toggle (W1g): header control cycling auto -> day -> night, values
derived from the Theme rows' own names; auto removes data-theme so the media
projection governs. Persisted like the mute.

Sound (A.2 root #1): the tick wraps scheduling in play() and routes through
resume().then(play) when the context is not running — the first-press swallow
dies; the sound_preamble_note records why the old no-resume claim was wrong.

Sandbox: captions collapse to bands, so every gallery/live cell gains an ARM
sublabel (state.key — the wire vocabulary stays on the diagnostic surface);
live cells start at the idle caption.

Green by execution: all 12 affected keystones (belt, component, tactile, page,
sandbox, serve, static-site, register, palette, presentation, site-register,
lift-parity). Pin migrations are deliberate and named: header markup gains the
toggle, chip-material witness re-grounds to band paint, reserved-width witness
to caption projection, roadmap css digest re-pinned with its note, session-chip
morph pin follows the 's' const. Emitted assets parse (JavaScriptCore); served
page carries band vars in all three theme blocks and the choreography constants.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1d polish (operator review round 2): 500ms read dwell, in-family inks, band-neutral approach

Three perceptual defects from the operator's live review, each fixed at the
model layer:

1. READ DWELL — 160ms (borrowed from the hover reveal token) was too short to
   read 'dispatching...'. A reading duration is a different concept from a
   transition clock, so it gets its own authority row
   (dispatch_requested_read_dwell_ms = 500, operator-tuned) instead of a
   retune of the shared TimingToken that would have made every hover 500ms.

2. IN-FAMILY INKS (the loam rule generalized) — the first cut shipped loam on
   every light fill, and mint's warm-brown ink read as venom-family. New rule:
   a fill's ink is the fill's OWN hue at ink depth — mint carries deep green
   (#1a4a2b), butter dark olive (#4a3c0a), aqua deep teal (#0e3e42), venom
   keeps ivory. Each lands as a Derived completion anchored on its fill in
   island_pastel_for_workspace, and the palette witnesses hold every ink >= AA
   on its own fill by the WCAG kernel.

3. BAND-NEUTRAL APPROACH — hover targeted var(--focus) = brass, which is
   hue-ambiguous against the fills (venom-adjacent brown on mint,
   mint-adjacent yellow-green on venom), so hover appeared to invert the state
   colors. The instrument's approach ring is now the theme ink (var(--text)) +
   the existing lift — pure emphasis on every fill under both themes. Brass
   stays the focus material elsewhere (the review mark keeps it).

Green by execution: all 12 keystones; css digest re-pinned with its note.
Served receipts: inks in all three theme blocks, hover ring var(--text),
gunbcDwellMs = 500 in the emitted asset.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1c: the dispatch button becomes a real instrument — pill geometry, tactile height, in-family press receipt

Geometry (operator archetype: the GitHub merge button; oval/oblong per the
ruling). Two control-geometry tokens land on the scale axis — h-control (40px,
the tactile target) and radius-999 (the oblong pill) — with the axis staying
token-grain until a second instrument fires the lift into a typed
ControlGeometry carrier (second-consumer discipline, noted on the token). The
button re-realizes: sans 600 at text-13, padding space-8/space-16, inline-flex
centering, min-height h-control, pill radius. The wire-metric strip is dead.

MinHeight was a grammar gap in CssPropertyName — closed at the language layer
(variant + wire arm), never routed around; css_grain walls stay green.

The press receipt goes in-family: OnActive used to flip the fill to the theme
border gray, which fought the band paint. A press is the same instrument
momentarily deeper — island_mint_pressed (mint deepened one stop, a Derived
completion anchored on mint; press only ever fires from idle) emitted as
--band-invite-pressed beside the band vars. Ink stays >= AA on the pressed
fill by the kernel.

Green by execution: all 13 keystones (the 12 affected + css_grain). Tactile
:active pin follows the receipt; css digest re-pinned with the W1c note.
Served receipts: radius/min-height/padding/flex/sans values all live.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1e: the disclosure enters the register — real mark, detent rotation, UA triangle dies

The brief disclosure was UA debug chrome (the operator's B.1): a default
details marker and an unstyled summary. It is now the register's third
element (DisclosureElement, verbs Approach + Enter — both pre-existing
vocabulary; Enter joins the dashboard archetype's admitted verbs).

The MARK is a real span inside the summary, never a pseudo-element: the
client program mirrors the details element's open state onto the mark as a
state class (the browser owns [open]; the state class belongs to the client
program — the dispatch button's own OnStateClass split), so the existing
trigger + detent machinery drives the turn with zero new trigger vocabulary
and zero descendant selectors.

The detent model gains its ROTATION axis: Detent.turn_deg, emitted only when
nonzero so every pre-existing detent's bytes are identical and the site
digests hold by construction. The open detent (rotate 90deg on respond_fast)
is the axis's first consumer. Turn joins the Response vocabulary — and the
coproduct-exhaustiveness wall caught the missing response_key arm at compile
exactly as designed. Approach realizes as the summary's dim->text brighten
on the reveal clock.

UA marker suppressed both ways (list-style none + the webkit pseudo, one
counted RawSelector). Green by execution: all 13 keystones; page disclosure
pin follows the new markup; css digest re-pinned. Served receipts: 44 marks,
the rotate rule, hover brighten, and the toggle binder all live.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W2: TicketLine — the roadmap node becomes a ticket; five exemplars migrated; read dwell 300ms

The model half of ts-wf-node-schema (which is itself migrated — the schema's
first recursive consumer). RoadmapItem gains TicketLine { done, TicketFields }:
headline · brief · displaced_cost · current_state · first_slice · red_control ·
out_of_scope · handback · updates (the time axis) · authored_on/last_verified_on.
The field set is ts-wf-node-schema's list ∪ the dispatch_brief_template slots —
the template was always the spec of what dispatch needs. References reuse the
node's carriers (Pointer is the existing ref concept). AuthoredLine survives as
the counted LEGACY frontier for W2-bulk. The coproduct-exhaustiveness wall
enumerated every consumer (status, md emit, page, spawner) — each got an honest
arm.

Projections:
- PAGE: ticket briefs render structured — brief paragraph, labeled field rows,
  a bordered updates thread with dated entries — instead of the word-vomit dump.
- LINKS (census row 7): Pointer hrefs project through the GitHub blob base, so
  every carrier link on the served page finally answers; the projection swaps
  for a served route in one place when that lands. Legacy prose-inline links
  stay a named residue that dies with the blobs.
- MD: TicketLine projects as "**headline** — brief"; ROADMAP.md regenerated
  (+5/−5, exactly the five faces); gate suite green.
- DISPATCH BRIEF: the template slots fill from REAL ticket fields; the
  title-stuffing stub survives only on the legacy frontier — both pinned by
  execution (ticket fixture fills all six slots; legacy fixture still stubs).

Brief budget: 100 words, the lead-budget pattern — typed/located/counted census
(node id + measured words), planted 101-word fixture reds with its id.

Exemplars: ts-dispatch-elevate (the blob-with-embedded-history specimen — its
GO-LIVE/UI-FORK/CLAUDE-DEP history decomposed into five dated updates),
ts-wf-node-schema, 2-dispatch-actuator, ts-dispatch-redispatch,
ts-wf-stage-artifacts. Originals in git history.

Also: requested read dwell 300ms (operator-tuned from 500); the multi-phase
motion session (Discord-mute shape: state lands fast, motion keeps attention)
+ size/overshoot tuning filed as the W1h follow-up in the remodel plan.

Green by execution: 14 suites incl. gate + actuator + page with the new
witnesses and REDs; css digest re-pinned. Served receipts: 5 ticket briefs,
35 field rows, 5 update threads, GitHub-projected carrier link, dwell 300.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1f: the swatch auditioner — audition whole palettes with one click, inks derived by the kernel

The operator is deliberately undecided on swatches, so switching must cost a
click, not a restructure. Each audition set (okabe-ito, solarized — the
catalog's cited sets) emits its band vars under :root[data-swatch-set=NAME] —
the data-theme selector grammar reused verbatim, emitted after the band blocks
so an audition overrides both themes uniformly.

The FILL mapping per set is five hand rows (which hue plays danger is a design
call); the INK per fill is DERIVED — the set's own swatch with the highest
computed WCAG contrast against that fill, by the same cited kernel that grades
the palette — so an audition set cannot ship an illegible pairing by
construction. A set whose mapping fails to resolve emits NO block and the
witness counts it (proven: a bogus swatch name resolves to absence, never a
fabricated color — the planted RED).

The control lives on /sandbox (the design surface owns auditioning), cycling
island-pastel -> okabe-ito -> solarized, persisted like the mute; the shared
client program applies the choice on load, so an audition made in the sandbox
follows the operator to the live roadmap — auditioning against real content,
not specimens. Set names are glued: control values == audition set_names ==
catalog names, witnessed.

Residue, named: the press fill stays island-derived under audition — the press
stop joins the mapping when a set graduates from audition to chosen.

Green by execution: all fifteen suites (incl. gate + actuator); css digest
re-pinned. Served receipts: both audition blocks with cited fills
(vermillion #d55e00, solarized red #dc322f), the control, the binder.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel W1f/W2 visibility fixes: the auditioner announces itself; tickets say ticket

Operator review round 4: 'the swatches button doesn't seem to do anything' and
'I don't see a ticket shape.' Both mechanisms were live and green — proven for
the toggle by execution in a JavaScriptCore DOM-stub harness driving the real
emitted asset (three clicks cycle label + data-swatch-set exactly as modeled) —
but neither announced itself where the operator was looking: the roles section
beside the toggle paints theme literals BY DESIGN, and a collapsed ticket row
was indistinguishable from a legacy prose row.

Fixes, both at the announcement layer:
- The auditioner bar gains five band chips filled from var(--band-*) (keys
  derived from workspace_band_paints, so the strip cannot drift from the band
  vocabulary) — a set flip repaints the strip in the same glance that clicked.
- Ticket rows' disclosures read 'ticket' (figure-colored summary, ticket-row
  marker class) instead of 'brief' — the five migrated rows are findable at a
  glance; the page witness pins the ticket summary shape.

All suites green; css digest re-pinned.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel: okabe-ito graduates from audition to the chosen band set

Operator choice after auditioning live: okabe-ito is the workspace default.
The graduation is the one-authority swap the auditioner machinery promised:
workspace_band_paints() IS audition_paints(okabe-ito) — fills from the mapping
rows, inks picked per fill by the WCAG kernel (black wins every light fill) —
and the graduated default holds a RAISED bar: every pairing >= AA normal text
by the kernel, witnessed. The press stop joins the chosen set's mapping
(bluish_green deepened one stop, #8561, a Derived completion on
okabe_ito_for_workspace — the obligation the auditioner note named).

island-pastel demotes to a one-click audition option built over its for-use
completion, so venom and the in-family inks stay modeled — and the kernel
derivation REPRODUCES the old hand ink rows exactly (mint-ink wins on mint,
ivory on venom): the in-family rule shown derivable rather than hand-held.
Toggle cycle: okabe-ito (default, attr absent) -> island-pastel -> solarized.
Flipping the choice back is one fn body plus the toggle defaults.

All fifteen suites green; css digest re-pinned. Served receipts: bluish-green
invite #009e73, sky-blue ok #56b4e9, vermillion fail #d55e00, black inks,
pressed #8561, island now an audition block.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Remodel: the node row composes — flex head line, dispatch at the right edge, disclosure indented

Operator round 5: 'the positioning of everything is still very clunky' — the
pill sat alone on its own line, the disclosure floated, badges ragged. The
button got physics in W1c; the ROW never did. Now one flex head line per node
(status chip · title · badges · carrier links · dispatch pushed to the right
edge — the GitHub PR-row shape: identity left, action right), with the
disclosure indented beneath. One shared node_head_row builder replaces the
duplicated head concats in node_li and frontier_flat_node_li.

This is the deferred P3 flex-container refactor landing: its deferral reason
('unverifiable without a browser') dissolved when the review loop gained live
operator eyes.

All affected suites green; css digest re-pinned.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Round-5 truth fix: a press deepens the material it presses — per family, derived, witnessed

Root-caused by the management lane, confirmed against the source: the press
receipt targeted the ONE pressed var that existed (invite's) on the base
selector, so pressing an orange fault pill flashed deep green for the press
window — a fabricated 'ready' painted over a fault, the pixel-layer twin of
the fabricated plausible output §5 forbids. Three classes stacked exactly as
diagnosed: partial derivation presenting as total (no witness asked the
totality question) · the graduation obligation discharged at the wrong grain
(okabe's graduation added only the invite stop while the residue note read as
dissolved) · a fabricated state on screen.

The fix goes one step further than the diagnosis: the 'one-stop-deeper kernel
completion' did not actually exist — both pressed swatches were HAND-deepened
— so the derivation now does: pressed_stop (one ratio authority, 842/1000)
applied to every BandPaint fill, emitted as --band-<key>-pressed for every
row. That makes the pressed family total over the bands AND over every
audition set by the same construction, and dissolves both hand swatches
(mint-pressed, bluish-green-pressed) into the derivation. The receipt
realizes per state family (each state class's :active targets ITS band's
pressed var), inks hold >= AA-large on every pressed fill by the kernel, and
the family-preservation witness holds with REDs against any cross-family
press returning.

The register law lands in the plan doc alongside the composition-physics
section (grains 2-4: RoadmapRow archetype + actuator-scale operator decision,
page altitude from the attention law, anomaly evidence as a surface not a
tooltip; W2-bulk sequenced after the row archetype; W1h parked as ruled).

All fifteen suites green; css digest re-pinned.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Plan: the interaction-totality law — prevention shape for the flash class

Operator question after the round-5 root cause: how do we prevent this in the
future — do we need an interaction layer/framework? Answer recorded on the
carrier: no new framework — one missing rule kind and one declared axis inside
the existing register. (1) StateResponse: the detent-table pattern generalized
past transforms — state-dependent decls authored once as functions of state,
realized by a fold total over the component's state family, so a missing
family is unwritable. (2) ResponseScope = PerStateFamily | ConstantByLaw with
the ruling attached, so a signed constant (the band-neutral hover ring) is
model-distinguishable from an accidental one and the undeclared middle stops
being representable. (3) The family-preservation census generalized over
(state x channel), counted, REDs live — a natural early StandingIntent row.
Decidability boundary named (band-var channels walled; sound a ratchet until
per-band). First slice of the composition session.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Plan: adopt DeclarationRef strengthening; record the actuator-scale recommendation (unsigned)

Management-lane round: ConstantByLaw's ruling becomes a typed DeclarationRef,
never prose — who signed a constant is a click, not archaeology. The
actuator-scale decision row gains the lane's thesis-grounded recommendation
(satisfying is behavior, not area: chip scale in rows, press physics carries
the instrument, full-size specimen stays in the sandbox) — recorded as
RECOMMENDED, explicitly NOT signed: the signature is the operator's own word,
and a forwarded recommendation is not it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Plan: actuator call SIGNED; iteration protocol ADOPTED; composition session GREENLIT

Three operator words, landed on the carrier (2026-07-24): (1) actuator scale
signed — chip-scale in rows, instrument feel carried by press physics,
full-size specimen in the sandbox gallery; (2) the iteration protocol adopted,
with the operator's standing gloss — keep stacking feedback/decisions and
root-cause the graph further, more systemically — plus the provisional-marks-
as-counted-rows addition so flips at the pass are located one-liners; (3) the
composition session greenlit, brief routing from the management lane seeded at
the flex-head-line cut, every decision row drained before entry.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: gunbc-ci-auto-heal <gunbc-ci-auto-heal@users.noreply.github.com>
Co-authored-by: Brian <briansrls@MacBook-Pro.local>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
briansrls added a commit that referenced this pull request Jul 26, 2026
…s debugging it surfaced (supersedes #7162) (#7216)

* D0 retention-truth close-out: unpin compile-clean memo, register all-hit keys, arm from loader closure

The three post-merge retention defects from the ci-two-tier-placement-redesign §5
review (routed to the #7129 worker) plus the two §7 acceptance controls. Sequenced
first: the falsifier cannot go green — and no downstream placement row can cite true
retention receipts — until these hold.

D0.1 — compile-clean aggregate memo unpin. The whole-tree gate resolved through
resolved_graph_from_sources_with_index, pinning the aggregate ResolvedGraph (hence
every TypedModule) in resolved_graph_memo for the process lifetime — a large slice of
the measured 9.2GB resident floor. Thread a ResolvedGraphMemoShare::{Memoize,Ephemeral}
flag: the gate resolves Ephemeral (no aggregate pin); per-entry discovery keeps
memoizing. The per-module typed-cache warming that IS the gate's purpose is unaffected.

D0.2 — prewarm all-hit registration. try_reconcile_all_cache_hits assembled and
returned on all-hit WITHOUT index_record_schedule_module, so a prewarmed run armed
retention referencing nothing (completion reported evictions while removing nothing).
Record each confirmed hit in the probe, same key forms as the slow path.

D0.3 — arm from the loader's exact closure (the #6985 Class-B root, third appearance).
Arming used selection_adjacency; the discovery loader load_sources_for_entry_with_pool
reaches wider via qualified-projection references from import-bearing files, so those
modules were re-cached after eviction and never re-evicted or counted — an invisible
resident leak. Arm from the loader itself (not a re-derived BFS that could become a
fourth divergence); cost-neutral because the loader memoizes into entry_closure_sources,
which discovery reuses. Removed the now-dead selection_closure_live_paths_with_facts.

D0.4 — the two §7 acceptance controls. index_schedule_entry_completed dropped the
resolved-graph pin unconditionally, so the eviction-disabled retain-all baseline
understated peak retention; gate it on evict_enabled. The E2E control armed BEFORE
prewarming (the order-blindness that let D0.2 pass green), so it never exercised the
all-hit probe; restructure to prewarm -> clear graph memo -> arm -> re-resolve through
the probe, and add a real-index retain-all RED.

Verified green by execution: 7/7 schedule_retention tests, incl. the two restructured
REDs (E2E arm-after-prewarm; real-index retain-all).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* D3 mechanism: two-tier CI placement axis (PrTier | Gauntlet) with fail-closed admission

The placement-axis half of ci-two-tier-placement-redesign.md D3, buildable ahead of the
D2 srv warm-cost probe. Placement is modeled as DATA (Placement = PrTier | Gauntlet),
never per-site prose, with a FAIL-CLOSED admission law: a check is admissible as PrTier
only with (a) a measured warm-cost receipt within the fast-lane budget AND (b) a
hermetic/ephemeral classification; unmeasured or unclassified => inadmissible as PrTier,
so its only valid placement is Gauntlet. No row rides the fast path by taste.

The 5s threshold is REUSED from the single fast-lane authority
(gunbc_ci_fast_lane_eval_budget_ms, v2.workflow.ci_floor_plan) — never a second 5s
definition (DESIGN §3).

Verified green by execution (claim_batch, 4 witnesses):
  - Gauntlet always admissible
  - a within-budget hermetic PrTier admissible
  - RED control: an over-budget (6000ms > 5s) PrTier is refused
  - RED control: an unclassified PrTier is refused
The controls pin the threshold discriminatingly (1600ms admits, 6000ms refuses) and the
classification gate (Hermetic admits, Unclassified refuses).

Deferred to PR-1 (D2-gated): filling the roster of real checks with measured receipts
(flipping rows to PrTier as srv warm-cost lands), wiring the law onto the live check
rows, and the Gauntlet workflow split (D3b).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* D5 DiffBaseline: dissolve the origin/main literal into a typed single authority

Per ci-two-tier-placement-redesign.md §11. Introduces DiffBaseline
(MergeTarget | PushParent | OperatorOverride{ref}) as the single authority for
"which git ref a diff/merge selects against", grounded on the extdeps.git atoms
(GitRef, git_remote_ref_parts). resolve_diff_baseline is a pure, fail-closed fold
over injected env values — a PushParent with no parent ref REFUSES rather than
fabricating a ref.

Live consequence fixed (site 1, floor selection): a stacked PR now selects
against its real merge target (origin/$GITHUB_BASE_REF), not origin/main.
DiffPolicy.base becomes a DiffBaseline; floor_diff_observe.floor_resolved_base
resolves it at eval time from GITHUB_BASE_REF, fail-closed to UnifiedDiffFail
(the floor widens to the full corpus) on an unresolvable base — never a silent
wrong selection.

Fork dissolution (no behavior change) — sites 2/3/4 re-ground the same literal
onto the authority: merge_admission_produce (merges into main),
roadmap_dispatch_actuator (branches from main), ci_workflow Push/PR triggers
(main). The ci_merge_base_ref alias and the dead ci_merge_base_diff_range are
deleted.

Also carries the parked miscite fix (rust_tests_removed_disposition ->
commit_gate_rust_suite_removed_disposition) in DESIGN.md / design_document.dag /
ci_spec.dag, per plan §3.3.

Verified by execution: ci_diff_baseline_witness_test (6/6, incl. the
discriminating stacked-PR pair and the PushParent-refuses fail-closed control);
ci_spec_witnesses (fetch renders "origin $GITHUB_BASE_REF"; single authority);
roadmap_dispatch_actuator_witnesses. ci.yml + DESIGN.md regenerated via main_wet
(drift clean; the two floor/regen fetch lines now expand $GITHUB_BASE_REF).

floor_diff_observe_witness_test runs green in the floor's wet mode; its eval-time
env reads are unmockable under claim_batch strict-hermetic, a PRE-EXISTING
harness limitation confirmed by a clean-tree stash run of the same witness (this
change adds no new hermetic red).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Progress/observation P0: the event model, five laws, one glyph authority

P0 of the progress-and-observation lane (docs/plans/progress-observation-design.md,
operator-signed 2026-07-23; §6b/§6c doctrine from #7169 folded in). Model only —
no renderer, no emit site touched.

ObservationEvent = subject (a typed containment path: run ⊃ batch ⊃ entry ⊃ module
⊃ phase) × Begin | Step{k,n} | Concluded{outcome} × measured facts. Outcomes are a
closed sum with Refused DISTINCT from Failed — the reference implementation conflates
them, which is how a deliberate refusal reads as a crash.

Grounded on existing authorities rather than minted:
- ancestry reuses std.effect_grant.path_is_prefix (one prefix relation, not a second walk)
- over-budget arithmetic calls std.temporal_effect.stall_budget_verdict
- change kind projects from std.change.KeyedDiffHunk — no second added/modified/removed enum
- glyphs extend std.symbols + extdeps.render.glyphs rows (the one table), never a fork
- module_path/source_path carry std's existing representation (std.decl_ref's), with
  convergence to QualifiedName/SourceRef declared, not assumed

Derived, never hand-set: AttentionLevel from a supplied basis (the signed clamp
constants — no threshold is invented in this module); BlockedOn from SchedulerHold,
which is held in lockstep with the seed governor's HoldReason by execution; T from the
heartbeat period the seed actually sleeps, declared a Scaffold with the measured
quiet-time distribution as its dissolve-on.

Construction over validation: the no-op sum is closed (docs-policy | uncovered |
no-decls-touched | generated-artifact | departed-path), so a bare unlabelled "nothing"
is unwritable rather than censused after the fact; uncovered derives a visible nudge,
departed-path is typed as a widen and not a no-op.

Green by execution, with discriminating REDs proven by perturbation:
- 28 model conjuncts + 6 lockstep conjuncts PASS
- orphaned law row (enforced_by names a missing declaration) → RED
- Refused/Failed collapsed onto one glyph → RED (both distinctness and collapse laws)
- glyph-table row perturbed → presentation moves → RED (single authority, by execution)

Compile-clean attributed: the closure's 47 errors are pre-existing in std/measure.dag
(46) and std/effect_grant.dag (1) — identical counts compiling those entries alone;
zero attributable to this change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Review 42157: collapse the duplicate display tables into one authority

Addresses the blocking finding on the three coproduct predicates, taking its
stronger alternative (dissolve into the canonical surface) rather than only
its weaker one (add a disposition receipt).

The finding was right about the real defect: observation_class_is_intrinsic_anomaly
was a second hand-written table beside observation_presentation, and a witness
asserted the two agreed. That witness was validation standing exactly where
construction was available — it conceded the tables could disagree and promised
to notice.

Fix: ObservationDensity (RoutineCollapsible | SummaryAlwaysShown | AnomalyExpanded)
is now the one table. collapsible, expands_fully and intrinsic-anomaly are all
derived projections of it, so disagreement is unwritable rather than detected.
The three display states stay distinct — the run summary is neither routine nor
an anomaly, which a single boolean would have forced it to borrow.

Disposition receipts added for the remaining structural readers, matching the
cited materialization_ladder pattern: outcome/class, subject/grain/hold, and
selection no-op. Each states why it is Terminal and names its discriminating
corpus rather than asserting terminality.

Witness roles now separated and both proven by execution:
- w_density_is_the_single_display_authority — the content check; reds when a
  class's density changes (verified: ClassRefused → RoutineCollapsible reds it,
  and reds ONLY it, since the projections cannot disagree)
- w_presentation_projects_density_rather_than_restating_it plus the two collapse
  witnesses — construction guards; red when the presentation stops projecting
  density (verified: hardcoding collapsible: true reds all three)

Full suite green: 30 model conjuncts, 6 lockstep conjuncts. Compile-clean
unchanged — 47 errors, all pre-existing in std/measure.dag (46) and
std/effect_grant.dag (1), zero attributable here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Review 42166: ground PSI avg10 on std.measure.BasisPoint

The finding is correct and the hard-blocker applies: avg10_centi was a
percentage magnitude with a scale carried on bare Nat, and the note beside it
self-justified the conflation rather than tracking it.

Fix consumes an EXISTING carrier rather than minting one, which the corpus
had already asked for in advance. std.measure.basis_point_dissolve_on warns:
"else a third dimensionless-ratio use-case mints a third nickname" — this
module is exactly that third use-case, so minting PerMille or a Percentage
quantity would have walked into the failure the row names. BasisPoint's own
note declares its semantic axis as utilization ratios, which is what a PSI
stall share is.

Resolution is exact rather than truncated: the governor reads one decimal of
a percentage and a basis point is a hundredth of a percentage point, so
37.5 percent is 3750 with nothing lost. Percent (Dimensionless, One) would
have truncated it.

Note rewritten to state the grounding and the deliberate non-mint, replacing
the self-justification. When the Ratio<Scale> unification that dissolve-on
calls for lands, this field follows Percent and BasisPoint onto it with no
change of meaning.

Suite green: 31 model conjuncts, 6 lockstep conjuncts. Compile-clean
unchanged — 47 pre-existing errors in std/measure.dag (46) and
std/effect_grant.dag (1), zero attributable here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Piece 3: derived per-batch floor clamp — delete the static wall-budget list

Per ci-two-tier-placement-redesign.md §9.8 (operator 2026-07-24). Replaces the
hand-set gunbc_ci_floor_batch_wall_budget_seconds list — a scalar wall budget
that conflated workload size (diff-proportional selection), host speed, and
per-unit cost creep — with a per-batch clamp computed at run time:
clamp_ms = overhead_seconds*1000 + runtime_unit_count * per_unit_ms.

The load-bearing row is the discovery witness batch (index 2): 300s + 1000ms per
witness, so a full corpus of ~2316 witnesses clamps at ~44min (under the 55-min
step cap, with headroom over the observed 1344-1629s walls) while a runaway reds
proportionally, instead of the fixed 1320s that redded legitimate hub-file PRs.
Fixed-count gate batches carry rate 0 at their measured basis; index 3 (wet
corpora) stays a declared fixed overhead pending the D2 probe's wet-per-witness
rate.

Authority: gunbc.ci_spec FloorBatchClamp + gunbc_ci_floor_batch_clamp_params
(index-aligned to the 7 batches; the cover-schedule witness pins the alignment)
+ gunbc_ci_floor_batch_clamp_note (carries the raise discipline from the kept
static-era note). The 5s per-WITNESS max is unchanged — still the single
gunbc_ci_fast_lane_eval_budget_ms authority, never redefined here.

claim_executor reads the two index-aligned param lists fail-closed, derives the
per-batch unit count from batch_results (corpus_witnesses for discovery
aggregates, 1 per gate row — the runtime datum the static list ignored), computes
the clamp at enforcement, and refuses over-clamp as a typed FLOOR-BATCH-OVER-BUDGET
(never a widen). The GUNBC_FLOOR_BATCH_BUDGET_TIGHTEN_MS RED-control hook now
lowers the COMPUTED clamp. The receipt emits batch_N_units / batch_N_clamp_ms /
verdict; its unit test is updated. Both run_walk call sites carry the new param.

Verified by execution: build clean; ci_floor_plan_witnesses green (the three new
clamp witnesses + cover-schedule). The receipt verdict unit test and the fixture
RED control (budget_red_control_plan; TIGHTEN_MS=0 -> clamp 0 -> the
FLOOR-BATCH-OVER-BUDGET refusal) are the e2e enforcement confirmations; the
fixture's control witness triggers a whole-tree emit that OOMs alongside a compile
in this container, so both run as a clean post-commit confirmation.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Finish #7146 adoption: regen ci.yml from merged authority, drop orphaned D5 witness

The merge that adopted #7146's landed gunbc.diff_baseline (and dropped my
redundant D5 gunbc.ci_diff_defaults) left two remnants:

- .github/workflows/ci.yml carried an auto-merge artifact — the regen step
  and floor step fetched `origin $GITHUB_BASE_REF` (my dropped D5's bare-var
  form) instead of `origin main` (#7146's authority, which resolves the diff
  baseline at floor eval-time via resolve_diff_baseline, not at fetch time).
  Re-running `gunbc ci` regen re-derives ci.yml from the merged
  ci_workflow.dag, restoring the `origin main` fetch.

- src/v2/test/claim/ci_diff_baseline_witness_test.dag imported the deleted
  gunbc.ci_diff_defaults module (my D5 authority), which would break the
  corpus compile. Its 6 witnesses are strictly superseded by #7146's landed
  dag/test/claim/diff_baseline_witness_test.dag (11 witnesses, with stronger
  fail-closed semantics on PR absent-base). Deleted as dead weight.

Co-Authored-By: Claude <noreply@anthropic.com>

* P1: the CI-log renderer, with the captured crawl window as its acceptance

Second phase of the atomic P0-P3 observation PR (operator ruling: only
finished work merges; a landed event model with no renderer is vocabulary
nobody can see).

gunbc.observation_ci_render projects the std.observation stream into
append-only log lines. It computes nothing and holds no telemetry source —
every number it prints arrives in an event or a heartbeat sample the process
already had — which is precisely what makes replaying a real captured run
possible rather than a synthetic fixture.

FLAGSHIP ACCEPTANCE, green by execution: the fixture is run 30044816605's
actual log, not a reconstruction. Its heartbeat at t=33m carried
current=16107200512 swap=34359738368 psi_some_avg10=9.01 and named no subject
at all, while the process sat inside v2.compiler.normalized_tree for 606984ms
and disclosed that only at walk end. Re-rendered through the escalation law
the same window produces named activity: identity-first heartbeats in human
units (15.0 GiB, not the raw byte dump), the quiet module surfaced at T, and
the memory-reclaim cause surfaced at 2T.

Contracts from section 6b in force: plain-sentence tone, real emojis from the
one glyph authority with the clock pulse, identity before vitals, durations on
every outcome line, refusals restated at the end so log truncation cannot hide
them, and relayed subject text neutralized through the existing GitHub guard
so a child's stderr cannot mint workflow commands in the parent run.

Law 4 made structural: line placement is DERIVED from attention, so a refusal
cannot be written into a collapsed group — the group is exactly where a reader
will not look. Escalation has two rates: reveal depth grows linearly (one tree
level per threshold) while emission points double (T, 2T, 4T), so a window
that stays quiet escalates without becoming a per-minute drumbeat, bounded by
construction.

Three REDs proven by perturbation, as the ruling requires:
- planted silent phase (escalation never emits) reds responsiveness
- an orphaned Begin reds the watchdog
- a Refused placed inside a collapsed group reds

Review 42203 (three findings, all correct, all fixed):
- ci_gibibyte_tenths respelled the GiB scale factor as a literal; it now
  consumes std.measure.gibibyte_scale_factor_bytes, and the duration helper
  consumes seconds_per_minute plus a new milliseconds_per_second added beside
  its siblings in that authority. A unit authority forked inside a formatting
  helper is easy to miss because it looks like arithmetic.
- the run summary picked the refused glyph whenever refusals+failures>0, so a
  failures-only run rendered as refused — collapsing at the last line exactly
  what the outcome sum exists to establish. Failures now dominate the glyph,
  refusals keep their own, both counts stay in the text.
- an unavailable duration silently vanished from concluded lines, breaking the
  model's own rule that an absent measurement names its cause. It now says so.
Each fix carries a witness; the summary fix carries its own RED.

Suite green: 31 model, 6 lockstep, 18 renderer conjuncts. Compile-clean
unchanged at 47 pre-existing errors, zero attributable here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* P2: the interactive TTY renderer, a sibling projection of the same carriers

Third phase of the atomic P0-P3 observation PR.

gunbc.observation_tty_render projects the SAME std.observation stream the CI
renderer projects — a sibling, not a successor and not a second model. The two
differ only where the medium differs: a terminal can be repainted, so routine
progress overwrites one line in place and stays quiet; a CI log cannot, so it
appends. Everything they share — the event vocabulary, the density authority,
the glyph table, the duration/byte/percent projections, the hold-cause text —
is imported from the CI renderer or the model, never re-derived. A witness
proves the sibling property by execution: the same event drives both surfaces
and moves together.

The three upgrades over the reference implementation are INHERITED from the
shared carriers, not re-earned: outcome lines carry durations, Refused is
distinct from Failed, and dwell escalation is recursive. The reference has none
of the three; the TTY renderer gets them for free by projecting the same model.

Law 4's asymmetry, expressed here as cursor action rather than group placement:
repaint-vs-scroll is DERIVED from attention, so a refusal cannot be repainted
away — overwriting it would erase it the instant the next line arrived, the
terminal form of burying it in a collapsed group. Required preamble (no
anonymous process), BlockedOn inline with named remaining (a bounded estimate
prints the time; an unknown one prints why, never a fabricated ETA), and the
reward animal on Final drawn deterministically from the one glyph authority so
replay is preserved and a non-emoji terminal degrades to a word.

Also in this commit: the self-host regen of the seed. P1 added
milliseconds_per_second to dag/std/measure.dag, a seed-emitted module, so
src/v1/stage0/src/std_measure.rs is regenerated to match — the required
same-PR regen for a generated-artifact source edit. Fixed point verified by
rebuilding regen_stage0 from the new seed and re-running to zero drift.

Suite green: 31 model, 6 lockstep, 18 CI-renderer, 10 TTY-renderer conjuncts.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* P3: the emit-site census wall

Fourth and final phase of the atomic P0-P3 observation PR.

gunbc.observation_emit_census is the census authority. Every place the floor
emits a progress line is either a projection of the observation event stream
or a counted frontier row with a reason and a dissolve-on — the same
discipline the site lane uses for unthemed colours. EmitSiteDisposition is a
closed sum, so a site cannot be half-classified, and there is no third arm for
a site the census has not looked at: the roster's completeness is what the
witness checks against the seed.

The roster carries the structured-tag emit families that exist regardless of
the CI rework: [floor-memory], [typecheck-attribution], [gantt], [governor],
[measurement]. The named negative example the operator called out — the
[floor-memory] raw byte dump — is a rostered frontier row, so the census
already carries the very site it exists to kill, with its dissolve-on naming
the P1 heartbeat projection that replaces it.

Sequencing per the ruling and design section 6b: the CI two-tier rework
rewrites the floor's emit sites, so the exhaustive per-print wall over the ~75
raw eprintlns in claim_executor is a declared frontier gated on this PR
rebasing over that rework and re-censusing. Censusing sites about to be
rewritten is the double-churn the operator ruled out. What lands now is the
census model, the roster, and the executable hygiene witness — never a hidden
zero: five families migrated-pending, the raw-print residue counted, and the
witness holding the roster against the seed so it cannot rot into a lie.

Executable, not inert: the witness reads the live seed and reds when a rostered
marker has vanished (staleness — proven by a RED control) or when a frontier
row lacks a real dissolve-on. The [floor-memory] shape is checked positively —
still present, still classified frontier — so the census cannot quietly drop it.

This completes P0-P3. Full suite green by execution: 31 model, 6 lockstep,
18 CI-renderer, 10 TTY-renderer, 6 census conjuncts, each with discriminating
REDs proven by perturbation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Piece 3: name the clamp coefficient's measurement basis (operator addition, 2026-07-24)

The 1000ms aggregate coefficient now records its basis in gunbc_ci_floor_batch_clamp_note:
host class (srv arm64 self-hosted, capped) x the adaptive governor's realized worker
width, denominated against the observed 0.58-0.70 s/witness (the 1344-1629s full-corpus
fleet envelope over ~2316 witnesses). Naming the basis makes a future width or fleet
change a deliberate re-sign of the constant, never a rediscovered fleet-wide red; the
~1.4-1.7x headroom over the observed top rate is exactly the >=~1.6x runaway the clamp
catches, with sub-threshold creep owned by the gauntlet's per-cadence s/unit receipt.

Co-Authored-By: Claude <noreply@anthropic.com>

* Probe (①/②): emit a per-gate warm-cost TSV from the floor's existing timings

Instruments claim_executor with write_gate_warm_cost_receipt — one row per gate/claim
(eval wall + resolve + combined warm_ms) and a discovery row carrying the per-witness
rate — derived from the ClaimResult timings the walk already records (operator ruling
2026-07-24: instrument the existing floor, no throwaway probe workflow). Written to
target/floor-gate-warm-cost-receipt.tsv and mirrored to the log as [gate-warm-cost] rows
so the placement probe lifts it from get_job_logs on a fleet run. This is the placement
roster's measurement basis: a gate rides PrTier only if its measured warm cost is within
the 5s fast-lane budget, else fail-closed to Gauntlet (v2.workflow.ci_placement). Every
floor run now auto-emits it; run cold-then-warm on >=2 hosts and the roster records value
+ host basis. Verified green-by-execution locally (single-claim row); the discovery-row
path verifies in the next full-corpus CI floor. Fail-closed on a write error, consistent
with the other floor receipts; never a verdict term.

Co-Authored-By: Claude <noreply@anthropic.com>

* Flagship replay as a green witness — the before/after made executable

The operator's "show me": proven-by-witness without a visible sample is the
fluent-but-unseen trap. dag/test/claim/observation_crawl_replay_test.dag
renders the captured crawl window of run 30044816605 through the P1 CI renderer
as one assembled block and asserts it by execution:

- names the module where the capture was silent ("still in witness discovery:
  entry 214 of 602, now typecheck v2.compiler.normalized_tree", surfaced at T,
  the memory-reclaim cause at 2T)
- uses human units, never the raw byte dump (15.0 GiB, not 16107200512)
- ends in a named refusal summary, not a silent 55-minute timeout

observation_crawl_after_block() is the exact function the PR body's after-sample
is produced from, so the pasted before/after is a projection of a green run
rather than prose. Every input number is read off the real log.

The earlier gunbc/observation_crawl_demo.dag (a run-entry that returned a String
and so errored on the ProcessExit contract) is replaced by this witness — a
green check is worth more than a run-entry that prints then fails.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Wiring flip (1/n): install the output policy BEFORE the naming walk — kill the [file] firehose

The floor's [file] read firehose (2265 lines / ~99% of the log, measured by execution)
was the pre-plan naming-hygiene walk reading the whole source tree at the OutputDecision
Full default, because install_output_policy ran AFTER the walk (claim_executor.rs order).
gunbc.output_policy already models Instrumentation => Suppressed at Normal (CI's default
verbosity) and ShellTrace => Condensed — the walk just never saw the policy.

Fix: install the policy (and group syntax) FIRST, before the naming walk and every
subsequent corpus read, so all host-effect traces are funnelled per the .dag authority.
Verified by execution on the minimal smoke plan: [file] read 2265 -> 0, total log
2613 -> 24 lines, claim still PASS (exit 0). The Ambient semantics hold — the policy's
divergence rule (ExpectedOutcome/ObservedOutcome) still expands a captured stream on
failure, so a red effect is never silenced; only the green firehose is.

This is the highest-leverage lever of the observation-emit census flip (the echo class
the census targets). Follow-on commits route the display families ([floor-memory],
[gantt], [governor], [measurement], [t+..]) through the observation stream as Ambient
projections (the ✅/🕐/🚫 format matching #7168's "after" block).

Co-Authored-By: Claude <noreply@anthropic.com>

* Wiring flip (2/n): render floor phase marks through the observation authority

Step 2 of the flip (format), after step 1 (the [file] firehose, volume). The
prelude phase marks are the visible display class in the short regen job's log;
they now render through the single-authority observation renderer instead of a
raw [t+…] byte string the seed would fork the format into.

  before: claim_executor: [t+86.1s] naming-hygiene walk complete
  after:  ✅ naming-hygiene walk done in 48 seconds

- New seed→.dag boundary gunbc.observation_seed_render: primitive args in, a
  rendered line out — exactly as cli_run.install_output_policy calls
  output_policy.resolve_channel_policy. A phase concluding is modelled as a
  Concluded event on a PhaseSegment subject, projected by
  ci_event_line ∘ ci_render_line, so the FORMAT stays single-authority in
  gunbc.observation_ci_render and the seed constructs no format of its own.
- The raw [t+{:.1}s] eprintln is DELETED, not suppressed (grep-clean for the
  print). §5: on a renderer-unreachable failure the arm names the degradation
  loudly and never reproduces the old marker.
- Per-phase walls (delta since the last mark), not a running t+, so the log
  itemizes which prelude phase is slow — the step toward the per-phase receipt
  keys the ci_spec prelude-coverage-hole follow-up (row a) calls for.
- Green by execution: phase_mark_renders_through_the_observation_render_authority
  resolves the adapter through a real interpreter and asserts human units + the
  completed glyph + NO [t+ marker (the discriminating RED). The seed→.dag
  resolve is memoized, so the renderer resolves once and later marks are cache
  hits. Rust-called-.dag-unimported has precedent (output_policy.dag).

Next in the series: the rostered census families. floor-memory (the flagship
byte dump) needs its subject feed plumbed first so it renders honestly (entry X
of Y, never a fabricated 0 of 0), then gantt/governor/typecheck-attribution,
each flipping its census row (CountedFrontierSite → MigratedToObservation) with
the witness restructured to assert the raw marker is gone — the "witness fixes"
step of flip → witness fixes → roster.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Witness fix: roster the observation stack's one wildcard site (non_fold_residue)

The progress-and-observation merge (#7168) added observation_ci_render.dag,
whose ci_hold_cause_text names the two memory-pressure SchedulerHold variants
specifically and gives the other five a generic cause via a top-level wildcard
arm — a non_fold_residue site. It landed unrostered because per-PR affected-set
selection predict-skips the corpus-read nfr witness (the masking class the
roster's dated rows document), so it reds only on a cold whole-corpus sweep
(falsifier / merge-to-main), not on the selected PR floor. That is the census
wall doing its job on its own author.

Roster it (gunbc.non_fold_residue, one FrontierRow, reason + dissolution trigger
toward a total match), matching the established masking-class fix and preserving
the observation author's design.

Green by execution: observation_hold_cause_wildcard_is_rostered asserts the live
roster now carries dag/gunbc/observation_ci_render.dag::ci_hold_cause_text via
the same host reader the corpus scan uses — reds if the row's key drifts from
the scan's {rel}::{fn} key or the hand edit malformed the 126-row list.

design_register_lift_parity (the other cold-red thought to be surfaced by the
merge) is NOT touched: this branch's gunbc.site.* inputs are byte-identical to
main and recent main-push runs are green cold, so it is green here too — not
attributable to this PR.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Wiring flip (4a/n): the floor-memory heartbeat's seed oracle + golden strings

Foundation for migrating the [floor-memory] byte dump to the observation heartbeat.
Adds gunbc.observation_seed_render.seed_heartbeat_line: the seed→.dag boundary that
takes the primitives the heartbeat thread has (elapsed, batch label, entry position,
memory vitals) and projects them through the one renderer (ci_heartbeat_line ∘
ci_render_line) — identity first, human units, no raw byte dump. The subject is
batch-grain by construction: the floor walks entries in parallel, so there is no
single active module to name, and the primitive interface carries none — never a
fabricated per-module "now typecheck X".

Green by execution: seed_heartbeat_line_renders_identity_first_in_human_units pins
the exact bytes for two samples through the real interpreter:

  🕐 33 minutes in — still in witness discovery: entry 214 of 602. memory 15.0 GiB, swap 32.0 GiB, pressure 9.0%
  🕐 500ms in — still in self-host fixed-point: entry 0 of 2. memory unreadable (cgroup field unreadable), swap 0.0 GiB, pressure unreadable (cgroup field unreadable)

The first is the captured crawl window re-rendered from the seed's own vitals (raw
byte value absent); the second proves an unreadable cgroup field names its cause,
never a fabricated zero (observation law 2 / §5). These golden strings are the oracle
the Rust mirror is proven byte-equal to in 4b.

Why a Rust mirror next, not an interpreter call: the heartbeat runs on a detached
liveness thread in a memory-constrained context — resolving the renderer there would
build a duplicate module index, consuming the very memory it watches (§2), and the
thread exists to stay alive when the main interpreter is busy. 4b adds that mirror
(proven == this oracle), plumbs the subject feed, wires it, deletes the byte dump,
and flips the census row.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* File finding: shell.Env.Get realized as a printenv subprocess (transport-decomposition lane)

Operator-directed finding (2026-07-24), do-not-fix-here. Records in the residual-shell
census (§0b) a class distinct from that doc's shell-EMISSION axis: modeled ops whose
interface shape is right but whose single hardwired transport is a shell escape where a
NATIVE in-process handler is correct — the verbatim §3(b) N×M-adapter tell.

shell.Env.Get (extdeps/shell/shell.dag:42) reads an env var the process already holds
in its own environment by spawning `printenv` (wet_env_var, v1_interpreter.rs:5096).
Reading your own environment is not a host effect; std::env::var is the native handler,
chosen when locality is OnTarget, with shell/ssh reserved for a var on another host.
Sibling: shell.Which.Check (`command -v`), already in the census. One root, three lanes.

Not a floor-time lever (~ms/spawn); filed so the deficit is counted and prioritizable
(§6), never absorbed into "it's only a few ms." Its native read is the lane's cheapest
first consumer (a pure in-process read, no host_effect_apply even).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Wiring flip (5/n): shell-echo §5 split — routine Ambient, failure Anomaly self-describing

The [shell]/$ echo class still printed at Normal after the firehose fix: it is the
ShellTrace channel at Condensed, not the Instrumentation channel that [file] read rode.
But naive "suppress ShellTrace at Normal" is a §5 fail-open — the failure stderr block
rides the SAME channel via trace_emit(), so Suppressed would silence failures too. That
Condensed was load-bearing.

Root (operator's naming): one channel carrying two content classes with OPPOSITE
attention — routine scaffolding (Ambient) and failure evidence (Anomaly) — a
state-space conflation at the channel grain, exactly what the observation model
dissolves by deriving attention per event, not per channel (law 4: routine collapses,
anomaly expands). The fix uses the two EXISTING mechanisms, each governing its class —
no third decision mechanism:

- Routine ($ argv pre-spawn echo + [shell] done exit=… count) → the ShellTrace CHANNEL
  → Suppressed at Normal (Instrumentation's debug-only shape), Full at Verbose.
- Failure evidence (stderr block) → the effect_stream DISPOSITION (SurfaceContent)
  ALONE, not the channel, so suppressing the routine echo cannot silence a failure.

Two upgrades the disposition-gated block gains, both §5-correct now that the count is
silent at Normal:
1. SELF-DESCRIBING — the block carries its own `$ <argv>`, so the failing command never
   scrolls away from its stderr (the pre-spawn echo it used to borrow from is gone at
   Normal). Strictly better than what suppression would have taken away.
2. SURFACES ON EMPTY STDERR — the block names the exit even when the command wrote
   nothing, because the routine count that used to carry the exit is now silent.

Proven by execution: four-corner effect-stream suite kept; new discriminating RED
at_normal_a_failing_effect_surfaces_its_command_a_passing_one_is_silent (passing →
None; failing → `$ <argv>` + stderr) + stderr_block_surfaces_on_surface_content_even_with_empty_stderr.
Channel witness updated (w_shell_trace_routine_is_debug_only: Suppressed at Normal).
Convergence named in output_policy.dag: when shell effects become observation events,
trace_emit(channel) stops being the gate and derived attention replaces this split.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Revert "Wiring flip (5/n): shell-echo §5 split" — approach was wrong, unbreak the branch

This reverts commit 60a4496. Two defects, the second fatal to the approach:

1. Parse break (caught late): the witness carried `//` comments, but daglang has NO
   line-comment syntax — documentation is `data …_note: String` only. build_module_path_index
   scans every .dag at install_output_policy startup, so the parse error panicked the whole
   floor, not just that witness. LESSON: verify .dag by execution before pushing; a Rust-lib
   test does not exercise the .dag parse/resolve path.

2. The approach itself was wrong (the real reason for the full revert). Making ShellTrace
   Suppressed at Normal does not just silence the routine echo — effect_stream_disposition is
   GATED BY channel_decision:

     match channel_decision(channel, verbosity) {
       Suppressed => StreamSuppressed          // failures silenced
       Condensed  => divergence_disposition(…) // divergence surfaces, agreement counts
       Full       => SurfaceContent
     }

   So Condensed-at-Normal is load-bearing TWICE (trace_emit AND the divergence disposition),
   and host-effect grouping keys on the same channel. Suppressing it is a §5 fail-open
   (a real failing effect's stderr goes silent at Normal); the Rust test passed only because
   it read the hardcoded EFFECT_STREAM_POLICY_FALLBACK, masking the installed-policy break.
   The alternative (route routine → Instrumentation, keep ShellTrace Condensed) leaves empty
   `##[group]` brackets and buries the failure block inside the collapsed section.

FINDING for the redo: the channel↔disposition↔grouping coupling IS the "one channel, two
content classes" conflation the operator named — and there is no clean immediate fix that
does not touch it. The correct fix decouples the failure disposition from the routine
channel verbosity (the "bigger lift" flagged as needing a design steer), which lands back
at the operator's "Hold — I'll steer". The self-describing failure-block design (carries its
own argv, surfaces on empty stderr) is sound and preserved in 60a4496's history for reuse.

Branch returns to the green b35a4b3 state. Shell-echo goes back to HELD pending the
disposition-decoupling design decision.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TUqWZP4HTVyUfW4qRqWya1

* Wiring flip (4b/n): floor-memory heartbeat via render_heartbeat_line_mirror

Flagship of the observation wiring flip: replace the [floor-memory] raw byte
dump with the identity-first 🕐 heartbeat, proven byte-equal to the 4a seed
oracle (seed_heartbeat_line).

- render_heartbeat_line_mirror: pure Rust mirror of ci_heartbeat_line ∘
  ci_render_line — the heartbeat thread cannot call the interpreter (duplicate
  module index under the memory envelope it watches). Discriminating RED
  render_heartbeat_line_mirror_matches_seed_oracle pins byte-equality on the
  crawl-window and unreadable-field goldens.
- HeartbeatFeed (cli_run): process-global batch label + entries done/total,
  armed only when entry_total is known and non-zero (never a fabricated
  0-of-0). Updated at batch-enter and at the existing
  index_schedule_entry_completed per-entry point (SingleClaim path increments
  per claim result). Discovery fills the total once the roster's entry-group
  count is known.
- Delete the byte dump; keep the regime-disclosure line (marker stays for
  census hygiene). Flip floor_memory_site → MigratedToObservation; restructure
  census/lockstep witnesses (frontier 5→4, dump shape asserted gone).
- Also: strip invalid // comments from output_policy_witness_test.dag that the
  shell-echo §5 commit left (dag has no // comments — parse Slash).

Co-Authored-By: Cursor <cursoragent@cursor.com>

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* cargo fmt: claim_executor + cli_run after floor-memory 4b / main merge

CI build failed at the fmt --all --check gate (assert_eq! wrapping +
HeartbeatFeed Mutex.lock() chain). No behavior change.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Wiring flip: [gantt] → Begin/Concluded PhaseSegment observation projection

Compile-path trace_mark and GUNBC_FLOOR_GANTT emit through
phase_begin_line / phase_concluded_line mirrors (byte-equal to the seed
oracle; interpreter render from inside compile would recurse). Census
row MigratedToObservation; raw t_ms/rss_mib shapes gone. Frontier 4→3.
Verified via claim_batch on observation_emit_census_witnesses.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Wiring flip: [governor] → ci_hold_cause_text / StatusBlocked observation projection

HoldReason emits through seed_governor_hold_line (mirror
render_governor_hold_line_mirror); hard/creep/receipt/startup lines lose
the raw [governor] key=value shape. Census MigratedToObservation;
frontier 3→2. Mirror↔oracle byte equality for PsiPressure and
CurrentHighWater. Verified via claim_batch + memory_governor unit tests.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* cargo fmt: claim_executor after governor hold oracle RED

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Fix runtime_rust.dag: escape Rust format braces for daglang parse

daglang treats {ident} inside string literals as interpolation; the
gantt mirror's format!("{glyph}…") (and use std::sync::{Mutex,…})
panicked the regen self-compile. Escape as \{…\} so the emitted Rust
keeps real braces. Emitter twin resynced; byte-equal to v1_rt.rs.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Wiring flip: [typecheck-attribution] → ModuleSegment+PhaseSegment observation

Per-module typecheck Begin/Concluded via typecheck_*_line mirrors
(render_typecheck_*_line_mirror); 2s pathology threshold preserved.
Census MigratedToObservation; frontier 2→1. Mirror↔oracle RED for the
captured crawl fixture module. Verified via claim_batch.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Wiring flip: [measurement] + shell-echo → ObservationEvents (one pass)

Measurement peak-RSS/cgroup dumps project through ci_measurement_rss_line
(seed_peak_rss_line ↔ render_peak_rss_line_mirror; identity-first, human GiB).
Shell host-effects become ObservationEvents: Ambient Begin/Done still gated by
ShellTrace; Anomaly Failed gated by effect_stream disposition alone (never
silenced by ShellTrace Suppressed), with law-4 idempotent group_end, self-
describing `$ argv (exit=N)`, and empty-stderr surfacing. ShellTrace/
disposition tables left unread for the interim Condensed-at-Normal split.

Census: measurement + shell MigratedToObservation; tagged frontier count 0;
76 raw eprintln residue recounted. Standing check: claim_batch census
witnesses PASS before push.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Fix GeneratedArtifact name collision in observation_model witnesses

Whole-tree compile-clean failed: bare SelectionNoOp.GeneratedArtifact
collided with v2.std.artifact.GeneratedArtifact and
gunbc.generated_artifact.GeneratedArtifact. Mint via
selection_noop_generated_artifact in the defining module so the
variant resolves unambiguously.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* Observation aesthetics: named-intent shell, glyph discipline, census bidir, failure-receipt miss

Operator live-log review (run 30142403230) — four pieces in one pass:
- Shell subjects are typed service.op intents; argv only in Failed.error. Ambient
  ShellTrace is Suppressed at Normal (silent scaffolding); Anomaly still surfaces
  via divergence alone (Quiet no longer forces StreamSuppressed).
- Governor receipt uses StatusPulse (not Done glyph); peak RSS / governor / cgroup
  wrap in one "floor receipts" group.
- Census roster grows four CountedFrontierSite rows ([floor-drain], [gate-warm-cost],
  [receipt], [file]) with a bidirectional hygiene witness.
- Undeclared *_failure_receipt companions (NoMainFunction) treat as empty detail
  instead of stuffing failure_receipt_refused onto ordinary Bool(false) reds.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* Silence Ambient shell on gunbc run; roster #7205 resolve/assembly split tags

Merge-admission stamp is `gunbc run`, which never installed output_policy — so
ShellTrace fell back to Full and every Ambient Begin/Done still printed despite
named-intent subjects. Install policy + group syntax at handle_run startup
(same as claim_executor). Census grows [resolve-split]/[assembly-split]
frontier rows so #7205's new tags stay bidirectional.

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* WIP: Floor #6848: memoize the per-entry bare-reference fixpoint so post-flip

* Re-merge #7205 tip + native shell.Env.Get (kill printenv Anomaly clutter)

Pull the two new #7205 commits (export_index canonical = fold element — kills
the O(|bindings|^2) rescan). Route OnTarget shell.Env.Get through wet_env_var
instead of printenv so optional floor_diff injections (GUNBC_CI_DIFF_*) no
longer paint ❌ Anomaly Failed when unset — reading this process's env is not
a host effect (§3(b) / shell-to-dag census 0b).

Co-authored-by: Brian Searls <briansrls@users.noreply.github.com>

* infer_semantics: unstale the slice control after #7196 admitted list slicing

#7196 (bb4347d, on main) deliberately extended `check_slice_access_node` to
admit ordered element collections — adding `base_is_list`, widening the
refusal arm to `base_is_string || base_is_list`, and returning the base type
rather than String on the list arm. `invalid_slice_returns_compiler_error_type`
still pinned the withdrawn refusal, so it asserted one diagnostic where the
compiler now correctly produces none:

    assertion `left == right` failed
      left: 0
     right: 1

The witness went stale; the compiler did not. Repointed the negative control at
a `Map` base — `ordered_element_collections()` (std_types.rs) holds `List`
alone, so a Map is neither String nor an ordered element collection and must
still refuse — and added the positive control #7196 admitted but never
witnessed: a `List<Int>` slice yields no diagnostic and preserves `List`.

Reproduced locally before the change (identical left 0 / right 1) and green
after. Both controls proven live by perturbation: restoring the `List` base
reds the negative control, expecting `String` reds the positive one.

Note on how this reached main green: the witness never ran there. It is a
binary witness whose transport (dag/tools/infer_semantics_witness_transport.dag)
declares no dependency on v1_compiler_infer_access.rs, so the affected set
cannot see the edge; main's run at bb4347d observed an empty diff and skipped
1761 of 2373 witnesses, this one among them. That selection escape is a
separate defect and is not addressed here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* gunbc run: add --arg name=value, the missing parameter channel at the .dag seam

`Commands::Run` was zero-arity by construction: `run_in_context` (v1_interpreter.rs:1543)
ends in `call_function(ctx, &item_node, &[], &env)` — an empty argument slice — while
`run_in_context_with_args` has sat twenty lines below at :1564 the whole time, already
used internally by claim_executor.rs:166. Only the CLI flag was missing.

The consequence is repo-wide and stated in the corpus itself
(dag/gunbc/roadmap_belt_actuate.dag:689): "gunbc run --function cannot pass an argument
(there is no --arg flag), so the node id enters through the environment". Every value
that must reach a `.dag` entry crosses as an environment variable instead — 34 live
GUNBC_* names across 77 read sites, including intra-process uses where sender and
receiver share a PID (floor_skip_discovery_witness.rs:112-127 set_vars a synthetic diff
and reads it back in the same process). The environment wins by economics, not design:
adding a modeled parameter costs an edit to `cli_run`'s 29,626 lines of SeedRetained
hand-Rust, adding an env var costs one line on each side, and `NamespaceTree`
(dag/std/effect_grant.dag:26-31) has no environment arm, so no grant bounds it and no
lens counts it.

Named-only by construction: a `.dag` entry's parameters are named, so positional order
across the CLI boundary would be an unchecked coincidence. A missing `=` or an empty
name refuses with exit 2 before the compile runs (§5) rather than guessing a position,
and one malformed spec refuses the whole list — a partial parse would silently drop a
caller's argument. Values enter as `Value::Str`; no coercion is fabricated here.

One path, not two: with an empty --arg list `run_in_context_with_args` passes the same
empty slice `run_in_context` did, so the zero-arity path is unchanged rather than
branched around.

Threaded through the emission authority (src/v1/05_emit_rust.dag:10270 variant, :10495
match arm) and its seed mirror in v1_compiler_emit_rust.rs so regen stays a fixed point.

Proven by execution against the built binary, not by typecheck:
  --arg node_id=roadmap-7   -> ExitSuccess, exit 0
  --arg node_id=wrong-node  -> callee received "wrong-node" (the value transports,
                               not merely the flag parses), exit 1
  --arg node_id             -> exit 2, "expected `name=value`"
  --arg =orphan             -> exit 2, "empty parameter name before `=`"
  --arg ok=1 broken also=2  -> exit 2, whole list refused
  no --arg                  -> zero-arity path unchanged
Plus six unit tests (three of them RED controls) and `05_emit_rust.dag` compiled through
the real pipeline: 0 blocking errors.

Known gap, not papered over: the unit tests run under `cargo test`, which left CI on
2026-07-11 (gunbc.commit_workflow rust_tests_removed_disposition). An enrolled floor
witness for this channel is a follow-on. Retiring the parameter-shaped env vars onto
this flag — GUNBC_BELT_NODE_ID, GUNBC_CI_DIFF_*, CI_FLOOR_EXIT — is also follow-on; this
commit adds the channel, it does not yet migrate the callers.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* CI floor: give re-homed witnesses a real scheduled lane (FalsifierCadenceJob)

Batch 4 breaches its clamp on every run of this PR — 571556ms (srv3-01) /
613864ms (srv2-02) against clamp_ms=420000 at units=74, authority
gunbc.ci_spec gunbc_ci_floor_batch_clamp_params[3]. Both batch-4 groups
PASS; it is the wall, not a witness.

Per the operator ruling, six declared rows move off the per-PR floor to the
4-hour falsifier cadence: the three wave1_gate1_d_* rows (141s + 29s + 27s)
and the three affected-set provenance walls (14s + 13s + 13s), measured in
the run-30148859947 slow-witness tables. That removes ~237s of eval, landing
batch 4 near 334-377s under the unchanged 420s clamp.

The vehicle is NOT gunbc.ci_layer_roots falsifier_rehomed_bin_wet_rows. That
roster is specifically the bin_witness_wet_entries per-row-budget overflow
(constructor bin_wet, budget datum bin_witness_wet_per_row_wall_budget_seconds)
and does not model CommitWitnessClaim rows; re-homing through it would mint a
second re-home authority. Instead this extends the axis that already answers
"where does this check run" — the enrollment surface — with a fourth variant,
FalsifierCadenceJob, plus the batch that reads it.

The batch lands in the SAME change as the surface deliberately: a surface tag
with no consumer is enrollment-by-illusion, which is the state ~54 files under
test/claim/long/ are already in (excluded from discovery at dir grain, not
walked by the falsifier, enrolled nowhere) and it would present as a clean
green diff. gauntlet_lane_enrollment_witness_test reds per-PR if a row ever
sits on the surface without reaching a batch.

Two entries split at the check_fn rather than moving whole, so each concern
keeps per-PR coverage at the cheap grain and loses only the wet grain:
affected_set_provenance_producer keeps its four <=161ms fns on the floor,
parse_binding_fidelity keeps witness_resolve_distinct_param_bindings_holds.

FOUND BY THE WALL, first execution: the doc-reachability witness
(doc_graph_has_no_orphan_docs, doc_graph_has_no_dangling_links) rode
surfaces: [GitPrePushHook] alone — enforced only by a mechanism this repo has
already ruled is not an enforcement authority (opt-in per clone, bypassable
with --no-verify, absent in container worktrees, proven ineffective by #6658).
Orphaned docs and dangling links had no wall on any CI path. Fixed by adding
the cadence surface, NOT by widening witness_enrollment_is_scheduled to accept
the hook — widening the predicate until the failure disappears is the
absorbing fallback, and would have re-buried the finding that surfaced it.

Placement (PrTier | Gauntlet) is the intended end-state authority and is
recorded as the dissolve-on, not wired here: PrTier is unwritable without a
WarmCostReceipt whose measured_ms is within the 5s fast-lane budget, so
wiring it onto all 36 CommitWitnessClaim rows needs a per-row measured
receipt and the D2 warm-cost probe has not run. Fabricating those receipts is
the fail-open the placement law exists to forbid; defaulting the unmeasured
rows to Gauntlet would de-enroll all 36 at once. Encouraging convergence: the
5s law selects exactly the twelve rows measured over 5s and admits every other
batch-4 row at <=1s, so placement and this surface agree on today's roster.

dag_compile_clean_perturb_receipts_holds is deliberately NOT re-homed. It was
retained by the 2026-07-23 ruling by name because it measured 53s, under the
60s per-row budget; it now measures 141s. Re-homing a row that got 2.7x slower
answers the wrong question and would zero the deficit's frequency by
construction. Its growth is diagnosed separately.

Proven by execution: all three files compile clean (0 blocking errors);
gauntlet_lane_enrollment_witness_test 3/3 green in 3ms, inside the fast lane.
Both claims proven live by perturbation — reverting one re-home reds
_rehomed_rows_are_cadence_enrolled_holds, and _is_never_bare_deenrollment_holds
was RED against the live roster before the doc-reachability fix and green
after. The RED control discriminates a synthetic bare de-enrollment.
commit_witness_claim_roster_holds (the #7060 stale-pair class, live) PASS.
No generated-artifact drift: the ymls invoke plan functions, so batches
compute at run time and the falsifier picks up the new batch.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* CI floor: operator-signed interim clamp raise, batch 4 420s -> 540s

Signs the margin ruling for the budget family, not just this number.

A clamp was doing double duty: merge-refusal threshold ("this must not
merge") and growth detector ("something got slower — look"). Tight margins
serve the second job and demonstrably worked — perturb's 53s -> 141s growth
was caught precisely because the clamp was tight. But they make the FIRST
job fire on host roulette, and a breach meaning "you landed on srv2-02"
trains the on-call to rerun, which is crying-wolf wearing budget clothes.

Policy signed here: clamps are sized to cover MEASURED fleet spread, so a
breach means content grew, never which host answered. The growth-detector
job moves to per-row trend receipts on the falsifier cadence — that piece is
what makes a wider clamp safe, and it is sequenced next behind the perturb
diagnosis.

Basis for 540: post-re-home projection 377s (worst observed wall 613864ms
minus the ~237s the six re-homed rows carried) x 1.2 worst observed spread
= ~452s, + ~20% policy margin = 540 (whole-minute grain).

Run ids: 30148859947 @ 619bba5 wall_ms=613864 units=74 srv2-02;
30163496549 @ 9f87967 wall_ms=571556 units=74 srv3-01 — identical content,
7.5% apart, which is the spread this funds.

Enrollment that grew the batch: NONE. Batch 4 shrank this cycle (units
74 -> 68). The raise buys spread coverage on a batch that got smaller.

Not the forbidden widen: batch 4's per_unit_ms is 0, which the clamp note
already calls "a declared calibration gap, not a hidden default". 540 funds
that gap with a dated, dissolving interim rather than leaving a flat rate to
fire on variance. It refuses exactly as before — only the threshold moved,
on a stated measurement, not to make a red go away.

Dissolve-on: the perturb diagnosis lands (141s = 38% of the remaining batch;
returning it toward its 53s basis puts worst case near 350s, under even the
retired 420) AND the D2 per-unit rate replaces the flat clamp.

The wet-receipt 600s budget (the 707s falsifier red) has the same disease —
ten-day-stale basis, zero spread allowance — and the policy above governs it,
but its NUMBER is deliberately not moved here: it is gated on its own
sccache-vs-growth attribution so the dosing lands with a measurement rather
than by analogy.

Host spread is not weather: srv1/srv2 still run pre-#7213 sccache units and
are typed expected-latent-defective until re-provisioned, so part of the
7.5-20% collapses when the fleet lane re-converges them.

Proven: ci_spec compiles clean; witness_floor_batch_clamp_params_cover_schedule,
_overhead_all_positive, _rate_all_nonneg all PASS.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* Extend the falsifier batch-count pin for the FalsifierCadenceJob batch

779e9dc appended gunbc_falsifier_cadence_witness_batch to
gunbc_falsifier_batches() without extending falsifier_plan_structure_holds,
which pins the schedule's batch count:

    let expected_batches = 1 + wet + probe + silent_pick + rehomed
    (length(xs: batches) == expected_batches) && ...

So length was expected_batches + 1 and the witness returned false, redding
ci_floor_plan_witnesses and with it batch 3 on run 30166208268. The pin
worked exactly as designed — it exists to red when a batch is added without
being declared, and that is what it did.

Note what this masked: batch 3 failing stopped the walk before dependent
batches, so batch 4 never ran on that run and the re-home + 540 clamp are
still UNMEASURED in CI. The floor-batch-wall receipt read "3 batch(es), 0
over budget" — green on the batches that ran, not evidence about batch 4.

The fix is not a count bump. falsifier_cadence_witness_batch_holds mirrors
the silent-pick sibling and checks the batch's actual shape: SelectionApplied,
zero scan_dirs, entry count matching falsifier_cadence_witness_entries(),
Wet execution mode, spawns_host_compiler, and NOT heavy_whole_tree_resolve.
The rehomed sibling is only counted, never shape-checked; this one is both.

Proven live by perturbation, not just by going green: flipping the cadence
batch's execution_mode from Wet to Hermetic reds falsifier_plan_structure_holds.
Verified green together with ci_floor_optin_roster_witnesses,
ci_corpus_discovery_flip_witnesses, and all three
gauntlet_lane_enrollment_witness_test claims.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* Decode \xNN in .dag string literals — no authored colour had ever rendered

process_escapes resolved exactly six escapes (\" \\ \n \t \{ \}) and fell
through on everything else to concat("\\", next), preserving the backslash.
So "\x1b" was never an ESC byte: it was the four characters backslash-x-1-b.
Every ANSI code this repo authored in .dag emitted as literal text —
extdeps/render/ansi.dag csi_esc, extdeps/render/terminal.dag's reset, and
gunbc/ci_render.dag's red/reset. That is the `\x1b[38;5;196m🔥` seen in the
TOP SLOWEST WITNESSES table of run 30167957464, which read as a renderer
leaking colours onto the CI path and was neither: the raw GitHub log carries
real escapes everywhere else, so the defect was the decode, not the target.

Fixed at the authority (src/v1/01_tokenize.dag), not the generated seed, via
the already-registered from_code_point builtin — no new builtin. The seed
file is regenerated by regen_stage0; it is `// Generated by v1 compiler`.
Regen produced exactly this one file's delta, so the self-host fixed point
held across the change.

The witness that should have caught this could not. It compared one
undecoded literal against another (code == "\x1b[38;5;34m"), so both sides
were equally wrong and it agreed with itself throughout — the vacuous-oracle
shape DESIGN §5 names, a check satisfiable by editing the declaration while
the realization lies. Its two replacements test properties of the DECODE
rather than of the spelling: the first character's code point is 27, and the
decoded string contains no backslash. Neither can be satisfied by editing a
literal on either side. Both were proven RED against the pre-fix binary
before regen was paid for, and green after.

Unknown-escape passthrough is knowingly RETAINED, and marked rather than
left silent: 🟡 dissolve-on tokenizer_unknown_escape_strict_close. Refusing
today would red 142 occurrences across 38 files — overwhelmingly regex
fragments (\' 28, \. 19, \| 13, \/ 12, \B 10) that intend the backslash to
survive — so the strict close needs a raw-string carrier to migrate onto
first, and lands with a corpus-wide compile receipt because it changes parse
semantics for every lane that compiles through this tokenizer. Not the four
sites a \x-only count suggests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013GELyMsZrGgZRrxte2TCsk

* Layer 1: bind ExpectedOutcome from the call site, not the transport

v1_interpreter.rs carried `let expected = ExpectedOutcome::ExpectSuccess`
hardwired at dispatch_shell, with a comment saying where the declaration
should live was still open. It is now read from the call site.

The whole downstream apparatus already existed and was pinned —
gunbc.output_policy's four corners, outcome_diverges, the Rust mirror in
EFFECT_STREAM_POLICY_FALLBACK. Only the binding was missing, which is why
output_policy.dag:105 could already describe the payoff in writing.

WHERE IT LIVES, and the two homes that look right and are not:

param_env is wrong because param_env IS the request:
content_hash_service_inputs iterates op_node.params and looks each up there,
so a service-op `input {}` would join the digest and two invocations
differing only in what the caller expected would become different cache
identities for the same request.

The transport is wrong less obviously, and this is the trap. The nearest
local precedent — transport_stdin, transport_response_format via
find_property — points straight at it. But dispatch_service_wet receives the
transport from op_node.transport.or(service_node.transport): the extdeps
service-op DECLARATION, shared by every caller. Hanging the expectation
there makes it a per-operation fact, so a red control and a genuine check
both calling shell.Test.IsFile could not differ — and caller policy declared
in extdeps is the DESIGN §3 layer inversion the original comment warned
about. It would have compiled and read as green while being wrong twice.

So it is a reserved argument on the call node, partitioned out in
eval_method_call before bu…
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants