Cutover: consume JustDummies from NuGet and remove its source from this repository

[Reefact]

Follow-up to #229, and the executable half of ADR-0069 (proposed in #403).

JustDummies now lives in Reefact/just-dummies, extracted with git filter-repo at fbf523b86acebdd34ba0bbfd437683864be3cb9c. Nothing was removed from this repository by that extraction — this issue is the removal, and it is deliberately blocked until a package exists.

Prerequisite — the one thing that unblocks everything

A restorable JustDummies package on nuget.org. It does not exist yet: the package has never been published, and Reefact/just-dummies cannot publish until its trusted-publishing policy is configured (owner Reefact, repo just-dummies, workflow release.yml, no environment, one policy per package ID, plus the NUGET_USER secret — full procedure in doc/handwritten/for-maintainers/migration/nuget-trusted-publishing.md over there).

Do not start this work before that version exists. Replacing a ProjectReference with a PackageReference to an unpublished version fails dotnet restore with NU1102 for every contributor and every CI run.

Record the version here when it lands: JustDummies X.Y.Z = _______

Why this cannot be split into small commits

FirstClassErrors.Testing does not merely reference JustDummies — it ships it. It carries a private ProjectReference plus the IncludeJustDummiesInPackage target that embeds JustDummies.dll inside the package's own lib/, with PrivateAssets="all" suppressing the <dependency> entry. Removing the project reference without removing the embedding produces a package that silently ships nothing; removing the embedding without adding the package reference produces one that resolves nothing. They move together, in one pull request.

The cutover, in the order that keeps the build green

Deleting the directories first turns every other step into a broken-build debugging session. Do them in this order.

1. Declare the version

Directory.Packages.props — add, alphabetically:

<PackageVersion Include="JustDummies" Version="X.Y.Z" />

2. Swap the four library references

File	Line	Today
FirstClassErrors.Testing/FirstClassErrors.Testing.csproj	62	<ProjectReference Include="..\JustDummies\JustDummies.csproj" PrivateAssets="all" />
FirstClassErrors.UnitTests/FirstClassErrors.UnitTests.csproj	34	<ProjectReference Include="..\JustDummies\JustDummies.csproj" />
FirstClassErrors.RequestBinder.UnitTests/FirstClassErrors.RequestBinder.UnitTests.csproj	31	idem
FirstClassErrors.Testing.UnitTests/FirstClassErrors.Testing.UnitTests.csproj	28	idem

Each becomes <PackageReference Include="JustDummies" />. On FirstClassErrors.Testing, drop PrivateAssets="all" — the package should declare an honest JustDummies dependency now.

3. Drop the analyzer plumbing

The analyzers ship inside the library package under analyzers/dotnet/cs, so the PackageReference above delivers them on its own. Delete the five OutputItemType="Analyzer" ReferenceOutputAssembly="false" PrivateAssets="all" ProjectReferences on JustDummies.Analyzers (FirstClassErrors.Testing.csproj:67, FirstClassErrors.UnitTests:39, FirstClassErrors.RequestBinder.UnitTests:36, FirstClassErrors.Testing.UnitTests:33, and any other consumer added since). ADR-0061 still holds — the analyzers keep running on this repository's code, they just arrive from NuGet.

4. Delete the embedding workaround

FirstClassErrors.Testing/FirstClassErrors.Testing.csproj, lines ~73–84: the TargetsForTfmSpecificBuildOutput hook and the whole IncludeJustDummiesInPackage target.

5. Unwire the dum train and the JustDummies CI

• FirstClassErrors.sln — remove the 7 JustDummies.* projects (and their GlobalSection(NestedProjects) rows)
• tools/trains.sh — the dum|dum-v|justdummies|… row
• tools/packaging/pack.sh — the dum) scope arm and its standalone guard
• .github/workflows/release.yml — the dum-v*.*.* tag trigger, the dum choice option, the dum-v*) case arm and lib|cli|dum) validation
• .github/workflows/release-dryrun.yml — the pack.sh … dum and release-notes.sh dum calls
• .github/workflows/changelog.yml — the dum choice option and its comment row
• tools/commit-lint/lint-commit-message.sh — the justdummies scope in SCOPES and SCOPES_HUMAN
• build/stryker/justdummies.json, justdummies-analyzers.json, justdummies-xunit.json
• .github/workflows/justdummies.yml, .github/workflows/justdummies-mutation.yml
• .gitignore — the tools/justdummies-check/ block

6. Delete the source, last

The 7 JustDummies*/ directories and tools/justdummies-check/, once nothing above references them.

7. Move the documentation that follows the code

Delete here what is now owned by the other repository: WritingJustDummiesTests.{en,fr}.md, specifications/justdummies-tool.{md,fr.md}, workflows/justdummies-mutation.{en,fr}.md, audit/2026-07-20-dummies-architecture-and-design-audit.{md,fr.md}, the 56 for-users/analyzers/JD0*.{en,fr}.md pages, and the JustDummies ADRs (0013, 0015, 0020, 0025, 0030–0033, 0035–0042, 0044, 0045, 0047–0054, 0058, 0059, 0063–0066).

Keep, and do not treat as leftovers:

• ADR-0011 and ADR-0022 — they bind both products and exist in both repositories
• ADR-0026, ADR-0061, ADR-0006 — their subject is this repository; FirstClassErrors.Testing's history is unreadable without them
• doc/handwritten/for-users/ArbitraryTestValues.{en,fr}.md — it documents this repository's testing package; give it a link to the new repository

Fix the resulting dangling links in the ADR index and in for-users/analyzers/README.md.

