From 790525afe8b7e0ff158dd15354eb03231b318926 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 3 May 2026 00:37:08 +0000 Subject: [PATCH 1/6] docs(r3): PB-Runtime test-predicate dissolution hook (R3 ledger row 83 PB share) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Docs-only PB-side packet pairing with Evaluator Manager's bespoke-arm freeze on test_runner.rs::run_claim. Names the structural landing point — convergence cases (a) value-domain fold over PB-Runtime result, (b) reflection-only fold, (c) P1-routed substrate gap — so freeze-blocked predicate authoring has a clean dissolution target rather than a new bespoke match arm. PB owns the §3.1 dissolution table (variant → convergence case → declaration ref). Evaluator owns the freeze mechanism. Both consume design-pb-runtime-interpreter.md §3/§6/§7.1 as the seam. STOP+PING boundaries explicit on TestPredicate variant additions, Value variant additions, and parallel PB-Runtime evaluation surfaces. R3 debt receipt — row 83 `test_runner.rs predicate-language growth`: disposition is Debt found + routed (partial — docs-only landing). Co-Authored-By: Claude Opus 4.7 (1M context) --- ...runtime-test-predicate-dissolution-hook.md | 148 ++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md diff --git a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md new file mode 100644 index 00000000000..157c0ff8f1d --- /dev/null +++ b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md @@ -0,0 +1,148 @@ +# R3 — PB-Runtime test-predicate dissolution hook (PB share of `test_runner.rs` predicate-language growth freeze) + +**Status:** PROPOSAL — docs-only PB-side packet. **Pairs with** Evaluator Manager's bespoke-arm freeze on `src/v3/compiler/src/test_runner.rs::run_claim`. This brief defines **where** new `TestPredicate` evaluation lands so freeze-blocked authoring has somewhere to dissolve to; it does **not** define the freeze mechanism itself (Evaluator's lane). + +**Authority parent (R3 ledger row):** +[`docs/debt/r3-debt-paydown-ledger-2026-05-02.md`](../debt/r3-debt-paydown-ledger-2026-05-02.md) row 83 — `test_runner.rs predicate-language growth` (Owner: R3 Evaluator + PB. Retirement shape: *Freeze bespoke arms unless paired with evaluator/PB-runtime dissolution hook*). + +**Authority cross-reads (in-tree on `main`):** +- [`docs/briefs/r2-evaluator-test-runner-authority-ratchet.md`](r2-evaluator-test-runner-authority-ratchet.md) §3 (ratchet recommendation), §2.1 / §2.8 (PB-runtime split, structural-predicates row). +- [`docs/briefs/r2-pr-b-2-runner-extension-bundle.md`](r2-pr-b-2-runner-extension-bundle.md) "Runner authority discipline" + per-workstream dissolution table. +- [`docs/design-pb-runtime-interpreter.md`](../design-pb-runtime-interpreter.md) §3 (PB-Runtime IS), §6 (anti-bridge invariants), §7.1 (PB-Runtime equivalence fixture). +- `src/v3/compiler/src/test_runner.rs::run_claim` and `src/v3/std/verification.dag::TestPredicate` (read for grounding only — this brief does not modify either). + +**Implementation request:** none. Docs-only. + +--- + +## 1. Problem statement + +`test_runner.rs::run_claim` is today a `match` over `TestPredicate` variants, each arm a bespoke Rust evaluator. Every new predicate adds a parallel test-truth authority alongside the eventual PB-Runtime / R2-Evaluator runtime. Evaluator Manager's ratchet (cross-read §3) freezes new bespoke arms unless a dissolution hook is named; without a PB-side landing point, the freeze either (a) blocks legitimate predicate work indefinitely, or (b) gets bypassed by reviewers who lack a structurally-clean alternative to point at. + +This packet names the **landing point**. It is the PB-side counterpart to Evaluator's freeze: the place a new predicate's evaluation **structurally lives** instead of becoming a `match` arm. + +## 2. Convergence model (what "PB-Runtime hook" means here) + +Per `design-pb-runtime-interpreter.md` §2, PB-Runtime ≡ R2-Evaluator's runtime model expressed as a `.dag` program. They are not parallel runtimes. The "hook" therefore is **not** a new runtime, **not** a new predicate language, and **not** a Rust-side dispatch on a sentinel field. The hook is the structural rule: + +> **A new `TestPredicate` variant is evaluable iff PB-Runtime's `evaluate` (the `.dag` program declared per `design-pb-runtime-interpreter.md` §3) can compose a value-domain answer for it from PB-Runtime's existing primitive evaluation rules.** + +This is exactly the convergence direction the design lock already names (§3.1: "Anything beyond the 5 primitives is a downstream lens, not the interpreter"). The dissolution hook is not new vocabulary; it is **gating discipline** on where new predicate authoring lands. + +Concretely, this means a new predicate's evaluation either: + +- **(a) Folds over PB-Runtime evaluation outputs** — the predicate is a `Lens`-shaped structural fold over `Value` results PB-Runtime already produces (per `design-pb-runtime-interpreter.md` §3.5 "reflection vs evaluation"; §1 "consumed by lenses *via the Evaluator*"). The runner arm then dispatches to the lens, not to a bespoke evaluator. *No new runtime mechanism is added; the predicate becomes a consumer of an existing one.* +- **(b) Folds over reflected (static) program structure** — the predicate is a structural projection per `design-reflection-completeness.md`, not an execution. The runner arm dispatches to the reflection lens. *Static, no PB-Runtime invocation needed; still no bespoke evaluator.* +- **(c) Routes to substrate-fact-introduction (P1)** — neither (a) nor (b) applies because the predicate semantics requires a primitive PB-Runtime cannot express via its 5-primitive base. This is a substrate carrier change, not a runner arm; it follows `INVARIANTS.md` §P1 and lands in `verification.dag` / substrate before any runner code is written. *The hook for case (c) is "STOP and route", not "add an arm".* + +Cases (a) + (b) are the dissolution path. Case (c) is the explicit STOP+PING. There is no fourth case; specifically, "open a new bespoke `match` arm pending future cleanup" is **not** a case under the freeze. + +## 3. Hook shape (PB-owned landing point) + +The PB-side artifact is a **convergence-discipline contract**, not a new piece of vocabulary. Its three elements: + +### 3.1 Per-predicate dissolution table (single authority) + +A single table keyed by `TestPredicate` variant naming, for each variant: + +| Column | Content | +|---|---| +| Variant | `TestPredicate` constructor name (per `src/v3/std/verification.dag`). | +| Convergence case | (a) value-domain fold over PB-Runtime result, (b) reflection-only fold, or (c) P1-routed (substrate gap). | +| Dissolution declaration ref | If (a)/(b): the lens / structural query the runner dispatches through, declared in `.dag`. If (c): the P1 escalation row. | +| Status today | Bespoke runner arm / partially-dissolved / fully-dissolved / P1-pending. | + +This table is the **single authority** for "is this predicate's evaluation structurally accounted for"; it consumes (does not duplicate) the per-workstream dissolution table at `r2-pr-b-2-runner-extension-bundle.md` "Runner authority discipline" and the inventory at `r2-evaluator-test-runner-authority-ratchet.md` §2. + +**Where it lives:** appended to `docs/briefs/r2-evaluator-test-runner-authority-ratchet.md` as §6 (or as a sibling `r3-test-predicate-dissolution-table.md` cited from there). PB Manager owns the table; Evaluator Manager consumes it as the freeze allow-list. **Owner pick is a follow-up coordination, not locked here** — see §7. + +The table is **the** authority; if a row is missing or marked (c) without a P1 row, the predicate is not freeze-allowed. There is no ad-hoc reviewer override. + +### 3.2 PB-Runtime convergence test-claim discipline + +For each predicate marked (a), the dissolution receipt is a `TestClaim` of the same shape as `design-pb-runtime-interpreter.md` §7.1's PB-Runtime equivalence fixture: PB-Runtime evaluates the predicate's program through its `.dag` `evaluate`, R2-Evaluator (Rust) evaluates the same program, and a `DifferentialEquals` claim asserts result equality. The claim's existence is the *proof* that the predicate is structurally evaluable; the runner arm becomes a thin adapter (or retires entirely once PR-B.1's eager evaluator is the runner's evaluation backend). + +This is **the same anti-bridge invariant #1** from the design lock: "the `.dag` declaration of PB-Runtime IS the spec the Rust crate's tests verify against". The hook does not invent a new convergence claim; it consumes the one already declared. + +### 3.3 Reviewer rule (the freeze's allow-condition, PB-side) + +A PR adding or modifying a `TestPredicate` evaluation lands iff: + +1. The §3.1 table has a row for the variant marked (a), (b), or (c). +2. If (a)/(b): a dissolution declaration ref exists in `.dag` *or* is being landed in the same PR. The runner arm cites the ref. +3. If (c): a P1 substrate-fact-introduction escalation row exists. Runner arm work is **deferred** to after P1 lands; the PR carrying runner code is not the place that work happens. + +This is the PB-side allow-condition for Evaluator's freeze. Evaluator's freeze mechanism (CI ratchet / `match`-arm count gate / equivalent — Evaluator's lane to design) checks the table; PB owns the table. + +## 4. Sequence (sequential vs parallelizable) + +| Step | Owner | Sequence | +|---|---|---| +| §3.1 table seeded with current `TestPredicate` variants (consume existing inventories — no new analysis) | PB Manager (this brief's follow-on) | After this brief lands | +| Evaluator freeze mechanism wired against §3.1 table | Evaluator Manager | After §3.1 table lands; can author in parallel against an empty placeholder, but freeze goes live only when table is non-empty + reviewed | +| Per-variant dissolution-ref authoring (predicate-by-predicate; §2 cases (a)/(b)) | Evaluator + PB workers, dispatched per row | Parallelizable across rows once §3.1 lands | +| §3.2 PB-Runtime equivalence claim per (a) variant | Evaluator (claim authoring) + PB (`.dag` evaluate bodies) | After PR-B.1 eager evaluator (already merged per `r2-pr-b-2-runner-extension-bundle.md` parent designs) + per-variant dissolution refs | +| Bespoke arm retirement (per row) | Evaluator | After §3.2 claim is green for the row | +| (c)-routed P1 escalations | Substrate Manager | Triggered per row; not on this brief's critical path | + +The whole hook is docs + table; nothing in this packet requires a substrate or runner edit before landing. + +## 5. Acceptance criteria (this brief) + +- ✅ The PB-side landing point is named structurally (§2 convergence cases) without inventing new vocabulary. +- ✅ The hook artifact (§3.1 table) is identified, with location, owner, and authority relationship to existing inventories. +- ✅ §3.2 cites the existing PB-Runtime equivalence fixture rather than authoring a new convergence claim shape. +- ✅ The PB-vs-Evaluator boundary is explicit (§7). +- ✅ STOP+PING conditions are enumerated (§6) and cover every shape change this brief must not silently make. +- ✅ Sequence (§4) separates sequential dependencies from parallelizable per-row work. + +## 6. STOP+PING boundary (binding) + +This brief does **not** propose, and any worker concluding any of the following is required must STOP and re-dispatch through the appropriate authority before drafting code or amending this brief: + +- **A new `TestPredicate` variant.** Substrate change. Routes to Substrate Manager via `INVARIANTS.md` §P1 (same routing as `Distributivity` in `r2-pr-b-2-runner-extension-bundle.md`). +- **A new `TestPredicate` discipline-marker field** (e.g., `pb_runtime_evaluable: Bit` on the variant). Substrate change. Same routing. The convergence case in §3.1 is a *table column*, not a runtime-typed field. +- **A new `Value` variant** in PB-Runtime. Anti-bridge invariant #2 of `design-pb-runtime-interpreter.md` §6 — escalates to Substrate Manager via P1. +- **A new bespoke runner arm landed before the §3.1 row exists.** That is exactly what the freeze blocks; the hook is the allow-condition, not a bypass. +- **A parallel PB-Runtime evaluation surface that diverges from R2-Evaluator's semantics.** Anti-bridge invariant #1; convergence is non-optional. +- **A second test-predicate language in `.dag`** (e.g., a "pb_runtime_predicate" sub-vocabulary distinct from `TestPredicate`). PB-Runtime is `.dag`; predicates remain `TestPredicate` inhabitants per `verification.dag`. §3.1's case-tagging is metadata about *where evaluation lives*, not a parallel predicate type. + +If freeze semantics turn out to require any of the above, the dispatch back to Director/Evaluator is: **STOP + name the missing substrate primitive**, do not invent a convergence shape locally. + +## 7. PB vs Evaluator ownership split + +| Owns | PB Manager | Evaluator Manager | +|---|---|---| +| §3.1 dissolution table (location, schema, per-row authoring) | ✅ | — | +| Per-variant convergence-case classification (a/b/c) | ✅ (with Evaluator review) | review | +| §3.2 PB-Runtime `.dag` `evaluate` bodies for each (a) row | ✅ (consumed from `design-pb-runtime-interpreter.md` §3) | review | +| §3.2 R2-Evaluator (Rust) side of the `DifferentialEquals` claim | — | ✅ | +| Freeze mechanism implementation (CI / `match`-arm count ratchet / equivalent) | — | ✅ | +| Reviewer rule enforcement at PR time | shared | shared | +| (c)-routed P1 escalation authoring | shared (per row) | shared (per row) | +| New `TestPredicate` variants | — | — (Substrate via P1) | +| Bespoke arm retirement PRs (per row, after §3.2 green) | — | ✅ | + +PB does **not** author Evaluator's freeze mechanism. Evaluator does **not** invent PB-Runtime semantics. Both consume `design-pb-runtime-interpreter.md` as the seam. + +The §3.1 table location (sibling brief vs §6 of `r2-evaluator-test-runner-authority-ratchet.md`) and exact ownership of cross-row coordination is a follow-up Director call when the seeding worker dispatches; this brief locks the *contract*, not the file path. + +## 8. R3 debt receipt (row 83) + +| Field | Value | +|---|---| +| Row | `test_runner.rs predicate-language growth` (ledger row 83) | +| Disposition | **Debt found + routed (partial — docs-only landing).** | +| Receipt PR | This brief landing (PB-side hook contract). | +| Remaining work | (1) §3.1 table seeded with existing variants (per-row dispatch). (2) Evaluator freeze mechanism wired to the table. (3) Per-variant dissolution refs. (4) §3.2 convergence claims. (5) Bespoke arm retirements per-row. Steps (1) + (2) close the row's *retirement-shape clause* ("Freeze bespoke arms unless paired with evaluator/PB-runtime dissolution hook"). Steps (3)–(5) are the long-tail implementation that the freeze gates. | +| Sibling rows touched | None paid by this PR. Adjacent rows that converge on the same hook (row 75 `test_runner.rs filename / sentinel bridges`; row 92 `Emitter as_bind().expect()` parked behind Substrate #1548) are noted but not closed here. | +| Velocity tripwire (`INVARIANTS.md` P5(c)) | This brief introduces zero new tracked-debt rows; no introduction:dissolution ratio impact. | + +## 9. Related + +- `docs/debt/r3-debt-paydown-ledger-2026-05-02.md` row 83 + cross-references to row 75 and row 92. +- `docs/briefs/r2-evaluator-test-runner-authority-ratchet.md` (audit + ratchet recommendation). +- `docs/briefs/r2-pr-b-2-runner-extension-bundle.md` (per-workstream dissolution table; runner-extension discipline). +- `docs/design-pb-runtime-interpreter.md` §3 / §6 / §7.1 (PB-Runtime IS, anti-bridge invariants, equivalence fixture). +- `docs/design-reflection-completeness.md` §3 / §6 (reflection-vs-evaluation distinction; consumed by §2 case (b)). +- `INVARIANTS.md` §P1 (substrate-fact-introduction; consumed by §2 case (c) and §6 STOP+PING boundaries). From 662313f7463a837b4e151346a8ccd7b20173047a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 3 May 2026 00:39:52 +0000 Subject: [PATCH 2/6] docs(r3): add citeable PB-Runtime Dissolution Hook Qualification section MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per Evaluator (snappy-moth-795) coordination on Bundle 4b: their freeze is docs/template enforcement and needs a stable, citeable PB-side anchor that defines what qualifies as a PB-runtime dissolution hook for future runner PRs. Adds top-level section `## PB-Runtime Dissolution Hook Qualification` (stable slug `#pb-runtime-dissolution-hook-qualification`) with four reviewable criteria (Q1 convergence-case classification, Q2 dissolution declaration ref, Q3 convergence claim for case (a), Q4 §3.1 table row) and an explicit disqualifier list (new TestPredicate variant / Value variant / discipline-marker field / producer identity / observation carrier / convention-only runner observation / self-citing arm). Reviewer rule reduced to one-line summary; §3.3 now cites the qualification section as the allow-condition rather than restating the rules. Co-Authored-By: Claude Opus 4.7 (1M context) --- ...runtime-test-predicate-dissolution-hook.md | 73 +++++++++++++++++-- 1 file changed, 67 insertions(+), 6 deletions(-) diff --git a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md index 157c0ff8f1d..b1760c8f58e 100644 --- a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md +++ b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md @@ -37,6 +37,71 @@ Concretely, this means a new predicate's evaluation either: Cases (a) + (b) are the dissolution path. Case (c) is the explicit STOP+PING. There is no fourth case; specifically, "open a new bespoke `match` arm pending future cleanup" is **not** a case under the freeze. +## PB-Runtime Dissolution Hook Qualification + +> **Stable citeable anchor.** Evaluator Manager's freeze template/docs cite this section by name. The heading text and slug (`#pb-runtime-dissolution-hook-qualification`) are stable; renames require Evaluator + PB Manager coordination. + +A future PR adding or extending a `test_runner.rs::run_claim` predicate arm or producer path **qualifies as PB-runtime-routed** (and is therefore freeze-allowed) iff **all** of the following are cited in the PR description and present in-tree at PR landing: + +### Q1 — Convergence-case classification + +The PR cites which of the three cases in §2 the predicate falls into: + +- **(a) Value-domain fold over PB-Runtime evaluation result.** The arm dispatches to a `Lens`-shaped fold that consumes a `Value` produced by PB-Runtime's `evaluate` (per `docs/design-pb-runtime-interpreter.md` §3). The arm is a thin adapter; it does not contain bespoke evaluation logic. +- **(b) Reflection-only structural projection.** The arm dispatches to a structural query per `docs/design-reflection-completeness.md`. No PB-Runtime invocation; no execution. Static fold over reflected program structure. +- **(c) P1-routed substrate gap.** Neither (a) nor (b) applies because the predicate semantics requires a primitive PB-Runtime cannot express via its 5-primitive base (`feedback_compiler_is_dag_processor.md`). **(c)-classified PRs do not land runner code in the same PR**; they land a P1 substrate-fact-introduction escalation row first. + +PRs that cannot place the predicate in (a), (b), or (c) are not freeze-allowed. There is no "(d) bespoke pending cleanup". + +### Q2 — Dissolution declaration reference + +For (a) and (b), the PR cites a `.dag` declaration ref by symbol/path that is the runner arm's dispatch target — either: + +- **Existing on `main`** at PR open time (preferred), or +- **Landing in the same PR** as the arm. + +The runner arm's body is the citation site (e.g., `// dissolves through: ` with the cited symbol). Bare prose pointers, ROADMAP rows, or cross-brief mentions do **not** satisfy Q2 — the citation is to a structural declaration, not to documentation. + +For (c), the citation is the P1 escalation row (issue/PR/ledger row authored by Substrate Manager); runner code is deferred to after the P1 disposition lands and the row converts to (a)/(b). + +### Q3 — Convergence claim (case (a) only) + +For (a)-classified arms, a `TestClaim` of the shape locked in `docs/design-pb-runtime-interpreter.md` §7.1 (PB-Runtime equivalence fixture: `DifferentialEquals` between PB-Runtime `evaluate` and R2-Evaluator) covers the predicate's semantics. The claim either: + +- **Exists on `main`** for an equivalent program shape consumed by the predicate, or +- **Lands in the same PR** as the arm (per-row authoring is parallelizable; the dispatch is the §3.1 table row's worker). + +The claim's existence is what makes the arm's evaluation structurally accountable; Q3 closure is the per-row dissolution receipt. + +### Q4 — §3.1 dissolution-table row + +The §3.1 per-predicate dissolution table (PB-owned; see §3) has a **row for the variant** with columns populated: + +- Variant constructor name (per `src/v3/std/verification.dag::TestPredicate`). +- Convergence case (a/b/c) matching Q1. +- Dissolution declaration ref matching Q2 (or P1 row for (c)). +- Status today (bespoke / partially-dissolved / fully-dissolved / P1-pending). + +A missing or unfilled row means the predicate is not freeze-allowed regardless of Q1/Q2/Q3 claims in the PR description. The table is the **single source of truth**; Evaluator's freeze mechanism reads it. + +### Disqualifiers (explicit non-criteria) + +The following do **not** qualify as PB-runtime dissolution hooks even if cited: + +- A new `TestPredicate` variant introduced by the PR. Substrate change → P1 → Substrate Manager. Not in scope of any runner PR. +- A new `Value` variant in PB-Runtime. Anti-bridge invariant #2 (`docs/design-pb-runtime-interpreter.md` §6) → P1. +- A new `TestPredicate` discipline-marker field (e.g., `pb_runtime_evaluable: Bit`). Substrate change → P1. +- A new producer identity in `test_runner.rs` (per Evaluator's freeze constraint). Producer dispatch lands only via the W1/W3 paths already locked in `docs/briefs/r2-pr-b-2-runner-extension-bundle.md`. +- A new substrate observation/channel carrier. Routes to P1 per `r2-pr-b-2-runner-extension-bundle.md` W3 "Structural observation authority". +- "Convention-only" runner observation (regex over stdout, ad-hoc parsing, env-variable signaling). Forbidden per `r2-pr-b-2-runner-extension-bundle.md` runner-authority discipline. +- A bespoke `match` arm whose dispatch target is itself in the same arm (self-citation). Q2 requires a structural declaration outside the arm body. + +### Reviewer rule (one-line summary) + +A `test_runner.rs` predicate-arm or producer-path PR is **PB-runtime-routed** iff Q1+Q2+Q4 hold (and Q3 for (a)). Anything else is **uncited bespoke runner growth** and the freeze blocks it. If a reviewer or worker concludes the predicate cannot satisfy Q1–Q4 without one of the disqualifiers, **STOP+PING** to PB Manager + Evaluator Manager rather than smuggling a carrier. + +--- + ## 3. Hook shape (PB-owned landing point) The PB-side artifact is a **convergence-discipline contract**, not a new piece of vocabulary. Its three elements: @@ -66,13 +131,9 @@ This is **the same anti-bridge invariant #1** from the design lock: "the `.dag` ### 3.3 Reviewer rule (the freeze's allow-condition, PB-side) -A PR adding or modifying a `TestPredicate` evaluation lands iff: - -1. The §3.1 table has a row for the variant marked (a), (b), or (c). -2. If (a)/(b): a dissolution declaration ref exists in `.dag` *or* is being landed in the same PR. The runner arm cites the ref. -3. If (c): a P1 substrate-fact-introduction escalation row exists. Runner arm work is **deferred** to after P1 lands; the PR carrying runner code is not the place that work happens. +A PR adding or modifying a `TestPredicate` evaluation lands iff it satisfies the **PB-Runtime Dissolution Hook Qualification** section above (Q1–Q4 + non-disqualifiers). -This is the PB-side allow-condition for Evaluator's freeze. Evaluator's freeze mechanism (CI ratchet / `match`-arm count gate / equivalent — Evaluator's lane to design) checks the table; PB owns the table. +This is the PB-side allow-condition for Evaluator's freeze. Evaluator's freeze mechanism (docs/template enforcement, per Evaluator coordination) cites the qualification section by name and checks the §3.1 table; PB owns the qualification text + the table. If docs/template enforcement turns out to be insufficient at the freeze layer, Evaluator STOP+PINGs rather than smuggling a carrier — the qualification stays the contract on PB's side. ## 4. Sequence (sequential vs parallelizable) From 759e56c10b219195192c95d43554dfb5420e2b10 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 3 May 2026 00:41:01 +0000 Subject: [PATCH 3/6] docs(r3): add explicit HTML anchor for PB-Runtime Dissolution Hook Qualification Per Evaluator coordination on PR #1550: their freeze template needs an explicit stable HTML anchor (independent of GitHub's auto-generated slug) to cite the qualification section by id. Adds `` immediately before the section heading; updates the stable-anchor note to point at the explicit id rather than the auto-slug. Co-Authored-By: Claude Opus 4.7 (1M context) --- docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md index b1760c8f58e..e2304a7455d 100644 --- a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md +++ b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md @@ -37,9 +37,11 @@ Concretely, this means a new predicate's evaluation either: Cases (a) + (b) are the dissolution path. Case (c) is the explicit STOP+PING. There is no fourth case; specifically, "open a new bespoke `match` arm pending future cleanup" is **not** a case under the freeze. + + ## PB-Runtime Dissolution Hook Qualification -> **Stable citeable anchor.** Evaluator Manager's freeze template/docs cite this section by name. The heading text and slug (`#pb-runtime-dissolution-hook-qualification`) are stable; renames require Evaluator + PB Manager coordination. +> **Stable citeable anchor.** Evaluator Manager's freeze template/docs cite this section via the explicit HTML anchor `#pb-runtime-dissolution-hook-qualification` immediately above the heading (independent of GitHub's auto-generated slug). The anchor id, heading text, and the four-criterion / disqualifier shape below are stable; renames require Evaluator + PB Manager coordination. A future PR adding or extending a `test_runner.rs::run_claim` predicate arm or producer path **qualifies as PB-runtime-routed** (and is therefore freeze-allowed) iff **all** of the following are cited in the PR description and present in-tree at PR landing: From 4f8fa2e107af8ff08d3dbac887c6281758497ee9 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 3 May 2026 01:13:04 +0000 Subject: [PATCH 4/6] test: refresh parse corpus manifest --- src/v3/compiler/tests/integration/parse_corpus_manifest.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/v3/compiler/tests/integration/parse_corpus_manifest.txt b/src/v3/compiler/tests/integration/parse_corpus_manifest.txt index c3b876bc165..34a3a52bb88 100644 --- a/src/v3/compiler/tests/integration/parse_corpus_manifest.txt +++ b/src/v3/compiler/tests/integration/parse_corpus_manifest.txt @@ -40,7 +40,7 @@ src/v3/std/effects.dag 53 97984 1acdbeaa68acfd2e src/v3/std/emit_model.dag 43 77647 4b063e9a5ddc50a1 src/v3/std/extdeps_bootstrap_fixtures.dag 4 14463 909ca7a1c1705e89 src/v3/std/go_method_template_contracts.dag 5 110898 7eb5c9f1296f4a45 -src/v3/std/induction.dag 56 88794 546f74c63c189c50 +src/v3/std/induction.dag 56 88794 e405e1549cf2fe08 src/v3/std/integer_diagnostic_order.dag 6 8124 5d7b31594a5b3d5c src/v3/std/lens.dag 6 9852 28d5539a5b28716e src/v3/std/list.dag 19 40269 8c648d4a4fd05c21 From a829be8082ca467b32241099eb2fc0880713167d Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 3 May 2026 01:36:08 +0000 Subject: [PATCH 5/6] test: refresh bootstrap snapshots --- src/v3/compiler/src/bootstrap_generated.rs | 312 +++++++++--------- ...otstrap_generated_without_parse_surface.rs | 312 +++++++++--------- 2 files changed, 312 insertions(+), 312 deletions(-) diff --git a/src/v3/compiler/src/bootstrap_generated.rs b/src/v3/compiler/src/bootstrap_generated.rs index e647ea9b2a1..1a9fb343b6e 100644 --- a/src/v3/compiler/src/bootstrap_generated.rs +++ b/src/v3/compiler/src/bootstrap_generated.rs @@ -24900,8 +24900,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(99), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 12177, - 12677, + 12138, + 12638, )), }, type_params: vec![], @@ -24912,7 +24912,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 12115, 12677), + span: SourceSpan::new("src/v3/std/induction.dag", 12076, 12638), }); declarations.push(Declaration { id: DeclarationId(944), @@ -24922,8 +24922,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(941), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 13200, - 14612, + 13229, + 14641, )), }, type_params: vec![], @@ -24934,7 +24934,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 13120, 14612), + span: SourceSpan::new("src/v3/std/induction.dag", 13149, 14641), }); declarations.push(Declaration { id: DeclarationId(945), @@ -24944,8 +24944,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(941), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 14944, - 16247, + 14973, + 16276, )), }, type_params: vec![], @@ -24956,7 +24956,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 14864, 16247), + span: SourceSpan::new("src/v3/std/induction.dag", 14893, 16276), }); declarations.push(Declaration { id: DeclarationId(946), @@ -24966,8 +24966,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(941), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 17356, - 17478, + 17419, + 17541, )), }, type_params: vec![], @@ -24978,7 +24978,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 17268, 17478), + span: SourceSpan::new("src/v3/std/induction.dag", 17331, 17541), }); declarations.push(Declaration { id: DeclarationId(947), @@ -24988,8 +24988,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(941), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 18334, - 19680, + 18397, + 19743, )), }, type_params: vec![], @@ -25000,7 +25000,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 18226, 19680), + span: SourceSpan::new("src/v3/std/induction.dag", 18289, 19743), }); declarations.push(Declaration { id: DeclarationId(948), @@ -25010,8 +25010,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 20455, - 21251, + 20518, + 21314, )), }, type_params: vec![], @@ -25022,7 +25022,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 20382, 21251), + span: SourceSpan::new("src/v3/std/induction.dag", 20445, 21314), }); declarations.push(Declaration { id: DeclarationId(949), @@ -25032,8 +25032,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1954), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 21843, - 22748, + 21906, + 22811, )), }, type_params: vec![], @@ -25044,7 +25044,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 21764, 22748), + span: SourceSpan::new("src/v3/std/induction.dag", 21827, 22811), }); declarations.push(Declaration { id: DeclarationId(950), @@ -25077,7 +25077,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 23991, 24246), + span: SourceSpan::new("src/v3/std/induction.dag", 24054, 24309), }); declarations.push(Declaration { id: DeclarationId(951), @@ -25087,8 +25087,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(950), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 24295, - 24334, + 24358, + 24397, )), }, type_params: vec![], @@ -25099,7 +25099,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24248, 24334), + span: SourceSpan::new("src/v3/std/induction.dag", 24311, 24397), }); declarations.push(Declaration { id: DeclarationId(952), @@ -25124,7 +25124,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24846, 24963), + span: SourceSpan::new("src/v3/std/induction.dag", 24909, 25026), }); declarations.push(Declaration { id: DeclarationId(953), @@ -25169,7 +25169,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26593, 27353), + span: SourceSpan::new("src/v3/std/induction.dag", 26656, 27416), }); declarations.push(Declaration { id: DeclarationId(954), @@ -25179,8 +25179,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 27764, - 27870, + 27827, + 27933, )), }, type_params: vec![], @@ -25191,7 +25191,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27714, 27870), + span: SourceSpan::new("src/v3/std/induction.dag", 27777, 27933), }); declarations.push(Declaration { id: DeclarationId(955), @@ -25201,8 +25201,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(99), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 28194, - 28447, + 28257, + 28510, )), }, type_params: vec![], @@ -25213,7 +25213,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 28145, 28447), + span: SourceSpan::new("src/v3/std/induction.dag", 28208, 28510), }); declarations.push(Declaration { id: DeclarationId(956), @@ -25223,8 +25223,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 28481, - 28498, + 28544, + 28561, )), }, type_params: vec![], @@ -25235,7 +25235,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 28449, 28498), + span: SourceSpan::new("src/v3/std/induction.dag", 28512, 28561), }); declarations.push(Declaration { id: DeclarationId(957), @@ -25245,8 +25245,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 28542, - 28626, + 28605, + 28689, )), }, type_params: vec![], @@ -25257,7 +25257,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 28499, 28626), + span: SourceSpan::new("src/v3/std/induction.dag", 28562, 28689), }); declarations.push(Declaration { id: DeclarationId(958), @@ -25267,8 +25267,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 28681, - 29080, + 28744, + 29143, )), }, type_params: vec![], @@ -25279,7 +25279,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 28627, 29080), + span: SourceSpan::new("src/v3/std/induction.dag", 28690, 29143), }); declarations.push(Declaration { id: DeclarationId(959), @@ -25289,8 +25289,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29130, - 29404, + 29193, + 29467, )), }, type_params: vec![], @@ -25301,7 +25301,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29081, 29404), + span: SourceSpan::new("src/v3/std/induction.dag", 29144, 29467), }); declarations.push(Declaration { id: DeclarationId(960), @@ -25311,8 +25311,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29446, - 29479, + 29509, + 29542, )), }, type_params: vec![], @@ -25323,7 +25323,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29405, 29479), + span: SourceSpan::new("src/v3/std/induction.dag", 29468, 29542), }); declarations.push(Declaration { id: DeclarationId(961), @@ -25333,8 +25333,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29521, - 29554, + 29584, + 29617, )), }, type_params: vec![], @@ -25345,7 +25345,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29480, 29554), + span: SourceSpan::new("src/v3/std/induction.dag", 29543, 29617), }); declarations.push(Declaration { id: DeclarationId(962), @@ -25355,8 +25355,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29595, - 29645, + 29658, + 29708, )), }, type_params: vec![], @@ -25367,7 +25367,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29555, 29645), + span: SourceSpan::new("src/v3/std/induction.dag", 29618, 29708), }); declarations.push(Declaration { id: DeclarationId(963), @@ -25377,8 +25377,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29689, - 29807, + 29752, + 29870, )), }, type_params: vec![], @@ -25389,7 +25389,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29647, 29807), + span: SourceSpan::new("src/v3/std/induction.dag", 29710, 29870), }); declarations.push(Declaration { id: DeclarationId(964), @@ -25399,8 +25399,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 29877, - 30053, + 29940, + 30116, )), }, type_params: vec![], @@ -25411,7 +25411,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 29809, 30053), + span: SourceSpan::new("src/v3/std/induction.dag", 29872, 30116), }); declarations.push(Declaration { id: DeclarationId(965), @@ -25444,7 +25444,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 31210, 31301), + span: SourceSpan::new("src/v3/std/induction.dag", 31273, 31364), }); declarations.push(Declaration { id: DeclarationId(966), @@ -25454,8 +25454,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1956), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 31892, - 32143, + 31955, + 32206, )), }, type_params: vec![], @@ -25466,7 +25466,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 31849, 32143), + span: SourceSpan::new("src/v3/std/induction.dag", 31912, 32206), }); declarations.push(Declaration { id: DeclarationId(967), @@ -25476,8 +25476,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1957), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 32188, - 32977, + 32251, + 33040, )), }, type_params: vec![], @@ -25488,7 +25488,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 32145, 32977), + span: SourceSpan::new("src/v3/std/induction.dag", 32208, 33040), }); declarations.push(Declaration { id: DeclarationId(968), @@ -25498,8 +25498,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1958), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 33437, - 33560, + 33500, + 33623, )), }, type_params: vec![], @@ -25510,7 +25510,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 33393, 33560), + span: SourceSpan::new("src/v3/std/induction.dag", 33456, 33623), }); declarations.push(Declaration { id: DeclarationId(969), @@ -25520,8 +25520,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1959), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 33912, - 34957, + 33975, + 35020, )), }, type_params: vec![], @@ -25532,7 +25532,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 33864, 34957), + span: SourceSpan::new("src/v3/std/induction.dag", 33927, 35020), }); declarations.push(Declaration { id: DeclarationId(970), @@ -25542,8 +25542,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1960), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 35175, - 35290, + 35238, + 35353, )), }, type_params: vec![], @@ -25554,7 +25554,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 35129, 35290), + span: SourceSpan::new("src/v3/std/induction.dag", 35192, 35353), }); declarations.push(Declaration { id: DeclarationId(971), @@ -25569,8 +25569,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(1961), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 35447, - 35809, + 35510, + 35872, )), }, type_params: vec![], @@ -25581,7 +25581,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 35376, 35809), + span: SourceSpan::new("src/v3/std/induction.dag", 35439, 35872), }); declarations.push(Declaration { id: DeclarationId(972), @@ -25591,8 +25591,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 35864, - 37901, + 35927, + 37964, )), }, type_params: vec![], @@ -25603,7 +25603,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 35811, 37901), + span: SourceSpan::new("src/v3/std/induction.dag", 35874, 37964), }); declarations.push(Declaration { id: DeclarationId(973), @@ -25613,8 +25613,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 38254, - 38412, + 38317, + 38475, )), }, type_params: vec![], @@ -25625,7 +25625,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 38184, 38412), + span: SourceSpan::new("src/v3/std/induction.dag", 38247, 38475), }); declarations.push(Declaration { id: DeclarationId(974), @@ -25640,8 +25640,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 38911, - 39935, + 38974, + 39998, )), }, type_params: vec![], @@ -25652,7 +25652,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 38810, 39935), + span: SourceSpan::new("src/v3/std/induction.dag", 38873, 39998), }); declarations.push(Declaration { id: DeclarationId(975), @@ -25662,8 +25662,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 40268, - 40325, + 40331, + 40388, )), }, type_params: vec![], @@ -25674,7 +25674,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 40229, 40325), + span: SourceSpan::new("src/v3/std/induction.dag", 40292, 40388), }); declarations.push(Declaration { id: DeclarationId(976), @@ -25684,8 +25684,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 40368, - 40426, + 40431, + 40489, )), }, type_params: vec![], @@ -25696,7 +25696,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 40327, 40426), + span: SourceSpan::new("src/v3/std/induction.dag", 40390, 40489), }); declarations.push(Declaration { id: DeclarationId(977), @@ -25706,8 +25706,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 40526, - 40581, + 40589, + 40644, )), }, type_params: vec![], @@ -25718,7 +25718,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 40490, 40581), + span: SourceSpan::new("src/v3/std/induction.dag", 40553, 40644), }); declarations.push(Declaration { id: DeclarationId(978), @@ -25728,8 +25728,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 40778, - 40893, + 40841, + 40956, )), }, type_params: vec![], @@ -25740,7 +25740,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 40740, 40893), + span: SourceSpan::new("src/v3/std/induction.dag", 40803, 40956), }); declarations.push(Declaration { id: DeclarationId(979), @@ -25750,8 +25750,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 40973, - 41088, + 41036, + 41151, )), }, type_params: vec![], @@ -25762,7 +25762,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 40939, 41088), + span: SourceSpan::new("src/v3/std/induction.dag", 41002, 41151), }); declarations.push(Declaration { id: DeclarationId(980), @@ -25772,8 +25772,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 41255, - 41374, + 41318, + 41437, )), }, type_params: vec![], @@ -25784,7 +25784,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 41221, 41374), + span: SourceSpan::new("src/v3/std/induction.dag", 41284, 41437), }); declarations.push(Declaration { id: DeclarationId(981), @@ -25794,8 +25794,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 41539, - 41653, + 41602, + 41716, )), }, type_params: vec![], @@ -25806,7 +25806,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 41506, 41653), + span: SourceSpan::new("src/v3/std/induction.dag", 41569, 41716), }); declarations.push(Declaration { id: DeclarationId(982), @@ -25816,8 +25816,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 41770, - 41795, + 41833, + 41858, )), }, type_params: vec![], @@ -25828,7 +25828,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 41731, 41795), + span: SourceSpan::new("src/v3/std/induction.dag", 41794, 41858), }); declarations.push(Declaration { id: DeclarationId(983), @@ -25838,8 +25838,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 41830, - 41855, + 41893, + 41918, )), }, type_params: vec![], @@ -25850,7 +25850,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 41796, 41855), + span: SourceSpan::new("src/v3/std/induction.dag", 41859, 41918), }); declarations.push(Declaration { id: DeclarationId(984), @@ -25860,8 +25860,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 41937, - 41968, + 42000, + 42031, )), }, type_params: vec![], @@ -25872,7 +25872,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 41898, 41968), + span: SourceSpan::new("src/v3/std/induction.dag", 41961, 42031), }); declarations.push(Declaration { id: DeclarationId(985), @@ -25882,8 +25882,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 42204, - 42255, + 42267, + 42318, )), }, type_params: vec![], @@ -25894,7 +25894,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 42172, 42255), + span: SourceSpan::new("src/v3/std/induction.dag", 42235, 42318), }); declarations.push(Declaration { id: DeclarationId(986), @@ -25904,8 +25904,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 42346, - 42628, + 42409, + 42691, )), }, type_params: vec![], @@ -25916,7 +25916,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 42313, 42628), + span: SourceSpan::new("src/v3/std/induction.dag", 42376, 42691), }); declarations.push(Declaration { id: DeclarationId(987), @@ -25926,8 +25926,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 42731, - 42891, + 42794, + 42954, )), }, type_params: vec![], @@ -25938,7 +25938,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 42694, 42891), + span: SourceSpan::new("src/v3/std/induction.dag", 42757, 42954), }); declarations.push(Declaration { id: DeclarationId(988), @@ -25948,8 +25948,8 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { output: DeclarationId(953), body: ArrowBody::Unparsed(SourceSpan::new( "src/v3/std/induction.dag", - 42998, - 43036, + 43061, + 43099, )), }, type_params: vec![], @@ -25960,7 +25960,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 42959, 43036), + span: SourceSpan::new("src/v3/std/induction.dag", 43022, 43099), }); declarations.push(Declaration { id: DeclarationId(989), @@ -57546,7 +57546,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 20442, 20454), + span: SourceSpan::new("src/v3/std/induction.dag", 20505, 20517), }); declarations.push(Declaration { id: DeclarationId(1954), @@ -57563,7 +57563,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 21827, 21842), + span: SourceSpan::new("src/v3/std/induction.dag", 21890, 21905), }); declarations.push(Declaration { id: DeclarationId(1955), @@ -57583,7 +57583,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27734, 27749), + span: SourceSpan::new("src/v3/std/induction.dag", 27797, 27812), }); declarations.push(Declaration { id: DeclarationId(1956), @@ -57600,7 +57600,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 31887, 31891), + span: SourceSpan::new("src/v3/std/induction.dag", 31950, 31954), }); declarations.push(Declaration { id: DeclarationId(1957), @@ -57617,7 +57617,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 32183, 32187), + span: SourceSpan::new("src/v3/std/induction.dag", 32246, 32250), }); declarations.push(Declaration { id: DeclarationId(1958), @@ -57634,7 +57634,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 33432, 33436), + span: SourceSpan::new("src/v3/std/induction.dag", 33495, 33499), }); declarations.push(Declaration { id: DeclarationId(1959), @@ -57651,7 +57651,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 33907, 33911), + span: SourceSpan::new("src/v3/std/induction.dag", 33970, 33974), }); declarations.push(Declaration { id: DeclarationId(1960), @@ -57668,7 +57668,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 35170, 35174), + span: SourceSpan::new("src/v3/std/induction.dag", 35233, 35237), }); declarations.push(Declaration { id: DeclarationId(1961), @@ -57685,7 +57685,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 35442, 35446), + span: SourceSpan::new("src/v3/std/induction.dag", 35505, 35509), }); declarations.push(Declaration { id: DeclarationId(1962), @@ -57866,7 +57866,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24019, 24033), + span: SourceSpan::new("src/v3/std/induction.dag", 24082, 24096), }); declarations.push(Declaration { id: DeclarationId(1973), @@ -57885,7 +57885,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24038, 24085), + span: SourceSpan::new("src/v3/std/induction.dag", 24101, 24148), }); declarations.push(Declaration { id: DeclarationId(1974), @@ -57910,7 +57910,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24090, 24167), + span: SourceSpan::new("src/v3/std/induction.dag", 24153, 24230), }); declarations.push(Declaration { id: DeclarationId(1975), @@ -57935,7 +57935,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24172, 24246), + span: SourceSpan::new("src/v3/std/induction.dag", 24235, 24309), }); declarations.push(Declaration { id: DeclarationId(1976), @@ -57960,7 +57960,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24866, 24922), + span: SourceSpan::new("src/v3/std/induction.dag", 24929, 24985), }); declarations.push(Declaration { id: DeclarationId(1977), @@ -57979,7 +57979,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 24938, 24963), + span: SourceSpan::new("src/v3/std/induction.dag", 25001, 25026), }); declarations.push(Declaration { id: DeclarationId(1978), @@ -57993,7 +57993,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26612, 26625), + span: SourceSpan::new("src/v3/std/induction.dag", 26675, 26688), }); declarations.push(Declaration { id: DeclarationId(1979), @@ -58012,7 +58012,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26669, 26701), + span: SourceSpan::new("src/v3/std/induction.dag", 26732, 26764), }); declarations.push(Declaration { id: DeclarationId(1980), @@ -58032,7 +58032,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26764, 26780), + span: SourceSpan::new("src/v3/std/induction.dag", 26827, 26843), }); declarations.push(Declaration { id: DeclarationId(1981), @@ -58051,7 +58051,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26740, 26782), + span: SourceSpan::new("src/v3/std/induction.dag", 26803, 26845), }); declarations.push(Declaration { id: DeclarationId(1982), @@ -58071,7 +58071,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26844, 26860), + span: SourceSpan::new("src/v3/std/induction.dag", 26907, 26923), }); declarations.push(Declaration { id: DeclarationId(1983), @@ -58091,7 +58091,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26839, 26861), + span: SourceSpan::new("src/v3/std/induction.dag", 26902, 26924), }); declarations.push(Declaration { id: DeclarationId(1984), @@ -58110,7 +58110,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 26811, 26863), + span: SourceSpan::new("src/v3/std/induction.dag", 26874, 26926), }); declarations.push(Declaration { id: DeclarationId(1985), @@ -58130,7 +58130,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27161, 27176), + span: SourceSpan::new("src/v3/std/induction.dag", 27224, 27239), }); declarations.push(Declaration { id: DeclarationId(1986), @@ -58149,7 +58149,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27143, 27178), + span: SourceSpan::new("src/v3/std/induction.dag", 27206, 27241), }); declarations.push(Declaration { id: DeclarationId(1987), @@ -58163,7 +58163,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27261, 27273), + span: SourceSpan::new("src/v3/std/induction.dag", 27324, 27336), }); declarations.push(Declaration { id: DeclarationId(1988), @@ -58177,7 +58177,7 @@ fn bootstrapped_fixture_dag_declarations() -> Vec { value_body: None, refinement: None, nominal_opacity: None, - span: SourceSpan::new("src/v3/std/induction.dag", 27343, 27353), + span: SourceSpan::new("src/v3/std/induction.dag", 27406, 27416), }); declarations.push(Declaration { id: DeclarationId(1989), diff --git a/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs b/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs index b3c4c1764c7..daaa788b392 100644 --- a/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs +++ b/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs @@ -24900,8 +24900,8 @@ fn bootstrapped_fixture_without_parse_surface_dag_declarations() -> Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Vec Date: Sun, 3 May 2026 01:49:05 +0000 Subject: [PATCH 6/6] =?UTF-8?q?docs(r3):=20swap=20stale=20memory-file=20ci?= =?UTF-8?q?tation=20for=20in-repo=20=C2=A73.1=20authority?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per codex review on a829be80: line 54 cited feedback_compiler_is_dag_processor.md, which is a session memory file not present in the repo. The 5-primitive authority (Node/Conj/Disj/Cardinality/ Bit) lives in docs/design-pb-runtime-interpreter.md §3.1, already cited elsewhere in the brief. Swap to that in-repo authority. No semantic change; one citation correction. Co-Authored-By: Claude Opus 4.7 (1M context) --- docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md index e2304a7455d..7d1448cdcad 100644 --- a/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md +++ b/docs/briefs/r3-pb-runtime-test-predicate-dissolution-hook.md @@ -51,7 +51,7 @@ The PR cites which of the three cases in §2 the predicate falls into: - **(a) Value-domain fold over PB-Runtime evaluation result.** The arm dispatches to a `Lens`-shaped fold that consumes a `Value` produced by PB-Runtime's `evaluate` (per `docs/design-pb-runtime-interpreter.md` §3). The arm is a thin adapter; it does not contain bespoke evaluation logic. - **(b) Reflection-only structural projection.** The arm dispatches to a structural query per `docs/design-reflection-completeness.md`. No PB-Runtime invocation; no execution. Static fold over reflected program structure. -- **(c) P1-routed substrate gap.** Neither (a) nor (b) applies because the predicate semantics requires a primitive PB-Runtime cannot express via its 5-primitive base (`feedback_compiler_is_dag_processor.md`). **(c)-classified PRs do not land runner code in the same PR**; they land a P1 substrate-fact-introduction escalation row first. +- **(c) P1-routed substrate gap.** Neither (a) nor (b) applies because the predicate semantics requires a primitive PB-Runtime cannot express via its 5-primitive base (`docs/design-pb-runtime-interpreter.md` §3.1 — `Node` / `Conj` / `Disj` / `Cardinality` / `Bit`). **(c)-classified PRs do not land runner code in the same PR**; they land a P1 substrate-fact-introduction escalation row first. PRs that cannot place the predicate in (a), (b), or (c) are not freeze-allowed. There is no "(d) bespoke pending cleanup".