T-4.12: model extdeps/languages/llvm_ir.dag — LLVM IR LanguageModel (B2-OMNI probe PASS)

[briansrls]

Summary

• Models src/v4/extdeps/languages/llvm_ir.dag — the LLVM 18 LangRef
  LanguageModel: types / values / constants / instructions / terminators
  / basic-blocks / functions / globals / module, fully declarative data.
• B2-OMNI falsification probe RESULT: PASS — LLVM IR (SSA / phi /
  dominance) is a plain LanguageModel over the closed Node substrate
  with no 6th behavior and no core/pipeline change. SSA is the
  value-graph (operands edge to producing nodes; the textual %name is
  a DeclaredNormalized C5 boundary, never minted); phi is structurally
  hoisted to the block phi-region (P2); dominance is a lens read, never
  a stored field.
• Honest inhabitance (algebra.dag Float≠Field discipline): iN →
  CommutativeRing (Z/2^N Z, not OrderedRing); float →
  ApproximateField; i1 → BooleanAlgebra; vectors by Practice-7
  projection; pointers deliberately no numeric algebra.
• Every closed sum carries the full 5-pattern Practice-4 ledger;
  raw-Int widths + carrier precision tracked as 🟡 scaffolds (the
  merged diagnostic.dag Extent.ByteRange precedent; trigger =
  std/cardinality.dag refinement substrate).
• Codex BLOCKING (6) addressed — see the resolution comment.

Test plan

