From 1c81da09a47b2765af16c769c25aa8461dc1524a Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 27 Sep 2026 15:32:18 +0000 Subject: [PATCH 01/11] Session arrival: act address landing prompt and bootstrap per DDD-dec-20 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit meta/sessions/2026-09-27-act-address-landing/ — prompt.md verbatim and bootstrap.md with branch, base commits (downstream cba63ef; upstream 361e88f = v5.14.1 verified), gate count 5 (0-4), principal Emil, and the pre-registration hash verified at arrival. First act, before any canon edit. Basis: DDD-dec-20; DDD-dec-17 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../bootstrap.md | 21 +++++ .../2026-09-27-act-address-landing/prompt.md | 78 +++++++++++++++++++ 2 files changed, 99 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address-landing/bootstrap.md create mode 100644 meta/sessions/2026-09-27-act-address-landing/prompt.md diff --git a/meta/sessions/2026-09-27-act-address-landing/bootstrap.md b/meta/sessions/2026-09-27-act-address-landing/bootstrap.md new file mode 100644 index 0000000..36c5819 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/bootstrap.md @@ -0,0 +1,21 @@ +# Bootstrap — act address landing + +Filled in at arrival and committed with `prompt.md` as the session's first commit. + +| Parameter | Value | +|---|---| +| Invocation | The contents of `prompt.md`, given verbatim with the bundle attached as `act-address-bundle.zip` | +| Principal | Emil (sole ratifier) | +| Bundle path | Unpacked in the session scratchpad as `act-address-bundle/`; outside both repositories | +| Upstream repo | github.com/mindovermachine-dev/actor-indexed-determination | +| Upstream base | `361e88f` — head of `main` at arrival; tag `v5.14.1` verified to point at it. No drift from the drafts' base | +| Downstream repo | github.com/mindovermachine-dev/decision-driven-design | +| Downstream base | `cba63ef` — head of `main` at arrival. No drift from the drafts' base | +| Branch, both repos | `claude/act-address-landing-bla6io` (the harness-assigned branch; the bundled template named `claude/act-address-landing`) | +| Gates | 0 arrival · 1 survey · 2 upstream · 3 downstream · 4 close | +| Pre-registration hash | `ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb` — verified against the bundled `prereg-act-coordinates.md` at arrival | + +## Deviations from the bundled template, recorded at arrival + +- **Directory name.** `LANDING-DATE` resolved to `2026-09-27`, the arrival date. The landing therefore shares its date with the session it lands (`2026-09-27-act-address/`); the slugs differ. +- **Branch name.** The session runs on the branch the harness assigned, which carries a suffix. The bundled template's unsuffixed name was not created. diff --git a/meta/sessions/2026-09-27-act-address-landing/prompt.md b/meta/sessions/2026-09-27-act-address-landing/prompt.md new file mode 100644 index 0000000..56c3a19 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/prompt.md @@ -0,0 +1,78 @@ +# Session prompt — act address landing + +You are the proposing agent for the act address landing session. Emil is the sole ratifier. Sessions propose; Emil rules. Nothing self-ratifies, and you merge nothing. + +## What this session does + +It lands the output of the 2026-09-27 act address session into both repositories: +- the session record, +- one upstream claim, term and decision, +- five downstream claims and one downstream decision, +- a staged pin advance. + +The bundle holding the material is at the path named in `bootstrap.md`. Every file in it is a draft. Nothing in it has canon status until filed at a gate. + +## Governing documents — read before GATE 1 + +- `decision-driven-design/meta/way-of-working.md`. It wins over this prompt where they disagree. +- `CLAUDE.md` in both repositories. +- `spec/claim-format.md` and `spec/claim-format-2-addendum.md` (upstream). +- `meta/sessions/README.md` (downstream). +- `meta/repo-topology.md` (upstream). +- The bundle's `README.md`. + +## Discipline + +- Stop at every gate and report. Proceed only on Emil's ruling. +- Three registers: Ruled, `[PROPOSED]`, `[OPEN]`. Flag unconfirmed reasoning as `UNVERIFIED — Emil review`. +- Supersession, never rewriting. No force-push. +- Write predictions before operations: the pin advance's predicted firing is committed before the bump. +- Every commit that changes canon carries a `Basis:` line citing claim or decision IDs. +- Name the weakest point first in every gate report. +- British spelling. One idea per sentence. Tables for structure, prose for arguments. +- Phoenix is a code name. No customer-identifying material in any file, commit message, or PR text. +- The pre-registration `prereg-act-coordinates.md` is fixed. Verify its SHA-256 is `ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb`, and never edit it. + +## Gates + +**GATE 0 — arrival.** Create `meta/sessions/-act-address-landing/` downstream. Commit this prompt verbatim as `prompt.md` and the filled-in `bootstrap.md`. Do both on the session branch, as the first commit, before touching anything else. Record the base commits of both repositories. Stop. + +**GATE 1 — survey.** Report the following, then stop: + +1. **Drift since the drafts were written.** The drafts were written against upstream `361e88f` (v5.14.1) and downstream `cba63ef`. List every change since then that touches their basis: `DDD-ground-01`, `DDD-frame-01`, `DDD-floor-02`, `term:act`, `core/04`, and the ground-axes holding note. +2. **ID collisions.** Check whether `DDD-ground-06`, `DDD-dec-37`, `DDD-dec-38`, `term:act-address` and the `DDD-address` area are free. Propose replacements for any that are taken, and rewrite cross-references to match. +3. **Validation.** Run the drafts through `validate-claims.py`, including decisions mode, and through the drift validator for the term. Report errors and warnings separately. +4. **Rule 1 candidates.** List them for adjudication. `DDD-ground-06` and `DDD-address-01` are pre-flagged. +5. **The Gate 0 behaviour bundle.** Has it been filed anywhere? If not, what does that mean for `DDD-address-05`: file with the dependency named, or hold? +6. **Seam-decay result.** Does a canonical home exist for it (`DDD-address-03` relies on it)? +7. **Unruled items.** Present E-1 and F-1 to F-3 from the dry-run results, and the T2a act map, for Emil's ruling. Do not file them. +8. **Registry fit.** Does `established_by` on the new term fit registry precedent? + +**GATE 2 — upstream.** On the session branch in `actor-indexed-determination`: +- File `DDD-ground-06`, `DDD-dec-37` and `term:act-address` as ruled at GATE 1. +- Add the Danish glossary rows only if Emil has ruled the terms. +- Run all validators. +- Prepare a release descriptor for the next minor version, and set `changed` fields to it. +- Open a PR and do not merge it. Stop. + +**GATE 3 — downstream.** On the session branch in `decision-driven-design`: +- Commit the 2026-09-27 session record: `meta/sessions/2026-09-27-act-address/`, exactly as bundled. +- Add both sessions to the `meta/sessions/README.md` index. +- File `DDD-address-01` to `05` and `DDD-dec-38` as ruled. +- Write the pin advance's predicted firing (E12, E13, W5, W6, W7, and pins added) into the landing session directory and commit it. +- Stage the `graph/upstream.yaml` advance against the upstream branch, per the DDD-dec-10/16/18/25/28 pattern. +- Run all validators, including `validate-core-order.py`. +- Open a PR and do not merge it. Stop. + +**GATE 4 — close.** After Emil accepts the upstream PR and it is tagged: +- Bump the pin to the tag. +- Verify the observed firing against the committed prediction, limb by limb. +- Write the session manifest and a successor-items file. The successor items must include T2b (first Phoenix slice) and any unruled findings. +- Stop. + +## Out of scope + +- Editing the pre-registration. +- Filing E-1 or F-1 to F-3 without a ruling. +- Changing `upstream.yaml`'s `repo:` URL from Hafeok to mindovermachine-dev. Report it as a successor item unless Emil rules otherwise. +- Any change to `method-instructions-draft.md` beyond landing it in the session record. From 6e0c336690c415b63197eb0b47e8fcf5c41f3811 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:04:09 +0000 Subject: [PATCH 02/11] GATE 1 survey (report only): act address landing Drift none on main; IDs all free; drafts validate clean except the term, which fails E10 as drafted (established_by must be a core/ doc) and passes when established by core/14 with the bare alias dropped. Weakest point: DDD-ground-06's address may be narrower than DDD-ground-01's predicate space (temporal predicates). Nothing filed; rulings requested. Basis: DDD-ground-01; DDD-ground-02; DDD-ground-05; DDD-dec-17; DDD-dec-20 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../gate1-survey.md | 177 ++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate1-survey.md diff --git a/meta/sessions/2026-09-27-act-address-landing/gate1-survey.md b/meta/sessions/2026-09-27-act-address-landing/gate1-survey.md new file mode 100644 index 0000000..b96a23e --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate1-survey.md @@ -0,0 +1,177 @@ +# GATE 1 — survey (act address landing) + +**Status.** Report only. Nothing is filed. Every recommendation is `[PROPOSED]` until Emil rules. +Surveyed 2026-09-28 against upstream `361e88f` (v5.14.1) and downstream `1c81da0` (`cba63ef` plus +the arrival commit). + +## Weakest point, named first + +**`DDD-ground-06` may be narrower than the predicates it anchors.** The draft says decisions are +anchored to acts by `DDD-ground-01`'s applicability predicates evaluated over the address. But +`DDD-ground-01`'s region refuses to make axes the ontology: "the predicate abstraction is wider +than coordinate geometry: categorical or interval constraints, graph queries, temporal +conditions, and compositions all serve; factored axes are one implementation … not the ontology +of every region." Its corpus evidence puts the beyond-region cases at about 27–36% of rows. + +The address is a position on declared axes plus a layer path. The layer path can plausibly +carry graph predicates. Temporal predicates are a different matter. The time index is kept out of +the address (`DDD-address-01`, criterion K5) and files downstream. So a decision with a temporal +applicability condition seems to need more than "its address and the decisions' applicability +predicates" to compute its governing set. That is `DDD-ground-06`'s own first falsifier limb. + +This does not show the claim is wrong. It may mean the falsifier limb needs "address and time +index", or that the region needs to exclude temporal predicates explicitly. Either repair touches +the synchronic/diachronic split that places the claim upstream. `UNVERIFIED — Emil review.` + +## 1. Drift since the drafts were written + +| Object | Change since `361e88f` / `cba63ef` | +|---|---| +| Both `main` branches | None. The drafts' bases are the current heads. | +| `DDD-ground-01`, `DDD-frame-01`, `DDD-floor-02`, `term:act`, `core/04` | None on `main`. The last change to any of them predates v5.14.0. | +| Unmerged branches (all `origin/*`, both repositories) | No branch carries a commit beyond `main` that touches the basis. `claude/act-primitive-lm1s03` is fully merged. | +| Open PRs | Upstream #3 (`claude/primitives-reader-clean`, last updated 2026-08-06) rewrites `core/00` prose about "the act". It does not touch the `term:act` embed. It is stale against the split and changes nothing now, but if it merged later it would reword the doc that establishes `term:act`. | +| Ground-axes holding note rev 18 | Not in either repository (held by Emil; cited as unratified in `DDD-frame-17` and the ground claims). No drift can be checked. | + +Two findings came out of checking the basis rather than from drift. + +- **Citation precision.** `DDD-ground-06`'s region and finding F-2 cite "`DDD-ground-01`'s + declared-space limit". `DDD-ground-01` states axis marking over declared axes. It does not state + a limit on undeclared space. The limit as stated lives in `DDD-ground-05` (the determinable space + is prior) and `DDD-ground-02` (`undeclared` as a source-coverage value). `[PROPOSED]` cite + `DDD-ground-05` (with `DDD-ground-02`) at filing. +- **`term:act` and `core/09` (the draft's flagged relation).** `core/09` §1 already says "acts + nest as actors nest": an inner check with its own verdict individuates an inner act, and the + outer boundary's verdict individuates the outer act. That supports the layer path, and it + supports reading individuation and address as orthogonal. `core/09` also says retry economics + "stays synchronic as an expectation over the outer act". T2a's attempts a3.1–a3.3 are separate + occurrences only if each attempt carries its own verdict. `[PROPOSED]` narrow the + `UNVERIFIED` flag to the retry case; the layer relation itself is consistent with canon. + +The **pin advance spans three releases**, not one. Downstream pins `v5.13.0`, so the advance +crosses v5.14.0 and v5.14.1 as well as the release that carries this landing. `DDD-frame-08` is +pinned and its statement moved at v5.14.0. That is at least one predicted W6 before this session's +own content. The full prediction belongs to GATE 3. + +## 2. ID collisions + +| ID | Free? | Checked | +|---|---|---| +| `DDD-ground-06` | Yes | Upstream holds `DDD-ground-01…05`. No ref on any branch of either repository names `-06`. | +| `DDD-dec-37`, `DDD-dec-38` | Yes | Decision numbers are shared across the two repositories; `01…36` are all in use, and `37`/`38` appear on no branch. | +| `term:act-address` | Yes | Not in the registry and on no branch. `term:act` and `term:act-individuation` exist and are distinct. | +| `DDD-address` area | Yes | No `DDD-address-*` file on any branch. New areas are cheap (`spec/claim-format.md` §3). | + +No replacements are needed, so no cross-references are rewritten. + +**A related scope finding.** Upstream `CLAUDE.md` says this repository carries no reference to its +dependents, "the software projection, its apparatus, or its applications", anywhere under +`core/`. The upstream drafts reference the dependent in two ways: + +| Reference | In | Precedent | +|---|---|---| +| Evidence `ref` to "decision-driven-design meta/sessions/2026-09-27-act-address/…" | `DDD-ground-06` | Precedented: `DDD-frame-02`, `DDD-frame-15`, `DDD-dec-30`, `DDD-dec-33` and `DDD-dec-36` cite session records "in the projection repository". | +| "the Phoenix engagement", "the first Phoenix slice" | `DDD-ground-06` `test`; `DDD-dec-37` statement and resolution | No precedent. Phoenix is an application of the software projection. | + +`[PROPOSED]` upstream wording: "the pre-registered independent case (T2b), fixed before the case +exists; its identity and predictions are held in the projection repository's session record". +Phoenix is then named only downstream. Emil to rule. + +## 3. Validation + +The drafts were copied into scratch trees of each repository and run. + +| Validator | Errors | Warnings | +|---|---|---| +| Upstream `validate-claims.py core/claims/` | 0 | 32; baseline 32, none on `DDD-ground-06` | +| Upstream `validate-claims.py core/decisions/ --decisions` | 0 | 0 | +| Downstream `validate-claims.py core/claims/` | 0 | 6; baseline 6, none on `DDD-address-01…05` | +| Downstream `validate-claims.py core/decisions/ --decisions` | 0 | 0 | +| Upstream `validate-core-order.py core/`, term as drafted | **1: E10** "term:act-address has no establishing doc contract" | 67 (+1: W3, `canonical_md` embedded nowhere) | +| Same, with the term established by `core/14` and the bare `address` alias dropped | 0 | 66; baseline 66, and W4 = 0 | + +The validators do not check the `changed: SESSION-SETS-AT-…` placeholders. They are set at +GATE 2 and GATE 3. + +## 4. Rule 1 candidates + +The mechanical proxy flags none of the six drafts. These are semantic candidates for +adjudication. + +| Claim | Joined limbs | `[PROPOSED]` | +|---|---|---| +| `DDD-ground-06` (pre-flagged) | (a) the address is position plus layer path, read at the act-site; (b) the occupant is not a component. The two falsifier limbs map one-to-one onto (a) and (b). | **Keep joined.** Without (b), (a) does not define an address, as the draft's notes argue. Alternative: split (b) as `DDD-ground-07`. | +| `DDD-address-01` (pre-flagged) | (a) a time index sits beside the address; (b) it is causal order, not wall-clock; (c) the "so that" consequence. | **Keep joined.** (c) is a consequence clause, and (a)+(b) define one object. Alternative: split (b) as `DDD-address-06`. | +| `DDD-address-02` | (a) every occurrence is its own act; (b) reuse is a derivation relation, never act identity. | Keep joined: (b) is what (a) excludes. | +| `DDD-address-05` | Two grains | Keep: one proposition about the reading grain. | +| `DDD-address-03`, `-04` | — | No candidate. | + +## 5. The Gate 0 behaviour bundle + +**It has not been filed anywhere.** There is no `term:behaviour`/`behavior` in the registry, and +nothing on any branch of either repository or in any open PR. `DDD-address-05`'s central noun has +no registered definition. Its region carries a working definition, "recurring acts at one address +under the same relative ground", and "relative ground" is also unregistered. + +| Option | Cost | +|---|---| +| **File with the dependency named** `[PROPOSED]` | The claim stands on a working definition. The later behaviour term must be checked against it, which is a successor item. `DDD-address-04`'s `breaks` stays resolvable. | +| Hold | `DDD-address-04`'s `breaks` and `DDD-dec-38`'s statement ("the two behaviour grains … 01 to 05") must be rewritten to 01–04. The claim waits for a bundle with no date. | + +The recommendation is to file with the dependency named. The falsifier ("a grain that adds no +detection over the other") can be evaluated under the working definition. + +## 6. Seam-decay result + +**No canonical home exists.** No claim, term, core document or meta note in either repository +states that a seam spanning k occurrences decays at the conjunction of k persistence +probabilities. The nearest canon is not it: + +| Nearest | What it says | +|---|---| +| `DDD-cost-27` (downstream, projected) | Mechanical assurance decays at the drift rate of the ground it read | +| `DDD-measure-03`, `DDD-measure-14` (upstream, reported) | Seam arithmetic, with no persistence or decay | + +`DDD-address-03`'s statement does not depend on the result; its notes and one limb of its +`breaks` ("the pricing of reuse as seam risk") do. `[PROPOSED]` file `DDD-address-03` with its +note restated ("no canonical home at v5.14.1; nearest `DDD-cost-27`"), keep the `UNVERIFIED` +flag, and carry the seam-decay result as a successor item. + +## 7. Unruled items, presented for ruling and not filed + +| Item | What it says | Observation from this survey | `[PROPOSED]` | +|---|---|---|---| +| **E-1** | The pre-registration mis-stated plain D's failure. Without the layer, the seam decision is ambiguously anchored (it matches parent and children), not unanchored. | Consistent with `core/09` §1: parent and child acts nest, so overlapping positions are expected. The pre-registration stays unedited. | Accept as a correction record. | +| **F-1** | One decision (retry count), three addresses: scaffold, incident, runtime. C would have merged them. | a3 differs from a1/a2 on act-kind alone. a1 and a2 differ only on gateway state, and a1's value is "not read". Under `DDD-ground-02`, "not read" looks like a coverage state (`unknown`), not a position. If so, a1 and a2 may not be separable on ground. `UNVERIFIED — Emil review.` | Hold until the act map is reviewed. | +| **F-2** | The layer carries inherited tolerance; an axis can emulate it but must be remembered. | "Roughly fourteen seconds against 800 ms" cannot be checked: the run records no backoff parameters. The "declared-space limit" citation should be `DDD-ground-05`/`-02` (§1). | Accept with the arithmetic flagged and the citation corrected. | +| **F-3** | Reuse (component fan-out) and replication (decision fan-out) are duals. | Only the component case is claimed (`DDD-address-03`). The decision case is computable from predicates today. | Accept as a finding; decision fan-out as a successor candidate claim. | +| **T2a act map** | Axes: act-kind, target client, gateway state, calling context. Five occurrences. | Two checks: whether "gateway state not read" is a position (F-1), and whether each retry attempt carries its own verdict, which `core/09` requires before the attempts are inner acts (§1). | Emil reviews. | + +## 8. Registry fit + +**`established_by: DDD-ground-06` does not fit.** All 70 registry entries name a `core/` document. +The drift validator enforces this: it reports E10 when no document's `ddd:contract` establishes +the term. + +| Option | Cost | +|---|---| +| **Establish it in `core/14-indexed-determination.md`** `[PROPOSED]` | A short section embedding the `canonical_md`, `act-address` added to the contract's `establishes`, and the intro's "two terms and no more" amended. This is precedented: `core/14` already establishes two `draft` terms, and it comes after every term the definition uses. Tested in scratch: 0 errors, warnings unchanged. It is a prose change to a core document, beyond the prompt's "claim, term, decision". | +| Establish it in another doc | `core/06` (composition) or `core/09` (individuation) would read naturally. Both are earlier in the reading order, so each needs its own backward-edge check. Not tested. | +| Hold the term | File `DDD-ground-06` alone. The address then has no canonical text to embed downstream, and downstream prose must cite the claim. | + +Either way, **drop the bare `address` alias**. It matches ordinary English ("addresses", `core/04` +line 505) and raises a W1 forward-use warning. Keep `act address`. + +## Rulings requested + +1. The weakest point: repair `DDD-ground-06`'s falsifier or region for temporal predicates before + filing, or file as drafted with the tension recorded in notes. +2. Phoenix out of upstream `core/`: adopt the proposed wording, or rule otherwise. +3. The `DDD-ground-05`/`-02` citation correction in `DDD-ground-06` (and F-2). +4. Rule 1: keep `DDD-ground-06` and `DDD-address-01` joined, or split. +5. `DDD-address-05`: file with the dependency named, or hold. +6. `DDD-address-03`: file with the seam-decay reliance as a successor item. +7. E-1, F-1, F-2, F-3 and the T2a act map. +8. The term's home: `core/14`, another doc, or hold. The alias drop. +9. The Danish glossary rows (`handlingsadresse`, `lagsti`): rule the terms, or leave them out of + GATE 2. From ae320f6a95ed8a6db51f8a55d090b7ffd7558618 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:18:29 +0000 Subject: [PATCH 03/11] GATE 1 rulings recorded: act address landing Emil's nine rulings on the survey, transcribed, with where each lands (GATE 2 upstream, GATE 3 downstream, GATE 4 successor items). Basis: DDD-ground-06 (draft); DDD-ground-01; DDD-ground-02; DDD-ground-05; DDD-dec-20 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../gate1-rulings.md | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate1-rulings.md diff --git a/meta/sessions/2026-09-27-act-address-landing/gate1-rulings.md b/meta/sessions/2026-09-27-act-address-landing/gate1-rulings.md new file mode 100644 index 0000000..8c42db8 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate1-rulings.md @@ -0,0 +1,31 @@ +# GATE 1 — rulings (act address landing) + +Principal: Emil. Given 2026-09-28 in reply to `gate1-survey.md`, prefaced "all approved". The +rulings are transcribed here and not paraphrased into more than was said. The numbers follow the +survey's "Rulings requested". + +| # | Subject | Ruling | +|---|---|---| +| 1 | The weakest point | Repair `DDD-ground-06`'s falsifier limb 1 to "address, ground readings and predicates, without the verdict itself". Amend `DDD-address-01` so that occurrence B depends on A iff a state change produced by A is in B's ground reading, with the time index as the resulting order over state changes. Flag the reading/verdict-input line `UNVERIFIED — Emil review`. | +| 2 | Phoenix out of upstream `core/` | Neutral upstream wording: "the first independent application case, pre-registered in the projection's session records". Phoenix is named downstream only. | +| 3 | Citation | Cite `DDD-ground-05` and `DDD-ground-02` for the declared-space limit. | +| 4 | Rule 1 | Keep `DDD-ground-06` and `DDD-address-01` joined. | +| 5 | `DDD-address-05` | File, with the behaviour-term dependency named. | +| 6 | `DDD-address-03` | File, with seam decay as a successor item. Do not cite `DDD-cost-27` as support. | +| 7 | Unruled dry-run items | Accept E-1. Accept F-3 as `[PROPOSED]`. Accept the T2a act map, with a1's gateway axis recorded as not read. Hold F-1 as a T2b test item: an act that never reads an axis a governing predicate uses. Hold F-2, and strike the 14 s figure. | +| 8 | Registry fit | Home `term:act-address` in `core/14`. Drop the bare `address` alias. The small `core/14` prose edit is allowed. | +| 9 | Danish glossary | `handlingsadresse` = act address; `lagsti` = layer path. | + +**Standing instruction for GATE 3.** The predicted firing includes the `DDD-frame-08` W6 from +crossing v5.14.0 and v5.14.1. + +**Instruction.** Proceed to GATE 2. + +## How the rulings land + +| Ruling | Lands at | Where | +|---|---|---| +| 1 (limb 1), 2, 3, 4, 8, 9 | GATE 2 | Upstream: `DDD-ground-06`, `DDD-dec-37`, `core/graph/terms.yaml`, `core/14`, `i18n/ordliste-dansk.md` | +| 1 (`DDD-address-01`), 4, 5, 6 | GATE 3 | Downstream: `DDD-address-01…05`, `DDD-dec-38` | +| 7 | GATE 3 | This directory. The 2026-09-27 session record lands exactly as bundled; the rulings on its findings are recorded here, not written into it. | +| Seam decay (6), F-1 as a T2b item (7), the behaviour term (5) | GATE 4 | Successor items | From fd194dfcd169130b31ea808ded379275454ec078 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:27:57 +0000 Subject: [PATCH 04/11] Land the 2026-09-27 act address session record, as bundled; index both sessions meta/sessions/2026-09-27-act-address/ byte-identical to the bundle (diff -r clean). prereg-act-coordinates.md SHA-256 verified: ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb. The arrival is marked retroactive in the index (DDD-dec-17 precedent). Basis: DDD-dec-20; DDD-dec-17 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../arrival-retroactive.md | 22 +++ .../method-instructions-draft.md | 85 ++++++++++ .../prereg-act-coordinates.md | 147 ++++++++++++++++++ .../results-act-address-dry-run.md | 71 +++++++++ .../2026-09-27-act-address/rulings.md | 31 ++++ meta/sessions/README.md | 2 + 6 files changed, 358 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address/arrival-retroactive.md create mode 100644 meta/sessions/2026-09-27-act-address/method-instructions-draft.md create mode 100644 meta/sessions/2026-09-27-act-address/prereg-act-coordinates.md create mode 100644 meta/sessions/2026-09-27-act-address/results-act-address-dry-run.md create mode 100644 meta/sessions/2026-09-27-act-address/rulings.md diff --git a/meta/sessions/2026-09-27-act-address/arrival-retroactive.md b/meta/sessions/2026-09-27-act-address/arrival-retroactive.md new file mode 100644 index 0000000..fcaf3f5 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address/arrival-retroactive.md @@ -0,0 +1,22 @@ +# Arrival record — retroactive + +**This file was written after the session ran.** It is not a prompt committed before arrival, and it must not be read as one. + +**Session.** 2026-09-27, act address. An interactive chat session in the "Measurement Paper" Claude project. Emil originating and ruling; Claude proposing. + +**Arrival failure.** `meta/sessions/README.md` requires `prompt.md` and `bootstrap.md` to be committed before a session begins work. This session ran in chat and committed nothing first. It is recorded as an arrival failure of the kind `DDD-dec-17` records, not backfilled as if it had arrived properly. + +**What bounds the session's scope instead.** The pre-registration `prereg-act-coordinates.md` was fixed and hashed before any case was run. The hash is SHA-256 `ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb`. It is the discipline boundary for the test. It does not bound the session's earlier design work. + +## What the session did, in order + +1. Drafted custom instructions for a practical-method Claude project (`method-instructions-draft.md`). At Emil's direction, the method opens by mapping and indexing acts. +2. Raised the `[OPEN]` act-coordinate definition, and proposed candidate C and "τ as pinning resolution". +3. Fetched both repositories, which caused two corrections (C-1, C-2). Candidate D was derived from `DDD-ground-01` and the ground-axes holding note rev 18. +4. Ruled by Emil: D under test, a causal time index, a layer path, occurrence uniqueness, the coincidence grain, and the T2 split (`rulings.md`). +5. Fixed and hashed the pre-registration. +6. Ran the dry run on T1 and T2a (`results-act-address-dry-run.md`). One error was recorded against the pre-registration (E-1). Three findings are unruled. + +## Basis read + +`actor-indexed-determination` at `361e88f` (tag v5.14.1). `decision-driven-design` at `cba63ef`. Both cloned 2026-09-27. diff --git a/meta/sessions/2026-09-27-act-address/method-instructions-draft.md b/meta/sessions/2026-09-27-act-address/method-instructions-draft.md new file mode 100644 index 0000000..39bb01a --- /dev/null +++ b/meta/sessions/2026-09-27-act-address/method-instructions-draft.md @@ -0,0 +1,85 @@ +# Project instructions — Decision-Driven Design: the practical method + +## Purpose + +This project turns actor-indexed determination into a practical design method. The method must have clear steps, and every step must show the value it delivers at the moment it is performed. A step whose value cannot be shown to the person doing it is a defect in the method, not a matter of presentation. + +The audience is practitioners: architects, developers, and the people who authorise their work. Theory is used to justify and shape each step. It is not the product. + +## Sources of truth + +The repositories in github.com/mindovermachine-dev are ground truth: `actor-indexed-determination` (actor-general principles), `decision-driven-design` (software projection), `product-cli` (tooling). Fetch the live repo before stating canon or producing file changes. Project files are projections and may lag. Where they disagree with the repo, the repo wins and the disagreement is reported. + +These instructions are standing prose, which the theory itself names a pathological cell: they do not accrue and can create a false appearance of declared ground. So they carry discipline and pointers, not canon. When the ground for a ruling is missing, ask. Do not fill the gap from these instructions. + +## The theory the method must respect + +Use these as constraints on every step. Status matters; do not upgrade it. + +| Principle | What it demands of the method | +|---|---| +| Work decomposes into decisions indexed by ⟨task, ground, acceptance relation, tolerance, arrangement, assurance⟩ | Every step names the decision it touches and the arrangement that resolves it | +| Escape is the only forbidden state | Every step must reduce or expose escaped decisions; escape count is the primary governance signal | +| Demand relocates, it does not disappear | Every step says where demand moved (commitment, seam, check, judgment, accepted risk), never that it vanished. The entropy measure `D = H(V)` applies only where the predicate operationally closes; the theorem is Shannon's, the identification is a modelling claim | +| Source of resolution is separate from assurance mechanism | Allocation records both, independently | +| Commitments attach at outcome, policy, or principal level, and compose | Allocation states the level(s), not an actor species | +| Closure is logical, operational, economic, normative | Assurance design asks which senses close; operational closure is the working sense | +| Stakes set assurance level | Assurance is derived from the worst outcome of a wrong verdict | +| Accountability is relational: attribution, persistent principal, authority, stake, remediation | No executor without an accountable principal; a language model needs an accountable proxy | +| Derivation runs forward only | Acts declare ground requirements, which pull components; never read back from code to acts | +| Fast-ticking ground is read at act time, slow-ticking ground is encoded | Ground declaration records tick rate and provenance | +| Behaviour is recurring acts at the same coordinates under the same relative ground | Post-execution observation uses behaviour change to detect ground shift and escape | +| Corrections are canonical acts | Errors, including Claude's, are recorded with attribution, not silently fixed | + +## The method shape + +Present every method step as a step card: + +| Field | Content | +|---|---| +| Step | Name and position | +| Decision discharged | What this step decides, and at which commitment level | +| Ground in | What must be declared before the step can run, with provenance | +| Act | What is done, and by which arrangement | +| Artefact out | What exists afterwards, preferably graph data, not prose | +| Value made visible | What the practitioner can now see, do, or refuse that they could not before | +| Cost and relocation | What the step costs and where demand went | +| Exit check | The acceptance relation for the step, and whether it closes | +| Principal | Who authorises the step's output | + +The working sequence below is `[PROPOSED]`. Refine it; do not treat it as ruled. + +1. **Map and index acts.** Map the acts the work consists of, forward from the domain and the request, never backward from existing code. Give each act a stable index: its coordinate. The coordinate excludes the actor, so the same coordinate can be occupied by different actors and their behaviour compared. Value: decisions and actors get a place to be anchored, and every later artefact has an address to attach to. +2. **Anchor authority.** Name the top authority for the codebase or domain and the role chain beneath it, anchored to act coordinates. Value: every indexed act has an owner, and acts cannot run when their principal leaves. +3. **Surface decisions.** Anchor each decision to the act coordinate where it is resolved. A decision with no coordinate is flagged as a candidate escape. Value: the backlog becomes visible, and escape becomes countable per act. +4. **Declare ground.** Per decision: provenance (controlled, observed, inferred, institutional, missing) and tick rate. Value: missing ground is found before build, not in production. +5. **Classify closure and set assurance.** Which closure senses hold; assurance from stakes. Value: the practitioner knows where automation is safe and where judgment is load-bearing. +6. **Allocate.** Place an actor or arrangement at each coordinate, with source, commitment level, and assurance mechanism; decompose into seams where it pays. Value: an explicit map of where demand sits and who carries it. +7. **Complete accountability.** Attribution, principal, authority, stake, remediation per allocation. Value: an auditable answer to the compliance question. +8. **Derive forward.** Acts pull ground requirements, which pull components and slices. Value: traceability from act to decision to code, by construction. +9. **Execute and record.** Acts, verdicts, corrections, waivers, each recorded against its coordinate. Value: evidence, not assertion. +10. **Observe and supersede.** Watch behaviour at fixed coordinates; supersede decisions; apply the invalidation policy. Value: escape is detected as it happens, and change is governed rather than absorbed. + +The coordinate definition is `[OPEN]`. The provisional form is decision × declared ground requirements × arrangement, with the actor index varying. The act index in step 1 must stay compatible with whichever ruling lands. Until then, treat the index as a stable identifier whose content fields may be superseded. + +The method is itself a set of decisions. Design it with the method: each step is an act with declared ground, an exit check, and a principal. + +## How to work + +- **Three registers.** Every claim is Ruled, `[PROPOSED]`, or `[OPEN]`. Nothing self-ratifies. Claude proposes; Emil ratifies. +- **Weakest point first.** Every proposal names its weakest point before anything else. +- **Falsifiers.** Every projected claim ships with a falsifier and what it would break. For method steps, the default falsifier is: practitioners perform the step and cannot name the value it gave them. +- **Status vocabulary.** Projected means a clean derivation, unexercised. Reported means exercised evidence. Never fuse the two. +- **Supersession, never rewriting.** Changes to ruled material proceed by supersession with history kept. +- **Gates.** Stop at every gate. Merge nothing and file nothing without a ruling. Predictions precede operation. +- **Prior theories are limiting cases.** OODA, PDCA, RACI, OKRs and similar are the framework with a parameter fixed, not competitors. Say which parameter. +- **Flag additions.** Mark reasoning Emil did not confirm so it can be struck. +- **Worked examples.** Prefer one sustained example carried through every step over many fragments. Test steps against a junior engineer's first contact. + +## Writing conventions + +British spelling. One idea per sentence. Tables for structure, prose for arguments. Use canon terms exactly as registered; do not coin new ones without marking them `[PROPOSED]`. Danish material follows `ordliste-dansk.md` strictly, with no translation choices outside it. + +## Confidentiality + +Never put customer-identifying material into repos, prompts, or canon-facing text. Pseudonymise repository names and abstract domain identifiers structurally. State findings structurally. diff --git a/meta/sessions/2026-09-27-act-address/prereg-act-coordinates.md b/meta/sessions/2026-09-27-act-address/prereg-act-coordinates.md new file mode 100644 index 0000000..1a80425 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address/prereg-act-coordinates.md @@ -0,0 +1,147 @@ +# Pre-registration — the act address ruling + +**Revision 3, 2026-09-27.** Revision 3 supersedes revision 2 with rulings R-4 to R-6 and the reuse finding in §3.3. Revision 1's correction record is carried unchanged in §1. + +**Status.** Fixed 2026-09-27. This document is the discipline boundary. Results go in a separate document and never edit this one. Nothing here is filed. Emil is sole ratifier. + +**Code name.** Phoenix is the first customer engagement (six weeks from October 2026). It is referred to by code name only. + +**Layer.** Actor-general. The ruling belongs upstream in `actor-indexed-determination`. + +**Basis read.** Both repos, cloned 2026-09-27: `DDD-frame-01`, `DDD-floor-02`, `DDD-ground-01` (projected), `core/04` (settled), `core/06`, `core/14`, corpus test results 2026-08-14, ground-axes holding note rev 18 (unratified). + +--- + +## 0. Rulings recorded (Emil, 2026-09-27) + +| # | Ruling | +|---|---| +| R-1 | Correction record accepted. | +| R-2 | The candidate under test is D. A and C are retired from the run, and their predictions stay on record in §5. | +| R-3 | T2 is to be supplied by Emil. | +| R-4 | Time is accepted as a second, causal index beside the address (§3.1). | +| R-5 | The layer path is accepted as part of the address (§3.2). | +| R-7 | Coincidence is defined on the ground-position component. Behaviour is read at two grains: full address within one parent, and ground position across parents (§3.3). | +| R-8 | T2 is split into T2a (retry-count, dry run) and T2b (first Phoenix slice, independent test). | +| R-6 | Every act occurrence is unique, and occurrences may coincide on the same address. Reusing one piece of code for several acts is an implementation optimisation, not the truth about the acts. The act map is therefore a tree of occurrences, and reuse lives in the derivation layer, not in the address space. | + +## 1. Correction record (carried from revision 1) + +| # | What was proposed | What the repo says | Consequence | +|---|---|---|---| +| C-1 | Pinning resolution and behavioural-sameness resolution may both be τ | `core/04` (settled) defines pinning resolution as an actor-side property. τ is task-side. | Withdrawn. Moved to `[OPEN]` in §7. | +| C-2 | Candidate C, the tuple minus the arrangement | The tuple indexes a determination problem, not an act. `DDD-ground-01` anchors decisions to acts through applicability predicates. | C fails one-address-per-act. D was added. | + +Cause: Claude reasoned from the project projection before fetching the repo. + +## 2. Criteria + +| # | Criterion | +|---|---| +| K1 | Each act occurrence has exactly one address | +| K2 | The address excludes the occupant, so behaviour is comparable across actors | +| K3 | The address is the act's ground address, and acts are retrieved by it | +| K4 | No contradiction with `DDD-frame-01` or `DDD-ground-01` | +| K5 | Behaviour stays definable: recurrence must be possible at a fixed address | + +K5 is new in this revision. It is added because of the weakest point of the time extension (§3.1). + +## 3. D and its two extensions + +**D (ruled into the test).** An act's address is its position on declared ground axes, extracted at the act-site. Decisions anchor through applicability predicates. Actors anchor as occupants. + +### 3.1 Time — Emil's extension, `[PROPOSED]` + +> The address plus the distance in time makes a real map. Two acts sharing an address will have two different time addresses if they are dependent. + +**Weakest point.** If time enters the address itself, every act occurrence gets a unique address. Then nothing recurs at a fixed address, and behaviour, which is defined as recurrence at the same address, disappears. That violates K5. + +**Proposed resolution** (Claude, flagged): time is a second index beside the address, not a component of it. The address says *where*. Time says *when, and after what*. Behaviour is read along the time index at a fixed address. This keeps K5 and gives exactly the map Emil describes. + +**Proposed form of the time index** (Claude, flagged): the time index should be causal position, not wall-clock. Dependent acts are ordered by dependency. Independent acts at the same address are concurrent and may share a time position. This is a partial order, which is what an event stream already records. Wall-clock distance is derived from it, not the other way round. + +**Relation to the holding note.** Rev 18 argues that time is weak as a coordinate, because each ground axis ages on its own clock. That argument is about the age of the *ground*. The extension is about the *act's* position in dependency order. These are different objects. `(UNVERIFIED — Emil review: that the two do not conflict.)` + +**What it buys in the method.** +- Invalidation fan-out becomes a query: the acts after a superseded decision in causal order, at addresses its predicate matches. +- As-of decay has an anchor: the distance from the act to the reading of each ground axis. + +### 3.2 Layering — Emil's extension, `[PROPOSED]` + +> By using the composite nature of the model we can use the layering of acts to add a dimension to the address. + +**Proposed form** (Claude, flagged): the address becomes ⟨layer path, ground position⟩. The layer path records the chain of composite acts that the act sits inside. Unlike time, layering is spatial, so recurrence survives: the same sub-act under the same parent recurs at one address. K5 holds. + +**What it buys.** `core/06` holds that decomposition manufactures seam decisions about how the parts coordinate. Without a layer, a seam decision has no act of its own to anchor to, so under D it would be flagged as a candidate escape. With a layer, it anchors at the parent act. The measure paper's seam, `I(V;S)`, then has an address. + +**Shared sub-acts — ruled (R-6).** The act map stays a tree of unique occurrences. Where two occurrences look like "the same act", that sameness is coincidence on an address, or reuse in the code. Neither makes them one act. + +**Second weak point.** The layer path depends on the decomposition, which is itself a decision (`S`). The same work decomposed two ways gets two sets of addresses. Proposed handling: the addresses are relative to a ruled decomposition, and re-decomposition proceeds by supersession. + +### 3.3 Reuse as a mechanism — consequence of R-6 + +**Emil's observation.** One act often demands a change to a single function, and that change incurs sudden changes in hundreds of other places. The mechanism is exactly the reuse that R-6 moves out of the address space. + +**Development** (Claude, flagged). Derivation runs forward: acts declare ground requirements, which pull components. Reuse is many occurrences pulling one component. That component is a seam spanning every occurrence that pulled it. By the ruled seam result, such a seam decays at the conjunction of k persistence probabilities. A function shared by a hundred acts is therefore a very fragile seam, and the theory already predicts that. + +When one act's decision changes the shared component, the decision is anchored at that one act's address. Its effect lands at every other occurrence that pulled the component. No applicability predicate covers those other occurrences, so the effect is an escaped decision crossing act addresses. That is the channel `theory.md` says behaviour change detects. + +**What it buys in the method.** +- The fan-out of a component change becomes a forward query: the occurrences that pulled the component. It is no longer discovered in production. +- The query result can be shown to the person changing the component before they change it. +- Reuse becomes a priced design choice. It amortises demand but concentrates seam risk, and the map shows both. + +**The grain question.** R-5 puts the layer path in the address. So two occurrences under different parents have different full addresses, even when their ground positions are equal. "Coincide on the same address" then needs a grain. + +`[PROPOSED]` (Claude): coincidence is defined on the ground-position component. Behaviour can then be read at two grains: +- At full address, within one parent, which shows how an act behaves in its composite. +- At ground position, across parents, which is where the hundreds-of-changes effect appears as simultaneous behaviour change. + +`[OPEN]` for ruling. + +## 4. Cases + +| Case | Content | +|---|---| +| T1 | Date validator, `(M,D)` over `M ∈ {1..4}`, `D ∈ {1..31}`, three occupants, and decompositions A (by month) and B (by day) | +| T2a | `[PROPOSED]` The retry-count worked example in `projections/tracks/01-determination.md`: a retry policy reused across clients, with a model proposing the count when scaffolding. It can be run now as a dry run. Its weakness is that it was written inside the framework, so it may fit by construction. | +| T2b | The first slice of Phoenix, pseudonymised. It does not exist yet, and its act map is itself produced by method step 1. Its predictions are fixed here before the slice exists. That makes it the independent test. | +| T3 | Architecture sign-off for the T2 slice: an open-predicate act | + +## 5. Predictions + +Each prediction is marked either analytic (follows from the definition) or empirical (can surprise). + +**D with both extensions:** + +| | T1 | T2 | T3 | +|---|---|---|---| +| Address | One address at the parent layer, with three occupants. *Analytic.* | Every act occurrence gets exactly one address. *Empirical.* | The address is declarable but low-information. *Empirical.* | +| Layer | The day-29 split in decomposition B anchors at the parent layer. It would be an unanchored escape without the layer. *Analytic.* | At least one seam decision would be unanchored under plain D and is anchored by the layer. At least one component is pulled by two or more occurrences, and its fan-out is computable forward from the derivation record. *Empirical.* | Sign-off sits at the slice's parent layer, above the acts it approves. *Empirical.* | +| Time | Not exercised. | At least two dependent acts share an address and are separated only by time. *Empirical.* | Successive sign-offs share one address and are distinguished by time. A ground shift appears as a behaviour change along time only if readings are recorded. *Empirical.* | + +**Retired candidates, on record:** +- A: fails K2 by construction. +- C: fails K1 on T2 wherever an act resolves two or more decisions. + +## 6. Falsifiers + +| Falsifier | What it breaks | +|---|---| +| An act whose governing set cannot be computed from its address plus the decision predicates, without verdict content | The address/readings split | +| Two occupants at one address that must declare different ground axes | K2 | +| The same act landing on two addresses through mapping choice alone, within one ruled decomposition | K1 | +| Two dependent acts whose order cannot be recovered from the record | The time index as causal position | +| A seam decision that anchors at no layer even with the layer path | The layering extension | +| A component change whose affected occurrences cannot be computed forward from the derivation record | §3.3; reuse would not be recoverable from the map | +| Two occurrences at the same ground position whose behaviour is incomparable across parents | The ground-position grain in §3.3 | + +## 7. Open, not tested here + +- The relation between pinning resolution (actor-side) and τ (task-side) in fixing the grain of behaviour. +- The term for the address. `[PROPOSED]` "act address", with "time index" and "layer path" for the two extensions. Registry entries are needed. +- The declared-space limit of `DDD-ground-01`, which is carried forward. + +## 8. Rulings needed before the run + +None. T2's predictions in §5 apply to both T2a and T2b. diff --git a/meta/sessions/2026-09-27-act-address/results-act-address-dry-run.md b/meta/sessions/2026-09-27-act-address/results-act-address-dry-run.md new file mode 100644 index 0000000..4c2cff6 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address/results-act-address-dry-run.md @@ -0,0 +1,71 @@ +# Results — act address dry run (T1, T2a) + +**Pre-registration.** `prereg-act-coordinates.md`, revision 3, fixed 2026-09-27. +The file was hashed immediately after fixing, and this run is scored against that hashed version. +SHA-256: `ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb`. + +**Status.** Dry run. Unratified. The act maps below were built by Claude alone. Nothing is filed, and Emil rules. + +**Scope.** This is a dry run: T1 is analytic, and T2a was written inside the framework. It tests the instrument, not the claim. T2b (Phoenix) is the independent test. + +**Weakest point of this run.** The T2a result depends on which ground axes Claude declared, gateway state in particular. A different mapper could produce a different address set. The act map in §2 is therefore the first thing to check. + +--- + +## 1. T1 — date validator + +| Prediction | Verdict | Note | +|---|---|---| +| One address at the parent layer, three occupants | **Holds** | Analytic | +| Day-29 split in B anchors at the parent layer; unanchored without the layer | **Holds, with a correction to the prediction** | See E-1 | +| Time | Not exercised | As pre-registered | + +**E-1 — error in the pre-registration, attributed to Claude.** The prediction said that under plain D the seam decision would be *unanchored*. It is not unanchored. + +Under plain D, the parent act (validate the date) and the child acts (the `D ≤ 28` part and the `D ≥ 29` part) sit on overlapping positions. So the split decision's predicate matches the children as well as the parent. The decision is therefore **ambiguously anchored**: it lands in the governing set of acts that did not make it. The layer path removes that ambiguity by anchoring it at the parent only. + +The extension is still needed. The failure mode it prevents is ambiguity, not absence. The pre-registration is not edited; this record stands instead. + +## 2. T2a — retry-count + +**Act map** (Claude, for review). Ground axes declared: act-kind, target client, gateway state, calling context. + +| Occurrence | Occupant | Layer path | Ground position | +|---|---|---|---| +| a1 | LLM | delivery pipeline / scaffold client / configure resilience | configure-retry, payment client, gateway state not read | +| a2 | on-call engineer | operations / incident / reconfigure resilience | configure-retry, payment client, gateway degraded | +| a3.n | program | runtime / checkout request / outbound call / retry attempt *n* | execute-retry, payment client, transient error | + +| Prediction | Verdict | Note | +|---|---|---| +| Every act occurrence gets exactly one address | **Holds** | Five occurrences (a1, a2, and three attempts), five addresses | +| A seam decision anchored by the layer, not by plain D | **Holds, same correction as E-1** | See F-2 | +| A component pulled by two or more occurrences, fan-out computable forward | **Indeterminate** | See F-3 | +| Dependent acts sharing an address, separated only by time | **Holds** | Retry attempts 1 to 3 of one call share an address. Each depends on the previous one failing. | +| T3 | Not exercised | T2a has no sign-off act | + +No falsifier in §6 of the pre-registration fired. + +## 3. Findings, all flagged `(UNVERIFIED — Emil review)` + +**F-1 — One decision, three addresses.** The track says that all three actors resolve the same axis. Under D, they resolve the same *decision* at three different *addresses*, because they act on different ground: at scaffold time, during an incident, and at runtime. + +Candidate C would have merged these into one coordinate with three occupants. It would then have compared the behaviour of acts that do not share ground. D compares behaviour across actors only where occupants actually swap at one address, for example if the LLM took over incident reconfiguration. + +This is the first case where D and C disagree on real material. D's answer is the one consistent with K3. + +**F-2 — The layer carries inherited tolerance.** The seam decision is how the retry policy fits the checkout latency budget. Three retries hold a request for roughly fourteen seconds against a budget of 800 ms. The same retry act under a batch-job parent would face a different tolerance. The layer path is what distinguishes the two. + +Plain D can emulate this with a declared calling-context axis, and this run did declare one. The difference is that the layer is derived from composition, while the axis must be remembered and declared. An undeclared context axis falls under `DDD-ground-01`'s declared-space limit. The layer does not. + +**F-3 — Two kinds of fan-out.** There are two, and T2a shows both: +- **Component fan-out.** `HandleTransientHttpError` is a library component pulled by every client occurrence. A version change reclassifies transient errors for all of them. Its fan-out is computable only from a derivation record, which T2a lacks, so the prediction is indeterminate here. +- **Decision fan-out.** The LLM *copies* the retry policy into each new client rather than sharing it. When the retry-count decision changes, the affected set is every occurrence its applicability predicate matches, not a component's pullers. This fan-out is computable today from predicates alone. + +Replication and reuse are duals. Reuse concentrates seam risk in a component. Replication spreads one decision across many occurrences. The method should query both. + +## 4. Rulings requested + +1. Accept E-1 as a correction record. +2. Review the T2a act map, specifically the axis declarations behind F-1. +3. Rule F-1 to F-3: accept as findings, `[PROPOSED]`, or strike. diff --git a/meta/sessions/2026-09-27-act-address/rulings.md b/meta/sessions/2026-09-27-act-address/rulings.md new file mode 100644 index 0000000..955bd5b --- /dev/null +++ b/meta/sessions/2026-09-27-act-address/rulings.md @@ -0,0 +1,31 @@ +# Rulings — act address session, 2026-09-27 + +Principal: Emil. Each ruling was given in session and is transcribed here, not paraphrased into more than was said. + +| # | Ruling | Emil's words, where given | +|---|---|---| +| R-1 | Correction record C-1, C-2 accepted | "Accepted" | +| R-2 | Candidate D is the candidate under test; A and C retired from the run | "D" | +| R-3 | T2 to be supplied by Emil | "I'll find it" | +| R-4 | Time is a second, causal index beside the address | "Accepted" | +| R-5 | Layer path is part of the address | "Accepted" | +| R-6 | Every act occurrence is unique; occurrences may coincide on an address; code reuse is an optimisation, not the truth about acts | "All are unique and coincide on the same address, our choice to reuse the same act in the code is an optimization not the truth" | +| R-7 | Coincidence is defined on ground position; behaviour is read at two grains | "Agreed" | +| R-8 | T2 split into T2a (retry-count dry run) and T2b (first Phoenix slice) | "Yes" | + +## Originating statements (Emil), for attribution + +- The method starts by mapping acts and indexing them, so decisions and actors have a place to be anchored. +- The address plus the distance in time makes a real map. Two acts sharing an address have different time addresses if they are dependent. +- The composite nature of the model lets the layering of acts add a dimension to the address. +- One act often demands a change to a single function, incurring sudden changes in hundreds of others, because of reuse. + +## Not ruled — carried to the landing session's GATE 1 + +- E-1: the correction to the pre-registration's layer prediction (ambiguous anchoring, not absence). +- F-1 to F-3 in the dry-run results. +- The T2a act map's axis declarations, on which F-1 depends. + +## Code name + +Phoenix is the first customer engagement (six weeks from October 2026). No customer-identifying material appears in this record or may appear in any file derived from it. diff --git a/meta/sessions/README.md b/meta/sessions/README.md index f1f9f93..f4dd943 100644 --- a/meta/sessions/README.md +++ b/meta/sessions/README.md @@ -38,3 +38,5 @@ session's later work exceeds the committed prompt, the excess is visible as exce | `2026-08-31-ground-migration-exec/` | Interactive canon curation with an execution phase — the ground migration executed upstream; the two-W6 firing predicted for the next pin advance (G1…G6) | | `2026-09-01-primer/` | Interactive drafting — the primer at `projections/primer/`, generated where it can be, pinned always (gates 1–4) | | `2026-09-02-pre-transfer/` | Interactive canon curation — publication readiness before transfer: the accountability arity, the front pages, the pin advance to `v5.13.0`, the readiness report (I-1…I-4) | +| `2026-09-27-act-address/` | Interactive design with a pre-registered dry run — the act address: candidate D under test, the layer path and causal time index, occurrence uniqueness (R-1…R-8). **Arrival retroactive**: no prompt was committed before the session ran (`arrival-retroactive.md`, the `DDD-dec-17` precedent); the hashed pre-registration bounds the test, not the design work | +| `2026-09-27-act-address-landing/` | Interactive canon curation — lands the act address session in both repositories: `DDD-ground-06`, `term:act-address` and `DDD-dec-37` upstream; `DDD-address-01…05` and `DDD-dec-38` here; the pin advance staged with its firing predicted (gates 0–4) | From 76d644e6ff77624a3066a5891bbfd070ec5eb564 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:27:57 +0000 Subject: [PATCH 05/11] DDD-address-01..05, DDD-dec-38: the act address's diachronic companions file As ruled at the landing session's GATE 1 and GATE 2 (Emil, 2026-09-28): - DDD-address-01: dependency defined over ground readings (B depends on A iff a state change produced by A is in B's reading); the index is the resulting order over state changes; reading/verdict-input line flagged UNVERIFIED; kept joined under rule 1. - DDD-address-02, -04: as drafted; -04 notes F-2 held, figure struck. - DDD-address-03: seam decay carried as a successor item; no support cited in its place. - DDD-address-05: filed with the behaviour-term dependency named. - DDD-dec-38: the filing and the advance (three pins added). - gate2-rulings.md: GATE 2 rulings and the accumulated T2b test items. Validators: claims 31 / 6 warnings (baseline 6); decisions 24 clean. Basis: DDD-ground-06; DDD-dec-37; DDD-ground-01; DDD-ground-02; DDD-ground-05; DDD-dec-09; DDD-agent-01 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- core/claims/DDD-address-01.yaml | 52 ++++++++++++++++ core/claims/DDD-address-02.yaml | 23 ++++++++ core/claims/DDD-address-03.yaml | 29 +++++++++ core/claims/DDD-address-04.yaml | 23 ++++++++ core/claims/DDD-address-05.yaml | 25 ++++++++ core/decisions/DDD-dec-38.yaml | 59 +++++++++++++++++++ .../gate2-rulings.md | 26 ++++++++ 7 files changed, 237 insertions(+) create mode 100644 core/claims/DDD-address-01.yaml create mode 100644 core/claims/DDD-address-02.yaml create mode 100644 core/claims/DDD-address-03.yaml create mode 100644 core/claims/DDD-address-04.yaml create mode 100644 core/claims/DDD-address-05.yaml create mode 100644 core/decisions/DDD-dec-38.yaml create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate2-rulings.md diff --git a/core/claims/DDD-address-01.yaml b/core/claims/DDD-address-01.yaml new file mode 100644 index 0000000..8bc4ea6 --- /dev/null +++ b/core/claims/DDD-address-01.yaml @@ -0,0 +1,52 @@ +format: 1 +id: DDD-address-01 +kind: conceptual +statement: | + Act occurrences carry a time index beside their address, given by causal dependency — occurrence B depends on occurrence A iff a state change produced by A is in B's ground reading — so that the index is the resulting order over state changes rather than wall-clock, dependent occurrences at one address are distinct in time, and independent ones may be concurrent. +status: projected +region: | + Diachronic — orders occurrences across acts, so it files with the projection (DDD-dec-09's + charter). Presupposes upstream DDD-ground-06 (pinned at the release that carries it). The + index is kept out of the address because an address containing time would make every + occurrence unique and leave nothing to recur at, dissolving behaviour (pre-registration + criterion K5). Dependency is read off ground readings, so it inherits their declared-space + limit (DDD-ground-05, DDD-ground-02): a state change that reaches B through ground nobody + declared does not order B after A. +evidence: + - kind: observation + ref: "meta/sessions/2026-09-27-act-address/results-act-address-dry-run.md — T2a" + note: | + Dry run: retry attempts 1 to 3 of one call share an address and are ordered by dependency + alone — each depends on the previous one failing. Read under the amended definition, the + previous attempt's failure is in each attempt's ground reading; the dry run predates the + amendment and did not record readings. Written inside the framework; instrument check, not + evidence for the claim. +falsifier: | + Two dependent occurrences whose order cannot be recovered from the state changes in their ground readings, or a behaviour-change detection that needs a wall-clock distinction the causal order cannot supply. +test: | + T2b (first Phoenix slice): at least two dependent occurrences share an address and are separated only by the time index, per the fixed pre-registration. +breaks: | + Invalidation fan-out as a forward query (the acts after a superseded decision in causal order), and as-of decay's anchor at the act. +owner: none +changed: 2026-09-28, act address landing session (GATE 3, on the GATE 1 rulings) +notes: | + Emil originated the extension ("address plus distance in time makes a real map"); ruled R-4, + 2026-09-27. The causal form, and keeping the index outside the address, were Claude's + proposals, accepted in the ruling. + + Amended at the landing session's GATE 1 (Emil, ruling 1, 2026-09-28). The draft left + "dependency" undefined. It is now defined over ground readings: B depends on A iff a state + change produced by A is in B's ground reading, and the time index is the resulting order over + state changes. This is the same line upstream DDD-ground-06's repaired falsifier draws, so the + address, the ground readings and the time index are read from one record. + UNVERIFIED — Emil review: the reading/verdict-input line — that a dependency always passes + through a ground reading and never through a verdict alone. Verdict-triggered decisions + (escalation rules) are the pressure case, carried as a T2b test item: they anchor at the + following act, whose reading contains the verdict (GATE 2 ruling). + + Rule 1 candidate, adjudicated: kept joined (GATE 1 ruling 4). The definition of dependency and + the index it induces are one object; the "so that" clauses are consequences. + + UNVERIFIED — Emil review: that this does not conflict with ground-axes holding note rev 18's + argument that time is weak as a coordinate. That argument concerns the age of ground + readings; this claim concerns an act's position in dependency order. diff --git a/core/claims/DDD-address-02.yaml b/core/claims/DDD-address-02.yaml new file mode 100644 index 0000000..6fd5753 --- /dev/null +++ b/core/claims/DDD-address-02.yaml @@ -0,0 +1,23 @@ +format: 1 +id: DDD-address-02 +kind: normative +statement: | + Every act occurrence is its own act, and reuse of code across occurrences is a derivation-layer relation — many occurrences pulling one component — never an identity between acts. +status: projected +region: | + Diachronic — relates occurrences across acts. Governs the act map (a tree of occurrences) and + places reuse in the derivation record, consistent with forward-only derivation: acts pull + components, and components never define acts. +evidence: [] +falsifier: | + A governance question answerable only by treating a reused component as a single act — a case where the occurrence map, with reuse in the derivation layer, cannot state what the identity reading states. +test: | + Counterexample search in T2b: every reused component in the first Phoenix slice is represented as derivation edges from distinct occurrences without loss of any governing decision. +breaks: | + DDD-address-03 and the forward fan-out query; the method's refusal to read acts back from code. +owner: none +changed: 2026-09-28, act address landing session (GATE 3, on the GATE 1 rulings) +notes: | + Emil's ruling R-6, 2026-09-27, in his words: "our choice to reuse the same act in the code is an + optimization not the truth." Filed as a normative claim: it is a governing choice about + representation, and its test is utility. diff --git a/core/claims/DDD-address-03.yaml b/core/claims/DDD-address-03.yaml new file mode 100644 index 0000000..562e9e8 --- /dev/null +++ b/core/claims/DDD-address-03.yaml @@ -0,0 +1,29 @@ +format: 1 +id: DDD-address-03 +kind: empirical +statement: | + A change to a component pulled by several act occurrences is an escaped decision at every pulling occurrence that the changing decision's applicability predicate does not cover. +status: projected +region: | + Diachronic, over the derivation record. Where occurrences replicate a decision instead of + sharing a component, the fan-out is the decision's predicate match set, not a component's pullers + (dry-run finding F-3, accepted as [PROPOSED] at the landing session's GATE 1). Only the + component case is claimed here. +evidence: [] +falsifier: | + Derivation records in which off-predicate pulling occurrences of changed components show no more behaviour change or incident than occurrences that did not pull the component. +test: | + Phoenix: compute each component change's off-predicate fan-out forward from the derivation record, and compare behaviour change at those occurrences against a matched non-pulling set. +breaks: | + The rationale for showing a component's fan-out to the person changing it before the change, and the pricing of reuse as seam risk. +owner: none +changed: 2026-09-28, act address landing session (GATE 3, on the GATE 1 rulings) +notes: | + Emil's observation, 2026-09-27: one act often demands a change to a single function, incurring + sudden changes in hundreds of others. The seam reading is Claude's, flagged: a component shared + by k occurrences is a seam spanning k, decaying at the conjunction of k persistence + probabilities. UNVERIFIED — the seam-decay result has no canonical home: the landing session's + GATE 1 survey found no claim, term, core document or meta note stating it in either repository + at 361e88f / cba63ef. Filed with the reliance carried as a successor item (GATE 1 ruling 6). + Only the notes and the "pricing of reuse as seam risk" limb of breaks lean on it; the statement + does not. No other claim is cited as support for it. diff --git a/core/claims/DDD-address-04.yaml b/core/claims/DDD-address-04.yaml new file mode 100644 index 0000000..c172ad6 --- /dev/null +++ b/core/claims/DDD-address-04.yaml @@ -0,0 +1,23 @@ +format: 1 +id: DDD-address-04 +kind: conceptual +statement: | + Two act occurrences coincide when their ground positions are equal, whatever their layer paths. +status: projected +region: | + Diachronic — compares occurrences. Needed because the layer path is part of the address + (DDD-ground-06), so occurrences under different parents never share a full address. +evidence: [] +falsifier: | + Two occurrences at one ground position under different parents whose comparison misleads — behaviour that differs only because the parents impose different tolerance, read as a ground shift. +test: | + T2b: every cross-parent coincidence in the first Phoenix slice is checked for inherited-tolerance differences (dry-run finding F-2). +breaks: | + DDD-address-05's cross-parent grain. +owner: none +changed: 2026-09-28, act address landing session (GATE 3, on the GATE 1 rulings) +notes: | + Ruled R-7, 2026-09-27, on Claude's proposal. The falsifier names the known risk: dry-run finding + F-2, that the layer carries inherited tolerance, so cross-parent coincidence may compare unlike + acts. F-2 is held, not accepted (landing session GATE 1 ruling 7), and its latency figure is + struck; the test checks for the risk rather than presupposing it. diff --git a/core/claims/DDD-address-05.yaml b/core/claims/DDD-address-05.yaml new file mode 100644 index 0000000..66a0420 --- /dev/null +++ b/core/claims/DDD-address-05.yaml @@ -0,0 +1,25 @@ +format: 1 +id: DDD-address-05 +kind: conceptual +statement: | + Behaviour is read at two grains: at full address within one parent, and at ground position across parents. +status: projected +region: | + Diachronic. Depends on a registered behaviour term, which the Gate 0 bundle queues; until that + term lands, "behaviour" here carries the working definition (recurring acts at one address + under the same relative ground) and nothing more. +evidence: [] +falsifier: | + A shared-component change that alters behaviour across parents but is invisible at both grains, or a grain that adds no detection over the other on the Phoenix record. +test: | + Phoenix: component changes are detected at the ground-position grain as simultaneous behaviour change across parents. +breaks: | + Behaviour change as the detection channel for DDD-address-03's escapes. +owner: none +changed: 2026-09-28, act address landing session (GATE 3, on the GATE 1 rulings) +notes: | + Ruled R-7, 2026-09-27. Filed with the dependency named (landing session GATE 1 ruling 5): the + Gate 0 behaviour bundle had not been filed in either repository at 361e88f / cba63ef, and no + behaviour term is registered. "Behaviour" here carries only the working definition in region; + "relative ground" is likewise unregistered. When the behaviour term lands, this claim is + checked against it (successor item). diff --git a/core/decisions/DDD-dec-38.yaml b/core/decisions/DDD-dec-38.yaml new file mode 100644 index 0000000..a51c5fd --- /dev/null +++ b/core/decisions/DDD-dec-38.yaml @@ -0,0 +1,59 @@ +format: 1 +id: DDD-dec-38 +kind: decision +statement: | + The projection files the act address ruling's diachronic companions — the causal time index, occurrence uniqueness, shared-component escape, the coincidence grain and the two behaviour grains (DDD-address-01 to 05) — as projected claims resting on upstream DDD-ground-06, and advances the upstream pin to the release that carries it, with DDD-ground-06, term:act-address and DDD-ground-01 pinned. +principal: Emil +made: 2026-09-27, act address session; filed 2026-09-28 at the act address landing session (GATE 3, on the GATE 1 and GATE 2 rulings) +resolution: | + The upstream ruling is DDD-dec-37. This decision records the downstream half. The address + itself is synchronic and lives upstream. Everything that compares or orders occurrences + persists between acts and lives here, per DDD-dec-09 and meta/repo-topology.md, the same split + the seam took. + + ## What files + + - DDD-address-01 — the causal time index, amended at GATE 1 (ruling 1): B depends on A iff a + state change produced by A is in B's ground reading; the index is the resulting order over + state changes. The reading/verdict-input line is flagged UNVERIFIED — Emil review. + - DDD-address-02 — every occurrence is its own act; reuse is a derivation relation. + - DDD-address-03 — shared-component escape. The seam-decay reading in its notes has no + canonical home and is carried as a successor item (ruling 6). + - DDD-address-04 — coincidence on ground position. Its known risk is dry-run finding F-2, + which is held (ruling 7). + - DDD-address-05 — the two behaviour grains, filed with the unregistered behaviour term named + as a dependency (ruling 5). + + DDD-address-01 and DDD-ground-06 were kept joined under rule 1 (ruling 4). + + ## The pin advance + + Staged against the upstream landing branch and bumped to the tag only on Emil's acceptance of + the upstream PR, per the DDD-dec-10/16/18/25/28 pattern. The predicted firing was committed + before the ref moved (meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md). The + advance runs from v5.13.0, so it crosses v5.14.0 and v5.14.1 as well: it carries v5.14.0's + published W6 on DDD-frame-08, and nothing else from the existing pins. + + Three pins are added. DDD-ground-06 and term:act-address are the basis of the five claims and + do not exist before the release that carries them, so they could not be pinned earlier. + DDD-ground-01 is this decision's basis and was not pinned: a basis cited without a pin can move + silently (DDD-agent-01). DDD-dec-37 is not pinned, because the checker indexes upstream claims + and terms, not decisions. + + ## Rulings on the dry run (GATE 1, ruling 7) + + E-1 is accepted as a correction record. F-3 is accepted as [PROPOSED]. The T2a act map is + accepted, with a1's gateway axis recorded as not read. F-1 is held as a T2b test item: an act + that never reads an axis a governing predicate uses. F-2 is held and its 14 s figure is struck. + The session record lands exactly as bundled; the rulings live in the landing session's + gate1-rulings.md, not in the record they rule on. +basedOn: + - DDD-ground-06 + - DDD-dec-37 + - DDD-ground-01 +notes: | + New claim area `address`. Areas are cheap and renumbering is forbidden (spec/claim-format.md + §3). The area name was confirmed free at the landing session's GATE 1. + + Phoenix is the code name of the first independent application case. It is named here and in + the claims' tests. Upstream names the case neutrally (GATE 1 ruling 2). diff --git a/meta/sessions/2026-09-27-act-address-landing/gate2-rulings.md b/meta/sessions/2026-09-27-act-address-landing/gate2-rulings.md new file mode 100644 index 0000000..5f55af6 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate2-rulings.md @@ -0,0 +1,26 @@ +# GATE 2 — rulings (act address landing) + +Principal: Emil. Given 2026-09-28 in reply to the GATE 2 report on upstream PR #24. + +| # | Subject | Ruling | +|---|---|---| +| 1 | Ruling 2 applied beyond the test wording (`breaks`, region) | Confirmed | +| 2 | README index row for `core/14` | Confirmed | +| 3 | Narrowing of the `term:act` flag in `DDD-ground-06` | Struck. The general individuation/location flag is restored. The retry note stays as an addition. The `core/09` §1 citation for the layer relation stays. | +| 4 | Danish notes on the two glossary rows | [keep / strike] after Emil's read. **Pending.** | +| 5 | T2b test items | Add one: verdict-triggered decisions (escalation rules) anchor at the following act, whose reading contains the verdict. | +| 6 | PR #24 | Watch for CI and report. Do not reply to reviews or push without a ruling. | +| 7 | GATE 3 | Proceed against the open upstream branch. Stage the pin advance; do not bump. | + +**Applied.** Ruling 3 is upstream commit `cc0abf8` on PR #24; it changes notes only, so the claim's +instrumented digest is unchanged. Ruling 6: the session is subscribed to PR #24. + +## T2b test items, accumulated + +The pre-registration is fixed and is not edited. These items are recorded for the T2b +pre-registration, which is written before the case exists. + +| Item | Source | What T2b must contain or check | +|---|---|---| +| F-1 | GATE 1 ruling 7 | An act that never reads an axis a governing predicate uses | +| Verdict-triggered decisions | GATE 2 ruling 5 | Escalation rules and other decisions triggered by a verdict anchor at the following act, whose reading contains the verdict. This is the pressure case for the reading/verdict-input line in `DDD-ground-06`'s falsifier and `DDD-address-01`'s dependency. | From ef0d444ab89f566f115d33be2a012a6819a9f6a8 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:27:57 +0000 Subject: [PATCH 06/11] GATE 3 prediction: the pin advance v5.13.0 -> v5.15.0, before the ref moves E12 0, E13 0, W5 0, W6 exactly 1 (DDD-frame-08 cf73b307 -> ef5d5faf, carried from v5.14.0), W7 1 unchanged; three pins added (DDD-ground-06, term:act-address, DDD-ground-01). Computed with the checker's own loader and digest against v5.13.0 and upstream cc0abf8. Basis: DDD-dec-38; DDD-dec-22; DDD-agent-01 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../gate3-prediction.md | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md diff --git a/meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md b/meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md new file mode 100644 index 0000000..145131d --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md @@ -0,0 +1,72 @@ +# GATE 3 — predicted firing of the pin advance (act address landing) + +**Written and committed before the ref moves.** This file is the prediction. The staging commit, +and later the bump at GATE 4, are the operation. Verification at GATE 4 compares the observed +firing with this file limb by limb, and records any divergence rather than reconciling it. + +## The advance + +| | Value | +|---|---| +| From | `v5.13.0` (the pin at `cba63ef`) | +| Staged at | upstream branch `claude/act-address-landing-bla6io`, head `cc0abf8` (PR #24) | +| To, at GATE 4 | tag `v5.15.0`, cut when PR #24 merges | +| Releases crossed | v5.14.0, v5.14.1, v5.15.0 | +| Pins before | 71 | +| Pins added | 3 | +| Pins after | 74 | + +## How it was computed + +Each pin's upstream object was loaded at `v5.13.0` and at `cc0abf8` with the checker's own +`load_upstream_graph`, and hashed with its own `pinned_content_digest` (statement, region, +`canonical_md`). Every pin was compared on existence (E12), status (W5) and digest (W6). Upstream +objects that changed between the two refs without being pinned were listed separately. They fire +nothing, because only pinned ids are instrumented. + +## Prediction, limb by limb + +| Limb | Predicted | Why | +|---|---|---| +| **E12** | **0** | All 71 existing pins exist at `cc0abf8`. The 3 added pins exist there and not at `v5.13.0`, so they are added only with the ref advance. | +| **E13** | **0** | No document in this repository embeds a pinned upstream id whose `canonical_md` moved. None embeds `term:act-address`. | +| **W5** | **0** | No pinned status moves. `DDD-measure-11` and `DDD-measure-13` were demoted at v5.14.0, but they are not pinned. | +| **W6** | **exactly 1**: `DDD-frame-08`, `sha256:cf73b307…` → `sha256:ef5d5faf…` | Its statement was re-scoped at v5.14.0 while its status held. This is v5.14.0's published prediction, carried forward because the pin never crossed v5.14. Full new digest: `sha256:ef5d5fafedb588994141c8f4df504c7589ab3ea7b5257f3ea97f37ba3db07ff7`. | +| **W7** | **1, unchanged** | The one standing shadowed id. `term:act-address` shadows nothing here. | + +Summary line expected from the checker, with the ref advanced and `DDD-frame-08` not yet +re-instrumented: **74 pins resolved, 0 basis-loss, 1 content-drift, 1 shadowed id**. After +re-instrumenting `DDD-frame-08` at GATE 4: **74 pins, 0 basis-loss, 0 content-drift, 1 shadowed +id**. + +## Pins added + +| Id | `status_at_pin` | `content_hash` at `cc0abf8` | Why | +|---|---|---|---| +| `DDD-ground-06` | projected | `sha256:87a6adab30551a4f464cdc1020ae0155f22d6a86d3baac30917894a1cb3b6609` | Basis of `DDD-address-01…05` and `DDD-dec-38` | +| `term:act-address` | draft | `sha256:d66ddee2ca634dc8ab84d96798b5ca0af36403551c826fb3affd86758f1df00c` | The term the five claims presuppose | +| `DDD-ground-01` | projected | `sha256:eb4679f9878a220b8a4c39e785b1d3cd9f6ad7eb717a02d1eff6ff97ef359d93` | `DDD-dec-38`'s basis, unpinned until now (`DDD-agent-01`) | + +`DDD-dec-37` is not pinned: the checker indexes upstream claims and terms, not decisions. + +## Unpinned upstream movement between the refs (fires nothing) + +| Id | Movement | +|---|---| +| `DDD-measure-11`, `DDD-measure-13` | Demoted `reported` → `projected` at v5.14.0 | +| `DDD-ground-06`, `term:act-address` | Added at v5.15.0 (and pinned by this advance) | + +## Conditions that void part of this prediction + +- **PR #24 changes before merge.** The added pins' digests are taken at `cc0abf8`. If a ruled + change to PR #24 moves `DDD-ground-06`'s statement or region, or `term:act-address`'s + `canonical_md`, those two hashes are re-stated in a new commit to this directory before the + bump. Notes-only changes do not move them. +- **Another release lands first.** If any upstream release is cut between `v5.14.1` and the tag + this advance targets, the prediction is re-run against it before the bump. + +## What staging is expected to show + +The staging run resolves against the branch, not the tag, so it previews the firing but does not +verify it. It should show the same limbs as above. The verification of record is at GATE 4, +against the tag. From 1419dbbb75a2b944b8c12feb3be634cb4ac044eb Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 10:28:24 +0000 Subject: [PATCH 07/11] Stage the upstream pin v5.13.0 -> v5.15.0 against the landing branch (not bumped) ref -> claude/act-address-landing-bla6io (upstream PR #24), per the DDD-dec-10/16/18/25/28 pattern; three pins added (DDD-ground-06, term:act-address, DDD-ground-01). DDD-frame-08 deliberately not re-instrumented, so the firing stays observable at the bump. Staged preview, after the prediction commit ef0d444: 74 pins resolved, 0 basis-loss, 1 content-drift (DDD-frame-08, cf73b307 -> ef5d5faf, both digests as predicted), 1 shadowed id. Preview, not verification: the verification of record is against the tag at GATE 4. Basis: DDD-dec-38; DDD-dec-37; DDD-dec-10; DDD-dec-16; DDD-dec-18; DDD-dec-25; DDD-dec-28 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- graph/upstream.yaml | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/graph/upstream.yaml b/graph/upstream.yaml index e203fc3..dc83058 100644 --- a/graph/upstream.yaml +++ b/graph/upstream.yaml @@ -100,7 +100,16 @@ upstream: # none removed. The same session's branch-only supersession of DDD-frame-08 (GATE 1 ruling C) # was predicted to contribute nothing to this advance — the tag does not carry it — and # contributed nothing; its firing belongs to the next advance. - ref: v5.13.0 # tag, never a branch + # STAGED advance v5.13.0 -> v5.15.0 (act address landing session, 2026-09-28): ref points at + # the upstream landing branch so the checks resolve during staging, per the + # DDD-dec-10/16/18/25/28 pattern; bumps to the tag v5.15.0 on Emil's acceptance of upstream + # PR #24. The advance is DDD-dec-38 here, DDD-dec-37 upstream. It crosses v5.14.0 and v5.14.1 + # as well. Predicted firing, committed before this ref moved at + # meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md: E12 0 - E13 0 - W5 0 - + # W6 exactly 1 (DDD-frame-08, cf73b307... -> ef5d5faf..., v5.14.0's published prediction) - + # W7 1, unchanged. DDD-frame-08's content_hash is deliberately NOT re-instrumented at staging, + # so the firing stays observable at the bump. Three pins added (below). + ref: claude/act-address-landing-bla6io # staged; bumps to tag v5.15.0 on acceptance pins: # basis claims for DDD-dec-04 (the split decision itself rests on these) - id: DDD-frame-01 @@ -357,3 +366,16 @@ upstream: - id: DDD-measure-17 status_at_pin: projected content_hash: sha256:164a18072145bc4a0cdb3c6e1ca8890fc64c1b36396c73be5ca8bd45c66114e5 + # [PROPOSED] Act address landing (2026-09-28, DDD-dec-38), staged with the v5.15.0 advance. + # DDD-ground-06 and term:act-address are the basis of DDD-address-01..05; they do not exist + # before v5.15.0, so pinning them earlier would fire E12. DDD-ground-01 is DDD-dec-38's + # basis and was unpinned (DDD-agent-01). Hashes taken at upstream cc0abf8. + - id: DDD-ground-06 + status_at_pin: projected + content_hash: sha256:87a6adab30551a4f464cdc1020ae0155f22d6a86d3baac30917894a1cb3b6609 + - id: term:act-address + status_at_pin: draft + content_hash: sha256:d66ddee2ca634dc8ab84d96798b5ca0af36403551c826fb3affd86758f1df00c + - id: DDD-ground-01 + status_at_pin: projected + content_hash: sha256:eb4679f9878a220b8a4c39e785b1d3cd9f6ad7eb717a02d1eff6ff97ef359d93 From 4b94593d7be701a8031df743502dd082b469a98d Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 13:16:35 +0000 Subject: [PATCH 08/11] GATE 4 deviation record: target v5.15.0 -> v5.15.1, before the bump Cause: PR #24 merged at e484ca5 without the GATE 2 fix cc0abf8; v5.15.1 carries it (PR #25, ratified head 7266306 merged exactly). Restated prediction identical in every limb: notes and i18n are outside the pinned digest. Basis: DDD-dec-38; DDD-dec-37; DDD-ground-06 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- .../gate4-target-deviation.md | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate4-target-deviation.md diff --git a/meta/sessions/2026-09-27-act-address-landing/gate4-target-deviation.md b/meta/sessions/2026-09-27-act-address-landing/gate4-target-deviation.md new file mode 100644 index 0000000..91a0cfa --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate4-target-deviation.md @@ -0,0 +1,44 @@ +# GATE 4 — deviation: the advance's target changes from v5.15.0 to v5.15.1 + +**Written and committed before the ref moves to the tag.** The prediction of record is +`gate3-prediction.md` (commit `ef0d444`), whose target was `v5.15.0`. This file records the +change of target and restates the prediction for the new target. It does not edit the original. + +## The deviation + +| | Predicted (`ef0d444`) | Now | +|---|---|---| +| Target tag | `v5.15.0` | `v5.15.1` | +| Staged at | upstream `cc0abf8` (the landing branch) | unchanged until the bump | +| Releases crossed | v5.14.0, v5.14.1, v5.15.0 | v5.14.0, v5.14.1, v5.15.0, v5.15.1 | + +## Cause + +PR #24 merged from `e484ca5`. The GATE 2 ruling 3 fix (`cc0abf8`) reached the branch after that +head and was never merged, so `v5.15.0` was cut carrying the narrowing Emil had struck. The fix +ships as `v5.15.1` (PR #25, merge `1cb3819`, ratified head `7266306`; merged with exactly that +head, no content difference). v5.15.1 also carries Emil's GATE 3 glossary ruling. Emil ruled at +GATE 3 that GATE 4 runs against v5.15.1, so the pin should name the release that carries the +ruled canon. + +This is the second head-moved miss after v5.14.0. The release-head guard is a priority successor +item. + +## Restated prediction for v5.15.1 + +v5.15.0 → v5.15.1 changes `DDD-ground-06`'s notes, two glossary notes, and adds a release +descriptor. Notes and `i18n/` are outside the pinned digest (statement, region, `canonical_md`), +so **the restated prediction is identical to the original in every limb**: + +| Limb | Predicted | +|---|---| +| E12 | 0 | +| E13 | 0 | +| W5 | 0 | +| W6 | exactly 1: `DDD-frame-08`, `sha256:cf73b307…` → `sha256:ef5d5faf…` | +| W7 | 1, unchanged | +| Pins | 74 (71 + `DDD-ground-06`, `term:act-address`, `DDD-ground-01`), with the three new digests exactly as in `gate3-prediction.md` | + +A pre-computation against merged `main` (`1cb3819`, the content v5.15.1 will tag) with the +checker's own loader and digest gives exactly this: 74 pins, one W6 on `DDD-frame-08`, nothing +else. That was a dry computation; the verification of record runs against the tag. From 662f8b206332ca26c13473c1a8fada8c687e146e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 13:17:05 +0000 Subject: [PATCH 09/11] Pin ref advances alone: staged branch -> v5.15.1 (hashes untouched) Observed at the tag, ref first and hashes second: 74 pins resolved, 0 basis-loss (W5 0), E12 0, E13 0, exactly 1 content-drift (DDD-frame-08, cf73b307 -> ef5d5faf, both digests as predicted at ef0d444 and restated at 4b94593), 1 shadowed id. Prediction held in every limb. Target deviation v5.15.0 -> v5.15.1 recorded before this commit. Basis: DDD-dec-38; DDD-dec-37; DDD-dec-35 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- graph/upstream.yaml | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/graph/upstream.yaml b/graph/upstream.yaml index dc83058..c915bba 100644 --- a/graph/upstream.yaml +++ b/graph/upstream.yaml @@ -100,16 +100,18 @@ upstream: # none removed. The same session's branch-only supersession of DDD-frame-08 (GATE 1 ruling C) # was predicted to contribute nothing to this advance — the tag does not carry it — and # contributed nothing; its firing belongs to the next advance. - # STAGED advance v5.13.0 -> v5.15.0 (act address landing session, 2026-09-28): ref points at - # the upstream landing branch so the checks resolve during staging, per the - # DDD-dec-10/16/18/25/28 pattern; bumps to the tag v5.15.0 on Emil's acceptance of upstream - # PR #24. The advance is DDD-dec-38 here, DDD-dec-37 upstream. It crosses v5.14.0 and v5.14.1 - # as well. Predicted firing, committed before this ref moved at - # meta/sessions/2026-09-27-act-address-landing/gate3-prediction.md: E12 0 - E13 0 - W5 0 - - # W6 exactly 1 (DDD-frame-08, cf73b307... -> ef5d5faf..., v5.14.0's published prediction) - - # W7 1, unchanged. DDD-frame-08's content_hash is deliberately NOT re-instrumented at staging, - # so the firing stays observable at the bump. Three pins added (below). - ref: claude/act-address-landing-bla6io # staged; bumps to tag v5.15.0 on acceptance + # Advanced v5.13.0 -> v5.15.1 at the act address landing session (2026-09-28), on Emil's + # acceptance of upstream PR #24 (merge 13128a7, tagged v5.15.0) and PR #25 (merge 1cb3819, + # tagged v5.15.1); the advance is DDD-dec-38 here, DDD-dec-37 upstream. Staged against the + # landing branch per the DDD-dec-10/16/18/25/28 pattern, then bumped to the tag. DEVIATION, + # recorded before the bump at meta/sessions/2026-09-27-act-address-landing/ + # gate4-target-deviation.md: the prediction (gate3-prediction.md, committed at ef0d444 before + # the ref first moved) targeted v5.15.0; v5.15.0 was cut from e484ca5 without the GATE 2 fix + # cc0abf8, which ships as v5.15.1, and Emil ruled the pin names v5.15.1. Notes and i18n only + # separate the two, so the restated prediction is identical: E12 0 - E13 0 - W5 0 - W6 + # exactly 1 (DDD-frame-08, cf73b307... -> ef5d5faf..., v5.14.0's published prediction) - W7 1, + # unchanged. Three pins added: DDD-ground-06, term:act-address, DDD-ground-01. + ref: v5.15.1 # tag, never a branch pins: # basis claims for DDD-dec-04 (the split decision itself rests on these) - id: DDD-frame-01 From 50e90ca16e305b1e1eb98aa9ce6e717e16995d4f Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 13:17:15 +0000 Subject: [PATCH 10/11] Re-instrument DDD-frame-08 at v5.15.1; the verification recorded content_hash cf73b307 -> ef5d5faf, the digest predicted at ef0d444. After re-instrumentation: 74 pins, 0 basis-loss, 0 content-drift, 1 shadowed id; validate-core-order 0 errors, 0 warnings. Basis: DDD-dec-38; DDD-frame-08; DDD-dec-36 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- graph/upstream.yaml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/graph/upstream.yaml b/graph/upstream.yaml index c915bba..292033c 100644 --- a/graph/upstream.yaml +++ b/graph/upstream.yaml @@ -111,6 +111,11 @@ upstream: # separate the two, so the restated prediction is identical: E12 0 - E13 0 - W5 0 - W6 # exactly 1 (DDD-frame-08, cf73b307... -> ef5d5faf..., v5.14.0's published prediction) - W7 1, # unchanged. Three pins added: DDD-ground-06, term:act-address, DDD-ground-01. + # Verified at the bump, ref advanced first and hashes re-instrumented second so the firing was + # observed rather than assumed: 74 pins resolved, 0 basis-loss, EXACTLY ONE content-drift — + # DDD-frame-08, both digests as written down beforehand — 1 shadowed id. The prediction held + # in every limb. After re-instrumenting DDD-frame-08: 74 pins, 0 basis-loss, 0 content-drift, + # 1 shadowed id. ref: v5.15.1 # tag, never a branch pins: # basis claims for DDD-dec-04 (the split decision itself rests on these) @@ -293,7 +298,7 @@ upstream: # stated without a citation; the citation is the fix). Same ref (v5.7.0), no advance. - id: DDD-frame-08 status_at_pin: projected - content_hash: sha256:cf73b307ede964603c2eb36863f4a4b7874894350e05ae467b300fcf54aa3590 + content_hash: sha256:ef5d5fafedb588994141c8f4df504c7589ab3ea7b5257f3ea97f37ba3db07ff7 - id: term:acceptance-predicate status_at_pin: settled content_hash: sha256:a3aaae2e710ffb955b30e2e4b0f8371b72c1ada7816ac698dab5e2310ee29e78 From a778ed2ffdef163771657c23116e6f48de100d5c Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 13:18:24 +0000 Subject: [PATCH 11/11] GATE 4 close: manifest, successor items, GATE 3 rulings; DDD-dec-38 final - manifest.md: what landed, the pin advance verified limb by limb (prediction held in every limb; one deviation, in the target v5.15.0 -> v5.15.1, not the firing), rulings by gate, corrections, validators at close. - successor-items.md: S-1 release-head guard (priority), S-2 T2b with the accumulated test items, S-3 seam decay, S-4 behaviour term, S-5 glossary pass, S-6 held findings, S-7 repo URL, S-8 decision pinning (low), S-9 term:act relation, S-10 stale upstream PR #3. - gate3-rulings.md: the GATE 3 rulings, both messages. - DDD-dec-38: Final section recording the completed advance. Basis: DDD-dec-38; DDD-dec-37; DDD-ground-06; DDD-frame-08; DDD-agent-01 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UYoSMH3Hn75vS3EKdZFT3 --- core/decisions/DDD-dec-38.yaml | 12 ++- .../gate3-rulings.md | 26 ++++++ .../manifest.md | 87 +++++++++++++++++++ .../successor-items.md | 17 ++++ 4 files changed, 141 insertions(+), 1 deletion(-) create mode 100644 meta/sessions/2026-09-27-act-address-landing/gate3-rulings.md create mode 100644 meta/sessions/2026-09-27-act-address-landing/manifest.md create mode 100644 meta/sessions/2026-09-27-act-address-landing/successor-items.md diff --git a/core/decisions/DDD-dec-38.yaml b/core/decisions/DDD-dec-38.yaml index a51c5fd..537ee40 100644 --- a/core/decisions/DDD-dec-38.yaml +++ b/core/decisions/DDD-dec-38.yaml @@ -4,8 +4,18 @@ kind: decision statement: | The projection files the act address ruling's diachronic companions — the causal time index, occurrence uniqueness, shared-component escape, the coincidence grain and the two behaviour grains (DDD-address-01 to 05) — as projected claims resting on upstream DDD-ground-06, and advances the upstream pin to the release that carries it, with DDD-ground-06, term:act-address and DDD-ground-01 pinned. principal: Emil -made: 2026-09-27, act address session; filed 2026-09-28 at the act address landing session (GATE 3, on the GATE 1 and GATE 2 rulings) +made: 2026-09-27, act address session; filed 2026-09-28 at the act address landing session (GATE 3, on the GATE 1 and GATE 2 rulings); the advance completed at GATE 4, 2026-09-28, against v5.15.1 on the GATE 3 ruling resolution: | + Final. The GATE 4 sequence completed as ruled. Upstream PR #24 was accepted (merge 13128a7, + tagged v5.15.0), but it merged one commit behind the GATE 2 fix. The fix shipped as v5.15.1 + (PR #25, merge 1cb3819, ratified head 7266306 merged exactly). The ref was bumped from the + staged branch to v5.15.1, not v5.15.0, on Emil's GATE 3 ruling. That change of target is a + recorded deviation (meta/sessions/2026-09-27-act-address-landing/gate4-target-deviation.md, + committed before the bump). The firing did not deviate: ref first, hashes second, it showed + 74 pins, 0 E12/E13/W5, exactly one W6 (DDD-frame-08, cf73b307… -> ef5d5faf…, both digests as + predicted) and W7 1. After re-instrumentation it showed 74 pins with 0 drift. The downstream + PR stands for Emil's acceptance. + The upstream ruling is DDD-dec-37. This decision records the downstream half. The address itself is synchronic and lives upstream. Everything that compares or orders occurrences persists between acts and lives here, per DDD-dec-09 and meta/repo-topology.md, the same split diff --git a/meta/sessions/2026-09-27-act-address-landing/gate3-rulings.md b/meta/sessions/2026-09-27-act-address-landing/gate3-rulings.md new file mode 100644 index 0000000..6f433e3 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/gate3-rulings.md @@ -0,0 +1,26 @@ +# GATE 3 — rulings (act address landing) + +Principal: Emil. Given 2026-09-28, in two messages, after PR #24 had merged at `e484ca5` and +`v5.15.0` had been cut without the GATE 2 fix `cc0abf8`. + +| # | Subject | Ruling | +|---|---|---| +| 1 | GATE 3 | Accepted. | +| 2 | The missed fix | Open v5.15.1 from a fresh branch. Cherry-pick `cc0abf8`. Write a descriptor recording the miss on the v5.14.1 precedent. Stop at the PR. | +| 3 | GATE 4 | After v5.15.1 is tagged, run GATE 4 against v5.15.1: bump the ref, verify limb by limb, record the change of target from the prediction as a deviation with its cause, re-instrument `DDD-frame-08`, and write the manifest. | +| 4 | Successor items | Add a release-head guard: the descriptor records the ratified head, and CI fails if the head moves. **Priority.** Add decision pinning for `basedOn` references. **Low priority.** | +| 5 | PR #37 | Watch it on the same terms as #24. | +| 6 | Danish notes (second message) | Strike. Replace both notes with "Se core/14." and keep the two rows. Add the commit to PR #25 and report the new head. "I ratify that head, not 1986110." | +| 7 | Successor item (second message) | A glossary pass for act, act occurrence, act-site and ground axis. "handling" for act is implicitly ruled by `handlingsadresse` and needs its own ruling. | + +**Note on ruling 6.** The first GATE 3 message carried the Danish-notes ruling as an unfilled +"[keep / strike]". The session applied nothing and flagged it. The second message filled it. + +## How the rulings landed + +| Ruling | Where | +|---|---| +| 2 | Upstream branch `claude/act-address-landing-bla6io-v5.15.1`: `7cfc828` (cherry-pick of `cc0abf8`), `1986110` (descriptor) | +| 6 | Upstream `7266306` (glossary notes, descriptor updated). PR #25 merged at `1cb3819` with exactly that head; tagged `v5.15.1` | +| 3 | Downstream `4b94593` (deviation, before the bump), `662f8b2` (ref alone), `50e90ca` (re-instrumentation) | +| 4, 7 | `successor-items.md` | diff --git a/meta/sessions/2026-09-27-act-address-landing/manifest.md b/meta/sessions/2026-09-27-act-address-landing/manifest.md new file mode 100644 index 0000000..d92c711 --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/manifest.md @@ -0,0 +1,87 @@ +# Manifest — act address landing (2026-09-27 … 2026-09-28) + +Interactive canon curation. Emil ruled at every gate. The session merged nothing. Branch +`claude/act-address-landing-bla6io` in both repositories, plus +`claude/act-address-landing-bla6io-v5.15.1` upstream for the correction release. + +## Weakest point, named first + +**The session's own release process failed once, in the way it failed before.** PR #24 merged +one commit behind the head that carried the GATE 2 ruling, so `v5.15.0` shipped a flag Emil had +struck. The correction is `v5.15.1`, and the pin names it. Nothing in the tooling would have +stopped it. The same shape as v5.14.0 means it is a class, not an accident. The release-head +guard (successor item S-1) is its remedy, and until it exists, every release depends on someone +checking the head by hand. + +## What landed + +| Where | Object | Status | Commit or release | +|---|---|---|---| +| Upstream | `DDD-ground-06` — the act address | conceptual, projected | `d30efe7` (v5.15.0); notes corrected `7cfc828` (v5.15.1) | +| Upstream | `term:act-address`, established by `core/14` §5 | draft | `d30efe7` (v5.15.0) | +| Upstream | `DDD-dec-37` — the ruling | decision | `d30efe7` (v5.15.0) | +| Upstream | Glossary: `handlingsadresse`, `lagsti`; notes "Se core/14." | — | `d30efe7` (v5.15.0); notes `7266306` (v5.15.1) | +| Upstream | `releases/v5.15.0.yaml`, `releases/v5.15.1.yaml` | tagged | `v5.15.0` at `13128a7`; `v5.15.1` at `1cb3819` | +| Downstream | `meta/sessions/2026-09-27-act-address/`, byte-identical to the bundle | — | `fd194df` | +| Downstream | `DDD-address-01` to `05` | projected | `76d644e` | +| Downstream | `DDD-dec-38` — the filing and the advance | decision | `76d644e`; finalised with this manifest | +| Downstream | `graph/upstream.yaml` — v5.13.0 → v5.15.1, three pins added | — | staged `1419dbb`; bumped `662f8b2`; re-instrumented `50e90ca` | + +The pre-registration's SHA-256 was verified at arrival, at landing and after landing: +`ef34e3bc14ab793800edd8c096e82adf0652ef8bc284d54d52efd20f8bf5f5eb`. It was never edited. + +## The pin advance, verified limb by limb + +Prediction of record: `gate3-prediction.md` (`ef0d444`, committed before the ref first moved). +Change of target: `gate4-target-deviation.md` (`4b94593`, committed before the bump). + +| Limb | Predicted | Observed at `v5.15.1`, ref first, hashes second | Held | +|---|---|---|---| +| E12 | 0 | 0 | Yes | +| E13 | 0 | 0 | Yes | +| W5 | 0 | 0 | Yes | +| W6 | Exactly 1: `DDD-frame-08`, `cf73b307…` → `ef5d5faf…` | Exactly 1: `DDD-frame-08`, `cf73b307…` → `ef5d5faf…` | Yes, both digests | +| W7 | 1, unchanged | 1 shadowed id | Yes | +| Pins | 74 | 74 resolved | Yes | +| Added-pin digests | `DDD-ground-06` `87a6adab…`, `term:act-address` `d66ddee2…`, `DDD-ground-01` `eb4679f9…` | No drift on any of the three at the tag | Yes | + +After re-instrumenting `DDD-frame-08`: 74 pins, 0 basis-loss, 0 content-drift, 1 shadowed id. +`validate-core-order.py` reports 0 errors and 0 warnings. + +**Deviation: one, in the target, not in the firing.** The prediction targeted `v5.15.0`. The pin +names `v5.15.1`, on Emil's GATE 3 ruling, because `v5.15.0` lacks the GATE 2 fix. Only notes and +`i18n/` separate the two, and neither is in the pinned digest, so the prediction was restated +unchanged before the bump and held unchanged after it. The v5.14.0 descriptor's published W6 for +`DDD-frame-08` is discharged here, two releases after it was written. + +## Rulings, by gate + +| Gate | Record | Rulings | +|---|---|---| +| 0 | `prompt.md`, `bootstrap.md` | Arrival committed before any canon. Push blocked by a 403 until GitHub access was fixed. | +| 1 | `gate1-survey.md`, `gate1-rulings.md` | Nine: falsifier repair, neutral upstream wording, citation, rule 1 kept joined, `address-05` filed, `address-03` filed, dry-run items, term home, glossary | +| 2 | `gate2-rulings.md` | Wider neutral wording and README row confirmed; `term:act` narrowing struck; the T2b escalation-rule item; PR watching; GATE 3 authorised | +| 3 | `gate3-rulings.md` | GATE 3 accepted; v5.15.1; GATE 4 against v5.15.1; the Danish notes struck; three successor items | +| 4 | This file, `successor-items.md` | — | + +## Corrections the session made to its own work + +| What | Correction | +|---|---| +| GATE 0 push loop reported "pushed" on a 403 | The loop tested for "ahead" on a branch with no upstream. Corrected in the next report; the push was verified with `ls-remote` from then on. | +| Survey's narrowing of the `term:act` flag | Struck at GATE 2 and restored in `v5.15.1`. | +| First GATE 3 message's Danish-notes placeholder | Not guessed. Flagged and held until ruled. | + +## Validators at close + +| Gate | Upstream `v5.15.1` | Downstream head | +|---|---|---| +| `validate-core-order.py` | 0 errors, 66 warnings (baseline), 0 W4 | 0 errors, 0 warnings; 74 pins clean | +| `validate-claims.py` claims | 64 claims, 32 warnings (baseline 32) | 31 claims, 6 warnings (baseline 6) | +| `validate-claims.py --decisions` | 14 decisions, clean | 24 decisions, clean | +| `validate-releases.py` | 13 descriptors, clean | — | + +## Open + +Everything open is in `successor-items.md`, S-1 to S-10. S-1 (the release-head guard) is the +priority. S-2 (T2b) is the item the whole act address set now waits on. diff --git a/meta/sessions/2026-09-27-act-address-landing/successor-items.md b/meta/sessions/2026-09-27-act-address-landing/successor-items.md new file mode 100644 index 0000000..ca8065e --- /dev/null +++ b/meta/sessions/2026-09-27-act-address-landing/successor-items.md @@ -0,0 +1,17 @@ +# Successor items — act address landing + +Items this session leaves for later sessions. Each is `[OPEN]` until a session takes it and Emil +rules. The order is by priority where one was ruled; otherwise it follows the order they arose. + +| # | Item | Priority | Source | What it needs | +|---|---|---|---|---| +| S-1 | **Release-head guard.** The descriptor records the ratified head. CI fails if the head that merges is not that head. | **Priority** (GATE 3 ruling 4) | Two misses of one kind: v5.14.0 (cut before `DDD-dec-36`) and v5.15.0 (cut from `e484ca5`, before `cc0abf8`). Both times the head that was ratified was not the head that merged. | A field in `spec/release-format.md` (additive), a check in the release workflow, and a hit-list run against the existing descriptors before its class is chosen. | +| S-2 | **T2b — the first Phoenix slice.** The independent test of `DDD-ground-06` and `DDD-address-01…05`. | — | Pre-registration R-8; `gate1-rulings.md` ruling 7; `gate2-rulings.md` ruling 5 | A T2b pre-registration written and hashed before the slice exists. It must include the accumulated test items: **F-1**, an act that never reads an axis a governing predicate uses; and **verdict-triggered decisions** (escalation rules), which anchor at the following act, whose reading contains the verdict. It must test the reading/verdict-input line flagged in both `DDD-ground-06` and `DDD-address-01`. No customer-identifying material. | +| S-3 | **Seam decay.** A seam spanning k occurrences decays at the conjunction of k persistence probabilities. | — | `DDD-address-03` notes; GATE 1 ruling 6 | Find or file a canonical home. `DDD-cost-27` is not support (ruled). Until then, `DDD-address-03`'s "pricing of reuse as seam risk" limb of `breaks` rests on an unfiled result. | +| S-4 | **The behaviour term.** The Gate 0 behaviour bundle was never filed. | — | `DDD-address-05`; GATE 1 ruling 5 | File the term, including "relative ground". Then check `DDD-address-05`'s working definition, and `DDD-address-01`'s K5 rationale, against it. | +| S-5 | **Glossary pass**: act, act occurrence, act-site, ground axis. | — | GATE 3 ruling 7 | "handling" for act is implicitly ruled by `handlingsadresse` and needs its own ruling. Rule each term; the act-address rows' notes currently read "Se core/14." | +| S-6 | **Held dry-run findings.** F-1 (held as a T2b test item) and F-2 (held; the 14 s figure struck). | — | GATE 1 ruling 7 | F-1 is carried into S-2. F-2 needs a ruling after T2b: whether the layer's inherited tolerance is a finding. `DDD-address-04`'s falsifier names it as the known risk. | +| S-7 | **The `repo:` URL.** `graph/upstream.yaml` still points at `github.com/Hafeok/actor-indexed-determination`. It resolves through the transfer redirect. | — | Out of scope by the session prompt | Change it to `mindovermachine-dev` in a ruled edit. A redirect that lapses would fire E12 on every pin. | +| S-8 | **Decision pinning for `basedOn` references.** The checker indexes upstream claims and terms only, so `DDD-dec-38`'s `basedOn: DDD-dec-37` cannot be pinned. | Low (GATE 3 ruling 4) | GATE 3 staging | Extend `load_upstream_graph` to decisions, and decide what a decision's digest covers (statement and resolution; decisions have no region). | +| S-9 | **The `term:act` relation.** `DDD-ground-06` carries the general `UNVERIFIED — Emil review` flag: individuation (one verdict, one act) versus location, not checked against `core/09`. | — | GATE 2 ruling 3 | A check against `core/09` §1. The retry note (each attempt is a separate occurrence only if it carries its own verdict) is the concrete case. | +| S-10 | **Stale upstream PR #3** (`claude/primitives-reader-clean`, last updated 2026-08-06). It rewrites `core/00` prose about the act. | — | GATE 1 survey §1 | Close or rebase by ruling. If it merged as is, it would reword the document that establishes `term:act`. |