From d84041ac5ec2af3cc122543a835af17b9e310a2a Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Tue, 10 Nov 2026 13:28:36 +0000 Subject: [PATCH 1/9] Session method-plugin: prompt and bootstrap (the charter, committed first) The prompt verbatim, and the arrival record. The v0.7.0 tag exists and peels to 84aa466, which is main's head at arrival. Branch from main. Issue #72. Refs #72 Basis: DDD-dec-17; DDD-dec-118 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/bootstrap.md | 61 +++++++++++++++++++ .../2026-11-08-method-plugin/prompt.md | 30 +++++++++ 2 files changed, 91 insertions(+) create mode 100644 meta/sessions/2026-11-08-method-plugin/bootstrap.md create mode 100644 meta/sessions/2026-11-08-method-plugin/prompt.md diff --git a/meta/sessions/2026-11-08-method-plugin/bootstrap.md b/meta/sessions/2026-11-08-method-plugin/bootstrap.md new file mode 100644 index 0000000..98960d5 --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/bootstrap.md @@ -0,0 +1,61 @@ +# Bootstrap — an installable plugin for the method, 2026-11-08 + +Filled in at arrival (2026-11-10) and committed with `prompt.md` as the session's first commit. + +| Parameter | Value | +|---|---| +| Invocation | Interactive. Emil's Round 27 (claude.ai conversation, 2026-11-08) is verbatim in `prompt.md` | +| Principal | Emil (sole ratifier; ratifies by landing the branch) | +| Issue | [#72](https://github.com/mindovermachine-dev/decision-driven-design/issues/72). Every commit of the session carries `Refs #72` | +| Start condition | `git ls-remote --tags origin v0.7.0` → `72f8f139d476cc1e5f559ccef601f497ddda3a4b refs/tags/v0.7.0` (the annotated tag object). **The tag exists**, so the session starts | +| The pin | `v0.7.0`, which peels to commit `84aa4665b4b0392ef4bb08ac042e42ae9fc6d12c` | +| Downstream base | `main` at arrival = `84aa466` ("releases/v0.7.0.yaml: ratified_head 74e4805 (canon ratify v0.7.0)"). **`main` is the `v0.7.0` commit**: `git log v0.7.0..origin/main` is empty | +| Downstream branch | `claude/confident-goldberg-c0y0ia`, from `main` at `84aa466` | +| Upstream pin | `v5.15.2` (`graph/upstream.yaml`), read only and unchanged by this session | +| Claude Code | `claude` 2.1.322 in the session container (`/opt/node22/bin/claude`) | +| Model | Claude Opus 5.5 | + +## Gates + +The prompt says "Stop at every gate" and also asks for items 1 to 8 in one run, ending "and +stop". This session reads that as follows. At each gate, the prediction and the outcome are +recorded in `predictions.md` and checked before the next item starts. **Only G3 stops for Emil.** +If Emil wanted to review the design before anything was built, the build is a separate later +commit that he can drop (flagged as F-1 in `findings.md`). + +| Gate | What | Who | +|---|---|---| +| G0 | This charter committed before any other change | Claude | +| G1 | `rulings.md` (Round 27 verbatim); `design.md`, `[PROPOSED]`: names, place, skills, thinness, the pin | Claude | +| G2 | The plugin and the marketplace file built; `claude plugin validate` on both; installed from the local marketplace in a scratch home; the command name confirmed; evals written and run; installation documented | Claude | +| G3 | `scripts/ci.py` green; pushed, CI green; head and land commands reported. **Stops for Emil. Not landed, no release cut** | Claude; **Emil** lands | + +## Ids + +This session files **no claim and no decision**. The prompt asks for Round 27 to be recorded and +the design proposed, not filed. Whether Round 27 becomes a decision is Emil's call (`findings.md`). +For the record, the highest decision file across all 59 `origin/*` branches at arrival was +`DDD-dec-118`. + +**"Round 27" is ambiguous in this repository.** The 2026-11-07 session's `rulings.md` has its own +Round 27 ("flow time"). The demand-flow `rulings.md` already notes that the claude.ai +conversation's round numbers and that record's numbers overlap. Here, Round 27 always means the +claude.ai conversation's Round 27, cited together with this record. + +## Read at arrival + +- **Claude Code docs, fetched live on 2026-11-10** (HTTP 200 for all ten): + `plugins.md`, `plugins/create.md`, `plugins/components.md`, `plugins/manifest-reference.md`, + `plugin-marketplaces.md`, `plugins/marketplace-reference.md`, `plugins/host-marketplace.md`, + `skills.md`, `plugin-evals.md`, `plugins/security.md`. What was confirmed, and what differed + from the prompt's summary, is in `design.md` §1. +- **This repository at `v0.7.0`:** `method/README.md`, every step card (`01`, `01b`, `02` to `10`), + `method/quick-start.md`, `graph/upstream.yaml`, `releases/v0.7.0.yaml`, `README.md`, + `LICENSING.md`, `meta/sessions/README.md`, the demand-flow session's `rulings.md` + (Rounds 23 to 26; **Round 25 has landed**). + +## Baseline + +`python3 scripts/ci.py` on `84aa466` first failed the `what` and `how` gates. The cause was the +environment, not the repository: rdflib, pyoxigraph and pyld were not installed. After +`pip install -r scripts/requirements.txt`, the result was **all gates passed**. diff --git a/meta/sessions/2026-11-08-method-plugin/prompt.md b/meta/sessions/2026-11-08-method-plugin/prompt.md new file mode 100644 index 0000000..8601c16 --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/prompt.md @@ -0,0 +1,30 @@ +New session: an installable plugin for the method, 2026-11-08, in mindovermachine-dev/decision-driven-design. Start only once the v0.7.0 tag exists: the release that carries step 1b (DDD-dec-118, PR #68). If `git ls-remote --tags origin v0.7.0` finds no tag, stop and say so. Branch from main. The plugin's pin is v0.7.0: the skill reads the step table, the step cards and the canon they cite at that tag. Re-read main's head at arrival and report it. Open an issue; Refs #N on every commit. Commit prompt.md and bootstrap.md under meta/sessions/2026-11-08-method-plugin/ first. +Emil's rulings, verbatim +Round 27, claude.ai conversation, 2026-11-08. Emil: "For the method part we should have a skill you can install". Claude flagged that a skill copying the method's text would drift as steps are ruled and superseded, and recommended a thin skill that reads the repository at a pin. Then: +Q: "Who installs the skill, and from where?" A: "From the repo, for practitioners (Recommended)" (option text: "A Claude Code plugin in decision-driven-design (a skill plus marketplace entry), installable by anyone adopting the method; versioned with the method") +Q: "What does the skill cover?" A: "The whole method (Recommended)" (option text: "All steps, each run from its step card; refuses to treat [PROPOSED] steps as ruled; step 1 and the demand-flow step first in practice") +Q: "How does the skill hold the method's content?" A: "Thin, reads the repo at a pin (Recommended)" (option text: "The skill carries procedure and discipline; step cards and canon are fetched from the repository at the pinned version, so it never drifts") +Sources to read before writing anything + +* Claude Code docs, fetched live, not from memory: code.claude.com/docs/en/plugins.md, plugins/create.md, plugins/components.md (skills), plugins/manifest-reference.md, plugin-marketplaces.md (create a marketplace), plugins/marketplace-reference.md (sources, pinning a ref or sha), plugins/host-marketplace.md (versions, updates), skills.md (SKILL.md frontmatter, who invokes a skill), plugin-evals.md, plugins/security.md. What they said on 2026-11-08: a plugin is a directory with .claude-plugin/plugin.json and components such as skills//SKILL.md; a marketplace is a repository with .claude-plugin/marketplace.json (name, owner, plugins[] with name and source; relative sources from the marketplace root, no ".."); users run `claude plugin marketplace add /` then `claude plugin install @`; `claude plugin validate` checks both. Confirm each before relying on it. +* This repository: method/README.md (registers, the step table, the step card, the release rule: a register move or a new card is MINOR, DDD-dec-82), every step card, quick-start.md, graph/upstream.yaml, the repo's version and release process, the Mind Over Machine stewardship standard as adopted (licence: CC BY-SA 4.0 text, MPL-2.0 code). +* The project's working discipline as it applies to a practitioner: registers (ruled, ruled for test, [PROPOSED], [OPEN]); projected versus reported, never fused; weakest point first; every projected claim with a falsifier; the practitioner's principal rules, Claude proposes; artefacts as graph data; never cite an id from memory. + +The work +Predict before each operation. Stop at every gate. + +1. Record Round 27 verbatim in rulings.md. +2. Design, as [PROPOSED] in design.md before building: the plugin's name (the manifest name is the skill prefix; keep the marketplace entry name identical), the marketplace name (not a reserved Anthropic name), the plugin's place in the repo (for example plugins//, with .claude-plugin/marketplace.json at the repo root), and the skills it holds. Propose one entry skill that runs the method and routes to a step, and say whether per-step skills earn their context cost (every skill Claude may invoke puts its name and description in every turn). +3. Thinness (Round 27): the skill carries procedure and discipline only. It must not contain step-card text, canon statements or ids. It reads the step table, the step cards and the canon they cite from the repository at the pin the plugin declares. Decide and justify how: a working clone if the user is in one; otherwise the files at the pinned tag over HTTPS; say what the skill does when neither is reachable (it says so and stops, never fills from memory). The pin is the method release the plugin version tracks; a method release that moves a step's register is a plugin release too. +4. The skill's behaviour, written into SKILL.md: + * Start by reading method/README.md at the pin, and present the steps with their registers. + * Run a step from its card's fields (Step, Decision discharged, Ground in, Act, Artefact out, Value made visible, Cost and relocation, Exit check, Principal). Name the value made visible at the moment the step is performed; if it cannot be named, say the step is defective rather than presenting it. + * Never treat a [PROPOSED] step as ruled: say its register before running it, and carry the card's own weakest point. + * Step 1 and the demand-flow step first in practice (Round 27). For demand flow, start from the PDLC's kinds of demand as the card offers them (Round 25 in meta/sessions/2026-11-08-demand-flow/, if landed), and record what the practitioner keeps, adds or drops. + * The practitioner's principal rules; the skill proposes. Weakest point first; falsifiers on projected claims; projected and reported kept apart. + * Artefacts as graph data where the card asks for it, validated against the repository's shapes at the pin. + * No customer-identifying material is ever written into a canon repository. +5. Build the plugin and the marketplace file. Run `claude plugin validate` on both, then install from the local marketplace in a scratch environment and confirm the skill loads and its command name is what design.md says. Record the commands and output. +6. Evals (plugin-evals.md): at least these cases, each with an expected behaviour: asked to run a [PROPOSED] step as ruled, it refuses and states the register; asked for a step card's content with the repository unreachable, it says so and stops; asked to run step 1 on a small example, it produces the artefact the card names; asked to run demand flow, it offers the PDLC's kinds as a start, not as the method's fixed set. Run them and report the results. +7. Document installation in the repository's README (one short section) and in the plugin's own README: the two commands, the pin, and how the plugin version tracks the method. +8. Run the validators. Push, wait for green CI, report the head and the land commands, and stop. Do not land. Do not cut a release. From be68658323270d1d00d00c53e9175c0890ad9cee Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Tue, 10 Nov 2026 13:31:10 +0000 Subject: [PATCH 2/9] Session method-plugin: Round 27 verbatim; the plugin's design, [PROPOSED] rulings.md holds Round 27, copied byte for byte from prompt.md. design.md proposes the following, before anything is built: - ddd-method@decision-driven-design: one entry skill, /ddd-method:run [step]. - Reads at the pin v0.7.0: from a clone with git show, otherwise over raw HTTPS. If neither is reachable, it stops. - version 0.7.0 tracks the pin. - The plugin ships in a PATCH release (tooling, DDD-dec-82). - A thinness check in CI. - Four eval cases. Refs #72 Basis: DDD-dec-82; DDD-dec-100; DDD-dec-79; DDD-dec-118 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/design.md | 189 ++++++++++++++++++ .../2026-11-08-method-plugin/rulings.md | 36 ++++ 2 files changed, 225 insertions(+) create mode 100644 meta/sessions/2026-11-08-method-plugin/design.md create mode 100644 meta/sessions/2026-11-08-method-plugin/rulings.md diff --git a/meta/sessions/2026-11-08-method-plugin/design.md b/meta/sessions/2026-11-08-method-plugin/design.md new file mode 100644 index 0000000..9968b97 --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/design.md @@ -0,0 +1,189 @@ +# Design — the method plugin `[PROPOSED]` + +**Register: `[PROPOSED]`.** Every choice below is Claude's proposal on Round 27 (method-plugin +`rulings.md`), `UNVERIFIED — Emil review`. Round 27 rules the form (a plugin in this repository, +a skill plus a marketplace entry), the scope (the whole method) and the holding (thin, reading the +repository at a pin). It does not rule anything below. + +**Weakest point.** The plugin is thin only to the extent that the model follows the instruction +to read instead of recall. The skill tells Claude to stop when the repository is unreachable, and +an eval case tests that once. Nothing mechanical stops a model from answering from its training +data, which may well include these cards. The CI check in §6 keeps card text out of the skill. It +cannot keep it out of the model. + +## 1. What the docs say, checked live on 2026-11-10 + +All ten pages named in `prompt.md` were fetched from `code.claude.com/docs/en/` (HTTP 200). Each +point the design relies on was checked against them: + +| Prompt's summary (2026-11-08) | Live docs (2026-11-10) | Where | +|---|---|---| +| A plugin is a directory with `.claude-plugin/plugin.json` and components such as `skills//SKILL.md` | Confirmed | `plugins/create.md`, `plugins/manifest-reference.md` | +| A marketplace is a repository with `.claude-plugin/marketplace.json`: `name`, `owner`, `plugins[]` with `name` and `source` | Confirmed. `description` is recommended (`validate` warns when it is missing) | `plugins/marketplace-reference.md` | +| Relative sources are written from the marketplace root, with no `..` | Confirmed. A `..` path fails `validate`. A missing directory passes `validate` and fails at `install` | `plugin-marketplaces.md` | +| `claude plugin marketplace add /`, then `claude plugin install @` | Confirmed. `#` appended to the add command pins the catalogue at a branch or tag | `plugin-marketplaces.md`, `plugins/host-marketplace.md` | +| `claude plugin validate` checks both | Confirmed. It takes the plugin directory or the marketplace root, and `--strict` fails on warnings too | `plugins/create.md`, `plugin-marketplaces.md` | +| *(not in the summary)* | **The manifest `name` is the skill prefix, and the entry `name` is the install id.** Keep the two identical, or installing by the manifest name fails | `plugin-marketplaces.md` | +| *(not in the summary)* | **A user gets a new copy only when `version` changes.** `plugin.json` wins over the entry. Set it in one place only | `plugins/host-marketplace.md` | +| *(not in the summary)* | **A model-invocable skill's description is in context every turn.** `disable-model-invocation: true` takes it out, but Claude then cannot choose the skill on its own | `skills.md` | +| *(not in the summary)* | A plugin or marketplace name beginning `claude-`, `anthropic-`, `anthropics-` or `cc-plugin-` is reserved, and so is any of the listed official names | `plugins/manifest-reference.md`, `plugins/marketplace-reference.md` | + +## 2. Names and place + +| Item | Proposed | Why | +|---|---|---| +| Plugin name (manifest **and** marketplace entry, identical) | **`ddd-method`** | It names the method, not the tool. A bare **`ddd`** would read as product-cli's `ddd`, which governs product repositories over a `.ddd/` graph (`DDD-dec-100`). It is not reserved: no `claude`/`anthropic` prefix or word | +| Entry skill | **`run`**, so the command is **`/ddd-method:run [step]`** | The plugin's prefix already says what it runs. `/ddd-method:run 1b` reads as what it does | +| Marketplace name | **`decision-driven-design`** | The repository's name, so the install id reads `ddd-method@decision-driven-design`. Not reserved: it is not on the official, community or directory lists, and it does not start with `claudeai-`. It is not the org's name, because this catalogue holds only this repository's plugin and should not claim the org's | +| Place | **`plugins/ddd-method/`**, with **`.claude-plugin/marketplace.json`** at the repository root, and entry source `./plugins/ddd-method` | This is the docs' layout, and `marketplace add /` finds the file only at the root. The plugin's directory is its own, so `validate` and `eval` run on it alone | +| Licence | `MPL-2.0` in `plugin.json`, because the manifest and skill are code and schemas. The README's prose is CC BY-SA 4.0 like every README (`LICENSING.md`) | `DDD-dec-79` | + +The plugin holds: + +``` +plugins/ddd-method/ +├── .claude-plugin/plugin.json name, version, description, author, repository, license +├── skills/run/SKILL.md the entry skill: procedure and discipline only +├── README.md the two commands, the pin, how the version tracks the method +├── check.py the thinness and pin check (§6), run by scripts/ci.py +└── evals/ the eval suite (§7) +``` + +## 3. One entry skill, not per-step skills + +**One model-invocable skill, `run`, that routes to a step.** Per-step skills do not earn their +context cost: + +- **Cost.** Every model-invocable skill puts its name and description into every turn, up to + 1,536 characters each (`skills.md`). Eleven step skills would mean eleven descriptions in every + turn of every session where the plugin is enabled, including sessions that never touch the + method. One skill means one. +- **Nothing to put in them.** Nine of the eleven cards say "Not filed" in every field but Step + (`v0.7.0`). A per-step skill would be either empty or a copy of the card, and a copy is what + Round 27 rules out. +- **Routing is the method's.** The step table at the pin decides which steps exist and in what + order. A skill per step would freeze the table at build time, and a card added at the next + MINOR release would have no skill until the plugin caught up. One router reads the table, so a + new card is runnable the day its release is pinned. +- **What it gives up.** No per-step `/` commands. `/ddd-method:run 1b` takes the step as its + argument instead. + +`disable-model-invocation` is left `false`. A practitioner who says "map the acts in this service" +should reach the skill without knowing its name, and that costs one description. + +## 4. Thinness: how the skill reaches the repository + +The skill contains no step-card text, no canon statement and no id. It names one pin, the +repository, and the paths it reads. It reads **only at the pin**, in this order: + +1. **A working clone.** If the session is inside a git clone whose `origin` is + `mindovermachine-dev/decision-driven-design`, or the user names one, read every file with + `git show :`, fetching the tag first if it is missing. **Not the working tree**: + the working tree may be at another commit or carry local edits, and `git show` at the tag is + the pin by construction. This is the cheapest path, it works offline once the tag is local, + and a practitioner who contributes back is usually in one. +2. **HTTPS at the pinned tag.** Otherwise read + `https://raw.githubusercontent.com/mindovermachine-dev/decision-driven-design//`. + Prefer a raw fetch (`curl -fsSL`), which returns the file's bytes. A fetch tool that summarises + is used only when asked for the text verbatim, and the skill tells the practitioner it was + read that way. (Checked: `method/README.md` and `core/claims/DDD-flow-01.yaml` at `v0.7.0`, and + upstream `core/claims/DDD-ground-06.yaml` at `v5.15.2`, each HTTP 200.) +3. **Neither reachable.** The skill **says so and stops.** It names what it tried and what the + practitioner can do (clone the repository, or allow the host). It does not run a step, does + not summarise a card, and does not fill anything from memory. A card the skill cannot read is + a card it does not have. + +**The canon a card cites** is read the same way. Downstream ids are read from `core/claims/` or +`core/decisions/` at the method pin. **Upstream ids** are read from the repository and tag named in +`graph/upstream.yaml` at the method pin, never from upstream's `main`. At `v0.7.0` that is +`actor-indexed-determination` at `v5.15.2`. + +### The pin and the version + +- **The pin is the method release whose cards the skill reads:** `v0.7.0`. It is written once, in + `SKILL.md`, and `plugin.json`'s `version` restates it. +- **`version` = the pin without its `v`: `0.7.0`.** A plugin-only change at the same pin, such as + better wording, appends a build suffix, `0.7.0+p.1`. Claude Code compares versions only for + change, so any new string reaches users. `version` is set in `plugin.json` only, never also in + the marketplace entry (`plugins/host-marketplace.md`). +- **A method release is a plugin release when it moves what the skill reads.** At a MINOR release + (a card added, or a register moved, `DDD-dec-82`), the pin advances in the same change, or + practitioners keep running the old registers. At a PATCH release, the pin advances when the + edited cards are ones the skill reads, and otherwise it may stay. +- **Which release carries the plugin.** The plugin's own files are not in `v0.7.0`: they land + after it. Under `DDD-dec-82`'s mapping, "tooling" is **PATCH**, so the first release that + carries the plugin is a PATCH (`v0.7.1`, if nothing else lands first), and it pins `v0.7.0`. + This session cuts no release. +- **Stale pins.** If the practitioner says a newer method release exists, the skill says the + plugin's pin is older, keeps reading the pin, and tells them to update the plugin. It does not + read a release the plugin was not built for. + +## 5. The skill's behaviour (what `SKILL.md` says) + +`SKILL.md` carries the procedure and discipline below, worded as instructions to Claude. Card text +is never in it. Field names are the method README's. + +1. **Reach the repository** (§4). If it is unreachable, stop. +2. **Start from `method/README.md` at the pin.** Present the steps with their registers, as the + table states them, plus the README's weakest point. With a step argument, route to it. +3. **State the register before running anything.** Name the step's register as its card states it. + For a `[PROPOSED]` step, say it is not ruled and carry the card's own weakest point. If asked to + treat it as ruled, refuse, because only a ruling filed as a decision moves a register, and + offer to run it as a proposal. Fields the card marks "Not filed" are reported as not filed, + never filled. +4. **Run a step from its card's fields**, in order: Step, Decision discharged, Ground in, Act, + Artefact out, Value made visible, Cost and relocation, Exit check, Principal. Ground in is + declared, with provenance, before the Act. The Exit check is applied, and its result is said. +5. **Name the value made visible at the moment the step is done**, in the practitioner's own + terms. If it cannot be named, say the step is defective (the method README's own rule) rather + than present it. +6. **Step 1 and step 1b first in practice** (Round 27). With no step named, offer step 1. For + demand flow, start from the PDLC's kinds of demand as the card offers them, as **a starting + point and not the method's fixed set**. Record which kinds the practitioner keeps, adds or + drops, and the source of pull behind each, in the form the card gives. +7. **The practitioner's principal rules; Claude proposes.** Every decomposition, axis, owner, + kind and exit verdict is a proposal until the practitioner, or whoever the card names as + Principal, rules it. The skill says who that is. +8. **Discipline.** Weakest point first. Every projected claim is stated with its falsifier, as read + from the claim file. Projected and reported are kept apart and never fused. An identity that + holds by arithmetic is not presented as evidence. No id is cited unless it was read at the pin + in this session. +9. **Artefacts as graph data where the card asks for it.** Write Turtle or YAML beside the + practitioner's work, and validate it with the shapes or checker the card names at the pin (run + from a checkout of the pin, never the working tree). If the card names none, or the tools are + missing, say the artefact is unvalidated. Do not claim it conforms. +10. **No customer-identifying material in a canon repository.** Artefacts go in the practitioner's + own project. Nothing is written into a clone of `decision-driven-design` or + `actor-indexed-determination` unless the principal directs it, and never anything that + identifies a customer, a person or a private system. A field report is drafted anonymised for + the practitioner to send. + +## 6. A check in CI + +`plugins/ddd-method/check.py`, run by `scripts/ci.py` as a gate `plugin`. It needs only the +standard library: + +- the manifest `name` equals the marketplace entry `name`, and the entry `source` is the plugin's + directory; +- `version` is set in `plugin.json` and not in the entry, and its base equals the pin in + `SKILL.md`; +- **thinness:** `SKILL.md` holds no claim or decision id (`DDD--`), and no run of 8 or + more words appears in both `SKILL.md` and any file under `method/`. + +Running `claude plugin validate` in CI would need the `claude` CLI in the devcontainer. It is run +in this session and recorded in `findings.md`, not added to CI (`UNVERIFIED — Emil review`). + +## 7. Evals + +The suite is in `plugins/ddd-method/evals/`, in the `claude plugin eval` format. Each case has a +judged rubric (`llm`) and a mechanical grader (`regex` or `tool_used`). + +| Case | Prompt, in brief | Expected behaviour | +|---|---|---| +| `proposed-as-ruled` | "Step 6 is settled, run allocate as ruled" | Refuses to treat it as ruled. States the register, `[PROPOSED]`, read at the pin. Offers to run it as a proposal | +| `unreachable` | "What does the step 1 card say?", with no clone and no network tool | Says the repository is unreachable at the pin and stops. Quotes no card text (a regex asserts the absence of step 1's value line) | +| `step-1-small` | Step 1 on a three-request example | Produces the artefact the card names: an act map, with an address and a time index for each occurrence. Declares the axes first. Names the value | +| `demand-flow-start` | "Map the flow of demand in our support process" | Offers the PDLC's kinds as a start, not as the method's fixed set. Asks which to keep, add or drop | + +The repository is supplied to a case by a scaffold script that clones this repository, from the +suite's own location, at the pin. The case's run then reads it with `git show`. diff --git a/meta/sessions/2026-11-08-method-plugin/rulings.md b/meta/sessions/2026-11-08-method-plugin/rulings.md new file mode 100644 index 0000000..6bfa514 --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/rulings.md @@ -0,0 +1,36 @@ +# Rulings — an installable plugin for the method, 2026-11-08 + +Emil's Round 27, verbatim, from the claude.ai conversation of 2026-11-08. The round number is that +conversation's. The 2026-11-07 session's `rulings.md` has a Round 27 of its own, with different +content ("flow time"), so cite this round together with this record ("Round 27, method-plugin +`rulings.md`"). + +The blockquote is copied from `prompt.md` byte for byte, apart from the quote markers. It includes +the prompt's framing sentence (what Claude flagged and recommended), because the answers respond +to it. Each answer is the option Claude marked Recommended, and the option text is Claude's +wording, which Emil chose. + +## Round 27, verbatim + +> Round 27, claude.ai conversation, 2026-11-08. Emil: "For the method part we should have a skill you can install". Claude flagged that a skill copying the method's text would drift as steps are ruled and superseded, and recommended a thin skill that reads the repository at a pin. Then: +> Q: "Who installs the skill, and from where?" A: "From the repo, for practitioners (Recommended)" (option text: "A Claude Code plugin in decision-driven-design (a skill plus marketplace entry), installable by anyone adopting the method; versioned with the method") +> Q: "What does the skill cover?" A: "The whole method (Recommended)" (option text: "All steps, each run from its step card; refuses to treat [PROPOSED] steps as ruled; step 1 and the demand-flow step first in practice") +> Q: "How does the skill hold the method's content?" A: "Thin, reads the repo at a pin (Recommended)" (option text: "The skill carries procedure and discipline; step cards and canon are fetched from the repository at the pinned version, so it never drifts") + +## What it rules, and what it leaves open + +**Ruled:** +- **Form and place.** The plugin is a Claude Code plugin in this repository, a skill plus a + marketplace entry, for anyone adopting the method. It is versioned with the method. +- **Scope.** The whole method: every step, each run from its card. The skill refuses to treat a + `[PROPOSED]` step as ruled. In practice, step 1 and the demand-flow step come first. +- **How it holds content.** Thinly. The skill carries procedure and discipline. The step cards + and canon are fetched from the repository at the pinned version. + +**Not ruled, and proposed in `design.md`:** the plugin's and the marketplace's names; how +"versioned with the method" maps onto the plugin's `version`; how the skill reaches the +repository; and how a step that is `[PROPOSED]` is run without being treated as ruled. These are +Claude's proposals, `UNVERIFIED — Emil review`. + +**Not filed.** Round 27 is recorded here and is not filed as a decision. Whether to file it is +Emil's call (`findings.md`). From 1d667b3a2704ef5f94398a381a4a4d1f81380d95 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Tue, 10 Nov 2026 13:37:32 +0000 Subject: [PATCH 3/9] plugins/ddd-method: the method as a Claude Code plugin, thin, pinned at v0.7.0 The design is in meta/sessions/2026-11-08-method-plugin/design.md ([PROPOSED]). - .claude-plugin/marketplace.json at the root: marketplace decision-driven-design, entry ddd-method, source ./plugins/ddd-method. - plugins/ddd-method/: plugin.json (version 0.7.0, which tracks the pin, MPL-2.0) and one entry skill, skills/run/SKILL.md (/ddd-method:run). - The skill carries procedure and discipline only. It reads the step table, the cards and the canon they cite at v0.7.0: a clone through git show, otherwise raw HTTPS at the tag. Otherwise it says so and stops. - check.py is the new `plugin` gate in scripts/ci.py. It checks that the names agree and that the version tracks the pin, and it enforces thinness: no id in the skill, and no 8-word run shared with method/. - The evals cover four cases: a [PROPOSED] step asked as ruled, an unreachable repository, step 1 on a small example, and the start of demand flow. - An install section in README.md and the plugin's own README. claude plugin validate passes on the plugin and on the marketplace, also with --strict. Installed from the local marketplace in a scratch HOME, the plugin loads as ddd-method:run at 0.7.0. Refs #72 Basis: DDD-dec-82; DDD-dec-100; DDD-dec-79; DDD-dec-118; DDD-dec-81 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .claude-plugin/marketplace.json | 15 +++ README.md | 18 +++ .../2026-11-08-method-plugin/predictions.md | 16 +++ meta/sessions/README.md | 1 + plugins/ddd-method/.claude-plugin/plugin.json | 13 ++ plugins/ddd-method/.gitignore | 1 + plugins/ddd-method/README.md | 63 +++++++++ plugins/ddd-method/check.py | 84 ++++++++++++ .../ddd-method/evals/_fixture/clone-at-pin.sh | 12 ++ .../evals/demand-flow-start/case.yaml | 4 + .../graders/kinds-as-start.md | 7 + .../demand-flow-start/graders/names-kinds.md | 5 + .../graders/read-card-at-pin.md | 5 + .../evals/demand-flow-start/prompt.md | 9 ++ .../evals/demand-flow-start/scaffold.sh | 2 + .../evals/proposed-as-ruled/case.yaml | 4 + .../graders/names-register.md | 4 + .../graders/read-card-at-pin.md | 5 + .../proposed-as-ruled/graders/refuses.md | 7 + .../evals/proposed-as-ruled/prompt.md | 9 ++ .../evals/proposed-as-ruled/scaffold.sh | 2 + .../ddd-method/evals/step-1-small/case.yaml | 4 + .../evals/step-1-small/graders/act-map.md | 7 + .../step-1-small/graders/artefact-file.md | 6 + .../step-1-small/graders/read-card-at-pin.md | 5 + .../ddd-method/evals/step-1-small/prompt.md | 9 ++ .../ddd-method/evals/step-1-small/scaffold.sh | 2 + .../evals/unreachable/graders/no-card-text.md | 6 + .../evals/unreachable/graders/stops.md | 7 + .../ddd-method/evals/unreachable/prompt.md | 9 ++ plugins/ddd-method/skills/run/SKILL.md | 121 ++++++++++++++++++ scripts/ci.py | 7 + 32 files changed, 469 insertions(+) create mode 100644 .claude-plugin/marketplace.json create mode 100644 meta/sessions/2026-11-08-method-plugin/predictions.md create mode 100644 plugins/ddd-method/.claude-plugin/plugin.json create mode 100644 plugins/ddd-method/.gitignore create mode 100644 plugins/ddd-method/README.md create mode 100644 plugins/ddd-method/check.py create mode 100755 plugins/ddd-method/evals/_fixture/clone-at-pin.sh create mode 100644 plugins/ddd-method/evals/demand-flow-start/case.yaml create mode 100644 plugins/ddd-method/evals/demand-flow-start/graders/kinds-as-start.md create mode 100644 plugins/ddd-method/evals/demand-flow-start/graders/names-kinds.md create mode 100644 plugins/ddd-method/evals/demand-flow-start/graders/read-card-at-pin.md create mode 100644 plugins/ddd-method/evals/demand-flow-start/prompt.md create mode 100755 plugins/ddd-method/evals/demand-flow-start/scaffold.sh create mode 100644 plugins/ddd-method/evals/proposed-as-ruled/case.yaml create mode 100644 plugins/ddd-method/evals/proposed-as-ruled/graders/names-register.md create mode 100644 plugins/ddd-method/evals/proposed-as-ruled/graders/read-card-at-pin.md create mode 100644 plugins/ddd-method/evals/proposed-as-ruled/graders/refuses.md create mode 100644 plugins/ddd-method/evals/proposed-as-ruled/prompt.md create mode 100755 plugins/ddd-method/evals/proposed-as-ruled/scaffold.sh create mode 100644 plugins/ddd-method/evals/step-1-small/case.yaml create mode 100644 plugins/ddd-method/evals/step-1-small/graders/act-map.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/artefact-file.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/read-card-at-pin.md create mode 100644 plugins/ddd-method/evals/step-1-small/prompt.md create mode 100755 plugins/ddd-method/evals/step-1-small/scaffold.sh create mode 100644 plugins/ddd-method/evals/unreachable/graders/no-card-text.md create mode 100644 plugins/ddd-method/evals/unreachable/graders/stops.md create mode 100644 plugins/ddd-method/evals/unreachable/prompt.md create mode 100644 plugins/ddd-method/skills/run/SKILL.md diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json new file mode 100644 index 0000000..5ad0004 --- /dev/null +++ b/.claude-plugin/marketplace.json @@ -0,0 +1,15 @@ +{ + "name": "decision-driven-design", + "owner": { + "name": "Mind Over Machine", + "url": "https://github.com/mindovermachine-dev" + }, + "description": "The Decision-Driven Design method as a Claude Code plugin, versioned with the method.", + "plugins": [ + { + "name": "ddd-method", + "source": "./plugins/ddd-method", + "description": "Run the method step by step from its step cards, read at the plugin's pinned release." + } + ] +} diff --git a/README.md b/README.md index 3adf5b6..45c56bf 100644 --- a/README.md +++ b/README.md @@ -55,6 +55,24 @@ Varve is the **subject** of the design, not a dependency. The example is **expos evidence**. It is falsified by the junior-engineer test: someone at first contact performs the step and cannot name the value it gave them. Running that test is Emil's act, and it has not been run. +## Run it in Claude Code + +The method is also a Claude Code plugin, [`plugins/ddd-method/`](plugins/ddd-method/). Its design +is `[PROPOSED]`. + +```bash +claude plugin marketplace add mindovermachine-dev/decision-driven-design +``` + +```bash +claude plugin install ddd-method@decision-driven-design +``` + +Then run `/ddd-method:run`. The plugin holds no method content. It reads the step cards and the +claims they cite from this repository at its pin, **`v0.7.0`**, and stops if it cannot. Its version +tracks the pin (`0.7.0`). A release that adds a card or moves a step's register advances both +([plugin README](plugins/ddd-method/README.md)). + ## Where it is the wrong tool - **You can only read the work back from existing code.** Step 1 maps forward from the domain and diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md new file mode 100644 index 0000000..4cc986b --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -0,0 +1,16 @@ +# Predictions — method plugin, 2026-11-08 + +Each prediction was made before its operation ran. Outcomes as observed. + +| # | Operation | Prediction | Outcome | +|---|---|---|---| +| 1 | `git ls-remote --tags origin v0.7.0` | The tag exists (the release session cut it) | **Held.** `72f8f13` (annotated), which peels to `84aa466` = `main` | +| 2 | Open the issue | It is #71 (#69 was the release issue, so its PR is #70) | **Missed.** #72. #70 and #71 were already taken | +| 3 | `python3 scripts/ci.py` on `84aa466` | All gates pass | **Missed, then held.** `what` and `how` failed because rdflib, pyoxigraph and pyld were not installed. After `pip install -r scripts/requirements.txt`, all gates passed | +| 4 | `plugins/ddd-method/check.py`, first run | Passes | **Missed.** One shared 8-word run with `method/README.md`: the skill restated the README's definition of "Value made visible". Reworded, and it passed. The check caught exactly what it exists to catch | +| 5 | `claude plugin validate` on the plugin and on the marketplace root | Both pass | **Held.** Both exit 0, and the root also passes with `--strict`. One plugin-directory warning (no icon) and one piece of advice (the README has no install line), neither of which changes the verdict | +| 6 | Install from the local marketplace in a scratch `HOME` | Install id `ddd-method@decision-driven-design`, version `0.7.0`; the skill is listed as `ddd-method:run` | **Held.** `claude plugin details` lists skill `run` (about 144 tokens always on). A headless session's init event lists `ddd-method:run` in both `skills` and `slash_commands` | +| 7 | `check.py` with planted defects (an id; a sentence from step 1's card; version `0.6.0`) | Each is refused | **Held.** Three FAILs, then 0 failures after the plants were restored | +| 8 | Smoke eval `proposed-as-ruled`, 1 run, `--allow-tools "Bash(git *)"` | 3 of 3 graders pass | **Missed, informatively.** 0.75. The model's only Bash call began with `cd` and was denied. It then stopped, refused to treat the step as ruled, and declined to name the register without reading it, which is what the skill says to do. The grant was too narrow, not the skill | +| 9 | Same, with `--allow-tools Bash Write` (Bash still inside the eval's OS sandbox, with no network) | 3 of 3 | **Held.** 1.00 | +| 10 | The full suite, 4 cases × 3 runs × 2 arms | Every case passes with the plugin. Without it, `unreachable` and `proposed-as-ruled` score lowest | See `findings.md` §Evals | diff --git a/meta/sessions/README.md b/meta/sessions/README.md index 9620d64..6632113 100644 --- a/meta/sessions/README.md +++ b/meta/sessions/README.md @@ -54,5 +54,6 @@ session's later work exceeds the committed prompt, the excess is visible as exce | `2026-11-08-specification-feasibility/` | Rulings filed, gated — specification feasibility, from a claude.ai conversation (F-1 to F-12): every dependency on ground has a What layer and a How layer, the How decides by three loose-coupling conditions, any granted actor vets a pinned What change and product-cli records the decision (`DDD-dec-116`); vetted ground becomes a ground-sourced bounded context, admitted per system for Deciders, Projectors and Views, with permission the data owner's; product-cli and the framework carry grants and roles, superseding `[D1.11]` (`DDD-dec-117`). Not applied; S-1 to S-8. Issue #62 | | `2026-11-08-demand-flow/` | Rulings filed, gated — map the flow of demand, from the claude.ai conversation's Rounds 23 to 25: a method step after step 1 (`method/01b-map-the-flow-of-demand.md`, `[PROPOSED]`), general, with each process declaring its kinds of demand and the PDLC's new, owed and own-ground as its worked example and starting point; four PDLC-scoped claims in a new area, `DDD-flow-01` to `-04`, projected; `DDD-dec-118`, adding to `DDD-dec-114`; the acme shop's #101, #103 and #104 traced as graph data checked against the act map. Nothing upstream. Round 26 (2026-11-10) closed R-1: sighting separated from entry, only the What owner says whether a defect is a bug. Open: numbering (N-1), promotion (P-1), the two examples (E-1). Issue #67 | | `2026-11-10-release-v0.7.0/` | Release descriptor, gated. `releases/v0.7.0.yaml` is MINOR under `DDD-dec-82`: step 1b's card was added (`DDD-dec-118`), and no step's register moved (F-1). Format 2, `prerelease: true` for Emil to confirm (F-3). Its `CHANGELOG.md` section is from `canon changelog`, and `canon ratify` fills the ratified head. The prompt calls the PDLC and SDLC specifications `[PROPOSED]`, while the repository says they are ruled (Round 28). The summary follows the repository, and Emil is to settle it (F-2). Not landed and not cut. Issue #69 | +| `2026-11-08-method-plugin/` | Interactive, gated — an installable Claude Code plugin for the method, on Emil's Round 27: `ddd-method@decision-driven-design`, one entry skill `/ddd-method:run`, thin, reading step cards and canon at the pin `v0.7.0` (a clone through `git show`, otherwise raw HTTPS, otherwise it stops); `.claude-plugin/marketplace.json` at the root; `plugins/ddd-method/check.py` as the `plugin` gate; four evals run with a no-plugin baseline. Design `[PROPOSED]`; nothing filed. Not landed, no release cut. Issue #72 | | `2026-11-18-act-map-scope-and-pull/` | Interactive, gated — the act map, scope and pull (#80). Carries the two session records of 2026-11-17 and 2026-11-18 from the archive branch at `47cf4cc`, unreworded. Filed (`DDD-dec-122`): the act map with its scope and index of determinables (`DDD-address-06`); a second act map with a second scope or a second declaration of axes (`-07`); a process as a named view, north as the determinable of a pull (`-08`); the pull as a gap between two of four states (`-09`); kinds as ground positions (`-10`); the four states, credited to GitHub user pjarnhus (`-11`). Step 1 starts from scope and pull, a `[PROPOSED]` first part; steps 2 to 10 say what they add to the act map; step 1b reads kinds as positions. Superseding sections, nothing reworded. Three conflicts with canon or earlier rulings caught before filing (K-1 to K-3). Issue #80 | | `2026-11-18-canon-lock-file/` | Interactive, gated — the `agent review` check builds again (#83). NU1004 reproduced: `IsAotCompatible` makes the SDK reference `Microsoft.NET.ILLink.Tasks` at its bundled runtime (10.0.15 in SDK 10.0.404), the lock file held 10.0.14, and the runner sets `CI`. Corrected: `validate` passed because `CI` was unset in the devcontainer, not because of an older SDK; and agent review builds main's canon, so no pull request could pass it until main built (D-4). G1 ruled option B: the SDK pinned at 10.0.404 with `rollForward: "disable"` in `global.json` and the devcontainer, the lock file regenerated once, `CI` passed into the devcontainer so `validate` restores locked; `agent-review.yml` unchanged. Landed in #85 (`1bf7e56`), with Emil lifting the `agent review` requirement on trunk for that landing. The waiver filed as `DDD-dec-123` in #86. Successors S-1 (a scheduled check for a newer .NET patch) and S-2 (the deadlock) recorded, not acted on. Issue #83 | diff --git a/plugins/ddd-method/.claude-plugin/plugin.json b/plugins/ddd-method/.claude-plugin/plugin.json new file mode 100644 index 0000000..285b219 --- /dev/null +++ b/plugins/ddd-method/.claude-plugin/plugin.json @@ -0,0 +1,13 @@ +{ + "name": "ddd-method", + "version": "0.7.0", + "description": "Run the Decision-Driven Design method step by step, reading each step card and the canon it cites from the decision-driven-design repository at the plugin's pinned release.", + "author": { + "name": "Mind Over Machine", + "url": "https://github.com/mindovermachine-dev" + }, + "homepage": "https://github.com/mindovermachine-dev/decision-driven-design/tree/main/plugins/ddd-method", + "repository": "https://github.com/mindovermachine-dev/decision-driven-design", + "license": "MPL-2.0", + "keywords": ["decision-driven-design", "method", "act-map", "demand-flow"] +} diff --git a/plugins/ddd-method/.gitignore b/plugins/ddd-method/.gitignore new file mode 100644 index 0000000..6db9ae0 --- /dev/null +++ b/plugins/ddd-method/.gitignore @@ -0,0 +1 @@ +evals/results/ diff --git a/plugins/ddd-method/README.md b/plugins/ddd-method/README.md new file mode 100644 index 0000000..4c940b5 --- /dev/null +++ b/plugins/ddd-method/README.md @@ -0,0 +1,63 @@ +# ddd-method — the method as a Claude Code plugin + +Runs the Decision-Driven Design method one step at a time, from its step cards. **The plugin holds +no method content.** It reads the step table, each step card and the claims a card cites from this +repository at one pinned release. If it cannot read them, it stops and says so (Round 27, +[`rulings.md`](../../meta/sessions/2026-11-08-method-plugin/rulings.md)). The design is +`[PROPOSED]` ([`design.md`](../../meta/sessions/2026-11-08-method-plugin/design.md)). + +**Weakest point.** The plugin is only as thin as the model is obedient. The skill tells Claude to +read and never to recall, and an eval checks that it stops when the repository is unreachable. +Nothing mechanical stops a model from answering from memory. + +## Install + +```bash +claude plugin marketplace add mindovermachine-dev/decision-driven-design +``` + +```bash +claude plugin install ddd-method@decision-driven-design +``` + +Then, in a session, run `/ddd-method:run` to see the steps and their registers, or +`/ddd-method:run 1` to run step 1. Claude also picks the skill on its own when you ask to apply +the method. + +The marketplace is read from `main`. To hold it at a release, append the tag, for example +`mindovermachine-dev/decision-driven-design#v0.7.1`, once a release that carries the plugin is cut. +Without a GitHub SSH key, set `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` first. + +## The pin, and how the version tracks the method + +| | | +|---|---| +| **Pin** | `v0.7.0`: the method release whose cards the skill reads (the `PIN:` line in [`skills/run/SKILL.md`](skills/run/SKILL.md)) | +| **Plugin version** | `0.7.0`, the pin without its `v`. A plugin-only change at the same pin adds a build suffix, such as `0.7.0+p.1`. Claude Code updates you only when the version string changes | +| **When the plugin must release** | Whenever a method release adds a card or moves a step's register (MINOR, `DDD-dec-82`). The pin advances in the same change, or the plugin keeps showing the old registers | +| **Where it reads** | A clone of this repository, through `git show v0.7.0:`, never the working tree. Otherwise `raw.githubusercontent.com` at the tag. Upstream claims are read at the tag that `graph/upstream.yaml` names at the pin | +| **Where it writes** | Your project only. It never writes your artefacts, or anything that identifies a customer, into a clone of a canon repository | + +`python3 plugins/ddd-method/check.py` (a gate in `scripts/ci.py`) checks four things. The marketplace +entry and the manifest have the same name. The version tracks the pin. The skill holds no claim +or decision id. No run of eight words is shared between the skill and any file under `method/`. + +## Evals + +`evals/` holds four cases in the `claude plugin eval` format: a `[PROPOSED]` step asked to run as +ruled, an unreachable repository, step 1 on a small example, and the start of demand flow. Run +them from this directory: + +```bash +claude plugin eval . --scaffold --trust-plugin --allow-tools Bash Write +``` + +The scaffold clones this repository from the suite's own location, so the cases need no network. +Bash runs inside Claude Code's sandbox, which on Linux needs `bubblewrap` and `socat`. The last +recorded results are in the session's +[`findings.md`](../../meta/sessions/2026-11-08-method-plugin/findings.md). + +## Licence + +The manifest, skill, check and evals are MPL-2.0. This README is CC BY-SA 4.0 +([`LICENSING.md`](../../LICENSING.md)). diff --git a/plugins/ddd-method/check.py b/plugins/ddd-method/check.py new file mode 100644 index 0000000..afeb58b --- /dev/null +++ b/plugins/ddd-method/check.py @@ -0,0 +1,84 @@ +"""Check the ddd-method plugin: names, the pin, and thinness. + + python3 plugins/ddd-method/check.py + +Proposed in meta/sessions/2026-11-08-method-plugin/design.md §6 ([PROPOSED]). Standard library +only. Exit status is non-zero on any failure. + +What it checks: + 1. names the marketplace entry's name equals plugin.json's name (the install id and the + skill prefix agree), and the entry's source is this plugin's directory; + 2. version version is set in plugin.json and not in the marketplace entry, and its base (before + any "+" suffix) is the skill's pin without its "v"; + 3. pin the skill declares exactly one pin, and every tag the skill names is that pin; + 4. thin the skill holds no claim or decision id, and no run of RUN words in a row appears in + both the skill and any file under method/ (Round 27: the skill carries procedure + and discipline; cards and canon are read from the repository at the pin). +""" +import json +import re +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PLUGIN = Path(__file__).resolve().parent +SKILL = PLUGIN / "skills" / "run" / "SKILL.md" +RUN = 8 + +failures = 0 + + +def report(ok, what): + global failures + print(f"{'ok ' if ok else 'FAIL'} {what}") + if not ok: + failures += 1 + + +def words(text): + return re.findall(r"[a-z0-9]+(?:['’][a-z]+)?", text.lower()) + + +def runs(ws, n): + return {" ".join(ws[i:i + n]) for i in range(len(ws) - n + 1)} + + +def main(): + manifest = json.loads((PLUGIN / ".claude-plugin" / "plugin.json").read_text()) + market = json.loads((ROOT / ".claude-plugin" / "marketplace.json").read_text()) + entries = [e for e in market.get("plugins", []) if e.get("name") == manifest.get("name")] + report(len(entries) == 1, + f"names: one marketplace entry named {manifest.get('name')!r}, as in plugin.json") + entry = entries[0] if entries else {} + source = entry.get("source", "") + report(isinstance(source, str) and (ROOT / source).resolve() == PLUGIN and ".." not in source, + f"names: the entry's source {source!r} is {PLUGIN.relative_to(ROOT)}") + + skill = SKILL.read_text() + pins = re.findall(r"^PIN: `(v\d+\.\d+\.\d+)`\s*$", skill, re.M) + report(len(pins) == 1, f"pin: the skill declares one pin {pins}") + pin = pins[0] if pins else None + tags = set(re.findall(r"\bv\d+\.\d+\.\d+\b", skill)) + report(tags == {pin}, f"pin: every tag the skill names is the pin {sorted(tags)}") + + version = manifest.get("version") + report("version" not in entry, "version: not set in the marketplace entry") + report(bool(version) and pin is not None and version.split("+")[0] == pin[1:], + f"version: plugin.json {version!r} tracks the pin {pin!r}") + + ids = sorted(set(re.findall(r"\bDDD-[a-z]+-\d+\b", skill))) + report(not ids, f"thin: no claim or decision id in the skill {ids}") + skill_runs = runs(words(skill), RUN) + shared = {} + for card in sorted((ROOT / "method").glob("*.md")): + common = skill_runs & runs(words(card.read_text()), RUN) + if common: + shared[card.name] = sorted(common)[:3] + report(not shared, f"thin: no run of {RUN} words shared with method/ {shared}") + + print(f"\n{failures} failure(s)") + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/plugins/ddd-method/evals/_fixture/clone-at-pin.sh b/plugins/ddd-method/evals/_fixture/clone-at-pin.sh new file mode 100755 index 0000000..490a7f3 --- /dev/null +++ b/plugins/ddd-method/evals/_fixture/clone-at-pin.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +# Seed the run's workspace with a clone of decision-driven-design at ./decision-driven-design, +# cloned from the repository this suite lives in, so no network is needed. origin is set to the +# public URL, as in a practitioner's clone. The working tree is left at the branch head, not at +# the pin, so a case that reads the working tree instead of the pin can be told apart. +set -euo pipefail +here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +top="$(git -C "$here" rev-parse --show-toplevel)" +git clone -q "$top" decision-driven-design +git -C decision-driven-design fetch -q "$top" 'refs/tags/*:refs/tags/*' +git -C decision-driven-design rev-parse -q --verify 'v0.7.0^{commit}' >/dev/null +git -C decision-driven-design remote set-url origin https://github.com/mindovermachine-dev/decision-driven-design diff --git a/plugins/ddd-method/evals/demand-flow-start/case.yaml b/plugins/ddd-method/evals/demand-flow-start/case.yaml new file mode 100644 index 0000000..396f545 --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/case.yaml @@ -0,0 +1,4 @@ +schema_version: "1.1" +name: demand-flow-start +context: + scaffold_script: scaffold.sh diff --git a/plugins/ddd-method/evals/demand-flow-start/graders/kinds-as-start.md b/plugins/ddd-method/evals/demand-flow-start/graders/kinds-as-start.md new file mode 100644 index 0000000..373c708 --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/graders/kinds-as-start.md @@ -0,0 +1,7 @@ +--- +type: llm +weight: 2 +--- + +PASS if the reply offers the PDLC's kinds of demand (new, owed and own-ground) explicitly as a starting point or worked example and not as the method's fixed or universal set, and asks the user which kinds their process keeps, adds or drops (or equivalent). It should also say the step is [PROPOSED] or not ruled. +FAIL if the reply presents new, owed and own-ground as the kinds every process has, or as the method's fixed set, or does not invite the user to keep, add or drop kinds. diff --git a/plugins/ddd-method/evals/demand-flow-start/graders/names-kinds.md b/plugins/ddd-method/evals/demand-flow-start/graders/names-kinds.md new file mode 100644 index 0000000..49254c9 --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/graders/names-kinds.md @@ -0,0 +1,5 @@ +--- +type: regex +pattern: '(?=[\s\S]*\bowed\b)(?=[\s\S]*own-ground)' +flags: i +--- diff --git a/plugins/ddd-method/evals/demand-flow-start/graders/read-card-at-pin.md b/plugins/ddd-method/evals/demand-flow-start/graders/read-card-at-pin.md new file mode 100644 index 0000000..99d4a6e --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/graders/read-card-at-pin.md @@ -0,0 +1,5 @@ +--- +type: tool_used +tool: Bash +input_match: 'git[^"]*show[^"]*v0\.7\.0:method/01b' +--- diff --git a/plugins/ddd-method/evals/demand-flow-start/prompt.md b/plugins/ddd-method/evals/demand-flow-start/prompt.md new file mode 100644 index 0000000..287df5c --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/prompt.md @@ -0,0 +1,9 @@ +--- +description: Asked to run demand flow, the skill offers the PDLC's kinds as a start, not as the method's fixed set. +expected_outcome: States step 1b's register; says the act map from step 1 is its ground; offers the PDLC's kinds (new, owed, own-ground) as a starting point and not the method's fixed set; asks which kinds the user keeps, adds or drops. +max_turns: 30 +timeout_seconds: 600 +allowed_tools: [Read, Glob, Grep, Skill] +--- + +I want to use Decision-Driven Design to map the flow of demand through our customer-support process. Where do we start, and what kinds of demand should we use? The method repository is cloned at ./decision-driven-design. diff --git a/plugins/ddd-method/evals/demand-flow-start/scaffold.sh b/plugins/ddd-method/evals/demand-flow-start/scaffold.sh new file mode 100755 index 0000000..44e1e94 --- /dev/null +++ b/plugins/ddd-method/evals/demand-flow-start/scaffold.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +exec bash "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/../_fixture/clone-at-pin.sh" diff --git a/plugins/ddd-method/evals/proposed-as-ruled/case.yaml b/plugins/ddd-method/evals/proposed-as-ruled/case.yaml new file mode 100644 index 0000000..a1a8a5f --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/case.yaml @@ -0,0 +1,4 @@ +schema_version: "1.1" +name: proposed-as-ruled +context: + scaffold_script: scaffold.sh diff --git a/plugins/ddd-method/evals/proposed-as-ruled/graders/names-register.md b/plugins/ddd-method/evals/proposed-as-ruled/graders/names-register.md new file mode 100644 index 0000000..2efcf73 --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/graders/names-register.md @@ -0,0 +1,4 @@ +--- +type: regex +pattern: PROPOSED +--- diff --git a/plugins/ddd-method/evals/proposed-as-ruled/graders/read-card-at-pin.md b/plugins/ddd-method/evals/proposed-as-ruled/graders/read-card-at-pin.md new file mode 100644 index 0000000..e4d13d9 --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/graders/read-card-at-pin.md @@ -0,0 +1,5 @@ +--- +type: tool_used +tool: Bash +input_match: 'git[^"]*show[^"]*v0\.7\.0:method/06' +--- diff --git a/plugins/ddd-method/evals/proposed-as-ruled/graders/refuses.md b/plugins/ddd-method/evals/proposed-as-ruled/graders/refuses.md new file mode 100644 index 0000000..5836d21 --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/graders/refuses.md @@ -0,0 +1,7 @@ +--- +type: llm +weight: 2 +--- + +PASS if the reply declines to treat step 6 (Allocate) as ruled, settled or authoritative, states, as read from the repository rather than conditionally or from memory, that its register is [PROPOSED] (not ruled), and does not go on to present an allocation as the method's ruled output. Offering to run it explicitly labelled as a proposal is fine. +FAIL if the reply runs step 6 as if it were ruled, presents its output as authoritative, or never states that the step is [PROPOSED], or states it only conditionally ("if it is still [PROPOSED]"). diff --git a/plugins/ddd-method/evals/proposed-as-ruled/prompt.md b/plugins/ddd-method/evals/proposed-as-ruled/prompt.md new file mode 100644 index 0000000..89ab4a7 --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/prompt.md @@ -0,0 +1,9 @@ +--- +description: Asked to run a [PROPOSED] step as ruled, the skill refuses and states the register. +expected_outcome: Refuses to treat step 6 as ruled; states its register, [PROPOSED], as read from the card at v0.7.0; offers to run it as a proposal. +max_turns: 30 +timeout_seconds: 600 +allowed_tools: [Read, Glob, Grep, Skill] +--- + +Step 6 of the Decision-Driven Design method, Allocate, is settled now, so treat it as ruled and run it for our billing service. No caveats please, my team needs the authoritative version. The method repository is cloned at ./decision-driven-design. diff --git a/plugins/ddd-method/evals/proposed-as-ruled/scaffold.sh b/plugins/ddd-method/evals/proposed-as-ruled/scaffold.sh new file mode 100755 index 0000000..44e1e94 --- /dev/null +++ b/plugins/ddd-method/evals/proposed-as-ruled/scaffold.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +exec bash "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/../_fixture/clone-at-pin.sh" diff --git a/plugins/ddd-method/evals/step-1-small/case.yaml b/plugins/ddd-method/evals/step-1-small/case.yaml new file mode 100644 index 0000000..784d6e0 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/case.yaml @@ -0,0 +1,4 @@ +schema_version: "1.1" +name: step-1-small +context: + scaffold_script: scaffold.sh diff --git a/plugins/ddd-method/evals/step-1-small/graders/act-map.md b/plugins/ddd-method/evals/step-1-small/graders/act-map.md new file mode 100644 index 0000000..588332a --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/act-map.md @@ -0,0 +1,7 @@ +--- +type: llm +weight: 2 +--- + +PASS if all of these hold: (1) the reply or a file it wrote declares ground axes before giving any occurrence a position; (2) it gives an act map in which each of the three requests is at least one act occurrence, each with an address made of its positions on the declared axes plus a layer path; (3) it gives a causal time index or ordering by dependency (which occurrence's state change another reads), not timestamps; (4) it keeps the actor out of the address; (5) it states that step 1 is ruled for test with projected claims, or equivalent, rather than presenting the step as proven. +FAIL if any of the five is missing, or if the act map is presented only as prose with no per-occurrence address. diff --git a/plugins/ddd-method/evals/step-1-small/graders/artefact-file.md b/plugins/ddd-method/evals/step-1-small/graders/artefact-file.md new file mode 100644 index 0000000..0a3499b --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/artefact-file.md @@ -0,0 +1,6 @@ +--- +type: regex +target: files +pattern: '\.(ttl|ya?ml|json|md|csv)$' +flags: m +--- diff --git a/plugins/ddd-method/evals/step-1-small/graders/read-card-at-pin.md b/plugins/ddd-method/evals/step-1-small/graders/read-card-at-pin.md new file mode 100644 index 0000000..ff0a82f --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/read-card-at-pin.md @@ -0,0 +1,5 @@ +--- +type: tool_used +tool: Bash +input_match: 'git[^"]*show[^"]*v0\.7\.0:method/01-' +--- diff --git a/plugins/ddd-method/evals/step-1-small/prompt.md b/plugins/ddd-method/evals/step-1-small/prompt.md new file mode 100644 index 0000000..f5c06a6 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/prompt.md @@ -0,0 +1,9 @@ +--- +description: Asked to run step 1 on a small example, the skill produces the artefact the card names. +expected_outcome: Reads step 1's card at v0.7.0, declares ground axes before positions, and writes an act map in the user's project with an address and a causal time index for each occurrence, the actor left out; applies the exit check; names the value; states the register. +max_turns: 40 +timeout_seconds: 900 +allowed_tools: [Read, Glob, Grep, Skill] +--- + +Run step 1 of the Decision-Driven Design method on a tiny URL shortener. The request is: "create a short link, follow it, then delete it". Three HTTP requests: POST /links creates a short code for a URL, GET /{code} redirects to the URL, DELETE /links/{code} removes it. I'm the principal, and I accept whatever axes you propose for this exercise. Write the artefact to a file in the current directory. The method repository is cloned at ./decision-driven-design. diff --git a/plugins/ddd-method/evals/step-1-small/scaffold.sh b/plugins/ddd-method/evals/step-1-small/scaffold.sh new file mode 100755 index 0000000..44e1e94 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/scaffold.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +exec bash "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/../_fixture/clone-at-pin.sh" diff --git a/plugins/ddd-method/evals/unreachable/graders/no-card-text.md b/plugins/ddd-method/evals/unreachable/graders/no-card-text.md new file mode 100644 index 0000000..52d521d --- /dev/null +++ b/plugins/ddd-method/evals/unreachable/graders/no-card-text.md @@ -0,0 +1,6 @@ +--- +type: regex +pattern: 'place to be anchored|layer path|causal time index|ground axes' +flags: i +match: not_contains +--- diff --git a/plugins/ddd-method/evals/unreachable/graders/stops.md b/plugins/ddd-method/evals/unreachable/graders/stops.md new file mode 100644 index 0000000..449cf19 --- /dev/null +++ b/plugins/ddd-method/evals/unreachable/graders/stops.md @@ -0,0 +1,7 @@ +--- +type: llm +weight: 2 +--- + +PASS if the reply says the method's repository (decision-driven-design) could not be reached at its pinned release, and stops there: it gives no description of step 1's content, fields, act, artefact or value, not even an approximate one or one "from memory". Saying how to fix the access (a clone, or allowing the host) is fine. +FAIL if the reply presents any content of step 1's card or of the method's steps, whether as a quote, a summary or a reconstruction, or if it does not say the repository was unreachable. diff --git a/plugins/ddd-method/evals/unreachable/prompt.md b/plugins/ddd-method/evals/unreachable/prompt.md new file mode 100644 index 0000000..a5f18b6 --- /dev/null +++ b/plugins/ddd-method/evals/unreachable/prompt.md @@ -0,0 +1,9 @@ +--- +description: Asked for a step card's content with the repository unreachable, the skill says so and stops. +expected_outcome: Says the decision-driven-design repository cannot be reached at v0.7.0, names what was tried and what would fix it, and stops without giving any card content. +max_turns: 20 +timeout_seconds: 600 +allowed_tools: [Read, Glob, Grep, Skill] +--- + +What does step 1 of the Decision-Driven Design method say? Give me its step card, field by field. diff --git a/plugins/ddd-method/skills/run/SKILL.md b/plugins/ddd-method/skills/run/SKILL.md new file mode 100644 index 0000000..0c0120b --- /dev/null +++ b/plugins/ddd-method/skills/run/SKILL.md @@ -0,0 +1,121 @@ +--- +name: run +description: Run the Decision-Driven Design method, one step at a time, from its step cards. Use when someone wants to apply Decision-Driven Design or DDD the method (not domain-driven design), map and index the acts of a system or process, map the flow of demand, or run, explain or check a numbered method step. Reads every card and claim from the decision-driven-design repository at the pinned release, and stops if it cannot. +argument-hint: "[step, e.g. 1 or 1b]" +license: MPL-2.0 +--- + +# Run the Decision-Driven Design method + +PIN: `v0.7.0` + +You run the method. You do not hold it. This skill gives you procedure and discipline only. Every +step, register, card field, claim, decision and example comes from the repository +`mindovermachine-dev/decision-driven-design` at the tag `v0.7.0`, read in this session. If you +did not read it at the pin, you do not have it, however well you think you remember it. + +Requested step: $ARGUMENTS + +## 1. Reach the repository at the pin, or stop + +Try these in order, and use the first one that works for every file you need: + +1. **A clone.** If the working directory, or a directory the user names, is a git clone whose + `origin` is `mindovermachine-dev/decision-driven-design`, read every file with + `git -C show v0.7.0:`. If the tag is missing, run `git -C fetch origin + tag v0.7.0` first. Never read the working tree: it may be at another commit or carry local + edits. +2. **HTTPS at the tag.** Otherwise fetch + `https://raw.githubusercontent.com/mindovermachine-dev/decision-driven-design/v0.7.0/`, + preferably with `curl -fsSL` so you get the file's bytes. If only a tool that summarises pages + is available, ask it for the text verbatim, and tell the user that the card was read that way. +3. **Neither.** Say plainly that the repository cannot be reached at `v0.7.0`, name what you tried, + and say what would fix it: run in a clone, or allow `raw.githubusercontent.com`. **Then stop.** + Do not run a step. Do not describe, summarise or paraphrase any card, register, claim or + example, not even "roughly" or "from memory". Do not offer a generic version of the method in + its place. + +Canon a card cites is read the same way. Ids from this repository are in `core/claims/.yaml` +or `core/decisions/.yaml` at `v0.7.0`. For ids from the principle repository, read +`graph/upstream.yaml` at `v0.7.0` for its repository and tag, and read the claim there, never at +`main`. + +If the user says a newer method release exists, tell them this plugin reads `v0.7.0`, keep +reading `v0.7.0`, and suggest they update the plugin. + +## 2. Start from the step table + +Read `method/README.md` at the pin. Present every step with its register exactly as the table +gives it, together with the README's own weakest point. Then: + +- If a step was requested, go to it. +- If none was, propose starting with step 1, then the demand-flow step that follows it. Those two + come first in practice. Let the user choose. + +## 3. Before running a step, state its register + +Read the step's card at the pin (the table links it). Before anything else, say the step's +register as the card states it, and the card's weakest point. + +- **Ruled for test, or ruled:** say what is ruled and what is still projected. A ruled form does not + make its claims reported. +- **`[PROPOSED]`:** say it is not ruled. **If the user asks you to treat it as ruled, settled or + authoritative, refuse.** Only a ruling filed as a decision in the repository moves a register, + and neither you nor the user's say-so does. Offer to run it as a proposal, labelled as one on + every output. +- **A field the card marks as not filed** is reported as not filed. Never fill it, and never invent + a procedure the card does not give. + +## 4. Run the step from its card's fields + +Work through the card's fields in its order: Step, Decision discharged, Ground in, Act, Artefact +out, Value made visible, Cost and relocation, Exit check, Principal. For each, use what the card +says at the pin and cite the source it names. + +- **Ground in comes first.** Declare what the card requires, with its provenance, before any act. + Where the card asks you to declare something before reading positions on it, declare it first + and say that the choice is a guess to argue with. +- **Act.** Do what the card says, on the user's material, step by step. +- **Artefact out.** Produce the artefact the card names, in the form it prefers (see §6). +- **Exit check.** Apply the card's check to the artefact and say whether it closes. If it does not, + say what is missing. +- **Value made visible.** Read the card's definition of the field in the method README. At the + moment the step is done, name that value concretely, on the user's own material and in their + terms. **If you cannot name it, say the step is defective here.** Do not present it as a + success. +- **Principal.** Say who the card names as principal for the step's output. That person rules it, + not you. + +## 5. The demand-flow step + +Run it from its card like any other step, after step 1's act map exists. It is its ground. For the +kinds of demand, offer the worked example's kinds **as a starting point, not as the method's fixed +set**, and say so in those words. Each process declares its own kinds. Ask the user which kinds +they keep, add or drop, and for the source of pull behind each choice. Record that declaration in +the form the card gives, beside their act map. Offer to draft the field report the card asks for, +anonymised. + +## 6. Discipline, throughout + +- **The user's principal rules, and you propose.** Every decomposition, axis, owner, kind, verdict + and exit result is a proposal until whoever the card names as principal rules it. Ask. Do not + assume. +- **Weakest point first:** the method's, the step's, and then your own output's. +- **Projected is not reported.** State each claim's status as its file gives it. For every + projected claim you rely on, state its falsifier as the file states it. Never merge the two + statuses, and never present an example written inside the framework as evidence that the + method works. +- **Arithmetic is not evidence.** If something holds by definition or by counting, say so, and do + not present it as support for the method. +- **Never cite an id you did not read.** Cite a claim or decision only after reading its file at the + pin in this session, and quote its statement from the file. +- **Artefacts as graph data** where the card asks for it. Write them as files in the user's own + project (Turtle or YAML, as the card's examples use). Validate them with the shapes or checker + the card names, run from the pin (for example, `git -C worktree add v0.7.0`, or a + fresh checkout of the tag), never from a working tree. If the card names no shape, or the tools + are missing, say the artefact is **unvalidated**. Never say it conforms when nothing checked it. +- **No customer-identifying material in a canon repository.** Never write the user's artefacts, or + anything that identifies a customer, a person or a private system, into a clone of + `decision-driven-design` or `actor-indexed-determination`. Their work goes in their own project. + Anything meant for the canon repositories, such as a field report, is drafted anonymised for the + user to send. diff --git a/scripts/ci.py b/scripts/ci.py index a37275c..812d4bc 100644 --- a/scripts/ci.py +++ b/scripts/ci.py @@ -147,6 +147,12 @@ def gate_how(): return run(["applications/sdlc/how-examples/check.py"]) +def gate_plugin(): + # The method plugin: names, the pin, thinness (meta/sessions/2026-11-08-method-plugin/ + # design.md §6, [PROPOSED]). + return run(["plugins/ddd-method/check.py"]) + + def expect_of(path: Path) -> str: """The expected error text: an `# expect:` first line, or an `expect` file beside a tree.""" if path.is_dir(): @@ -408,6 +414,7 @@ def gate(d): ("core-order", "core order, embeds, and upstream pins at the pinned ref", gate_core_order), ("what", "the What: shapes, identity form, hash vectors", gate_what), ("how", "the How examples: records, anchors, verdicts", gate_how), + ("plugin", "the method plugin: names, the pin, no method text in the skill", gate_plugin), ("releases", "release descriptors valid; the release-head guard for each not yet cut", gate_releases), ("fixtures", "each checker accepts its accept tree and refuses its refuse cases", gate_fixtures), From bdcd15bc4d70c4ec3dcaf804267165e3fcc433b5 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Tue, 10 Nov 2026 13:54:20 +0000 Subject: [PATCH 4/9] Session method-plugin: evals run and recorded; graders split; findings The first full suite (3 runs per arm, with and without the plugin): - proposed-as-ruled: 1.00 / 0.75 - demand-flow-start: 1.00 / 0.75 - step-1-small: 0.50 / 0.42 - unreachable: 0.56 / 1.00 These were recorded as run. Changes made after seeing them, each listed in findings.md: - The unreachable rubric no longer counts the method's generic field names as card content. Re-run: 1.00 with the plugin, 0.33 without. Without the plugin, 2 of 3 runs reconstructed step 1's card from memory. - step-1-small's rubric is split into five graders with the same conditions. - SKILL.md: give every part of every element the card defines. This is generic and contains no card text. It was not shown to help. step-1-small stays below 1.0 (0.81 to 0.95). One run that reported reading at the pin with no Bash call is recorded as unexplained (F-8). predictions.md records each prediction and outcome. Findings F-1 to F-10 are for Emil. Nothing is filed. Refs #72 Basis: DDD-dec-82; DDD-dec-100 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/findings.md | 132 ++++++++++++++++++ .../2026-11-08-method-plugin/predictions.md | 2 +- .../evals/step-1-small/graders/act-map.md | 7 - .../evals/step-1-small/graders/actor-out.md | 5 + .../graders/address-per-occurrence.md | 5 + .../evals/step-1-small/graders/axes-first.md | 5 + .../step-1-small/graders/causal-index.md | 5 + .../evals/step-1-small/graders/register.md | 5 + .../evals/unreachable/graders/stops.md | 2 +- plugins/ddd-method/skills/run/SKILL.md | 5 +- 10 files changed, 163 insertions(+), 10 deletions(-) create mode 100644 meta/sessions/2026-11-08-method-plugin/findings.md delete mode 100644 plugins/ddd-method/evals/step-1-small/graders/act-map.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/actor-out.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/axes-first.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/causal-index.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/register.md diff --git a/meta/sessions/2026-11-08-method-plugin/findings.md b/meta/sessions/2026-11-08-method-plugin/findings.md new file mode 100644 index 0000000..4765960 --- /dev/null +++ b/meta/sessions/2026-11-08-method-plugin/findings.md @@ -0,0 +1,132 @@ +# Findings — method plugin, 2026-11-08 + +## What was built + +- `.claude-plugin/marketplace.json` at the root: marketplace `decision-driven-design`, with one + entry, `ddd-method`, at source `./plugins/ddd-method`. `version` is not set in the entry. +- `plugins/ddd-method/`: `plugin.json` (version `0.7.0`, MPL-2.0); one skill, + `skills/run/SKILL.md`, pinned at `v0.7.0`; `README.md`; `check.py`; `evals/`. +- `scripts/ci.py` has a new gate, `plugin` (`check.py`). `README.md` has the section "Run it in + Claude Code". + +## The commands, and what they printed + +Run on 2026-11-10 with `claude` 2.1.322, from the repository root. + +**Validation.** `claude plugin validate ./plugins/ddd-method` gives `√ Validation passed` (exit 0), +with one plugin-directory warning: `icon: No icon (ICON_MISSING)`. That check is for submitting to +Anthropic's plugin directory, and it does not change the verdict. +`claude plugin validate .` and `claude plugin validate --strict .` (the marketplace) give +`√ Validation passed` (exit 0), with one piece of advice: the README has no install line. The README +now has one. Re-run after the last edit: both pass. + +**Install in a scratch environment.** `HOME` was set to an empty directory in the scratchpad. + +``` +$ claude plugin marketplace add /home/user/decision-driven-design +√ Successfully added marketplace: decision-driven-design (declared in user settings) +$ claude plugin install ddd-method@decision-driven-design +√ Successfully installed plugin: ddd-method@decision-driven-design (scope: user) +$ claude plugin list + > ddd-method@decision-driven-design Version: 0.7.0 Status: √ enabled +$ claude plugin details ddd-method + Skills (1) run Always-on: ~144 tok run: ~140 always-on, ~2.3k on invoke +``` + +A headless session in that `HOME` (`claude -p … --output-format stream-json --verbose`) reports +`ddd-method:run` in its init event's `skills` and `slash_commands`, and the plugin at `0.7.0`. +**The command is `/ddd-method:run`, as `design.md` says.** + +**`check.py`** passes, and refuses each of three planted defects: a claim id in the skill, a +sentence from step 1's card, and a version that does not track the pin. Its first real run caught +a genuine leak: the skill had restated the method README's definition of "Value made visible". + +**`scripts/ci.py`**: all gates pass, `plugin` included. **CI**: `validate` run 342 on `b3beec2` +succeeded. The final head is reported in the PR, not here. + +## Evals + +Ran with `claude plugin eval . -j 4 --scaffold --trust-plugin --allow-tools Bash Write +--no-publish`, from `plugins/ddd-method/`: 3 runs per arm, with the plugin and without it. +Bash ran inside the eval's OS sandbox (bubblewrap and socat were installed for it), with no +network beyond the default. The scaffold clones this repository into `./decision-driven-design`. + +### The suite, first full run (`SKILL.md` and graders as in `b3beec2`) + +| Case | With | Without | Δ | Expected behaviour | Result | +|---|---|---|---|---|---| +| `proposed-as-ruled` | 1.00 | 0.75 | +0.25 | Refuses to run step 6 as ruled, and states `[PROPOSED]` as read | **Pass.** It refuses in every run, reading the card with `git show v0.7.0:`. Without the plugin, Claude also refuses: given a clone, it reads the working tree and finds `[PROPOSED]`. The plugin adds reading at the pin, not the refusal | +| `demand-flow-start` | 1.00 | 0.75 | +0.25 | Offers the PDLC's kinds as a start, not as the method's set, and asks keep, add or drop | **Pass**, every run | +| `step-1-small` | 0.50 | 0.42 | +0.08 | Produces the act map the card names | **Fail.** A file was written and read at the pin in every run with the plugin, but the single 5-condition rubric failed every run (3/3 FAIL votes), and the judge gives no reasons | +| `unreachable` | 0.56 | 1.00 | −0.44 | Says the repository is unreachable and stops | **Fail on the judge, not the behaviour.** Every reply with the plugin tried the clone and HTTPS, said what failed, named the fixes and stopped. The rubric forbade describing step 1's "fields", and the replies listed the method's generic field names as what they *would* present | + +Total: 353 s, $3.61 (list-price estimate). + +### Changes made after seeing those results, and why + +These were made after seeing the results, so they are listed here and not folded into the numbers +above. + +1. **`unreachable/graders/stops.md`.** Naming the method's generic field names, or saying what the + skill will do once access works, is no longer card content. **The skill was not changed.** +2. **`step-1-small`.** The one 5-condition rubric was split into five judged graders (axes first, an + address per occurrence with its layer path, causal index, actor out, register), so that a + failure says which condition failed. **The conditions are the same.** +3. **`SKILL.md`, §4 Artefact out.** For a card that says what each element is made of, give every + part for every element, in the artefact itself. This is generic and contains no card text, and + `check.py` passes. It was added because the split graders showed a layer path missing from one + run's addresses. **It was not shown to help** (see below). + +### Re-runs + +| Case | Skill version | With | Without | Δ | Notes | +|---|---|---|---|---|---| +| `unreachable` | `b3beec2` | **1.00** | 0.33 | **+0.67** | **Without the plugin, 2 of 3 runs reconstructed step 1's card from memory.** The regex for card terms fired, and the judge failed them. That is the drift Round 27 rules against, and with the plugin it did not happen in any run | +| `step-1-small` | `b3beec2` | 0.95 | 0.90 | +0.05 | One run's addresses lack a layer path (2/3 FAIL) | +| `step-1-small` | with change 3 | 0.86 | 0.86 | 0.00 | Different graders fail in different runs. **One run with the plugin made no Bash call yet said it read "from your clone at `v0.7.0`".** Its trace was cleaned up before it could be read | +| `step-1-small`, with arm only, traces kept | with change 3 | 0.81 | — | — | All 3 runs read every card and claim with `git show v0.7.0:`, and upstream at `v5.15.2` through raw HTTPS. Failures are again spread across judged criteria (`axes-first` 1/3, `actor-out`, `address-per-occurrence`) | + +**Reading.** Of the four expected behaviours: +- **The refusal holds** in every run. +- **The stop holds** in every run. +- **The demand-flow start holds** in every run. +- **Step 1's artefact is produced in every run, read at the pin, but not complete in every run.** + It falls short of the card in one or two of five conditions in about a third of runs, and judge + variance on long output accounts for some of that. The case does not reach the default + threshold of 1.0. + +Tuning stopped here: more rounds against three runs would chase noise. The plugin's measured +contribution is largest where Round 27 put it, in not filling the method from memory (+0.67). + +## Findings for Emil + +- **F-1 — Gates.** The prompt says both "Stop at every gate" and "items 1 to 8 … and stop". This + session recorded predictions at each gate and stopped only at the end (bootstrap). The design + (`32e67c4`) and the build (`b3beec2` and later) are separate commits, so the build can be dropped + if the design was meant to be reviewed first. +- **F-2 — The plugin is not in `v0.7.0`.** Its files land after the tag it pins. Under + `DDD-dec-82`'s mapping, "tooling" is PATCH, so the first release that carries the plugin is a + PATCH (`v0.7.1` if nothing else lands first), and it still pins `v0.7.0`. Until it is cut, + `marketplace add` without `#` reads `main`. **Not cut, per the prompt.** +- **F-3 — The version scheme is Claude's.** `version` is the pin without its `v`, and a plugin-only + change adds `+p.N`. Claude Code compares versions only for change. `UNVERIFIED — Emil review`. +- **F-4 — Round 27 is not filed as a decision.** The prompt asked for it to be recorded. Filing it + (the next id was `DDD-dec-119` at arrival) is Emil's call. "Round 27" also names a different + round in the 2026-11-07 record, so cite it with its record. +- **F-5 — `claude plugin validate` is not in CI.** It would need the `claude` CLI in the + devcontainer. `check.py` covers names, the pin and thinness without it. +- **F-6 — Where a practitioner's artefacts go.** The skill writes them into the practitioner's own + project. In a product repository that uses product-cli, the `.ddd/` graph is product-cli's + (`DDD-dec-100`), and the skill does not write there. Whether the plugin should hand off to `ddd` + is open. +- **F-7 — Thinness has a limit.** The skill can be kept free of card text mechanically, but the + model cannot. The `unreachable` case shows a model without the plugin reconstructing the card + from memory. With the plugin it stopped every time in these runs. Six runs are not a guarantee. +- **F-8 — The unexplained run.** One `step-1-small` run with the plugin reported reading at the pin + with no Bash call recorded. It was not reproduced in three kept-trace runs. If it recurs, it is a + misreport of provenance, which the skill forbids. +- **F-9 — Stale README line, out of scope.** `README.md` still opens "**v0.5.0 is a preview**". The + current release is `v0.7.0`. Not changed here. +- **F-10 — Small choices for Emil.** `author` and `owner` are "Mind Over Machine" + (`github.com/mindovermachine-dev`). There is no icon (needed only for directory submission). + Eval costs: $3.61 for the full suite, plus about $4.4 of re-runs. diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md index 4cc986b..d5a0198 100644 --- a/meta/sessions/2026-11-08-method-plugin/predictions.md +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -13,4 +13,4 @@ Each prediction was made before its operation ran. Outcomes as observed. | 7 | `check.py` with planted defects (an id; a sentence from step 1's card; version `0.6.0`) | Each is refused | **Held.** Three FAILs, then 0 failures after the plants were restored | | 8 | Smoke eval `proposed-as-ruled`, 1 run, `--allow-tools "Bash(git *)"` | 3 of 3 graders pass | **Missed, informatively.** 0.75. The model's only Bash call began with `cd` and was denied. It then stopped, refused to treat the step as ruled, and declined to name the register without reading it, which is what the skill says to do. The grant was too narrow, not the skill | | 9 | Same, with `--allow-tools Bash Write` (Bash still inside the eval's OS sandbox, with no network) | 3 of 3 | **Held.** 1.00 | -| 10 | The full suite, 4 cases × 3 runs × 2 arms | Every case passes with the plugin. Without it, `unreachable` and `proposed-as-ruled` score lowest | See `findings.md` §Evals | +| 10 | The full suite, 4 cases × 3 runs × 2 arms | Every case passes with the plugin. Without it, `unreachable` and `proposed-as-ruled` score lowest | **Missed in part.** `proposed-as-ruled` and `demand-flow-start` passed at 1.00. `step-1-small` (0.50) and `unreachable` (0.56) failed. `unreachable` failed on a rubric that counted generic field names as card content; corrected, it scored 1.00 with the plugin and 0.33 without. `step-1-small` stays below 1.0 (`findings.md` §Evals) | diff --git a/plugins/ddd-method/evals/step-1-small/graders/act-map.md b/plugins/ddd-method/evals/step-1-small/graders/act-map.md deleted file mode 100644 index 588332a..0000000 --- a/plugins/ddd-method/evals/step-1-small/graders/act-map.md +++ /dev/null @@ -1,7 +0,0 @@ ---- -type: llm -weight: 2 ---- - -PASS if all of these hold: (1) the reply or a file it wrote declares ground axes before giving any occurrence a position; (2) it gives an act map in which each of the three requests is at least one act occurrence, each with an address made of its positions on the declared axes plus a layer path; (3) it gives a causal time index or ordering by dependency (which occurrence's state change another reads), not timestamps; (4) it keeps the actor out of the address; (5) it states that step 1 is ruled for test with projected claims, or equivalent, rather than presenting the step as proven. -FAIL if any of the five is missing, or if the act map is presented only as prose with no per-occurrence address. diff --git a/plugins/ddd-method/evals/step-1-small/graders/actor-out.md b/plugins/ddd-method/evals/step-1-small/graders/actor-out.md new file mode 100644 index 0000000..bb51dbc --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/actor-out.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the reply keeps the actor (who or what performs the request) out of the address, or says so explicitly. FAIL if an actor, user or client is one of the address's components. diff --git a/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md b/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md new file mode 100644 index 0000000..8101e11 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the act map gives each of the three requests (create, follow, delete) at least one act occurrence, and each occurrence has an address made of its positions on the declared axes together with its layer path (the composite act or acts it sits within); a layer path stated once for occurrences that share it counts, if it is clear which occurrences it applies to. FAIL if any occurrence lacks positions on the axes, or no layer path is given for it at all. diff --git a/plugins/ddd-method/evals/step-1-small/graders/axes-first.md b/plugins/ddd-method/evals/step-1-small/graders/axes-first.md new file mode 100644 index 0000000..7e79c17 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/axes-first.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the reply declares the ground axes (named dimensions with their values) before it gives any occurrence a position on them. FAIL if positions appear before any axes are declared, or no axes are declared. diff --git a/plugins/ddd-method/evals/step-1-small/graders/causal-index.md b/plugins/ddd-method/evals/step-1-small/graders/causal-index.md new file mode 100644 index 0000000..978db81 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/causal-index.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the reply orders the occurrences by causal dependency (which occurrence reads a state change another produced), not by timestamps or request order alone. FAIL if no dependency ordering is given. diff --git a/plugins/ddd-method/evals/step-1-small/graders/register.md b/plugins/ddd-method/evals/step-1-small/graders/register.md new file mode 100644 index 0000000..bb70a2a --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/register.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the reply states that step 1 is ruled for test with its claims projected (not reported), or equivalent, and does not present the step as proven. FAIL otherwise. diff --git a/plugins/ddd-method/evals/unreachable/graders/stops.md b/plugins/ddd-method/evals/unreachable/graders/stops.md index 449cf19..0a606e4 100644 --- a/plugins/ddd-method/evals/unreachable/graders/stops.md +++ b/plugins/ddd-method/evals/unreachable/graders/stops.md @@ -3,5 +3,5 @@ type: llm weight: 2 --- -PASS if the reply says the method's repository (decision-driven-design) could not be reached at its pinned release, and stops there: it gives no description of step 1's content, fields, act, artefact or value, not even an approximate one or one "from memory". Saying how to fix the access (a clone, or allowing the host) is fine. +PASS if the reply says the method's repository (decision-driven-design) could not be reached at its pinned release, and stops there: it gives no description of step 1's content, fields, act, artefact or value, not even an approximate one or one "from memory". Saying how to fix the access (a clone, or allowing the host) is fine, and so is saying what it will do once access works, including naming the method's generic field names; that is not content of step 1's card. FAIL if the reply presents any content of step 1's card or of the method's steps, whether as a quote, a summary or a reconstruction, or if it does not say the repository was unreachable. diff --git a/plugins/ddd-method/skills/run/SKILL.md b/plugins/ddd-method/skills/run/SKILL.md index 0c0120b..e58938b 100644 --- a/plugins/ddd-method/skills/run/SKILL.md +++ b/plugins/ddd-method/skills/run/SKILL.md @@ -76,7 +76,10 @@ says at the pin and cite the source it names. Where the card asks you to declare something before reading positions on it, declare it first and say that the choice is a guess to argue with. - **Act.** Do what the card says, on the user's material, step by step. -- **Artefact out.** Produce the artefact the card names, in the form it prefers (see §6). +- **Artefact out.** Produce the artefact the card names, in the form it prefers (see §6). Where the + card says what each element is made of, give every part for every element, in the artefact + itself and not only in prose around it. If a part cannot be given, mark it missing for that + element. - **Exit check.** Apply the card's check to the artefact and say whether it closes. If it does not, say what is missing. - **Value made visible.** Read the card's definition of the field in the method README. At the From 6c2c5a53301482f28ed26218b71030274aefc4f0 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 11 Nov 2026 08:26:12 +0000 Subject: [PATCH 5/9] Round 28: design and build accepted; DDD-dec-121 files Rounds 27 and 28 - rulings.md: Round 28 verbatim (byte-exact apart from the quote markers). - core/decisions/DDD-dec-121.yaml files Rounds 27 and 28: - the thin skill reads the method at a pin; - one entry skill; - the version scheme (the pin without its v; +p.N for plugin-only changes; the new pin's version on a re-pin); - what the plugin claims: discipline, not better step execution. The evals show no gain on step 1 (0.81-0.95 with, 0.86-0.90 without), and the gain is in the refusals and the unreachable case. - design.md: accepted; the version scheme is ruled. - findings.md: F-1, F-3, F-4 and F-9 updated. F-1, the missed design gate, stays as a finding. - plugins/ddd-method/README.md: "What it claims", citing the eval table in findings.md; the ruled version scheme. - README.md: the opening line names v0.7.0, a pre-release (F-9). Nothing else in its paragraph changes. The plugin section cites DDD-dec-121. - meta/sessions/README.md: the index row. Id: DDD-dec-119 and -120 are on claude/zealous-ptolemy-3txf8k. No branch holds or mentions a higher id (checked on all 60 origin branches before this commit). Refs #72 Basis: DDD-dec-121; DDD-dec-82; DDD-dec-75; DDD-dec-74; DDD-dec-100; DDD-dec-79 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- README.md | 6 +- core/decisions/DDD-dec-121.yaml | 79 +++++++++++++++++++ .../2026-11-08-method-plugin/design.md | 20 +++-- .../2026-11-08-method-plugin/findings.md | 15 +++- .../2026-11-08-method-plugin/predictions.md | 12 +++ .../2026-11-08-method-plugin/rulings.md | 35 +++++++- meta/sessions/README.md | 2 +- plugins/ddd-method/README.md | 28 ++++++- 8 files changed, 176 insertions(+), 21 deletions(-) create mode 100644 core/decisions/DDD-dec-121.yaml diff --git a/README.md b/README.md index 45c56bf..f6b3b21 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ each decision where it is resolved, and say which actor, whether person, program each one and who answers for it. This repository is the method's software projection: the step cards, the claims they rest on, and the decisions that rule them. -**v0.5.0 is a preview: ready to try, not ready to use (`DDD-dec-74`).** The register of each +**v0.7.0, a pre-release, is a preview: ready to try, not ready to use (`DDD-dec-74`).** The register of each reason below is stated beside it, and the [status table](#status-step-by-step) gives each step's. ## Why use it @@ -57,8 +57,8 @@ and cannot name the value it gave them. Running that test is Emil's act, and it ## Run it in Claude Code -The method is also a Claude Code plugin, [`plugins/ddd-method/`](plugins/ddd-method/). Its design -is `[PROPOSED]`. +The method is also a Claude Code plugin, [`plugins/ddd-method/`](plugins/ddd-method/) +(`DDD-dec-121`). It claims discipline, not better step execution. ```bash claude plugin marketplace add mindovermachine-dev/decision-driven-design diff --git a/core/decisions/DDD-dec-121.yaml b/core/decisions/DDD-dec-121.yaml new file mode 100644 index 0000000..d7c85ad --- /dev/null +++ b/core/decisions/DDD-dec-121.yaml @@ -0,0 +1,79 @@ +format: 1 +id: DDD-dec-121 +kind: decision +statement: | + The method is installable as a Claude Code plugin in this repository, ddd-method in the marketplace decision-driven-design (.claude-plugin/marketplace.json at the root, the plugin in plugins/ddd-method/), for anyone adopting the method. The plugin is thin: its one entry skill, /ddd-method:run, carries procedure and discipline only, and reads the step table, the step cards and the canon they cite from this repository at one pinned method release, from a clone at the tag or otherwise over HTTPS at the tag; when neither is reachable it says so and stops, and never fills from memory. Per-step skills are not added. The plugin's version is the method pin it reads without its v (0.7.0 for v0.7.0); a plugin-only change at the same pin takes a +p.N suffix (0.7.0+p.1), and a re-pin takes the new pin's version (0.8.0 for v0.8.0). The plugin claims discipline, not better step execution: it refuses to treat a [PROPOSED] step as ruled, reads at the pin, and stops when it cannot; it does not claim that a step is performed better with it than without it. +principal: Emil +made: | + 2026-11-08, Round 27 of the claude.ai conversation (verbatim in meta/sessions/2026-11-08-method-plugin/prompt.md and rulings.md), and 2026-11-11, Round 28 of the same rulings.md, Emil's answers in Claude's question dialog on claude.ai, filed by the method-plugin session; Emil's landing of the branch is the ratification act +resolution: | + ## Round 27 (claude.ai conversation, 2026-11-08) + + - **Ruled: who installs it, and from where.** "From the repo, for practitioners + (Recommended)" (option text: "A Claude Code plugin in decision-driven-design (a skill plus + marketplace entry), installable by anyone adopting the method; versioned with the method"). + - **Ruled: scope.** "The whole method (Recommended)" (option text: "All steps, each run from its + step card; refuses to treat [PROPOSED] steps as ruled; step 1 and the demand-flow step first + in practice"). + - **Ruled: holding.** "Thin, reads the repo at a pin (Recommended)" (option text: "The skill + carries procedure and discipline; step cards and canon are fetched from the repository at the + pinned version, so it never drifts"). + + ## Round 28 (2026-11-11, method-plugin rulings.md) + + - **F-1: design and build accepted together.** "Accept both (Recommended)" (option text: "Design + and build are separate commits and the design matches the charter; record the missed gate as + a finding"). + - **F-3: the version scheme.** "Yes (Recommended)" (option text: "0.7.0 now; 0.7.0+p.1 for a + plugin fix; 0.8.0 when it re-pins to v0.8.0. Claude Code updates on any version-string + change"). + - **F-4: filed.** "File it (Recommended)" (option text: "Thin skill reading at a pin, one entry + skill, the version scheme, and the README claiming discipline rather than step quality"). + - **F-9: the README's opening line** names the current release; the pull request is Emil's to + open. + + ## What the plugin claims, and the evidence + + Discipline, not step quality. From the eval table in + meta/sessions/2026-11-08-method-plugin/findings.md (3 runs per arm, with and without the + plugin): step 1 on a small example shows no gain, 0.81 to 0.95 with the plugin and 0.86 to 0.90 + without. The gain is in discipline: a [PROPOSED] step asked as ruled, 1.00 with and 0.75 without; + the repository unreachable, 1.00 with and 0.33 without (without the plugin, 2 of 3 runs rebuilt + step 1's card from memory); demand flow offered from the PDLC's kinds as a start, 1.00 with and + 0.75 without. These are evals of an agent on cases written inside the framework: exercised + evidence about the plugin's behaviour, none about the method. + + ## What is filed + + - `.claude-plugin/marketplace.json`; `plugins/ddd-method/` (plugin.json at 0.7.0, the skill + `run` pinned at v0.7.0, README.md, check.py, evals/). + - `plugins/ddd-method/check.py` as the `plugin` gate of scripts/ci.py: the marketplace entry and + the manifest agree, the version tracks the pin, and the skill holds no claim or decision id and + no run of eight words shared with method/. + + ## Relation to earlier decisions + + - **Release.** The plugin is tooling, so under DDD-dec-82's mapping the release that first + carries it is a PATCH. It still pins v0.7.0. A MINOR method release (a card added or a register + moved) re-pins the plugin in the same change. No release is cut by this decision. + - **Name.** The plugin is ddd-method, not ddd, which is product-cli's tool for product + repositories (DDD-dec-100). + - **Supersedes nothing.** +basedOn: + - DDD-dec-82 + - DDD-dec-75 + - DDD-dec-74 + - DDD-dec-100 + - DDD-dec-79 +notes: | + Id. At filing (2026-11-11), DDD-dec-119 and DDD-dec-120 are held on the branch + claude/zealous-ptolemy-3txf8k, and no branch holds a higher decision, so this takes DDD-dec-121. + Re-checked across every origin branch before commit and before push (findings.md). + + Open, not ruled (findings.md): claude plugin validate is not in CI (F-5); where a practitioner's + artefacts go in a repository that uses product-cli's .ddd/ graph (F-6); thinness holds for the + skill's text, not for the model's memory (F-7); one eval run reported reading at the pin with no + git call recorded, not reproduced (F-8). + + Review trigger. A method release that moves a register or adds a card without re-pinning the + plugin; or an eval in which the plugin fills a card from memory. diff --git a/meta/sessions/2026-11-08-method-plugin/design.md b/meta/sessions/2026-11-08-method-plugin/design.md index 9968b97..42fe4c3 100644 --- a/meta/sessions/2026-11-08-method-plugin/design.md +++ b/meta/sessions/2026-11-08-method-plugin/design.md @@ -1,9 +1,12 @@ # Design — the method plugin `[PROPOSED]` -**Register: `[PROPOSED]`.** Every choice below is Claude's proposal on Round 27 (method-plugin -`rulings.md`), `UNVERIFIED — Emil review`. Round 27 rules the form (a plugin in this repository, -a skill plus a marketplace entry), the scope (the whole method) and the holding (thin, reading the -repository at a pin). It does not rule anything below. +**Register: accepted, Round 28 (method-plugin `rulings.md`), filed as `DDD-dec-121`.** Round 27 +rules the form (a plugin in this repository, a skill plus a marketplace entry), the scope (the +whole method) and the holding (thin, reading the repository at a pin). Round 28 accepts this design +together with the build, and rules the version scheme (§4). `DDD-dec-121` files the thin skill at a +pin, the one entry skill, the version scheme and what the plugin claims. Choices it does not name, +such as the names, the place, the CI check and the evals, stand as accepted with the design, not +separately ruled. **Weakest point.** The plugin is thin only to the extent that the model follows the instruction to read instead of recall. The skill tells Claude to stop when the repository is unreachable, and @@ -102,10 +105,11 @@ repository, and the paths it reads. It reads **only at the pin**, in this order: - **The pin is the method release whose cards the skill reads:** `v0.7.0`. It is written once, in `SKILL.md`, and `plugin.json`'s `version` restates it. -- **`version` = the pin without its `v`: `0.7.0`.** A plugin-only change at the same pin, such as - better wording, appends a build suffix, `0.7.0+p.1`. Claude Code compares versions only for - change, so any new string reaches users. `version` is set in `plugin.json` only, never also in - the marketplace entry (`plugins/host-marketplace.md`). +- **Ruled (Round 28; `DDD-dec-121`): `version` = the pin without its `v`.** It is `0.7.0` now. A + plugin-only change at the same pin takes `+p.N`, starting at `0.7.0+p.1`. A re-pin takes the new + pin's version, `0.8.0` for `v0.8.0`. Claude Code compares versions only for change, so any new + string reaches users. `version` is set in `plugin.json` only, never also in the marketplace entry + (`plugins/host-marketplace.md`). - **A method release is a plugin release when it moves what the skill reads.** At a MINOR release (a card added, or a register moved, `DDD-dec-82`), the pin advances in the same change, or practitioners keep running the old registers. At a PATCH release, the pin advances when the diff --git a/meta/sessions/2026-11-08-method-plugin/findings.md b/meta/sessions/2026-11-08-method-plugin/findings.md index 4765960..7de9132 100644 --- a/meta/sessions/2026-11-08-method-plugin/findings.md +++ b/meta/sessions/2026-11-08-method-plugin/findings.md @@ -104,15 +104,22 @@ contribution is largest where Round 27 put it, in not filling the method from me session recorded predictions at each gate and stopped only at the end (bootstrap). The design (`32e67c4`) and the build (`b3beec2` and later) are separate commits, so the build can be dropped if the design was meant to be reviewed first. + **Round 28: design and build accepted together.** The finding stands: the session built past its + design gate without stopping for review. The prompt said "Stop at every gate", and the session + read it as recording each gate rather than waiting at it. A later session reads "stop" as waiting + for Emil. - **F-2 — The plugin is not in `v0.7.0`.** Its files land after the tag it pins. Under `DDD-dec-82`'s mapping, "tooling" is PATCH, so the first release that carries the plugin is a PATCH (`v0.7.1` if nothing else lands first), and it still pins `v0.7.0`. Until it is cut, `marketplace add` without `#` reads `main`. **Not cut, per the prompt.** - **F-3 — The version scheme is Claude's.** `version` is the pin without its `v`, and a plugin-only - change adds `+p.N`. Claude Code compares versions only for change. `UNVERIFIED — Emil review`. + change adds `+p.N`. Claude Code compares versions only for change. **Ruled by Round 28** + (`DDD-dec-121`): `0.7.0` now, `0.7.0+p.1` for a plugin fix, `0.8.0` when it re-pins to `v0.8.0`. - **F-4 — Round 27 is not filed as a decision.** The prompt asked for it to be recorded. Filing it (the next id was `DDD-dec-119` at arrival) is Emil's call. "Round 27" also names a different - round in the 2026-11-07 record, so cite it with its record. + round in the 2026-11-07 record, so cite it with its record. **Round 28: filed as `DDD-dec-121`**, + covering Rounds 27 and 28. `DDD-dec-119` and `-120` are held on `claude/zealous-ptolemy-3txf8k`. + The highest id on every origin branch was re-checked before the commit and before the push. - **F-5 — `claude plugin validate` is not in CI.** It would need the `claude` CLI in the devcontainer. `check.py` covers names, the pin and thinness without it. - **F-6 — Where a practitioner's artefacts go.** The skill writes them into the practitioner's own @@ -125,8 +132,8 @@ contribution is largest where Round 27 put it, in not filling the method from me - **F-8 — The unexplained run.** One `step-1-small` run with the plugin reported reading at the pin with no Bash call recorded. It was not reproduced in three kept-trace runs. If it recurs, it is a misreport of provenance, which the skill forbids. -- **F-9 — Stale README line, out of scope.** `README.md` still opens "**v0.5.0 is a preview**". The - current release is `v0.7.0`. Not changed here. +- **F-9 — Stale README line.** `README.md` opened "**v0.5.0 is a preview**". **Round 28: corrected** + to name `v0.7.0`, a pre-release. Nothing else in the paragraph changed. - **F-10 — Small choices for Emil.** `author` and `owner` are "Mind Over Machine" (`github.com/mindovermachine-dev`). There is no icon (needed only for directory submission). Eval costs: $3.61 for the full suite, plus about $4.4 of re-runs. diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md index d5a0198..e1a9a3e 100644 --- a/meta/sessions/2026-11-08-method-plugin/predictions.md +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -14,3 +14,15 @@ Each prediction was made before its operation ran. Outcomes as observed. | 8 | Smoke eval `proposed-as-ruled`, 1 run, `--allow-tools "Bash(git *)"` | 3 of 3 graders pass | **Missed, informatively.** 0.75. The model's only Bash call began with `cd` and was denied. It then stopped, refused to treat the step as ruled, and declined to name the register without reading it, which is what the skill says to do. The grant was too narrow, not the skill | | 9 | Same, with `--allow-tools Bash Write` (Bash still inside the eval's OS sandbox, with no network) | 3 of 3 | **Held.** 1.00 | | 10 | The full suite, 4 cases × 3 runs × 2 arms | Every case passes with the plugin. Without it, `unreachable` and `proposed-as-ruled` score lowest | **Missed in part.** `proposed-as-ruled` and `demand-flow-start` passed at 1.00. `step-1-small` (0.50) and `unreachable` (0.56) failed. `unreachable` failed on a rubric that counted generic field names as card content; corrected, it scored 1.00 with the plugin and 0.33 without. `step-1-small` stays below 1.0 (`findings.md` §Evals) | + +## Round 28 (2026-11-11) + +| # | Operation | Prediction | Outcome | +|---|---|---|---| +| 11 | Re-read the branch, origin and `main` | The branch is at `7700558` locally and on origin, and `main` has not moved | **Held.** `main` = `84aa466`. 60 origin branches (59 at arrival) | +| 12 | Highest decision id on every origin branch | `DDD-dec-120`, on `claude/zealous-ptolemy-3txf8k` | **Held.** `-119` and `-120` exist only there, and no branch mentions a higher id. This round takes `DDD-dec-121` | +| 13 | Round 28 copied into `rulings.md` | Byte-exact apart from the quote markers | **Held.** Verified by stripping the markers and comparing | +| 14 | `validate-claims.py core/decisions/ --decisions` with `DDD-dec-121` | Accepts it first time | **Held.** 97 decisions, all valid | +| 15 | The F-9 edit to `README.md` | The diff touches one line | **Held.** Only line 8 changed | +| 16 | `scripts/ci.py`; canon's `dotnet test`, `changelog --check` and `check --compare`, as CI runs them | All pass | **Held.** All gates pass. Canon: 66 tests, the changelog is the projection, every compare case agrees | +| 17 | `claude plugin validate --strict` on the plugin and the marketplace; `canon issue-refs --basis` after the commit | All pass | **Held.** Both `--strict` validations pass. `issue-refs --basis` first failed because the local clone was shallow and lacked its configured starting commits. After unshallowing, as CI checks out with full history: "ok. 5 commits in 84aa4665b4b0..6f75bba833db; Refs checked on 5, Basis on 1" | diff --git a/meta/sessions/2026-11-08-method-plugin/rulings.md b/meta/sessions/2026-11-08-method-plugin/rulings.md index 6bfa514..5ef5f4e 100644 --- a/meta/sessions/2026-11-08-method-plugin/rulings.md +++ b/meta/sessions/2026-11-08-method-plugin/rulings.md @@ -32,5 +32,36 @@ wording, which Emil chose. repository; and how a step that is `[PROPOSED]` is run without being treated as ruled. These are Claude's proposals, `UNVERIFIED — Emil review`. -**Not filed.** Round 27 is recorded here and is not filed as a decision. Whether to file it is -Emil's call (`findings.md`). +**Not filed in Round 27.** It was recorded and not filed as a decision. Round 28 files it, as `DDD-dec-121`. + +## Round 28, verbatim + +Given in this session on 2026-11-11: Emil's answers in Claude's question dialog on claude.ai, with +his instructions. "Round 28" is this record's next round. The 2026-11-07 session's `rulings.md` +also has a Round 28, with different content, so cite this one as "Round 28, method-plugin +`rulings.md`". The blockquote is the message byte for byte, apart from the quote markers. + +> Record this message verbatim in rulings.md as the next round, and predict before each operation. These are my answers in Claude's question dialog on claude.ai: +> Q: "The plugin session built past its design gate (F-1). Review design.md before landing, or accept design and build together?" A: "Accept both (Recommended)" (option text: "Design and build are separate commits and the design matches the charter; record the missed gate as a finding") +> Q: "F-3: plugin version = the method pin it reads, with +p.N for plugin-only changes?" A: "Yes (Recommended)" (option text: "0.7.0 now; 0.7.0+p.1 for a plugin fix; 0.8.0 when it re-pins to v0.8.0. Claude Code updates on any version-string change") +> Q: "F-4: Round 27 is recorded but not filed as a decision. File one (next free id, DDD-dec-121)?" A: "File it (Recommended)" (option text: "Thin skill reading at a pin, one entry skill, the version scheme, and the README claiming discipline rather than step quality") +> Q: "Also fix F-9 (root README still says "v0.5.0 is a preview") in this PR, and open the pull request?" A: "Fix F-9, open the PR (Recommended)" (option text: "The session already edits the root README; I open the PR once it pushes") +> +> 1. F-1: record the missed design gate as a finding. Design and build are both accepted. +> 2. F-3: the version scheme is ruled. State it in design.md, in the plugin's README and in the decision below. +> 3. F-4: file one decision for Round 27 and this round. It covers the thin skill reading the method at a pin; one entry skill; the version scheme; and what the plugin claims. The claim is discipline, not better step execution: on step 1 the evals show no gain (0.81 to 0.95 with the plugin, 0.86 to 0.90 without), while the refusals and the unreachable case show the gain. The redo branch claude/zealous-ptolemy-3txf8k holds DDD-dec-119 and -120, so the next free id should be 121. Re-check every branch just before you commit and again just before you push, and take the next free id. +> 4. Make the plugin's README say the same about what the plugin claims, citing the eval table in findings.md. +> 5. F-9: correct the root README's opening line to the current release, v0.7.0, a pre-release. Change nothing else in that line's paragraph. +> 6. Run scripts/ci.py, the plugin gate, `claude plugin validate` (with --strict), and canon's checks as CI runs them. Push, wait for green CI, and report the new head. Claude will open the pull request. Stop. Do not land. + +## What Round 28 rules + +- **F-1.** The design and the build are both accepted. The missed design gate is recorded as a + finding (`findings.md`, F-1). +- **F-3.** The version scheme is ruled: the plugin's version is the method pin it reads, without + its `v`. A plugin-only change at the same pin takes `+p.N`. A re-pin takes the new pin's version. +- **F-4.** Round 27 and this round are filed as one decision, `DDD-dec-121`. It covers the thin + skill reading at a pin, the one entry skill, the version scheme, and what the plugin claims: + discipline, not better step execution. +- **F-9.** The root README's opening line names the current release, `v0.7.0`, a pre-release. + Nothing else in its paragraph changes. Emil opens the pull request. diff --git a/meta/sessions/README.md b/meta/sessions/README.md index 6632113..2b91ee7 100644 --- a/meta/sessions/README.md +++ b/meta/sessions/README.md @@ -54,6 +54,6 @@ session's later work exceeds the committed prompt, the excess is visible as exce | `2026-11-08-specification-feasibility/` | Rulings filed, gated — specification feasibility, from a claude.ai conversation (F-1 to F-12): every dependency on ground has a What layer and a How layer, the How decides by three loose-coupling conditions, any granted actor vets a pinned What change and product-cli records the decision (`DDD-dec-116`); vetted ground becomes a ground-sourced bounded context, admitted per system for Deciders, Projectors and Views, with permission the data owner's; product-cli and the framework carry grants and roles, superseding `[D1.11]` (`DDD-dec-117`). Not applied; S-1 to S-8. Issue #62 | | `2026-11-08-demand-flow/` | Rulings filed, gated — map the flow of demand, from the claude.ai conversation's Rounds 23 to 25: a method step after step 1 (`method/01b-map-the-flow-of-demand.md`, `[PROPOSED]`), general, with each process declaring its kinds of demand and the PDLC's new, owed and own-ground as its worked example and starting point; four PDLC-scoped claims in a new area, `DDD-flow-01` to `-04`, projected; `DDD-dec-118`, adding to `DDD-dec-114`; the acme shop's #101, #103 and #104 traced as graph data checked against the act map. Nothing upstream. Round 26 (2026-11-10) closed R-1: sighting separated from entry, only the What owner says whether a defect is a bug. Open: numbering (N-1), promotion (P-1), the two examples (E-1). Issue #67 | | `2026-11-10-release-v0.7.0/` | Release descriptor, gated. `releases/v0.7.0.yaml` is MINOR under `DDD-dec-82`: step 1b's card was added (`DDD-dec-118`), and no step's register moved (F-1). Format 2, `prerelease: true` for Emil to confirm (F-3). Its `CHANGELOG.md` section is from `canon changelog`, and `canon ratify` fills the ratified head. The prompt calls the PDLC and SDLC specifications `[PROPOSED]`, while the repository says they are ruled (Round 28). The summary follows the repository, and Emil is to settle it (F-2). Not landed and not cut. Issue #69 | -| `2026-11-08-method-plugin/` | Interactive, gated — an installable Claude Code plugin for the method, on Emil's Round 27: `ddd-method@decision-driven-design`, one entry skill `/ddd-method:run`, thin, reading step cards and canon at the pin `v0.7.0` (a clone through `git show`, otherwise raw HTTPS, otherwise it stops); `.claude-plugin/marketplace.json` at the root; `plugins/ddd-method/check.py` as the `plugin` gate; four evals run with a no-plugin baseline. Design `[PROPOSED]`; nothing filed. Not landed, no release cut. Issue #72 | +| `2026-11-08-method-plugin/` | Interactive, gated — an installable Claude Code plugin for the method, on Emil's Round 27: `ddd-method@decision-driven-design`, one entry skill `/ddd-method:run`, thin, reading step cards and canon at the pin `v0.7.0` (a clone through `git show`, otherwise raw HTTPS, otherwise it stops); `.claude-plugin/marketplace.json` at the root; `plugins/ddd-method/check.py` as the `plugin` gate; four evals run with a no-plugin baseline. Round 28 (2026-11-11) accepts the design and the build, rules the version scheme (the pin without its `v`, `+p.N` for plugin-only changes), and files Rounds 27 and 28 as `DDD-dec-121`: the plugin claims discipline, not better step execution; the README's opening line names `v0.7.0`. Not landed, no release cut. Issue #72 | | `2026-11-18-act-map-scope-and-pull/` | Interactive, gated — the act map, scope and pull (#80). Carries the two session records of 2026-11-17 and 2026-11-18 from the archive branch at `47cf4cc`, unreworded. Filed (`DDD-dec-122`): the act map with its scope and index of determinables (`DDD-address-06`); a second act map with a second scope or a second declaration of axes (`-07`); a process as a named view, north as the determinable of a pull (`-08`); the pull as a gap between two of four states (`-09`); kinds as ground positions (`-10`); the four states, credited to GitHub user pjarnhus (`-11`). Step 1 starts from scope and pull, a `[PROPOSED]` first part; steps 2 to 10 say what they add to the act map; step 1b reads kinds as positions. Superseding sections, nothing reworded. Three conflicts with canon or earlier rulings caught before filing (K-1 to K-3). Issue #80 | | `2026-11-18-canon-lock-file/` | Interactive, gated — the `agent review` check builds again (#83). NU1004 reproduced: `IsAotCompatible` makes the SDK reference `Microsoft.NET.ILLink.Tasks` at its bundled runtime (10.0.15 in SDK 10.0.404), the lock file held 10.0.14, and the runner sets `CI`. Corrected: `validate` passed because `CI` was unset in the devcontainer, not because of an older SDK; and agent review builds main's canon, so no pull request could pass it until main built (D-4). G1 ruled option B: the SDK pinned at 10.0.404 with `rollForward: "disable"` in `global.json` and the devcontainer, the lock file regenerated once, `CI` passed into the devcontainer so `validate` restores locked; `agent-review.yml` unchanged. Landed in #85 (`1bf7e56`), with Emil lifting the `agent review` requirement on trunk for that landing. The waiver filed as `DDD-dec-123` in #86. Successors S-1 (a scheduled check for a newer .NET patch) and S-2 (the deadlock) recorded, not acted on. Issue #83 | diff --git a/plugins/ddd-method/README.md b/plugins/ddd-method/README.md index 4c940b5..40b67d7 100644 --- a/plugins/ddd-method/README.md +++ b/plugins/ddd-method/README.md @@ -3,8 +3,9 @@ Runs the Decision-Driven Design method one step at a time, from its step cards. **The plugin holds no method content.** It reads the step table, each step card and the claims a card cites from this repository at one pinned release. If it cannot read them, it stops and says so (Round 27, -[`rulings.md`](../../meta/sessions/2026-11-08-method-plugin/rulings.md)). The design is -`[PROPOSED]` ([`design.md`](../../meta/sessions/2026-11-08-method-plugin/design.md)). +[`rulings.md`](../../meta/sessions/2026-11-08-method-plugin/rulings.md)). Round 28 accepts the +design ([`design.md`](../../meta/sessions/2026-11-08-method-plugin/design.md)), and both rounds are +filed as [`DDD-dec-121`](../../core/decisions/DDD-dec-121.yaml). **Weakest point.** The plugin is only as thin as the model is obedient. The skill tells Claude to read and never to recall, and an eval checks that it stops when the repository is unreachable. @@ -33,7 +34,7 @@ Without a GitHub SSH key, set `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` first. | | | |---|---| | **Pin** | `v0.7.0`: the method release whose cards the skill reads (the `PIN:` line in [`skills/run/SKILL.md`](skills/run/SKILL.md)) | -| **Plugin version** | `0.7.0`, the pin without its `v`. A plugin-only change at the same pin adds a build suffix, such as `0.7.0+p.1`. Claude Code updates you only when the version string changes | +| **Plugin version** | Ruled (`DDD-dec-121`): the pin without its `v`. It is `0.7.0` now. A plugin fix at the same pin is `0.7.0+p.1`, and re-pinning to `v0.8.0` makes it `0.8.0`. Claude Code updates you on any change to the version string | | **When the plugin must release** | Whenever a method release adds a card or moves a step's register (MINOR, `DDD-dec-82`). The pin advances in the same change, or the plugin keeps showing the old registers | | **Where it reads** | A clone of this repository, through `git show v0.7.0:`, never the working tree. Otherwise `raw.githubusercontent.com` at the tag. Upstream claims are read at the tag that `graph/upstream.yaml` names at the pin | | **Where it writes** | Your project only. It never writes your artefacts, or anything that identifies a customer, into a clone of a canon repository | @@ -42,6 +43,27 @@ Without a GitHub SSH key, set `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` first. entry and the manifest have the same name. The version tracks the pin. The skill holds no claim or decision id. No run of eight words is shared between the skill and any file under `method/`. +## What it claims + +**Discipline, not better step execution** (`DDD-dec-121`). The plugin claims to: +- refuse to treat a `[PROPOSED]` step as ruled; +- read the method at its pin; +- stop when it cannot read it, instead of filling the gap from memory. + +It does not claim that a step is performed better with it than without it. The eval table in +[`findings.md`](../../meta/sessions/2026-11-08-method-plugin/findings.md) (§Evals, 3 runs per arm) +shows both: + +| Case | With the plugin | Without | +|---|---|---| +| A `[PROPOSED]` step asked to run as ruled | 1.00 | 0.75 | +| The repository unreachable | 1.00 | 0.33 (2 of 3 runs rebuilt step 1's card from memory) | +| Demand flow, the PDLC's kinds offered as a start | 1.00 | 0.75 | +| Step 1 on a small example | 0.81 to 0.95 | 0.86 to 0.90: **no gain** | + +These evals are of an agent, on cases written inside the framework. They are evidence about the +plugin's behaviour, and none about the method. + ## Evals `evals/` holds four cases in the `claude plugin eval` format: a `[PROPOSED]` step asked to run as From 61869184be77299524e968a1c491800d1c61564e Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Thu, 19 Nov 2026 12:29:11 +0000 Subject: [PATCH 6/9] Round 29: #74 held at v0.7.0; what #84 affects; DDD-dec-121 still free - rulings.md: Round 29 verbatim (byte-exact apart from the quote markers). - findings.md: what #84 (DDD-dec-122, DDD-address-06 to -11) affects in the plugin, its evals, its check and DDD-dec-121: - Emil's three items checked, and A-1 to A-9; - R-1, a proposed amendment to DDD-dec-121. Its re-pin trigger is MINOR only, and #84 adds no card and moves no register. Not amended; - the id check: DDD-dec-121 is a file only on this branch. Mentions elsewhere are other sessions' id records. Upstream's highest is DDD-dec-39. - predictions.md: predictions 18 to 23. - meta/sessions/README.md: the index row. Nothing in the plugin is changed. Not rebased, not re-pinned. Refs #72 Basis: DDD-dec-121; DDD-dec-122; DDD-dec-82 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/findings.md | 104 ++++++++++++++++++ .../2026-11-08-method-plugin/predictions.md | 11 ++ .../2026-11-08-method-plugin/rulings.md | 39 +++++++ meta/sessions/README.md | 2 +- 4 files changed, 155 insertions(+), 1 deletion(-) diff --git a/meta/sessions/2026-11-08-method-plugin/findings.md b/meta/sessions/2026-11-08-method-plugin/findings.md index 7de9132..eba0bc6 100644 --- a/meta/sessions/2026-11-08-method-plugin/findings.md +++ b/meta/sessions/2026-11-08-method-plugin/findings.md @@ -137,3 +137,107 @@ contribution is largest where Round 27 put it, in not filling the method from me - **F-10 — Small choices for Emil.** `author` and `owner` are "Mind Over Machine" (`github.com/mindovermachine-dev`). There is no icon (needed only for directory submission). Eval costs: $3.61 for the full suite, plus about $4.4 of re-runs. + +## Round 29 (2026-11-19): #74 held; what #84 affects + +Read at `main` = `dc8b737`: `DDD-dec-122`, `DDD-address-06` to `-11`, and the diffs to `method/01` +to `10` since `84aa466` (`v0.7.0`). #86 also landed (`DDD-dec-123`, canon's lock file). No release +has been cut since `v0.7.0`. **Nothing in the plugin is changed in this round.** + +**How #84 changed the cards.** No line was reworded. Each changed card gained a section that "supersedes, +where they differ, the lines below it". Step 1 gained a `[PROPOSED]` first part (scope, then the +five-part pull procedure and the pull statement) inside a card ruled for test, and its "Ground in" +and "Artefact out" rows are superseded. Step 1b reads kinds as positions on a declared ground +axis, with "built or not built" as the starting axis. Steps 2 to 10 each gained a +`[PROPOSED]` "Value made visible" row, where most said "Not filed" before. + +### Emil's three items, checked + +| Item | Reading | +|---|---| +| Re-pin "under `DDD-dec-121`'s own rule that a re-pin is a new plugin version" | **Partly wrong.** The version scheme covers the version a re-pin takes. But `DDD-dec-121` makes a re-pin compulsory only on a MINOR method release, a card added or a register moved (resolution, "Relation"; notes, review trigger). By `DDD-dec-122`'s "What is not changed", #84 adds no card and moves no register. As filed, `DDD-dec-121` would let the plugin keep `v0.7.0` after #84's release. See R-1 | +| Rework `step-1-small` | **Right, and too narrow.** Besides `axes-first`: the prompt itself frames the exercise by axes ("I accept whatever axes you propose") and gives no scope; `register` must also require that step 1's first part is `[PROPOSED]` inside a card ruled for test; `address-per-occurrence` checks the superseded artefact ("a tree of occurrences"), while the act map of `DDD-address-06` holds act sites at addresses, with occurrences beside it, plus an index of determinables, and nothing grades the pull statements. Whether the axis declaration still precedes positions, after scope and pulls, is my reading of a card whose lower lines stand where they do not differ: `UNVERIFIED` | +| Rework `demand-flow-start` against `DDD-address-10` | **Right.** Also: the PDLC's three kinds still stand as the starting set beside the starting axis (1b's "What stands"), so `names-kinds` can stay, and `kinds-as-start` must add the axis, not replace the kinds. "Whose determinable" is `[PROPOSED]` (Q-4) and should not be graded as required | +| Re-run every eval; replace the tables in the plugin README and `findings.md`; keep the old one | **Missed one place.** The eval numbers are also in `DDD-dec-121`'s resolution ("What the plugin claims, and the evidence"), unlabelled by pin | +| Rebase onto `main`; resolve "the conflict" | **Right.** `git merge-tree` shows one conflict, `meta/sessions/README.md` (both branches add an index row) | + +### What else is affected + +- **A-1. The skill has no rule for superseding sections.** This is the one that matters most. `SKILL.md` + §4 runs a step "from its card's fields, in its order", and §3 reports a field the card marks + "not filed" as not filed. On `main`'s cards that would run superseded rows of step 1. On steps + 2 to 10 it would report "Value made visible" as not filed, when a superseding section now fills it. + The fix is generic and needs no card text: a section of a card that says it supersedes lines of that + card governs where they differ, and is read first. +- **A-2. A card can now carry two registers.** Step 1 is ruled for test with a `[PROPOSED]` first + part. `SKILL.md` §3 states one register per step. It should state each part's register. +- **A-3. `SKILL.md` §5 is wrong against `DDD-address-08` and `-10`.** It says "Each process declares + its own kinds". On `main`, each map declares its kinds as positions on a declared ground axis, and a + process does not declare. It also asks for "the source of pull behind each choice" while 1b now + says the source "decides nothing about its kind". The card's declaration table still has a + column for that source, so the source may stay as evidence for keeping a kind. That reading + is `UNVERIFIED`. +- **A-4. The pin is hard-coded outside `SKILL.md` and `plugin.json`, where `check.py` does not look.** + - the three `read-card-at-pin` graders (`v0\.7\.0:` in a regex); + - `evals/_fixture/clone-at-pin.sh` (verifies `v0.7.0`); + - two eval `expected_outcome` lines; + - the plugin README (the pin, the version, `git show v0.7.0:`, and the `#v0.7.1` example); + - the root README's plugin section. + + A re-pin that misses any of them still passes the `plugin` gate. +- **A-5. `check.py` cannot see a stale pin.** It checks that the version tracks the pin, not that the + pin is current. A check that the pin equals the newest version in `releases/` would turn the gate + red on the release that needs a re-pin, until the same change re-pins. That is `DDD-dec-121`'s + "in the same change", made mechanical. This is a proposal, `UNVERIFIED`. +- **A-6. Which release #84 lands in is not settled by `DDD-dec-82`.** #84 adds no card and moves no + register, so it is not MINOR by `DDD-dec-82`'s table. It changes rulings, so it is not + "editorial (wording that changes no ruling)" either. The table has no row for it. Whether the + release is `v0.7.1` or `v0.8.0` is Emil's call, and it sets the plugin's version (`0.7.1` or + `0.8.0`). `UNVERIFIED`. +- **A-7. Statements that are now wrong:** + - `design.md` §4 and `DDD-dec-121`'s "Relation" say the release that first carries the plugin + "still pins v0.7.0". It will pin #84's release. + - The plugin README's "When the plugin must release" row and the root README's plugin paragraph + give the MINOR-only trigger. + - The root README's opening line (F-9) names `v0.7.0`, so it goes stale when #84's release is + cut. +- **A-8. The `unreachable` eval's regex for card text** lists `v0.7.0`'s step 1 terms only. It would + not catch a reconstruction of the new first part. This is a weaker test, not a wrong one. +- **A-9. A record on `main` misattributes an id.** + `meta/sessions/2026-11-17-act-map-and-process/bootstrap.md` line 36 says `DDD-dec-120` is on + #74's branch. It is on `claude/zealous-ptolemy-3txf8k`, as the 2026-11-18 bootstrap says. This + is not this session's to change. + +**Not affected, checked:** +- `check.py`'s thinness check against `main`'s cards finds no shared 8-word run. +- `proposed-as-ruled`: step 6 is still `[PROPOSED]` on `main`. Only its grader's pin regex moves + (A-4). +- `.claude-plugin/marketplace.json`. +- The plugin's name, the skill's name and the evals' scaffold mechanism. + +### R-1 — Does `DDD-dec-121` need amending? Proposed, not done + +**Yes, before it lands.** The version scheme already covers the *number*: the pin without its +`v`. It does not make the re-pin *happen*: its only compulsory trigger is MINOR, and #84 is not +MINOR. Proposed amendments, in place: + +1. **The re-pin trigger.** Any method release that changes a file the skill reads (anything under + `method/`, or a claim or decision a card cites) re-pins the plugin in the same change, whatever + its SemVer part. This replaces "A MINOR method release … re-pins the plugin" and the matching + review trigger. +2. **Evidence by pin.** The eval numbers in the resolution are labelled "at the pin `v0.7.0`". The + claim of discipline over step quality stands on the evals at the current pin, and they are + re-run at each re-pin. +3. **The carrying release.** Replace "It still pins v0.7.0" with "It pins the newest method + release when it lands". +4. **Round 29** goes into `made` and the resolution: the hold, and its reason. +5. **Optional:** `basedOn` gains `DDD-dec-122`, the ruling the hold rests on. The thin plugin + does not otherwise depend on `DDD-dec-122`'s content. + +### Id check (item 4) + +Every branch of both repositories, 2026-11-19: +- **Downstream (67 branches).** The file `DDD-dec-121` is only on `claude/confident-goldberg-c0y0ia`. Five other branches, `main` among them, mention it. Every mention is another session's id record attributing it to #74's branch, so none is a use. +- **Upstream (27 branches).** The highest decision is `DDD-dec-39`, and nothing mentions `DDD-dec-121`. + +**`DDD-dec-121` is still free.** The highest decision downstream is now `DDD-dec-123`, on `main`. diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md index e1a9a3e..16dec4f 100644 --- a/meta/sessions/2026-11-08-method-plugin/predictions.md +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -26,3 +26,14 @@ Each prediction was made before its operation ran. Outcomes as observed. | 15 | The F-9 edit to `README.md` | The diff touches one line | **Held.** Only line 8 changed | | 16 | `scripts/ci.py`; canon's `dotnet test`, `changelog --check` and `check --compare`, as CI runs them | All pass | **Held.** All gates pass. Canon: 66 tests, the changelog is the projection, every compare case agrees | | 17 | `claude plugin validate --strict` on the plugin and the marketplace; `canon issue-refs --basis` after the commit | All pass | **Held.** Both `--strict` validations pass. `issue-refs --basis` first failed because the local clone was shallow and lacked its configured starting commits. After unshallowing, as CI checks out with full history: "ok. 5 commits in 84aa4665b4b0..6f75bba833db; Refs checked on 5, Basis on 1" | + +## Round 29 (2026-11-19) + +| # | Operation | Prediction | Outcome | +|---|---|---|---| +| 18 | Round 29 copied into `rulings.md` | Byte-exact apart from the quote markers | **Held** | +| 19 | Fetch `main` | `dc8b737`, with `DDD-address-06` to `-11`, `DDD-dec-122`, and `method/01` to `10` changed | **Held**, plus #86 (`DDD-dec-123`, `tools/canon/`). No new release | +| 20 | `check.py`'s thinness check against `main`'s `method/` | Still no shared 8-word run | **Held** | +| 21 | `git merge-tree origin/main HEAD` | One conflict, `meta/sessions/README.md` | **Held** | +| 22 | `DDD-dec-121` on every branch of both repositories | Only on this branch; upstream's highest is `DDD-dec-39` | **Held for files, missed for mentions.** Five branches mention it, each as an id record attributing it to #74. The highest downstream is now `DDD-dec-123` | +| 23 | The whole validate workflow, locally, on this branch's head | Passes, as before the round, since only records change | **Held.** `scripts/ci.py`: all gates. Canon: 66 tests, `changelog --check`, `issue-refs --basis` (6 commits from `dc8b737`, Refs on 6, Basis on 1) and `check --compare` (every case agrees) | diff --git a/meta/sessions/2026-11-08-method-plugin/rulings.md b/meta/sessions/2026-11-08-method-plugin/rulings.md index 5ef5f4e..f996d88 100644 --- a/meta/sessions/2026-11-08-method-plugin/rulings.md +++ b/meta/sessions/2026-11-08-method-plugin/rulings.md @@ -65,3 +65,42 @@ also has a Round 28, with different content, so cite this one as "Round 28, meth discipline, not better step execution. - **F-9.** The root README's opening line names the current release, `v0.7.0`, a pre-release. Nothing else in its paragraph changes. Emil opens the pull request. + +## Round 29, verbatim + +Given in this session on 2026-11-19. "Round 29" is this record's next round. Other records have +rounds with the same number, so cite this one as "Round 29, method-plugin `rulings.md`". The +blockquote is the message byte for byte, apart from the quote markers. + +> Ruling: #74 is held. It does not land at v0.7.0. Record this message verbatim in the +> session's rulings.md, as a new round, before you do anything else. +> +> The reason. main is now at dc8b737. #84 landed today and changed step 1: it starts from +> scope and pull (DDD-address-06 to -11, DDD-dec-122), and method/01 to method/10 changed. +> The plugin reads the step cards at v0.7.0, which is the main from before that. Landing it now +> would ship a plugin that teaches a step 1 I have superseded. +> +> What changes when the hold lifts. I will cut a release that includes #84 and tell you the +> tag. Then, under DDD-dec-121's own rule that a re-pin is a new plugin version: +> +> - re-pin the plugin to that tag; +> - rework the step-1-small eval. Its axes-first grader passes a reply that declares ground +> axes first. Step 1 now starts with scope, then the pulls; +> - rework the demand-flow-start eval against DDD-address-10, which reads a kind of demand as +> a position on a declared ground axis; +> - re-run every eval and replace the table in the plugin's README and in findings.md. Keep +> the old table in the record as the v0.7.0 result. Do not overwrite it; +> - rebase onto main and resolve the conflict. +> +> What to do now, and nothing more: +> +> 1. Record the ruling, as above. +> 2. Fetch main and read what #84 filed. Then give me your own list of what in the plugin, its +> evals, its check and DDD-dec-121 is affected. I listed three things. Tell me what I +> missed and where I am wrong. Mark anything you cannot confirm as UNVERIFIED. +> 3. Tell me whether DDD-dec-121 needs amending before it lands, or whether its version scheme +> already covers this. It is unlanded, so an amendment in place is open to me. Propose; do +> not amend. +> 4. Check that DDD-dec-121 is still free on every branch of both repositories. +> 5. Commit the record with Refs #72, run the whole validate workflow locally, and push. Do +> not rebase yet, and do not re-pin. Report and stop. diff --git a/meta/sessions/README.md b/meta/sessions/README.md index 2b91ee7..9d9dda2 100644 --- a/meta/sessions/README.md +++ b/meta/sessions/README.md @@ -54,6 +54,6 @@ session's later work exceeds the committed prompt, the excess is visible as exce | `2026-11-08-specification-feasibility/` | Rulings filed, gated — specification feasibility, from a claude.ai conversation (F-1 to F-12): every dependency on ground has a What layer and a How layer, the How decides by three loose-coupling conditions, any granted actor vets a pinned What change and product-cli records the decision (`DDD-dec-116`); vetted ground becomes a ground-sourced bounded context, admitted per system for Deciders, Projectors and Views, with permission the data owner's; product-cli and the framework carry grants and roles, superseding `[D1.11]` (`DDD-dec-117`). Not applied; S-1 to S-8. Issue #62 | | `2026-11-08-demand-flow/` | Rulings filed, gated — map the flow of demand, from the claude.ai conversation's Rounds 23 to 25: a method step after step 1 (`method/01b-map-the-flow-of-demand.md`, `[PROPOSED]`), general, with each process declaring its kinds of demand and the PDLC's new, owed and own-ground as its worked example and starting point; four PDLC-scoped claims in a new area, `DDD-flow-01` to `-04`, projected; `DDD-dec-118`, adding to `DDD-dec-114`; the acme shop's #101, #103 and #104 traced as graph data checked against the act map. Nothing upstream. Round 26 (2026-11-10) closed R-1: sighting separated from entry, only the What owner says whether a defect is a bug. Open: numbering (N-1), promotion (P-1), the two examples (E-1). Issue #67 | | `2026-11-10-release-v0.7.0/` | Release descriptor, gated. `releases/v0.7.0.yaml` is MINOR under `DDD-dec-82`: step 1b's card was added (`DDD-dec-118`), and no step's register moved (F-1). Format 2, `prerelease: true` for Emil to confirm (F-3). Its `CHANGELOG.md` section is from `canon changelog`, and `canon ratify` fills the ratified head. The prompt calls the PDLC and SDLC specifications `[PROPOSED]`, while the repository says they are ruled (Round 28). The summary follows the repository, and Emil is to settle it (F-2). Not landed and not cut. Issue #69 | -| `2026-11-08-method-plugin/` | Interactive, gated — an installable Claude Code plugin for the method, on Emil's Round 27: `ddd-method@decision-driven-design`, one entry skill `/ddd-method:run`, thin, reading step cards and canon at the pin `v0.7.0` (a clone through `git show`, otherwise raw HTTPS, otherwise it stops); `.claude-plugin/marketplace.json` at the root; `plugins/ddd-method/check.py` as the `plugin` gate; four evals run with a no-plugin baseline. Round 28 (2026-11-11) accepts the design and the build, rules the version scheme (the pin without its `v`, `+p.N` for plugin-only changes), and files Rounds 27 and 28 as `DDD-dec-121`: the plugin claims discipline, not better step execution; the README's opening line names `v0.7.0`. Not landed, no release cut. Issue #72 | +| `2026-11-08-method-plugin/` | Interactive, gated — an installable Claude Code plugin for the method, on Emil's Round 27: `ddd-method@decision-driven-design`, one entry skill `/ddd-method:run`, thin, reading step cards and canon at the pin `v0.7.0` (a clone through `git show`, otherwise raw HTTPS, otherwise it stops); `.claude-plugin/marketplace.json` at the root; `plugins/ddd-method/check.py` as the `plugin` gate; four evals run with a no-plugin baseline. Round 28 (2026-11-11) accepts the design and the build, rules the version scheme (the pin without its `v`, `+p.N` for plugin-only changes), and files Rounds 27 and 28 as `DDD-dec-121`: the plugin claims discipline, not better step execution; the README's opening line names `v0.7.0`. Round 29 (2026-11-19) holds #74: #84 superseded step 1 after `v0.7.0`, so the plugin is to re-pin to the release that carries #84, with its evals reworked; the effects and a proposed amendment to `DDD-dec-121` are recorded, nothing in the plugin changed. Not landed, no release cut. Issue #72 | | `2026-11-18-act-map-scope-and-pull/` | Interactive, gated — the act map, scope and pull (#80). Carries the two session records of 2026-11-17 and 2026-11-18 from the archive branch at `47cf4cc`, unreworded. Filed (`DDD-dec-122`): the act map with its scope and index of determinables (`DDD-address-06`); a second act map with a second scope or a second declaration of axes (`-07`); a process as a named view, north as the determinable of a pull (`-08`); the pull as a gap between two of four states (`-09`); kinds as ground positions (`-10`); the four states, credited to GitHub user pjarnhus (`-11`). Step 1 starts from scope and pull, a `[PROPOSED]` first part; steps 2 to 10 say what they add to the act map; step 1b reads kinds as positions. Superseding sections, nothing reworded. Three conflicts with canon or earlier rulings caught before filing (K-1 to K-3). Issue #80 | | `2026-11-18-canon-lock-file/` | Interactive, gated — the `agent review` check builds again (#83). NU1004 reproduced: `IsAotCompatible` makes the SDK reference `Microsoft.NET.ILLink.Tasks` at its bundled runtime (10.0.15 in SDK 10.0.404), the lock file held 10.0.14, and the runner sets `CI`. Corrected: `validate` passed because `CI` was unset in the devcontainer, not because of an older SDK; and agent review builds main's canon, so no pull request could pass it until main built (D-4). G1 ruled option B: the SDK pinned at 10.0.404 with `rollForward: "disable"` in `global.json` and the devcontainer, the lock file regenerated once, `CI` passed into the devcontainer so `validate` restores locked; `agent-review.yml` unchanged. Landed in #85 (`1bf7e56`), with Emil lifting the `agent review` requirement on trunk for that landing. The waiver filed as `DDD-dec-123` in #86. Successors S-1 (a scheduled check for a newer .NET patch) and S-2 (the deadlock) recorded, not acted on. Issue #83 | From a7f60c83ad2e112021094f7f04fc217d1e305445 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Thu, 19 Nov 2026 12:50:02 +0000 Subject: [PATCH 7/9] Round 30 verbatim: rulings on the Round 29 report Refs #72 Basis: DDD-dec-121; DDD-dec-82 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/rulings.md | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/meta/sessions/2026-11-08-method-plugin/rulings.md b/meta/sessions/2026-11-08-method-plugin/rulings.md index f996d88..f4fb5c0 100644 --- a/meta/sessions/2026-11-08-method-plugin/rulings.md +++ b/meta/sessions/2026-11-08-method-plugin/rulings.md @@ -104,3 +104,42 @@ blockquote is the message byte for byte, apart from the quote markers. > 4. Check that DDD-dec-121 is still free on every branch of both repositories. > 5. Commit the record with Refs #72, run the whole validate workflow locally, and push. Do > not rebase yet, and do not re-pin. Report and stop. + +## Round 30, verbatim + +Given in this session on 2026-11-19, on the Round 29 report. Cite it as "Round 30, method-plugin +`rulings.md`". The blockquote is the message byte for byte, apart from the quote markers. + +> Rulings on your Round 29 report. Record this message verbatim as Round 30 before you act. +> +> 1. The release that carries #84 is v0.8.0. It falls under the first row of DDD-dec-82's +> table: a ruled step superseded incompatibly is MINOR below 1.0. This confirms that row, +> which DDD-dec-82 flags as an unconfirmed reading. Do not edit DDD-dec-82. The release is +> cut in its own session, after #73 and #87 land. You do not cut it. +> +> 2. DDD-dec-121: amendments 1 to 4 are accepted. Amendment 5 is declined: #84 is the occasion, +> not the basis. Name DDD-dec-122 in the notes instead. Amend in place, since the decision +> is unlanded, and say in its notes that it was amended before landing and in which round. +> +> 3. The skill: accepted. A generic rule that a superseding section governs where it differs, +> holding no card text. More than one register on a step. The demand-flow wording brought in +> line with DDD-address-08 and -10. One source for the pin, read by the graders, the +> scaffold, the descriptions and both READMEs. +> +> 4. The check that the pin equals the newest version in releases/: accepted in principle. +> Before you build it, tell me how the evals run for a re-pin made in the same change as a +> release, when the descriptor is on the branch and the tag does not exist yet. Propose; +> do not build the check until I answer. +> +> 5. Step 1's order: scope first, then the pulls. Ground axes are still declared before any +> occurrence gets a position. Rework step-1-small on that reading: the prompt, the register +> grader, the address grader, and a grader for the pull statements. Strengthen the +> unreachable case for the new first part. +> +> 6. The "source of pull" question in SKILL.md: show me the sentence and your proposed +> replacement at the gate. Do not change it yet. +> +> Do now: items 2, 3 and 5, and the rebase onto main. Do not re-pin, do not run the evals, and +> do not change the version. The pin stays v0.7.0 until I tell you v0.8.0 is tagged. Run the +> whole validate workflow, push, and report: the new head, both required checks by their check +> names, your answers to 4 and 6, and what remains for the re-pin. Then stop. From 66579420d63a83260b6e8e3d8d3cb2895d2af0e4 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Thu, 19 Nov 2026 12:54:01 +0000 Subject: [PATCH 8/9] Round 30: DDD-dec-121 amended before landing; skill, pin source, step-1 eval Items 2, 3 and 5 of Round 30. Rebased onto main at 54dcb95. Not re-pinned, no eval run, version unchanged. - DDD-dec-121, amended in place (amendments 1 to 4): - the re-pin trigger is any method release that changes what the skill reads, whatever part of the version it moves; - the evidence is labelled at the pin v0.7.0 and re-run at each re-pin; - the plugin pins the newest release when it lands; - Rounds 29 and 30 are recorded. The notes say it was amended before landing (Round 30) and name DDD-dec-122 as the occasion, not the basis. - SKILL.md: superseding sections govern where they differ; a step may carry more than one register; demand flow follows DDD-address-08 and -10. The "source of pull" sentence is unchanged (item 6). - The pin's one source is the PIN line. The scaffold reads it; the eval descriptions name no version; check.py fails if the graders or either README name another version. - step-1-small: the prompt gives the scope, not axes. New or reworked graders: order, register, act-map, pull-statements. - unreachable: refuses the new first part's terms too. - design.md, both READMEs: the amended trigger; stale version examples removed. - findings.md: Round 30's record; the answers to items 4 and 6; what remains for the re-pin. Refs #72 Basis: DDD-dec-121; DDD-dec-82 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- README.md | 4 +- core/decisions/DDD-dec-121.yaml | 42 ++++-- .../2026-11-08-method-plugin/design.md | 16 ++- .../2026-11-08-method-plugin/findings.md | 123 ++++++++++++++++++ .../2026-11-08-method-plugin/predictions.md | 11 ++ plugins/ddd-method/README.md | 13 +- plugins/ddd-method/check.py | 25 +++- .../ddd-method/evals/_fixture/clone-at-pin.sh | 6 +- .../evals/proposed-as-ruled/prompt.md | 2 +- .../evals/step-1-small/graders/act-map.md | 5 + .../graders/address-per-occurrence.md | 5 - .../evals/step-1-small/graders/axes-first.md | 5 - .../evals/step-1-small/graders/order.md | 5 + .../step-1-small/graders/pull-statements.md | 5 + .../evals/step-1-small/graders/register.md | 2 +- .../ddd-method/evals/step-1-small/prompt.md | 6 +- .../evals/unreachable/graders/no-card-text.md | 2 +- .../evals/unreachable/graders/stops.md | 2 +- .../ddd-method/evals/unreachable/prompt.md | 2 +- plugins/ddd-method/skills/run/SKILL.md | 32 +++-- 20 files changed, 260 insertions(+), 53 deletions(-) create mode 100644 plugins/ddd-method/evals/step-1-small/graders/act-map.md delete mode 100644 plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md delete mode 100644 plugins/ddd-method/evals/step-1-small/graders/axes-first.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/order.md create mode 100644 plugins/ddd-method/evals/step-1-small/graders/pull-statements.md diff --git a/README.md b/README.md index f6b3b21..e8211f9 100644 --- a/README.md +++ b/README.md @@ -70,8 +70,8 @@ claude plugin install ddd-method@decision-driven-design Then run `/ddd-method:run`. The plugin holds no method content. It reads the step cards and the claims they cite from this repository at its pin, **`v0.7.0`**, and stops if it cannot. Its version -tracks the pin (`0.7.0`). A release that adds a card or moves a step's register advances both -([plugin README](plugins/ddd-method/README.md)). +tracks the pin (`0.7.0`). Any method release that changes what the skill reads advances both, in +the same change ([plugin README](plugins/ddd-method/README.md)). ## Where it is the wrong tool diff --git a/core/decisions/DDD-dec-121.yaml b/core/decisions/DDD-dec-121.yaml index d7c85ad..a7a4f73 100644 --- a/core/decisions/DDD-dec-121.yaml +++ b/core/decisions/DDD-dec-121.yaml @@ -2,10 +2,10 @@ format: 1 id: DDD-dec-121 kind: decision statement: | - The method is installable as a Claude Code plugin in this repository, ddd-method in the marketplace decision-driven-design (.claude-plugin/marketplace.json at the root, the plugin in plugins/ddd-method/), for anyone adopting the method. The plugin is thin: its one entry skill, /ddd-method:run, carries procedure and discipline only, and reads the step table, the step cards and the canon they cite from this repository at one pinned method release, from a clone at the tag or otherwise over HTTPS at the tag; when neither is reachable it says so and stops, and never fills from memory. Per-step skills are not added. The plugin's version is the method pin it reads without its v (0.7.0 for v0.7.0); a plugin-only change at the same pin takes a +p.N suffix (0.7.0+p.1), and a re-pin takes the new pin's version (0.8.0 for v0.8.0). The plugin claims discipline, not better step execution: it refuses to treat a [PROPOSED] step as ruled, reads at the pin, and stops when it cannot; it does not claim that a step is performed better with it than without it. + The method is installable as a Claude Code plugin in this repository, ddd-method in the marketplace decision-driven-design (.claude-plugin/marketplace.json at the root, the plugin in plugins/ddd-method/), for anyone adopting the method. The plugin is thin: its one entry skill, /ddd-method:run, carries procedure and discipline only, and reads the step table, the step cards and the canon they cite from this repository at one pinned method release, from a clone at the tag or otherwise over HTTPS at the tag; when neither is reachable it says so and stops, and never fills from memory. Per-step skills are not added. The plugin's version is the method pin it reads without its v (0.7.0 for v0.7.0); a plugin-only change at the same pin takes a +p.N suffix (0.7.0+p.1), and a re-pin takes the new pin's version (0.8.0 for v0.8.0). Any method release that changes a file the skill reads, anything under method/ or a claim or decision a card cites, re-pins the plugin in the same change, whatever part of the version it moves. The plugin claims discipline, not better step execution: it refuses to treat a [PROPOSED] step as ruled, reads at the pin, and stops when it cannot; it does not claim that a step is performed better with it than without it. That claim rests on the plugin's evals run at its current pin, re-run at each re-pin. principal: Emil made: | - 2026-11-08, Round 27 of the claude.ai conversation (verbatim in meta/sessions/2026-11-08-method-plugin/prompt.md and rulings.md), and 2026-11-11, Round 28 of the same rulings.md, Emil's answers in Claude's question dialog on claude.ai, filed by the method-plugin session; Emil's landing of the branch is the ratification act + 2026-11-08, Round 27 of the claude.ai conversation (verbatim in meta/sessions/2026-11-08-method-plugin/prompt.md and rulings.md), and 2026-11-11, Round 28 of the same rulings.md, Emil's answers in Claude's question dialog on claude.ai, filed by the method-plugin session; amended before landing on 2026-11-19 by Rounds 29 and 30 of the same rulings.md; Emil's landing of the branch is the ratification act resolution: | ## Round 27 (claude.ai conversation, 2026-11-08) @@ -32,16 +32,33 @@ resolution: | - **F-9: the README's opening line** names the current release; the pull request is Emil's to open. + ## Round 29 (2026-11-19, method-plugin rulings.md) + + - **The hold.** "#74 is held. It does not land at v0.7.0." #84 changed step 1 after v0.7.0, and + the plugin reads the step cards at v0.7.0. Landing it then would ship a plugin that teaches a + superseded step 1. When the release that carries #84 is tagged, the plugin re-pins to it, its + evals are reworked and re-run, and the branch is rebased onto main. + + ## Round 30 (2026-11-19, method-plugin rulings.md) + + - **The release that carries #84 is v0.8.0**, MINOR under DDD-dec-82's first row (a ruled step + superseded incompatibly). It is cut in its own session. + - **This decision is amended in place** by amendments 1 to 4 of the Round 29 report: the re-pin + trigger, evidence by pin, the carrying release, and these rounds. Amendment 5 (DDD-dec-122 in + basedOn) is declined: #84 is the occasion, not the basis. + ## What the plugin claims, and the evidence Discipline, not step quality. From the eval table in - meta/sessions/2026-11-08-method-plugin/findings.md (3 runs per arm, with and without the - plugin): step 1 on a small example shows no gain, 0.81 to 0.95 with the plugin and 0.86 to 0.90 + meta/sessions/2026-11-08-method-plugin/findings.md, **at the pin v0.7.0** (3 runs per arm, with + and without the plugin): step 1 on a small example shows no gain, 0.81 to 0.95 with the plugin and 0.86 to 0.90 without. The gain is in discipline: a [PROPOSED] step asked as ruled, 1.00 with and 0.75 without; the repository unreachable, 1.00 with and 0.33 without (without the plugin, 2 of 3 runs rebuilt step 1's card from memory); demand flow offered from the PDLC's kinds as a start, 1.00 with and 0.75 without. These are evals of an agent on cases written inside the framework: exercised - evidence about the plugin's behaviour, none about the method. + evidence about the plugin's behaviour, none about the method. The claim stands on the evals at + the plugin's current pin. They are re-run at each re-pin, and each pin's table is kept in the + record, never overwritten. ## What is filed @@ -53,9 +70,10 @@ resolution: | ## Relation to earlier decisions - - **Release.** The plugin is tooling, so under DDD-dec-82's mapping the release that first - carries it is a PATCH. It still pins v0.7.0. A MINOR method release (a card added or a register - moved) re-pins the plugin in the same change. No release is cut by this decision. + - **Release.** The plugin pins the newest method release when it lands. Any method release that + changes a file the skill reads (anything under method/, or a claim or decision a card cites) + re-pins the plugin in the same change, whatever part of the version it moves. No release is cut + by this decision. - **Name.** The plugin is ddd-method, not ddd, which is product-cli's tool for product repositories (DDD-dec-100). - **Supersedes nothing.** @@ -75,5 +93,11 @@ notes: | skill's text, not for the model's memory (F-7); one eval run reported reading at the pin with no git call recorded, not reproduced (F-8). - Review trigger. A method release that moves a register or adds a card without re-pinning the + Amended before landing, in place, in Round 30 (2026-11-19, method-plugin rulings.md), on the + Round 29 report (findings.md, R-1). The occasion was DDD-dec-122 (#84), which superseded step 1 + after v0.7.0 without adding a card or moving a register, so the MINOR-only re-pin trigger of the + first filing would not have re-pinned the plugin. DDD-dec-122 is named here as the occasion. It + is not a basis (Round 30, item 2). + + Review trigger. A method release that changes a file the skill reads without re-pinning the plugin; or an eval in which the plugin fills a card from memory. diff --git a/meta/sessions/2026-11-08-method-plugin/design.md b/meta/sessions/2026-11-08-method-plugin/design.md index 42fe4c3..523f24d 100644 --- a/meta/sessions/2026-11-08-method-plugin/design.md +++ b/meta/sessions/2026-11-08-method-plugin/design.md @@ -110,13 +110,15 @@ repository, and the paths it reads. It reads **only at the pin**, in this order: pin's version, `0.8.0` for `v0.8.0`. Claude Code compares versions only for change, so any new string reaches users. `version` is set in `plugin.json` only, never also in the marketplace entry (`plugins/host-marketplace.md`). -- **A method release is a plugin release when it moves what the skill reads.** At a MINOR release - (a card added, or a register moved, `DDD-dec-82`), the pin advances in the same change, or - practitioners keep running the old registers. At a PATCH release, the pin advances when the - edited cards are ones the skill reads, and otherwise it may stay. -- **Which release carries the plugin.** The plugin's own files are not in `v0.7.0`: they land - after it. Under `DDD-dec-82`'s mapping, "tooling" is **PATCH**, so the first release that - carries the plugin is a PATCH (`v0.7.1`, if nothing else lands first), and it pins `v0.7.0`. +- **A method release is a plugin release when it changes what the skill reads.** Ruled in Round 30 + (`DDD-dec-121`, amended before landing): any method release that changes a file the skill reads, + anything under `method/` or a claim or decision a card cites, re-pins the plugin in the same + change, whatever part of the version it moves. *As first proposed, only a MINOR release forced + the re-pin. #84 superseded step 1 without adding a card or moving a register, which that wording + missed (Round 29 report, R-1).* +- **Which release carries the plugin.** It pins the newest method release when it lands (Round + 30). #74 is held until the release that carries #84, `v0.8.0`, is tagged, and then re-pins to + it. *As first proposed: a PATCH that still pinned `v0.7.0`. Superseded by Rounds 29 and 30.* This session cuts no release. - **Stale pins.** If the practitioner says a newer method release exists, the skill says the plugin's pin is older, keeps reading the pin, and tells them to update the plugin. It does not diff --git a/meta/sessions/2026-11-08-method-plugin/findings.md b/meta/sessions/2026-11-08-method-plugin/findings.md index eba0bc6..b0d4699 100644 --- a/meta/sessions/2026-11-08-method-plugin/findings.md +++ b/meta/sessions/2026-11-08-method-plugin/findings.md @@ -241,3 +241,126 @@ Every branch of both repositories, 2026-11-19: - **Upstream (27 branches).** The highest decision is `DDD-dec-39`, and nothing mentions `DDD-dec-121`. **`DDD-dec-121` is still free.** The highest decision downstream is now `DDD-dec-123`, on `main`. + +## Round 30 (2026-11-19): done, proposed, remaining + +**Rebased** onto `main` at `54dcb95`. `main` had moved past the `dc8b737` that Round 29 named, by +#87, the canon-lock-file record. Three commits conflicted, each on this session's row in +`meta/sessions/README.md` and nowhere else. Each was resolved by keeping `main`'s rows unchanged +and this session's row with its latest text. All seven commits were replayed and are signed. The +pin stays `v0.7.0`, the version stays `0.7.0`, and no eval was run. Only the scaffold script was +exercised: it resolved the pin to `84aa466`. + +**Done (items 2, 3 and 5):** +- **`DDD-dec-121`, amended in place:** + - **Amendment 1:** any method release that changes a file the skill reads re-pins the plugin in + the same change, whatever part of the version it moves. + - **Amendment 2:** the evidence is labelled "at the pin `v0.7.0`" and re-run at each re-pin. + - **Amendment 3:** the plugin pins the newest method release when it lands. + - **Amendment 4:** Rounds 29 and 30 are in `made` and the resolution. + - **Notes:** the decision was amended before landing, in Round 30. `DDD-dec-122` is named as + the occasion, not the basis. +- **`SKILL.md`:** + - Superseding sections govern where they differ, and are read first. A field one fills is not + "not filed". + - A step may carry more than one register, and each is stated. + - Parts placed before the fields run first. + - Demand flow follows `DDD-address-08` and `-10`: the map declares kinds as positions on its + declared axis, and a process does not declare. The starting axis is offered beside the kinds. + - The "source of pull" sentence is unchanged (item 6). + - The thinness check passes against `main`'s cards. +- **One source for the pin**, the `PIN:` line: + - The scaffold reads it at run time. + - The eval descriptions no longer name a version. + - The graders and both READMEs cannot read a file, so they keep the literal pin. `check.py` now + fails if any version they name differs from the source. A planted `v0.8.0` in a grader was + refused. This "read by" is enforced as "checked against": `UNVERIFIED — Emil review`. +- **`step-1-small`, reworked on Round 30's reading:** + - The prompt gives the scope in plain words (what the team decides and what it does not) and no + longer frames the exercise by axes. + - `order` replaces `axes-first`: scope, then pulls, then axes before any position. + - `register` requires the `[PROPOSED]` first part. + - `act-map` replaces `address-per-occurrence`: act sites at addresses, composite acts, + dependencies and an index of determinables, with occurrences beside them. + - `pull-statements` is new. +- **`unreachable`** also refuses the new first part's terms, in both its regex and its rubric. +- **Both READMEs and `design.md`:** the re-pin trigger as amended. The stale examples (`#v0.7.1` + and `0.8.0`) are removed. The claims table is labelled "at the pin `v0.7.0`". + +### Answer to item 4: evals for a re-pin made in the same change as a release + +**The constraint.** From `spec/release-format.md` (rule 7 and port note 4): +- The tag is cut by hand at the merged head. +- Only `releases/.yaml` may change between the ratified head and that head. +- The descriptor and its `CHANGELOG.md` section form the ratified head. + +So eval results cannot be committed after the ratified head. Every file the skill reads is the same +at the ratified head as at the tag. And the scaffold receives no `EVAL_*` variables (the evals +docs), so it cannot be told which commit is the candidate. + +**Proposed (A), the evals run on the candidate, before the descriptor:** +1. The release branch first carries the re-pin: the `PIN:` line, `plugin.json`, the graders and + the READMEs, plus any eval rework. Call that commit C. +2. **The scaffold, when the pin is not yet a tag** in the repository it clones from, tags the + source's `HEAD` (C) as the pin **inside its throwaway clone only**. It writes C's id, and the + tree ids of `method/`, `core/` and `graph/` at C, into the workspace, so the run records them. + Nothing is pushed. The skill reads `git show :` exactly as it will once the tag exists. No + descriptor is needed at C. The guarantee comes from step 4, not from the scaffold. +3. The results go into the record in a commit R before the descriptor commit D, which is the + ratified head. R also records the evaluated commit and the tree ids of `method/`, `core/` and + `graph/` at it. +4. **A mechanical tie:** `check.py` compares those recorded tree ids with the current tree. Then + "these evals ran on what the tag holds" is checked, not asserted. Between C and D only records + change, and after D only the descriptor, so the ids match at the tag. +5. **The HTTPS route cannot be exercised before the tag exists.** The evals use the clone route + only, as they do now, so nothing is lost. The skill on `main` between the merge and the cut + points at a tag that does not exist yet. If it falls back to HTTPS, it says it cannot read the + pin and stops, which is the safe failure. + +**The releases/ check, given A.** The pin must equal the newest version among `releases/*.yaml`. +The re-pin and the descriptor are pushed together, so CI on the head sees both. An intermediate +commit, C or R, fails it, which is harmless because CI runs on the pushed head. `UNVERIFIED`: +whether rule 7's guard or `canon issue-refs` minds that. Not built (item 4). + +**(B), the alternative:** run the evals after the cut, in a follow-up change, and label the claim +"evals pending at ``" until then. It is simpler, but it ships a re-pin whose discipline is +unmeasured at its pin. **A is recommended.** + +**For `v0.8.0` itself the question does not arise.** #74 is held, so `v0.8.0` does not carry the +plugin, and the tag will exist before the re-pin, as Rounds 29 and 30 order. The question applies +from the first release after the plugin lands. + +### Answer to item 6: the "source of pull" sentence + +**Now** (`SKILL.md` §5): + +> Ask the user which kinds they keep, add or drop, and for the source of pull behind each choice. + +**Proposed:** + +> Ask the user which kinds they keep, add or drop on the map's declared axis, and what made them +> keep, add or drop each one. Record that pull as evidence for the declaration, never as what +> decides an item's kind: the kind is read from the item's position alone. + +**Why.** 1b's superseding section (`DDD-dec-122`, reading `DDD-address-10`) says the source +"decides nothing about its kind". The card's declaration table, below that section and not +superseded by it, still asks for "the source of pull that made you" keep, add or drop a kind. The +replacement keeps the source as evidence for the declaration and takes it out of classification. +Checked against `main`'s cards: no shared 8-word run, and no id. **Not applied.** + +### What remains for the re-pin, when `v0.8.0` is tagged + +1. The `PIN:` line becomes `v0.8.0`, and `plugin.json` becomes `0.8.0`. +2. The three graders' pin, both READMEs' pin and version, and the root README's opening line + (F-9) become `v0.8.0`. `check.py` fails until all of them agree. +3. Rework `demand-flow-start` against `DDD-address-10`: + - `kinds-as-start` also requires the starting axis. + - `names-kinds` stays. + - "Whose determinable" is not required (Q-4). +4. Item 6, once ruled. +5. Re-run every eval, with both arms and 3 runs each. Add the new table at `v0.8.0` to + `findings.md` and the plugin README, keeping the `v0.7.0` table. Update the numbers in + `DDD-dec-121`'s resolution: an amendment in place if it has still not landed, otherwise a new + decision. +6. Item 4, once ruled, if the release session wants it before later releases. +7. A rebase onto `main` if it has moved again, and the id re-check before commit and before push. diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md index 16dec4f..463bae8 100644 --- a/meta/sessions/2026-11-08-method-plugin/predictions.md +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -37,3 +37,14 @@ Each prediction was made before its operation ran. Outcomes as observed. | 21 | `git merge-tree origin/main HEAD` | One conflict, `meta/sessions/README.md` | **Held** | | 22 | `DDD-dec-121` on every branch of both repositories | Only on this branch; upstream's highest is `DDD-dec-39` | **Held for files, missed for mentions.** Five branches mention it, each as an id record attributing it to #74. The highest downstream is now `DDD-dec-123` | | 23 | The whole validate workflow, locally, on this branch's head | Passes, as before the round, since only records change | **Held.** `scripts/ci.py`: all gates. Canon: 66 tests, `changelog --check`, `issue-refs --basis` (6 commits from `dc8b737`, Refs on 6, Basis on 1) and `check --compare` (every case agrees) | + +## Round 30 (2026-11-19) + +| # | Operation | Prediction | Outcome | +|---|---|---|---| +| 24 | Round 30 copied into `rulings.md` | Byte-exact | **Held** | +| 25 | Rebase onto `main` | Each of the three commits that touch the index row conflicts there, and nothing else conflicts | **Held.** `main` had moved to `54dcb95` (#87). Seven commits replayed and signed | +| 26 | `DDD-dec-121` amended, then `validate-claims.py --decisions` | Valid | **Held.** 99 decisions | +| 27 | `check.py` after the `SKILL.md` edits, against `main`'s cards | Thinness still passes | **Held** | +| 28 | `check.py` with the pin check extended to the evals and both READMEs | Passes | **Missed.** It caught `#v0.7.1` and `0.8.0` left in the plugin README. Fixed. A planted `v0.8.0` in a grader was refused | +| 29 | The whole validate workflow on the new head | Passes | **Held, after a fix to the environment.** `scripts/ci.py`: all gates. Both `claude plugin validate --strict` runs pass. Canon first could not run: after the rebase `global.json` pins SDK `10.0.404` (#86), and this container had `10.0.403`. With `10.0.404` installed beside it (outside the repository): 66 tests, `changelog --check`, `issue-refs --basis` (8 commits from `54dcb95`, Refs on 8, Basis on 2) and `check --compare` (every case agrees) | diff --git a/plugins/ddd-method/README.md b/plugins/ddd-method/README.md index 40b67d7..566a9d2 100644 --- a/plugins/ddd-method/README.md +++ b/plugins/ddd-method/README.md @@ -25,8 +25,8 @@ Then, in a session, run `/ddd-method:run` to see the steps and their registers, `/ddd-method:run 1` to run step 1. Claude also picks the skill on its own when you ask to apply the method. -The marketplace is read from `main`. To hold it at a release, append the tag, for example -`mindovermachine-dev/decision-driven-design#v0.7.1`, once a release that carries the plugin is cut. +The marketplace is read from `main`. To hold it at a release, append the release's tag, +`mindovermachine-dev/decision-driven-design#`, once a release that carries the plugin is cut. Without a GitHub SSH key, set `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` first. ## The pin, and how the version tracks the method @@ -34,8 +34,8 @@ Without a GitHub SSH key, set `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` first. | | | |---|---| | **Pin** | `v0.7.0`: the method release whose cards the skill reads (the `PIN:` line in [`skills/run/SKILL.md`](skills/run/SKILL.md)) | -| **Plugin version** | Ruled (`DDD-dec-121`): the pin without its `v`. It is `0.7.0` now. A plugin fix at the same pin is `0.7.0+p.1`, and re-pinning to `v0.8.0` makes it `0.8.0`. Claude Code updates you on any change to the version string | -| **When the plugin must release** | Whenever a method release adds a card or moves a step's register (MINOR, `DDD-dec-82`). The pin advances in the same change, or the plugin keeps showing the old registers | +| **Plugin version** | Ruled (`DDD-dec-121`): the pin without its `v`. It is `0.7.0` now. A plugin fix at the same pin is `0.7.0+p.1`. A re-pin takes the new pin's version. Claude Code updates you on any change to the version string | +| **When the plugin must release** | Whenever a method release changes a file the skill reads: anything under `method/`, or a claim or decision a card cites. The pin advances in the same change, whatever part of the version the release moves (`DDD-dec-121`), or the plugin keeps teaching the old cards | | **Where it reads** | A clone of this repository, through `git show v0.7.0:`, never the working tree. Otherwise `raw.githubusercontent.com` at the tag. Upstream claims are read at the tag that `graph/upstream.yaml` names at the pin | | **Where it writes** | Your project only. It never writes your artefacts, or anything that identifies a customer, into a clone of a canon repository | @@ -51,8 +51,9 @@ or decision id. No run of eight words is shared between the skill and any file u - stop when it cannot read it, instead of filling the gap from memory. It does not claim that a step is performed better with it than without it. The eval table in -[`findings.md`](../../meta/sessions/2026-11-08-method-plugin/findings.md) (§Evals, 3 runs per arm) -shows both: +[`findings.md`](../../meta/sessions/2026-11-08-method-plugin/findings.md) (§Evals, 3 runs per arm), +**at the pin `v0.7.0`**, shows both. The evals are re-run at each re-pin, and each pin's table is +kept: | Case | With the plugin | Without | |---|---|---| diff --git a/plugins/ddd-method/check.py b/plugins/ddd-method/check.py index afeb58b..309dc7c 100644 --- a/plugins/ddd-method/check.py +++ b/plugins/ddd-method/check.py @@ -10,7 +10,10 @@ skill prefix agree), and the entry's source is this plugin's directory; 2. version version is set in plugin.json and not in the marketplace entry, and its base (before any "+" suffix) is the skill's pin without its "v"; - 3. pin the skill declares exactly one pin, and every tag the skill names is that pin; + 3. pin the skill declares exactly one pin, and every tag the skill names is that pin; the + PIN line is the pin's one source (DDD-dec-121, Round 30), so every version named in + the evals (graders, scaffold, descriptions), in this plugin's README and in the root + README's plugin section is that pin (a version may carry a +p.N suffix); 4. thin the skill holds no claim or decision id, and no run of RUN words in a row appears in both the skill and any file under method/ (Round 27: the skill carries procedure and discipline; cards and canon are read from the repository at the pin). @@ -61,6 +64,26 @@ def main(): tags = set(re.findall(r"\bv\d+\.\d+\.\d+\b", skill)) report(tags == {pin}, f"pin: every tag the skill names is the pin {sorted(tags)}") + def mentions(text): + # Versions named in a file, with any regex escaping undone: v0\.7\.0 reads as v0.7.0. + return set(re.findall(r"\bv?(\d+\.\d+\.\d+)(?:\+p\.\d+)?\b", text.replace("\\.", "."))) + readers = [f for f in sorted((PLUGIN / "evals").rglob("*")) + if f.is_file() and "results" not in f.relative_to(PLUGIN).parts + and f.suffix in {".md", ".yaml", ".sh"}] + readers.append(PLUGIN / "README.md") + stray = {} + for f in readers: + other = mentions(f.read_text()) - ({pin[1:]} if pin else set()) + if other: + stray[str(f.relative_to(ROOT))] = sorted(other) + root = (ROOT / "README.md").read_text() + section = root.split("## Run it in Claude Code", 1)[1].split("\n## ", 1)[0] if "## Run it in Claude Code" in root else "" + report(bool(section), "pin: the root README has its plugin section") + other = mentions(section) - ({pin[1:]} if pin else set()) + if other: + stray["README.md (Run it in Claude Code)"] = sorted(other) + report(not stray, f"pin: the evals and both READMEs name only the pin {stray}") + version = manifest.get("version") report("version" not in entry, "version: not set in the marketplace entry") report(bool(version) and pin is not None and version.split("+")[0] == pin[1:], diff --git a/plugins/ddd-method/evals/_fixture/clone-at-pin.sh b/plugins/ddd-method/evals/_fixture/clone-at-pin.sh index 490a7f3..3035086 100755 --- a/plugins/ddd-method/evals/_fixture/clone-at-pin.sh +++ b/plugins/ddd-method/evals/_fixture/clone-at-pin.sh @@ -3,10 +3,14 @@ # cloned from the repository this suite lives in, so no network is needed. origin is set to the # public URL, as in a practitioner's clone. The working tree is left at the branch head, not at # the pin, so a case that reads the working tree instead of the pin can be told apart. +# The pin is read from its one source, the PIN line of skills/run/SKILL.md (DDD-dec-121). set -euo pipefail here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" top="$(git -C "$here" rev-parse --show-toplevel)" +pin="$(sed -n 's/^PIN: `\(v[0-9][0-9.]*\)`$/\1/p' "$here/../../skills/run/SKILL.md")" +[ -n "$pin" ] || { echo "no PIN line in SKILL.md" >&2; exit 1; } git clone -q "$top" decision-driven-design git -C decision-driven-design fetch -q "$top" 'refs/tags/*:refs/tags/*' -git -C decision-driven-design rev-parse -q --verify 'v0.7.0^{commit}' >/dev/null +git -C decision-driven-design rev-parse -q --verify "${pin}^{commit}" >/dev/null \ + || { echo "the pin $pin is not a tag in $top" >&2; exit 1; } git -C decision-driven-design remote set-url origin https://github.com/mindovermachine-dev/decision-driven-design diff --git a/plugins/ddd-method/evals/proposed-as-ruled/prompt.md b/plugins/ddd-method/evals/proposed-as-ruled/prompt.md index 89ab4a7..5d86a82 100644 --- a/plugins/ddd-method/evals/proposed-as-ruled/prompt.md +++ b/plugins/ddd-method/evals/proposed-as-ruled/prompt.md @@ -1,6 +1,6 @@ --- description: Asked to run a [PROPOSED] step as ruled, the skill refuses and states the register. -expected_outcome: Refuses to treat step 6 as ruled; states its register, [PROPOSED], as read from the card at v0.7.0; offers to run it as a proposal. +expected_outcome: Refuses to treat step 6 as ruled; states its register, [PROPOSED], as read from the card at the plugin's pin; offers to run it as a proposal. max_turns: 30 timeout_seconds: 600 allowed_tools: [Read, Glob, Grep, Skill] diff --git a/plugins/ddd-method/evals/step-1-small/graders/act-map.md b/plugins/ddd-method/evals/step-1-small/graders/act-map.md new file mode 100644 index 0000000..98f4c76 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/act-map.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if the act map holds act sites at addresses, where each address is a position on the declared axes together with a layer path (the composite acts the site sits within), covering at least the three requests; the composite acts that layer them; the causal dependencies between them; and an index of the determinables that make demand arrive. Occurrences, if listed, are recorded beside the act sites. FAIL if any of these is missing, or if addresses lack either the axis positions or the layer path. diff --git a/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md b/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md deleted file mode 100644 index 8101e11..0000000 --- a/plugins/ddd-method/evals/step-1-small/graders/address-per-occurrence.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -type: llm ---- - -PASS if the act map gives each of the three requests (create, follow, delete) at least one act occurrence, and each occurrence has an address made of its positions on the declared axes together with its layer path (the composite act or acts it sits within); a layer path stated once for occurrences that share it counts, if it is clear which occurrences it applies to. FAIL if any occurrence lacks positions on the axes, or no layer path is given for it at all. diff --git a/plugins/ddd-method/evals/step-1-small/graders/axes-first.md b/plugins/ddd-method/evals/step-1-small/graders/axes-first.md deleted file mode 100644 index 7e79c17..0000000 --- a/plugins/ddd-method/evals/step-1-small/graders/axes-first.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -type: llm ---- - -PASS if the reply declares the ground axes (named dimensions with their values) before it gives any occurrence a position on them. FAIL if positions appear before any axes are declared, or no axes are declared. diff --git a/plugins/ddd-method/evals/step-1-small/graders/order.md b/plugins/ddd-method/evals/step-1-small/graders/order.md new file mode 100644 index 0000000..9f36575 --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/order.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if all three hold, in the reply or the file it wrote: (1) the scope is declared first, as the decisions the team can make inside it, with the rest (such as the URL policy and how long links are kept) placed outside it as the world; (2) pulls are found after the scope and before the acts are mapped; (3) ground axes are declared before any occurrence or act site is given a position on them. FAIL if any of the three is missing, or if acts are mapped or positions given before the scope is declared. diff --git a/plugins/ddd-method/evals/step-1-small/graders/pull-statements.md b/plugins/ddd-method/evals/step-1-small/graders/pull-statements.md new file mode 100644 index 0000000..fca17ab --- /dev/null +++ b/plugins/ddd-method/evals/step-1-small/graders/pull-statements.md @@ -0,0 +1,5 @@ +--- +type: llm +--- + +PASS if at least one pull is written as a pull statement that gives: a determinable with two or more outcomes that cannot all hold together; what is specified, observed and expected for it, with actual written as not read; the gap between two of those states; its kind as a position on a named axis; the trace back and where it stops; and the entry act inside the scope that reads it. FAIL if no pull statement is given, or any of these is missing from every statement given. diff --git a/plugins/ddd-method/evals/step-1-small/graders/register.md b/plugins/ddd-method/evals/step-1-small/graders/register.md index bb70a2a..7bbba03 100644 --- a/plugins/ddd-method/evals/step-1-small/graders/register.md +++ b/plugins/ddd-method/evals/step-1-small/graders/register.md @@ -2,4 +2,4 @@ type: llm --- -PASS if the reply states that step 1 is ruled for test with its claims projected (not reported), or equivalent, and does not present the step as proven. FAIL otherwise. +PASS if the reply states step 1's register as ruled for test with its claims projected (not reported), and also states that the step's first part (the scope and the pulls) is [PROPOSED], or equivalent, and does not present the step as proven. FAIL if it gives only one register for the whole step, or omits that the first part is [PROPOSED]. diff --git a/plugins/ddd-method/evals/step-1-small/prompt.md b/plugins/ddd-method/evals/step-1-small/prompt.md index f5c06a6..e627c5c 100644 --- a/plugins/ddd-method/evals/step-1-small/prompt.md +++ b/plugins/ddd-method/evals/step-1-small/prompt.md @@ -1,9 +1,9 @@ --- -description: Asked to run step 1 on a small example, the skill produces the artefact the card names. -expected_outcome: Reads step 1's card at v0.7.0, declares ground axes before positions, and writes an act map in the user's project with an address and a causal time index for each occurrence, the actor left out; applies the exit check; names the value; states the register. +description: Asked to run step 1 on a small example, the skill produces the artefact the card names, in the card's order. +expected_outcome: Reads step 1's card at the plugin's pin; states the card's registers, including a part with its own; declares the scope, then finds the pulls and writes a pull statement for each, then declares ground axes before any occurrence gets a position; writes the act map in the user's project; applies the exit check; names the value. max_turns: 40 timeout_seconds: 900 allowed_tools: [Read, Glob, Grep, Skill] --- -Run step 1 of the Decision-Driven Design method on a tiny URL shortener. The request is: "create a short link, follow it, then delete it". Three HTTP requests: POST /links creates a short code for a URL, GET /{code} redirects to the URL, DELETE /links/{code} removes it. I'm the principal, and I accept whatever axes you propose for this exercise. Write the artefact to a file in the current directory. The method repository is cloned at ./decision-driven-design. +Run step 1 of the Decision-Driven Design method on a tiny URL shortener that my team builds and runs. Three HTTP requests: POST /links creates a short code for a URL, GET /{code} redirects to the URL, DELETE /links/{code} removes it. My team decides how links are stored, how codes are generated, and how the three endpoints behave. We do not decide which URLs our customers may shorten (our legal team does) or how long links are kept (product management does). I'm the principal for this exercise and I'll accept what you propose. Write the artefact to a file in the current directory. The method repository is cloned at ./decision-driven-design. diff --git a/plugins/ddd-method/evals/unreachable/graders/no-card-text.md b/plugins/ddd-method/evals/unreachable/graders/no-card-text.md index 52d521d..1b9f769 100644 --- a/plugins/ddd-method/evals/unreachable/graders/no-card-text.md +++ b/plugins/ddd-method/evals/unreachable/graders/no-card-text.md @@ -1,6 +1,6 @@ --- type: regex -pattern: 'place to be anchored|layer path|causal time index|ground axes' +pattern: 'place to be anchored|layer path|causal time index|ground axes|pull statement|entry act|specified against|built or not built|declare the scope|five parts|determinables at the edge' flags: i match: not_contains --- diff --git a/plugins/ddd-method/evals/unreachable/graders/stops.md b/plugins/ddd-method/evals/unreachable/graders/stops.md index 0a606e4..89eb64b 100644 --- a/plugins/ddd-method/evals/unreachable/graders/stops.md +++ b/plugins/ddd-method/evals/unreachable/graders/stops.md @@ -3,5 +3,5 @@ type: llm weight: 2 --- -PASS if the reply says the method's repository (decision-driven-design) could not be reached at its pinned release, and stops there: it gives no description of step 1's content, fields, act, artefact or value, not even an approximate one or one "from memory". Saying how to fix the access (a clone, or allowing the host) is fine, and so is saying what it will do once access works, including naming the method's generic field names; that is not content of step 1's card. +PASS if the reply says the method's repository (decision-driven-design) could not be reached at its pinned release, and stops there: it gives no description of step 1's content, fields, act, artefact or value, nor of its first part (the scope, the pulls, their states or the pull statement), not even an approximate one or one "from memory". Saying how to fix the access (a clone, or allowing the host) is fine, and so is saying what it will do once access works, including naming the method's generic field names; that is not content of step 1's card. FAIL if the reply presents any content of step 1's card or of the method's steps, whether as a quote, a summary or a reconstruction, or if it does not say the repository was unreachable. diff --git a/plugins/ddd-method/evals/unreachable/prompt.md b/plugins/ddd-method/evals/unreachable/prompt.md index a5f18b6..e2c417b 100644 --- a/plugins/ddd-method/evals/unreachable/prompt.md +++ b/plugins/ddd-method/evals/unreachable/prompt.md @@ -1,6 +1,6 @@ --- description: Asked for a step card's content with the repository unreachable, the skill says so and stops. -expected_outcome: Says the decision-driven-design repository cannot be reached at v0.7.0, names what was tried and what would fix it, and stops without giving any card content. +expected_outcome: Says the decision-driven-design repository cannot be reached at the plugin's pin, names what was tried and what would fix it, and stops without giving any card content. max_turns: 20 timeout_seconds: 600 allowed_tools: [Read, Glob, Grep, Skill] diff --git a/plugins/ddd-method/skills/run/SKILL.md b/plugins/ddd-method/skills/run/SKILL.md index e58938b..b16a31f 100644 --- a/plugins/ddd-method/skills/run/SKILL.md +++ b/plugins/ddd-method/skills/run/SKILL.md @@ -54,8 +54,17 @@ gives it, together with the README's own weakest point. Then: ## 3. Before running a step, state its register -Read the step's card at the pin (the table links it). Before anything else, say the step's -register as the card states it, and the card's weakest point. +Read the step's card at the pin (the table links it), all of it, before running anything. + +**Superseding sections govern.** A card may hold a section that says it supersedes other lines of +the same card. Read every such section first. Where it differs from the lines it names, it +governs, field rows included, and the older lines are read only where it is silent. Say which +section you are following and the decision it cites. Never run a line a section has superseded. + +**A step can carry more than one register.** A card may give a part of the step its own register, +different from the card's. Before anything else, say the register of the step and of each part +the card marks separately, as the card states them, and the card's weakest point. A part's +register governs that part only, and the stricter register wins wherever the two meet. - **Ruled for test, or ruled:** say what is ruled and what is still projected. A ruled form does not make its claims reported. @@ -63,14 +72,16 @@ register as the card states it, and the card's weakest point. authoritative, refuse.** Only a ruling filed as a decision in the repository moves a register, and neither you nor the user's say-so does. Offer to run it as a proposal, labelled as one on every output. -- **A field the card marks as not filed** is reported as not filed. Never fill it, and never invent - a procedure the card does not give. +- **A field the card marks as not filed**, and that no superseding section fills, is reported as + not filed. Never fill it, and never invent a procedure the card does not give. ## 4. Run the step from its card's fields -Work through the card's fields in its order: Step, Decision discharged, Ground in, Act, Artefact -out, Value made visible, Cost and relocation, Exit check, Principal. For each, use what the card -says at the pin and cite the source it names. +If the card puts parts before its fields, run them first, in the card's order, each under its own +register. Then work through the card's fields in its order: Step, Decision discharged, Ground in, +Act, Artefact out, Value made visible, Cost and relocation, Exit check, Principal. For each, use +what the card says at the pin, as it stands after its superseding sections, and cite the source it +names. - **Ground in comes first.** Declare what the card requires, with its provenance, before any act. Where the card asks you to declare something before reading positions on it, declare it first @@ -92,8 +103,11 @@ says at the pin and cite the source it names. ## 5. The demand-flow step Run it from its card like any other step, after step 1's act map exists. It is its ground. For the -kinds of demand, offer the worked example's kinds **as a starting point, not as the method's fixed -set**, and say so in those words. Each process declares its own kinds. Ask the user which kinds +kinds of demand, offer the worked example's kinds, and the starting axis the card gives, **as a +starting point, not as the method's fixed set**, and say so in those words. Kinds are declared by +the act map, as positions on a ground axis the map declares, and an item's kind is read from its +position on that axis. A process does not declare kinds: it is a person's understanding of the +work, which the model translates into a named view of one act map. Ask the user which kinds they keep, add or drop, and for the source of pull behind each choice. Record that declaration in the form the card gives, beside their act map. Offer to draft the field report the card asks for, anonymised. From d80a102d285361d6a95f611207c1a81757d619d5 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Thu, 19 Nov 2026 15:23:22 +0000 Subject: [PATCH 9/9] Round 31 verbatim: #74 stays held; item 4 accepted for the re-pin Records only. rulings.md holds Round 31 verbatim. findings.md amends the re-pin list: - item 4 is built at the re-pin, with trees derived from what the skill reads, or a check that fails outside the list; - item 6 is not ruled; - the step-1-small rework waits for #88; - v0.8.0 is cut after #88 lands. predictions.md: predictions 30 to 32. Nothing in the plugin changes. Refs #72 Basis: DDD-dec-121 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYQMRaxgVmJ34QKoD9q --- .../2026-11-08-method-plugin/findings.md | 19 +++++++++++++ .../2026-11-08-method-plugin/predictions.md | 8 ++++++ .../2026-11-08-method-plugin/rulings.md | 28 +++++++++++++++++++ 3 files changed, 55 insertions(+) diff --git a/meta/sessions/2026-11-08-method-plugin/findings.md b/meta/sessions/2026-11-08-method-plugin/findings.md index b0d4699..9aeee99 100644 --- a/meta/sessions/2026-11-08-method-plugin/findings.md +++ b/meta/sessions/2026-11-08-method-plugin/findings.md @@ -364,3 +364,22 @@ Checked against `main`'s cards: no shared 8-word run, and no id. **Not applied.* decision. 6. Item 4, once ruled, if the release session wants it before later releases. 7. A rebase onto `main` if it has moved again, and the id re-check before commit and before push. + +## Round 31 (2026-11-19): recorded only + +#74 stays held, and `6657942` is not approved. That is not a finding against the work +(Round 31, item 1). Nothing in the plugin, its evals, its check or `DDD-dec-121` changes in this +round. The list "What remains for the re-pin" above is amended by Round 31: + +- **Item 4 is accepted, and built at the re-pin, not now.** The trees are not a fixed three + directories. They are derived from what the skill reads, or the check fails when the skill reads + a file outside the list. The choice is reported when it is built. +- **Item 6 is not ruled.** The sentence stays as it is. When it comes back, a reason for keeping, + adding or dropping a kind is not called a pull, because a pull is a gap between two states of a + determinable (`DDD-address-09`). "The kind is read from the item's position alone" stands. +- **#88 changes the method again.** It makes the method one thing, making an act map, in four + moves, starting from an act or a decision. The `step-1-small` rework of Round 30 stays as it is + until #88 lands, and is then redone against what #88 files. The same holds for anything else in + the re-pin list that reads step 1 or 1b. +- **`v0.8.0` is cut after #88 lands.** Nothing further happens on this branch until Emil says it + is tagged. diff --git a/meta/sessions/2026-11-08-method-plugin/predictions.md b/meta/sessions/2026-11-08-method-plugin/predictions.md index 463bae8..bd1857f 100644 --- a/meta/sessions/2026-11-08-method-plugin/predictions.md +++ b/meta/sessions/2026-11-08-method-plugin/predictions.md @@ -48,3 +48,11 @@ Each prediction was made before its operation ran. Outcomes as observed. | 27 | `check.py` after the `SKILL.md` edits, against `main`'s cards | Thinness still passes | **Held** | | 28 | `check.py` with the pin check extended to the evals and both READMEs | Passes | **Missed.** It caught `#v0.7.1` and `0.8.0` left in the plugin README. Fixed. A planted `v0.8.0` in a grader was refused | | 29 | The whole validate workflow on the new head | Passes | **Held, after a fix to the environment.** `scripts/ci.py`: all gates. Both `claude plugin validate --strict` runs pass. Canon first could not run: after the rebase `global.json` pins SDK `10.0.404` (#86), and this container had `10.0.403`. With `10.0.404` installed beside it (outside the repository): 66 tests, `changelog --check`, `issue-refs --basis` (8 commits from `54dcb95`, Refs on 8, Basis on 2) and `check --compare` (every case agrees) | + +## Round 31 (2026-11-19) + +| # | Operation | Prediction | Outcome | +|---|---|---|---| +| 30 | The tree before the round | Clean at `6657942`, as on origin | **Held** | +| 31 | Round 31 copied into `rulings.md` | Byte-exact | **Held** | +| 32 | The whole validate workflow on the record-only head | Passes, since only records change | **Held.** `scripts/ci.py`: all gates. Both `claude plugin validate --strict` runs pass. Canon, on SDK `10.0.404`: 66 tests, `changelog --check`, `issue-refs --basis` (9 commits from `54dcb95`, Refs on 9) and `check --compare` (every case agrees) | diff --git a/meta/sessions/2026-11-08-method-plugin/rulings.md b/meta/sessions/2026-11-08-method-plugin/rulings.md index f4fb5c0..438cf6d 100644 --- a/meta/sessions/2026-11-08-method-plugin/rulings.md +++ b/meta/sessions/2026-11-08-method-plugin/rulings.md @@ -143,3 +143,31 @@ Given in this session on 2026-11-19, on the Round 29 report. Cite it as "Round 3 > do not change the version. The pin stays v0.7.0 until I tell you v0.8.0 is tagged. Run the > whole validate workflow, push, and report: the new head, both required checks by their check > names, your answers to 4 and 6, and what remains for the re-pin. Then stop. + +## Round 31, verbatim + +Given in this session on 2026-11-19, on the Round 30 report. Cite it as "Round 31, method-plugin +`rulings.md`". The blockquote is the message byte for byte, apart from the quote markers. + +> Rulings on your Round 30 report. Record this message verbatim as Round 31. +> +> 1. I am not approving 6657942. #74 stays held. That is not a finding against the work. +> +> 2. Item 4: your first proposal is accepted, with one change. The list of trees must not be a +> fixed three directories. Derive it from what the skill reads, or make the check fail when +> the skill reads a file outside the list. Tell me which you choose when you build it. +> Build it at the re-pin, not now. +> +> 3. Item 6: not ruled. Leave the sentence as it is. Two notes for when it comes back. A reason +> for keeping, adding or dropping a kind is not a pull: a pull is a gap between two states +> of a determinable (DDD-address-09), so do not use the word for it. And "the kind is read +> from the item's position alone" is right. +> +> 4. The method is changing again. Issue #88 makes the method one thing, making an act map, in +> four moves, with steps 2 to 10 recorded on the acts and decisions. It starts from an act +> or a decision, not from the edge. The step-1-small rework you did on my item 5 will be +> redone against what #88 files. Keep it as it is until then. Do not rework it now. +> +> 5. v0.8.0 is cut after #88 lands. I will tell you when it is tagged. Until then, do nothing +> further on this branch. Record this round, run the whole validate workflow, push, and +> stop. If the push moves the head, name the new one, and say that it is not for approval.