8. Verify

dotnet build FirstClassErrors.sln -c Release then dotnet test FirstClassErrors.sln -c Release, and check the produced FirstClassErrors.Testing package actually declares <dependency id="JustDummies" version="X.Y.Z" /> and no longer carries lib/netstandard2.0/JustDummies.dll.

What this fixes for consumers

Today FirstClassErrors.Testing carries a copy of JustDummies.dll with no dependency entry, so a consumer who also references JustDummies directly can end up with two copies at different versions and no diagnostic. After the cutover NuGet resolves one assembly and the version is visible and reviewable.

Constraint that outlives this issue

Commit messages in Reefact/just-dummies older than 2026-07-31 cite issue and pull-request numbers of this repository, and nothing there can be renumbered. Those references must keep resolving: close issues here, never delete them.

[Reefact]

Step 9 — renumber this repository's ADR base, in a separate pull request right after the cutover

Deleting the 34 JustDummies ADRs (step 7) leaves this base at 34 decisions and 35 holes:

1–10, 12, 14, 16–19, 21, 23, 24, 26–29, 34, 43, 46, 55, 56, 57, 60, 61, 62, 67, 69

Reefact/just-dummies hit exactly this and closed it on 2026-07-31; the protocol below is the one that worked there, with the traps it actually ran into. Do it as its own pull request, immediately after the cutover — folding a 34-file renumbering plus a citation sweep into a PR that already deletes seven projects makes both unreviewable.

Renumbering is indexing, not deciding: it changes an identifier, never a context, decision, rationale, alternative, consequence, status, date or attribution. It is not the thing ADR-0024 refuses to set a precedent for.

The one that bites first

Deleting the 34 does not only make holes — it orphans every citation of them, and those citations are not confined to the ADR folder. Measured on main today, and excluding everything that step 6/7 deletes anyway, 38 surviving files cite a departing ADR:

File	Citations
doc/handwritten/for-maintainers/adr/README.md	34
audit/2026-07-20-firstclasserrors-architecture-and-design-audit.{md,fr.md}	20 each
adr/0026-rebase-testing-arbitrary-values-on-dummies.{md,fr.md}	17 each
adr/0069-consume-justdummies-from-its-own-repository.{md,fr.md}	5 each
FirstClassErrors.UnitTests/OutcomeTryTests.cs	4
adr/0060, adr/0061	3 each
adr/0002, adr/0028, adr/0043, adr/0055, specifications/adr-implementation-reference, workflows/mutation	2 each
FirstClassErrors.Testing/FirstClassErrors.Testing.csproj, AGENTS.md, CLAUDE.md, adr/0023, adr/0046, adr/0056, adr/0062, for-maintainers/README.{md,fr.md}	1 each

The two in bold are the dangerous ones: a .cs and a .csproj. Nothing compiles a comment, so a stale ADR number there rots in silence — that is exactly the class of citation the target repository nearly missed.

Every one of those becomes a link to the decision's new home. The mapping is fixed and already published:

FCE number → its number in Reefact/just-dummies (34 decisions)

0011→0003  0013→0004  0015→0005  0020→0006  0022→0007  0025→0008  0030→0009
0031→0010  0032→0011  0033→0012  0035→0014  0036→0015  0037→0016  0038→0017
0039→0018  0040→0019  0041→0020  0042→0021  0044→0023  0045→0024  0047→0026
0048→0027  0049→0028  0050→0029  0051→0030  0052→0031  0053→0032  0054→0033
0058→0037  0059→0038  0063→0040  0064→0041  0065→0042  0066→0043

Base URL: https://github.com/Reefact/just-dummies/blob/main/doc/handwritten/for-maintainers/adr/

Procedure

1. Convert the orphaned citations first, before renumbering anything. ADR-0045 → a link to just-dummies ADR-0024, qualified in text as ADR-0024 (just-dummies) so a bare number always means this base. Doing this after the local renumbering makes the two number spaces collide while you work.
2. Renumber the 34 survivors into a contiguous 0001–0034 in one atomic pass — a substitution callback over a full old→new map, never sequential sed. Source and target ranges overlap heavily; sequential replacement corrupts silently.
3. Skip anything already qualified. A reference reading ADR-0011 (just-dummies) must not be caught by the local renumbering, even though 0011 is also a local number. This is the single easiest way to break the pass.
4. Add a provenance line to each header — Formerly ADR-NNNN — beside the existing dated lines, never replacing one (ADR-0057). The git history is not rewritten, so ~1350 commit messages keep citing the old numbers and this line is their only decoder.
5. Rename the files with git mv so rename detection survives.
6. Record it as a new ADR carrying the full mapping table, and regenerate the index with a Was column.

Verification that actually catches things

Do not trust the pass; diff it. For every renumbered ADR, normalise both sides (numbers → placeholder, ADR filenames → placeholder, provenance line stripped) and diff against the pre-change file. The expected result is zero content difference. On just-dummies this proved 74 of 86 files byte-identical and isolated the 12 intended edits — it is what turns "I think the regex was fine" into evidence.

Then check, mechanically: sequence contiguous, every ADR has its bilingual pair and correct cross-links, each title carries its own number, index statuses and titles match the files, supersession targets exist, no broken links, and every (just-dummies) citation resolves to a real file over there.

While you are in there

just-dummies also found that 84 of its 114 cross-repository references were dead text — a bare number in another repository's namespace, correct and unusable at once. Making them proper links costs nothing and touches no prose. Worth doing here in the same pass rather than discovering it later.

---

Generated by Claude Code