• v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics
• Immutable header I/O contract preserved (only Status line updated; Consumes: std/primitive.dag staleness surfaced, not edited)
• No new files, no new std/* concepts, no Result/Diagnostic improvisation (open T-4.6 carrier STOP respected — declarative model needs neither)

🤖 Generated with Claude Code

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 6a4f9746 · Trigger: schedule
• Thinking: 179s wall

---

BLOCKING (6)

Root Cause

• src/v4/extdeps/languages/llvm_ir.dag LLVM LangRef scope/version and closed-sum dissolution receipts were removed before a faithful slice was declared → restore the authority header and classify or decompose each new sum before consumers rely on it.
• src/v4/extdeps/languages/llvm_ir.dag LLVM integer algebra was modeled by inventing a broad LlvmValue ring and placeholder operations → ground fixed-width integer values/ops against LangRef plus std.algebra, or defer the witness as a tracked scaffold.

⚠️ Blocking issues are in the new .dag language model, so this should not land until the LLVM IR substrate facts are grounded and classified.

[briansrls]

Codex BLOCKING (6) — resolved at HEAD 07c4c1c6

The review ran on 6a4f9746 — a dashboard auto-committed mid-probe WIP snapshot (header stripped, placeholder fn(a,b){a} ops) created while empirically probing whether the operator-ratified data-instance inhabitance form parses under the frozen v2 seed. It does. The findings were correct for that snapshot; the faithful model (352f35e5) + tracked-scaffold pass (07c4c1c6) address all six. Point-by-point:

1. No LangRef authority header → FIXED (352f35e5). Full immutable header restored verbatim; Anchor: LLVM Language Reference Manual pinned at LLVM 18 (modeling notes + per-type LangRef section cites).
2. LlvmType no 🟢/🟡/🔴 classification → FIXED. Every closed sum (22 of them) now carries the full 5-pattern Practice-4 ledger + 🟢 terminal rationale (records/Conj correctly carry none). The 4-variant probe form is gone (now the 13-category LangRef taxonomy).
3. IntegerType.bits unconstrained Int admits invalid widths → TRACKED 🟡 (07c4c1c6). Isolated residual (bits/count/address_space) with the three bridge properties, verbatim the merged diagnostic.dag Extent.ByteRange precedent (PR v4 T-3: model std/diagnostic.dag — fail-closed Diagnostic schema #3161); named trigger = std/cardinality.dag refinement substrate (parallel Wave-A1, not in this file's whitelist). The SUM stays 🟢 — exactly the merged Locus(🟢)/Extent.ByteRange(🟡) split.
4. LlvmValue no dissolution classification → FIXED. Full 5-pattern ledger + 🟢; also restructured to the value-graph (operands edge to producing nodes — the scaffold's own "the value graph is Node edges").
5. CommutativeRing<LlvmValue> carrier over-broad (spans non-integer values) → TRACKED 🟡 (07c4c1c6), the resolution this review explicitly offers ("defer the witness as a tracked scaffold"). Producer-side restriction to the typed-value subset + same named trigger; algebra.dag Float≠Field honesty discipline.
6. Ring witness fabricates add/mul as left-projection, inverse as identity → FIXED (352f35e5). Operations are now the real LangRef instructions (OpAdd/OpSub/OpMul Binary via InstructionValue), identities the LangRef-typed 0/1 constants. No placeholder, no law-violating projection. Honest grounding: iN → CommutativeRing = Z/2^N Z (wrapping two's-complement), deliberately not OrderedRing (wrap breaks order-compatibility — the same call algebra.dag makes for Float≠Field); icmp order modeled separately.

B2-OMNI probe RESULT: PASS — LLVM IR is a plain declarative LanguageModel over the closed Node substrate with no 6th behavior and no core/pipeline change. Verified: v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics.

— sent from snappy-badger-570

[briansrls]

Status update — codex BLOCKING(6) batch + T-4 mgr ruling resolved (HEAD a9757b2b8, back to DRAFT)

The codex BLOCKING(6) inline relays all target the stale mid-probe WIP snapshot 6a4f9746 (a dashboard auto-WIP of a header-stripped probe state). Net resolution at HEAD, superseding my earlier per-finding comment (findings 5/6 are now removed, a stronger resolution than the 🟡-track I first posted):

• Add SVG viz, test helpers, and makegen scaffold #1 LangRef authority header / Codex/graph viz test helpers #2 LlvmType classification / Consolidate binaries into gunbc-dag package #4 LlvmValue classification → FIXED: full LLVM-18 LangRef header restored; every closed sum carries the full 5-pattern Practice-4 ledger (🟢 terminal); records carry none.
• . #3 IntegerType.bits unconstrained Int → TRACKED 🟡 (raw-Int width residual; the merged diagnostic.dag Extent.ByteRange three-bridge-properties precedent; trigger = std/cardinality.dag refinement). T-4 mgr audited this as fine (no new substrate).
• Add cloud resource + secret modeling with DAG upsert patterns #5 over-broad CommutativeRing<LlvmValue> carrier / feat(cloud): add cloud resource management layer with GCP and AWS sup… #6 placeholder ring ops → REMOVED entirely. The three data llvm_* algebra inhabitance instances + fn carrier-type helpers were the D2-gated surface (an operator-pending substrate-design decision — INVARIANTS P1:42 + the D2 STOP escalated 2026-05-16). Per the T-4 manager ruling, an operator-PENDING decision is HOLD/defer, not 🟡-track-and-ship. Inhabitance is now an "Owned ELSEWHERE" deferral (P2 single-authority: std/integer|float|logic T-3 + the ratified D2 form) — the verified-clean ptx#3170 / spice#3168 shape.

What stands (the probe deliverable): the declarative LLVM-IR LanguageModel (~32 declaration-class types), the SSA value-graph structural finding (operands edge to producing nodes; result names DeclaredNormalized — resolves the K-1 Symbol-mint tension structurally), and the B2-OMNI probe RESULT: PASS — LLVM IR is a plain LanguageModel over the closed Node substrate, no 6th behavior, no core/pipeline change. Verified: v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics. Re-surfaced as the clean declarative probe; back to draft pending T-4-mgr re-review.

— sent from snappy-badger-570

[briansrls]

Verified, not dismissed — finding #4 (LlvmValue no dissolution classification) checked against current HEAD a9757b2b8: LlvmValue is at line 456 and the lines directly above it carry the full Practice-4 receipt — classification: 🟢 GREEN (terminal), "five patterns attempted", all five (Fact placement / Variant-is-data / Algebraic form / Dimensional / Parameterized family) each with explicit FAILS/N-A reasoning, plus the Terminal: line. So this is resolved at HEAD; it held only for the stale auto-WIP probe snapshot 6a4f9746.

Note on the remaining relays: the codex BLOCKING(6) batch all target 6a4f9746. Each has been verified against current HEAD and the net resolution is in the consolidated status comment (#issuecomment-4464862191) — every new substrate sum now carries the 5-pattern ledger; the D2-gated inhabitance instances were removed (not 🟡-shipped) per the T-4-mgr ruling. To avoid per-relay noise I'm not re-commenting each queued relay individually; this comment + the consolidated one are the verification record. v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics.

— sent from snappy-badger-570

[briansrls]

Verified, not dismissed — finding #5 (llvm_int_commutative_ring asserts CommutativeRing<LlvmValue>, carrier not faithfully grounded, M9/P1) checked against current HEAD a9757b2b8: grep for llvm_int_commutative_ring, CommutativeRing<LlvmValue>, CommutativeRing, ^data llvm_, ApproximateField<LlvmValue>, BooleanAlgebra<LlvmValue> → zero matches. All three data llvm_* algebra inhabitance instances + their fn carrier-type helpers were removed entirely (commit 835cd40b2, reframed a9757b2b8), not 🟡-tracked — because this is the operator-pending D2 substrate-design surface (per-target <Algebra><Concrete> contradicts INVARIANTS P1:42; the T-4-mgr ruling: an operator-pending decision is HOLD/defer). Inhabitance is now an "Owned ELSEWHERE" P2 deferral (std/ scalar wave + ratified D2 form). So the finding is resolved by removal at HEAD; it held only for the stale auto-WIP probe snapshot 6a4f9746.

This + the consolidated status comment (#issuecomment-4464862191) are the verification record for the 6a4f9746 codex BLOCKING(6) batch (each relay verified against HEAD; not re-commenting per relay to avoid noise). v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics.

— sent from snappy-badger-570

[briansrls]

Verified, not dismissed — finding #6 (ring witness fabricates add/mul as left-projection / inverse as identity, violating algebra laws) checked against current HEAD a9757b2b8: grep for fn(a, b) { a }, inverse: fn(x) { x }, op: fn(, Magma {, : CommutativeRing, data llvm → no ring-witness matches. The only InstructionValue hits are the legitimate LlvmValue value-graph grammar variant (a kept finding), and one historical mention in the deferral note describing the removed instances. The entire law-violating placeholder ring witness was removed with the rest of the D2-gated inhabitance surface (835cd40b2 → reframed a9757b2b8) — per the T-4-mgr ruling an operator-pending substrate decision is HOLD/defer, not patch-the-placeholder. Resolved by removal at HEAD; held only for the stale probe snapshot 6a4f9746.

This completes verification of the 6a4f9746 codex BLOCKING(6) batch: #1/#2/#4 fixed (header + 5-pattern ledgers), #3 tracked 🟡 (diagnostic.dag Extent.ByteRange precedent, mgr-audited fine), #5/#6 removed entirely (D2-deferred). Net record: this comment + #issuecomment-4464862191. v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics. PR is draft pending T-4-mgr re-review.

— sent from snappy-badger-570

[briansrls]

Self-authored status (snappy-badger-570 is the source-of-record session for this file) — not external review. The relayed point-by-point above is my own earlier comment; it is partially SUPERSEDED. Authoritative status at current HEAD a9757b2b8, verified:

• Add SVG viz, test helpers, and makegen scaffold #1 LangRef-18 authority header, Codex/graph viz test helpers #2 LlvmType 5-pattern ledger, Consolidate binaries into gunbc-dag package #4 LlvmValue 5-pattern ledger → FIXED (every closed sum carries the full Practice-4 receipt; records none).
• . #3 IntegerType.bits/count/address_space raw Int → TRACKED 🟡, isolated, diagnostic.dag Extent.ByteRange three-bridge precedent; trigger = std/cardinality.dag refinement. T-4-mgr audited as acceptable (no new substrate).
• Add cloud resource + secret modeling with DAG upsert patterns #5 over-broad CommutativeRing<LlvmValue> carrier, feat(cloud): add cloud resource management layer with GCP and AWS sup… #6 placeholder/law-violating ring ops → REMOVED ENTIRELY (supersedes the older comment's "tracked 🟡"/"fixed-in-place" wording). These were the operator-pending D2 substrate-design surface (per-target <Algebra><Concrete> vs INVARIANTS P1:42); per the T-4-mgr ruling an operator-pending decision is HOLD/defer, not 🟡-ship. Inhabitance is now an "Owned ELSEWHERE" P2 deferral (std/ scalar wave + ratified D2 form). grep-confirmed absent at HEAD.

What stands: the declarative LLVM-IR LanguageModel + SSA value-graph finding + B2-OMNI probe PASS (no 6th behavior, no core/pipeline change). v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics.

Merge readiness: PR is draft by T-4-mgr directive (D2 operator-pending; manager re-review pending) — intentionally not merge-ready; I am not merging (operator merges manually per policy). No code change needed; the 6a4f9746 codex BLOCKING(6) batch is fully verified-resolved at HEAD. No further action from me until the T-4-mgr re-review or the D2 decision lands.

— sent from snappy-badger-570

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: a9757b2b · Trigger: schedule
• Thinking: 253s wall

---

BLOCKING (7)

Root Cause

• src/v4/extdeps/languages/llvm_ir.dag LangRef taxonomy was transcribed from a narrowed happy-path subset while comments promoted it to a closed LLVM 18 model → reconcile each omitted LangRef instruction/opcode either as modeled structure or explicit FailClosed disposition data.
• src/v4/extdeps/languages/llvm_ir.dag SSA value authority was split by hoisting PhiNode out of LlvmInstruction without adding a phi def-site value reference → make phi results first-class in LlvmValue or move phi into the producer shape while preserving block-start structure.
• src/v4/extdeps/languages/llvm_ir.dag Operation-specific LangRef constraints were collapsed into shared broad carriers and prose-only dispositions → introduce constrained substrate types/records or tracked scaffolds with checkable dissolution triggers.

Non-blocking — Strengths

• src/v4/extdeps/languages/llvm_ir.dag The prior invented algebra witnesses are gone, and the new text correctly treats scalar inhabitance as owned outside this extdeps language file.

⚠️ The algebra fixes are real, but the replacement model still commits substrate-level LLVM IR shapes that are incomplete or admit invalid LangRef states.

[briansrls]

Fresh codex BLOCKING(7) @a9757b2b — verified each; fix-forward at HEAD 933f373fb

This is a NEW schedule review of current HEAD (not the stale 6a4f9746 batch). Verified every finding against the code; 3 root causes were substantive and are now fixed; 4 inline items are stale-rubric artifacts (false at HEAD).

RC#2 — phi value-authority split (GENUINE; my bug). FIXED. Hoisting PhiNode to BasicBlock.phis (for the block-start P2 guarantee) dropped its def-site value reference — a phi result was unreferenceable as an operand, i.e. broken SSA. Added PhiValue { phi: PhiNode } to LlvmValue: phi results are now first-class operands via the value-graph edge, while PhiNode stays ONLY constructible inside BasicBlock.phis (phi-after-non-phi remains unrepresentable). Both invariants now hold; the 5-pattern ledger re-justified for 5 variants.

RC#1 — "narrowed happy-path subset" claimed as a closed LLVM-18 model (GENUINE over-claim). RECONCILED. Added the omitted core LangRef non-terminator instructions: FNeg (the LangRef Unary op), VaArg, LandingPad/CatchPad/CleanupPad + LandingPadCleanup/LandingClause support sums (each with the full 5-pattern Practice-4 ledger). Reframed the LlvmType and LlvmInstruction "Terminal: the closed LangRef set" lines to honest scoping: the modeled core + an explicit FidelityDisposition.FailClosed boundary for the genuine residue (x86_amx/target-extension types, target-specific opcodes) — declared and diagnosed, never silently dropped. Completeness of F is now declared, not over-claimed.

RC#3 — broad carriers + prose-only dispositions. TRACKED 🟡 with a CHECKABLE trigger. Added a consolidated operation-specific-operand-constraint scaffold note (icmp/fcmp/GEP/select/binary type-agreement) with the three bridge properties and a checkable dissolution trigger = std/cardinality.dag refinement substrate landing — the merged, T-4-mgr-audited diagnostic.dag Extent.ByteRange precedent. Introducing a constrained carrier now would mean improvising not-yet-ratified refinement substrate (the failure mode v4 forbids); the tracked-scaffold-with-checkable-trigger is the sanctioned path.

The 4 stale-rubric inline items (e.g. "LlvmType is a new substrate coproduct with four variants but no 🟢/🟡/🔴 classification" at :280) are false against HEAD: LlvmType has 12 variants and carries the full classification: 🟢 GREEN (terminal) + "five patterns attempted" ledger + Terminal: line + the 🟡 raw-Int residual note directly above it. "Four variants" is factually the old 6a4f9746 probe snapshot's shape; the inline view was generated against a stale rubric/snapshot even though the review header says sha:a9757b2b. Per the standing STALE-HARNESS instruction I reply-explain (modeling-discipline.md §4 L112/L131 + Practice 7 L29) and do not revert the correct 5-pattern ledger or add a spurious pattern.

Verified: v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics. No new STOP. To avoid per-relay noise the remaining queued inline relays of this batch are covered by this consolidated mapping, not re-commented individually.

— sent from snappy-badger-570

[briansrls]

Verified at HEAD 933f373fb — already addressed via the sanctioned tracked-🟡 scaffold; no code change (a constrained type here would be the forbidden improvise-past-not-ready-substrate).

The finding (IntegerType.bits unconstrained Int admits invalid LLVM widths, INVARIANTS P1/P2) is true at the bare-type level, but the model's response is already in the file — the RAW-Int WIDTH RESIDUAL — TRACKED 🟡 SCAFFOLD note directly above type LlvmType (lines ~265–286), covering IntegerType.bits / VectorType.count / ArrayType.count / PointerType.address_space with the three bridge properties:

• (a) scaffold doc — the raw Int widths are provisional, not terminal;
• (b) bounds on use — producer MUST construct only LangRef-valid widths (bits >= 1; count >= 0; address_space >= 0) — producer-side until type-enforced;
• (c) checkable dissolution trigger — std/cardinality.dag refinement substrate landing (its own T-3 entry); the SUM stays 🟢, only the payload reclassifies.

This is verbatim the merged, operator-ratified diagnostic.dag Extent.ByteRange precedent (PR #3161) and was explicitly audited by the T-4 manager as acceptable ("the two raw-Int-width 🟡 scaffolds — diagnostic.dag Extent.ByteRange precedent — fine, no new substrate"). std/cardinality.dag is parallel Wave-A1 and not in this file's whitelist; introducing a constrained width type now is exactly the improvise-past-not-ready-substrate failure mode v4 exists to kill. modeling-discipline.md §4: 🟡 is precisely "richer source exists, substrate not ready" with a named trigger — which is what is in place.

This inline is part of the a9757b2b codex batch already consolidated-mapped in #issuecomment-4465012447 (RC-class #3 / the raw-Int residual). To avoid per-relay noise the remaining queued inline relays of this batch are covered by that mapping + this note, not re-commented individually. v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics. PR is already at dashboard merge-readiness (ready=True); I am not self-merging (operator merges manually).

— sent from snappy-badger-570

[briansrls]

On the cursor APPROVE's optional editorial observation (heavy task/PR/codex/SHA comment references): actioned at HEAD 525a4fa54. It is not an invariant breach, but it aligns with CODING.md's comment discipline (durable comments shouldn't reference the current task/fix/PR/commits — those rot and belong in PR/commit history) and was a real quality regression I introduced over the review-handling commits. Since the cycle is open (not merge-ready pending the codex re-review on the settled HEAD) I fixed it rather than defer it.

Surgically stripped ONLY the process archaeology — review-provider names, "the codex BLOCKING/finding", commit SHAs, PR/#issuecomment ids, session names, the inverse-error play-by-play, "manager-audited/confirmed" — rewriting each to the timeless modeling WHY. Preserved 100% of load-bearing content: every 5-pattern Practice-4 ledger, the tracked-🟡 three-bridge properties + named triggers, the D2-deferral rationale, the name-reference / cyclic-SSA / A1 reasoning, the ConstExprOpcode spec version-pin + LangRef URL (the durable authority), the ptx/spice deferral-shape cross-ref, std/ owner references. The inverse-error + process trail remain in commit/PR history (their correct home).

Comment-only; zero semantic/structural change; v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics. Merge readiness unchanged (still gated on the open codex REQUEST_CHANGES clearing via a fresh re-review on the settled HEAD — all its findings are resolved across the prior commits, consolidated-mapped). Not self-merging.

— sent from snappy-badger-570

[briansrls]

Verified — the exploratory observation concerns the IMMUTABLE scaffold header, already-surfaced, not a worker edit. The Owns: ("Inhabitance: … per std/algebra.dag") / Consumes: ("std/primitive.dag") bullets are the file's frozen I/O contract (header lines 22–31). Per the v4 worker contract, that header is immutable: a worker does not edit Owns/Consumes/Scope — a header that reads wrong is a STOP/contract-tier escalation, not a silent worker rewrite (exactly why the reviewer scoped this as "when the header is allowed to move … not a diff-grounded finding", outside the hunk).

It is not a silent inconsistency: the Status line + modeling notes already explicitly surface it — std/primitive.dag is the pre-T-1-closeout staleness (decomposed; Symbol/Hash re-homed to std/node.dag, which this file imports accordingly), and inhabitance is the D2-deferred "Owned ELSEWHERE" surface (the new prose says so at length). So the "reader whiplash" is already reconciled in-file — the divergence is documented as a known frozen-header staleness, not contradicted. A header revision to retire the staleness is contract/operator-tier (the same immutable-contract discipline the whole v4 program rests on), correctly out of worker scope; flagging it for that owner is the right disposition, which the Status line does.

No code change (editing the immutable header would itself violate the contract; the reviewer agrees it's not diff-grounded). v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics at HEAD 525a4fa54. Merge readiness unchanged: gated on the open codex REQUEST_CHANGES clearing via a fresh re-review on the settled HEAD (all its findings resolved across prior commits + consolidated-mapped); 2 distinct approvals (claude, cursor), mergeable CLEAN, CI passing. Not self-merging.

— sent from snappy-badger-570

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 58064609 · Trigger: schedule
• Thinking: 240s wall

---

BLOCKING (1)

Root Cause

• src/v4/extdeps/languages/llvm_ir.dag Call-shaped terminator result modeling was applied to Invoke but not CallBr → either add result: CallResult to CallBr or move CallBr to an explicit fail-closed boundary if inline-asm callbr remains outside the modeled core.

⚠️ One spec-faithfulness gap remains in the modeled terminator surface.

[briansrls]

Verified at HEAD 7aeaeca15 — already resolved, NOT a regression, not stale-dismissed. This is a drain-out of the original 6a4f9746 codex review's RC#1 ("no LangRef authority header"), resolved long ago and re-confirmed present at HEAD (the comment-hygiene pass preserved every spec/version anchor — it stripped only review/process archaeology):

• Immutable header Anchor: (l.6–8) pins "LLVM Language Reference Manual … LLVM 18 LangRef … the versioned fidelity authority (L-2: the spec IS the anchor)".
• Modeling notes (l.66): "pinned at LLVM 18".
• Every construct cites its LangRef section (e.g. FloatKind — LangRef "Floating-Point Types"; LlvmType — LangRef "Type System" + "MODELED LangRef (LLVM 18) type taxonomy").
• ConstExprOpcode retains the explicit version-pinned URL https://releases.llvm.org/18.1.8/docs/LangRef.html#constant-expressions (l.627) as its in-file authority.

So the versioned fidelity authority is present in exactly the form the immutable scaffold header prescribes ("pin a concrete release … the spec IS the anchor") — header LLVM-18 anchor + per-construct LangRef-section cites + the explicit 18.1.8 URL on the version-volatile constexpr set. No per-construct URL is "missing"; that is not the L-2 pattern this file (or the frozen header) defines.

No newer review exists; all 3 codex reviews (6a4f9746/a9757b2b/021aa3cb) are on stale pre-fix shas, every finding resolved at HEAD + consolidated-mapped (#issuecomment-4465242970). The remaining "+4 queued" relays are the same stale drain-out — not re-commenting each (anti-noise). v2-compiler compile --source-root src/v4 --target dag → 63 modules, 0 diagnostics at 7aeaeca15 (post-main-merge). PR is functionally complete, merge-blocked solely on the stale codex RC (escalated to the operator); HOLD in effect — not pushing/re-rolling/self-merging.

— sent from snappy-badger-570

[briansrls]

Two things — verified at HEAD 7aeaeca15:

(1) The relayed ConstExprOpcode inline is STALE/resolved. At HEAD ConstExprOpcode already includes CeAdd|CeSub|CeMul|CeShl|CeXor|CeICmp|CeFCmp|CeExtractElement|CeInsertElement|CeShuffleVector + the pointer/cast core, version-pinned to the cited releases.llvm.org/18.1.8/...#constant-expressions URL (fixed at the inverse-error self-correction, kept through HEAD). Not stale-dismissed — verified present.

(2) The 4th codex review (sha:58064609, a RECENT main-merge ancestor of HEAD — not stale) has a GENUINE valid BLOCKING(1) I have NOT yet addressed: the CallResult void/value sweep was applied to Call and Invoke but CallBr lacks result: CallResult. callbr is void-or-value per LangRef exactly like call/invoke, so this is a real spec-faithfulness gap (a miss in the e82a200 sweep). The fix is in-pattern and trivial: add result: CallResult to the CallBr terminator + result: _ to its block_successors match arm — the same RetVoid/RetValue / Call/Invoke void-value discipline.

It is identified and prepared but HELD, not dismissed: the T-4 manager issued an explicit HOLD (do not re-roll HEAD / push — more rolls defer the codex re-review needed to clear the stale RC; stay on 7aeaeca15). Pushing this fix now would violate that HOLD. I am flagging it to the manager/operator with the decision (lift the HOLD for this one declaration-class fix — recommended, since a bare re-trigger will otherwise correctly BLOCK again on CallBr). This also corrects my earlier "purely stale RC" status: there is one genuine, current, trivial in-pattern gap; the re-review will not cleanly clear until CallBr carries result: CallResult.

v2-compiler … --target dag → 63 modules, 0 diagnostics at 7aeaeca15. Not pushing/re-rolling/self-merging (HOLD). Remaining "+3 queued" relays are stale drain-out of the resolved earlier reviews.

— sent from snappy-badger-570

[briansrls]

Verified at HEAD 7aeaeca15 — resolved, and already present in the reviewed sha; not stale-dismissed. FidelityFeature is exhaustive over the FailClosed boundaries: +UnmodeledType/+UnmodeledInstruction/+UnmodeledConstExpr (l.1722–1724) with the total feature_disposition projection mapping each → FailClosed (l.1744–1746); the LlvmType/LlvmInstruction/ConstExprOpcode cross-refs name the concrete machine-consumable variant. P2/P3 satisfied.

This is a stale drain-out of the earlier 021aa3cb codex review's RC-B (the FidelityFeature/C5 finding), fixed at b15c4434d. Confirmed b15c4434d is an ancestor of sha:58064609 — i.e. the fix was already in the sha the latest (4th) codex review evaluated, which is why that review's sole genuine BLOCKING is the CallBr/CallResult gap (not this). That one genuine finding is verified, fix-identified, and flagged to the manager/operator — currently HELD by the manager's no-re-roll HOLD (a push would defer the codex re-review). The remaining "+2 queued" relays are likewise stale drain-out of the resolved earlier reviews.

v2-compiler … --target dag → 63 modules, 0 diagnostics at 7aeaeca15. Not pushing/re-rolling/self-merging (HOLD). The only open genuine item on this PR is the trivial in-pattern CallBr result: CallResult fix, pending the operator/manager decision to lift the HOLD for it.

— sent from snappy-badger-570

[briansrls]

This is THE one genuine open finding — verified VALID at HEAD 7aeaeca15, not stale, not dismissed; fix prepared but HELD (not silently deferred). The cited LangRef URL (#callbr-instruction) corroborates it: callbr permits a value result, but CallBr { callee, arguments, fallthrough, indirect_targets } carries no result: CallResult while Call/Invoke do — a real P1/P2 spec-narrowing (a miss in the earlier CallResult void/value sweep).

Status (already actioned, see #issuecomment-4465461503): fix identified and trivial/in-pattern — add result: CallResult to the CallBr terminator + result: _ to its block_successors match arm (the exact RetVoid/RetValue / Call/Invoke void-value discipline already light-audited clean). It is not pushed because the T-4 manager issued an explicit HOLD (do not re-roll HEAD — a push defers the codex re-review). The HOLD's original premise ("purely stale RC, just re-trigger") is superseded by exactly this genuine finding; I have surfaced that correction to the manager/operator with the decision shape (recommend: lift the HOLD for this single declaration-class fix). The lift-HOLD decision is the manager/operator's — pushing unilaterally would improvise past a decision I escalated, so I am holding.

Verified-not-dismissed: the finding stands; only the timing of the push is gated on the HOLD disposition. v2-compiler … --target dag → 63 modules, 0 diagnostics at 7aeaeca15. The remaining "+1 queued" relay is stale drain-out of the resolved earlier reviews. Not pushing/re-rolling/self-merging pending the disposition.

— sent from snappy-badger-570

[briansrls]

4th codex review (sha:58064609) BLOCKING(1) — verified VALID at HEAD 7aeaeca15, single root cause = the CallBr/CallResult gap, already dispositioned (not stale, not dismissed, fix prepared, HELD). sha:58064609 is a recent main-merge that includes all prior fixes (the SSA reversal, FidelityFeature exhaustiveness, ConstExprOpcode correction, CallResult on Call/Invoke), which is why this review's only remaining BLOCKING is the one genuine gap: CallBr lacks result: CallResult though callbr is void-or-value per LangRef.

Disposition (consolidated, see #issuecomment-4465461503 and #issuecomment-4465467719):

• Verified valid at HEAD; fix is trivial + in-pattern — add result: CallResult to the CallBr terminator + result: _ to its block_successors arm (the RetVoid/RetValue / Call/Invoke void-value discipline, already light-audited clean on the siblings).
• Not pushed: the T-4 manager's explicit HOLD forbids re-rolling HEAD (a push defers the codex re-review). I surfaced the correction that this is a genuine finding (not the prior "purely-stale-RC" framing) and escalated the lift-HOLD decision with a recommendation to lift the HOLD for this single declaration-class fix. That decision is the manager/operator's and is pending; pushing unilaterally would improvise past an escalated decision.

So the BLOCKING is acknowledged and resolved-in-principle (verified + fix-prepared); only the timing of the push is gated on the HOLD disposition. v2-compiler … --target dag → 63 modules, 0 diagnostics at 7aeaeca15. Not pushing/re-rolling/self-merging pending the manager/operator decision.

— sent from snappy-badger-570

[briansrls]

Fresh codex REQUEST_CHANGES (re-review ran) — all 3 findings VERIFIED VALID at HEAD b44b740cc, none dismissed; dispositions below. Not pushed (HOLD).

1. CallBr lacks result: CallResult — VALID, already known/flagged. In-pattern fix prepared (the Call/Invoke void-value discipline). HELD by the manager's no-re-roll HOLD.
2. CatchSwitch omits its token result — VALID, NEW. Per LangRef <resultval> = catchswitch within … unwind … defines a token consumed by its catchpads; CatchSwitch { parent_pad, handlers, unwind } carries no result, while CatchPad/CleanupPad correctly carry result: Symbol. In-pattern fix: add result: Symbol (a token def-site, always-produced — not void/CallResult) to CatchSwitch + result: _ to its block_successors arm. HELD by the HOLD.
3. catchswitch must be the block's only non-phi instruction — VALID, NEW (P2). BasicBlock { phis, body: List<LlvmInstruction>, terminator } admits a non-empty body with a CatchSwitch terminator, which LangRef forbids. Making this type-unrepresentable is a BasicBlock/Terminator shape change (beyond declaration-class variant refinement) → non-in-pattern. node.dag's own D3 precedent is directly on point — there, an analogous structural rule (edge-discipline) is deliberately CHECK-enforced (node_well_formed), explicitly NOT type-unrepresentable, by an operator no-redesign call ("keep one children list"). The faithful resolution here is likely the same shape (a documented block_well_formed-style structural invariant citing the D3 precedent, not a BasicBlock redesign) — but choosing checked-invariant-vs-redesign for the block shape the whole file rests on is a substrate-shape design decision, not a worker autonomous shape-change. Escalated.

Net: this is no longer "one trivial fix" — it's 2 in-pattern fixes (#1, #2; both HELD by the HOLD) + 1 non-in-pattern structural design decision (#3). All verified valid, none worked around or dismissed; surfaced to the manager/operator with the decision shape. v2-compiler … --target dag → 63 modules, 0 diagnostics at b44b740cc. Not pushing/re-rolling/self-merging pending disposition.

— sent from snappy-badger-570

[briansrls]

Update — all 3 codex #12877 findings RESOLVED at settled HEAD d4f57e59c (manager-authorized, HOLD fully lifted; supersedes the earlier "pending/HELD" status on #2/#3):

1. CallBr result: CallResult (72242cb42) — value-producing callbr now representable; in-pattern, the verified Call/Invoke void-value discipline.
2. CatchSwitch result: Symbol (d4f57e59c) — catchswitch defines a token per LangRef (<resultval> = catchswitch …); now carries the token def-site like CatchPad/CleanupPad, + its block_successors arm updated.
3. catchswitch = block's only non-phi instruction (d4f57e59c) — resolved via the operator-ratified D3 disposition (the std/node.dag precedent: a structural rule whose type-unrepresentable form would require a core-type redesign is CHECK-enforced, not redesigned). Implemented as block_well_formed (+ terminator_is_catchswitch): a pure total local predicate enforcing "a CatchSwitch-terminated block's body is empty", fail-closed (INVARIANTS P3), citing operator directive D3 + the node_well_formed precedent. No BasicBlock/Terminator shape redesign, no new variant/field — exactly the D3-checked-invariant shape.

v2-compiler compile --source-root src/v4 --target dag → 64 modules, 0 diagnostics at d4f57e59c (post-auto-main-merge tree). No D1/D2/Outcome/imports/file-scope change; no substrate extension; no novel operator decision (ratified-D3 application). Every genuine finding across all codex reviews is now actually resolved — a fresh codex re-review on d4f57e59c clears legitimately. Not self-merging (operator merges).

— sent from snappy-badger-570

[briansrls]

APPROVE noted (no rubric violation). The optional exploratory observation is verified ALREADY-CORRECT, not a regression — no action needed.

The header's scaffold Brief: see BRIEF_TEMPLATE.md pointer was not "lost" — it was the standard, sanctioned worker-closeout transformation, matching the merged precedents (std/node.dag, std/diagnostic.dag): on completion the scaffold Status: scaffold … / Brief: see BRIEF_TEMPLATE.md lines become a modeled Status: note, while the load-bearing immutable-contract semantics are preserved verbatim-equivalent — current header retains "The header I/O contract is immutable for downstream workers" and "Splitting this file requires explicit operator ratification (substrate extension = stop signal)". The brief-pointer is a scaffold-state aid; BRIEF_TEMPLATE.md itself defines that the brief POINTS to the file's frozen header contract (not the reverse), so the canonical worker/downstream anchor remains TASKS.md T-4.12 + the (intact) immutable I/O-contract header. node.dag/diagnostic.dag closed out exactly this way — so this is the in-precedent form, not an unsanctioned immutable-header change or a downstream-anchor loss. Not an invariant breach (as you note); verified, not dismissed.

Verified at HEAD 66e69d916 (auto-main-merge-rolled from d4f57e59c; git rev-parse==gh pr view==66e69d916): all genuine codex findings remain resolved (CallBr/CatchSwitch result, the D3-checked block_well_formed), v2-compiler … --target dag → 64 modules, 0 diagnostics. Content-complete + manager-verified. The only open item is the operator's codex re-trigger on the current auto-rolled HEAD → legitimate APPROVE → operator merge. Not self-merging.

— sent from snappy-badger-570

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: d4f57e59 · Trigger: schedule
• Thinking: 293s wall

---

BLOCKING (2)

Root Cause

• src/v4/extdeps/languages/llvm_ir.dag identified-struct declarations were modeled as always body-bearing -> make the named-struct body a closed sum such as OpaqueStruct or DefinedStruct.
• src/v4/extdeps/languages/llvm_ir.dag optional module target configuration was modeled as required identity fields -> introduce typed present/absent carriers for data layout and target triple.

⚠️ Two spec-faithfulness gaps remain in the LLVM IR substrate model.

[briansrls]

BLOCKING: NamedStructDef.definition is mandatory, but LLVM 18 permits identified structure declarations with no body (%X = type opaque), so valid opaque structs are unrepresentable (P1/P2 extdeps fidelity).

[briansrls]

BLOCKING: LlvmModule requires data_layout and target_triple even though LLVM 18 says modules may specify each, so valid modules that omit one are unrepresentable (P1/P2 extdeps fidelity).