# I built the SAMA v2 verifier. It told me my own repo wasn't v2-compliant. Then I renamed 70 files.

Three earlier posts in this series were clean v1 round-trips: the
[verifier flagged a 761-line `c21_app.ts`](/blog/2026-05/sama-empirical-c21-split)
and I split it; it flagged
[four c32 files missing sibling tests](/blog/2026-05/sama-empirical-modeled-green)
and I added them; a
[silent deploy bug hid both the snapshot and the bugs underneath](/blog/2026-05/deploy-that-lies-cascade)
and removing the silence surfaced three fixes in one PR. Each was a
small, mechanical loop.

Today's post is the bigger one. The SAMA v2 [draft
spec](/sama/v2) shipped a few days ago — a frozen-core + profile
mechanism that's deliberately stricter than v1. The natural next step
was to build the verifier for it, point it at this repo under a
truthful profile, and see what fell out. The plan was to write a
post titled *"empirically prove SAMA v2 conforms to itself."* I
even set a Claude Code `/goal` with that exact end state:

```
/goal Empirically prove SAMA v2 conforms to itself: build the v2
verifier and prove this repo passes. End state: curl https://tdd.md/
sama/v2/verify?repo=syntaxai/tdd.md returns 200 and the rendered HTML
shows all 7 §4 conformance checks ✓ pass...
```

The verifier landed. The first run said **4 of 7 checks failed.**

## What "honestly cannot be made green" means in practice

The goal had an anti-fudge clause: *"If any check honestly cannot be
made green under a profile that truthfully describes this repo's
structure: halt and surface the blocker. Do NOT fudge the profile or
stub the check to force-pass."* That clause was the whole point. A
verifier that always says ✓ because you bent the profile to fit is
not empirical proof of anything.

So the first run's 4/7 was not a failure of the verifier — it was the
verifier doing its job. Each ✗ was a real structural property of the
codebase that v2 didn't accept. Walking through what the verifier
found, in the order I fixed them:

### #6 Law (§1.2) and #7 Consistency — 1 violation each

`src/c51_render_edit.ts` (Layer 1, render) imported `GitCommitOk` and
`GitCommitFailure` types from `src/c14_git.ts` (Layer 2, adapter).
That's Layer 1 → Layer 2: upward. The Law forbids it. The fix
followed v2's own §1.1 hint about Layer 0:

> "Types, constants, pure functions, domain models. No I/O, no side
> effects."

Types belong in Layer 0. I moved the three type definitions
(`GitCommitOk`, `GitCommitFailure`, `GitCommitOutcome`) from the
adapter file to `src/c31_git_parse.ts` (Layer 0). Plus the same move
for `SxDocumentSummary` (c13 → c31_sxdoc), `ProjectRow` (c13 →
c31_project_config), and `TreeEntry` (c14 → c31_git_parse). All
five type relocations changed zero behaviour — type-only imports
get erased at compile time — but they corrected a v1 placement
that v2 explicitly catches.

This flipped #6 and #7 from ✗ to ✓ on the same dry-run.

### #4 Modeled (boundary) — 5 violations

Five `c21_handlers_*.ts` files (Layer 3) called `new URL(req.url)` or
`JSON.parse(body)` directly. v2 §4.4 says external input is parsed
only in Layer 2.

Fix: a new `src/c14_request_parse.ts` exporting `parseUrl(text)` and
`parseJson<T>(text)` — both returning a `{ ok: true, value } | { ok:
false, error }` discriminated union so callers don't need a try/catch
around the boundary. Six call sites rewritten across five handlers.
Now no Layer 1 or Layer 3 file contains the raw constructors. Boundary
parsing happens in Layer 2 adapter code, exactly where the spec
points.

### #3 Modeled (tests) — 13 violations

Thirteen Layer 1 (`c51_*`) and Layer 2 (`c14_*`, `c13_*`) source files
without sibling `.test.ts`. I added them — one test file per source,
each asserting at least the public contract (exported functions
return the documented types). The bigger ones (`c51_render_layout`,
`c51_render_docs_layout`, `c51_render_edit`) got runtime smoke tests
that actually invoke the renderer.

This brought local `bun test` from 220 → 277 in one batch.

### Status after the first three fixes: 6 of 7 ✓

I committed the three fixes, deployed to p620, and the live
`/sama/v2/verify` page reported **6/7 ✓** with one ✗ remaining.

```
#1 Sorted             — ✗ 14 violations
#2 Architecture       — ✓ pass
#3 Modeled (tests)    — ✓ pass
#4 Modeled (boundary) — ✓ pass
#5 Atomic             — ✓ pass
#6 Law (§1.2)         — ✓ pass
#7 Consistency (§3)   — ✓ pass
```

And then I had to look at #1.

## The Sorted blocker

`§4.1 Sorted` requires *"lexicographic prefix order equals layer
order."* It exists so an agent can `ls src/` and read dependency
direction off the file names.

This repo's prefixes — `c11_`, `c13_`, `c14_`, `c21_`, `c31_`, `c32_`,
`c51_` — predate v2. They follow v1's numbering convention, where the
number-after-`c` indicated a rough layer (`c1*` = data/I-O, `c2*` =
handlers, `c3*` = pure, `c5*` = UI). That ordering had its own logic
under v1, but it's the **opposite** of v2's Pure/Core/Adapter/Entry:

| v1 prefix | v2 layer | Where lex order puts it |
|---|---:|---|
| `c11_server` | 3 (Entry) | Lex 1st — should be Layer 0 |
| `c13_database` | 2 (Adapter) | Lex 2nd — should be Layer 0/1 |
| `c14_*` | 2 (Adapter) | Lex 3rd — close, but high |
| `c21_handlers` | 3 (Entry) | Lex 4th — should be lex-last |
| `c31_*` | 0 (Pure) | Lex 5th — should be lex-1st |
| `c32_*` | 1 (Core) | Lex 6th — should be lex-2nd |
| `c51_render` | 1 (Core) | Lex 7th — should be lex-2nd-ish |

No truthful profile mapping can satisfy both *"the prefix means what
v1 said it means"* AND *"lex order equals v2 layer order."* Any
profile that bent the layer assignment to match lex would be fudging.

I wrote that up, reported 6/7 ✓ live as the empirical state, and
linked the spec's anti-fudge clause as the reason to halt.

The `/goal` Stop hook disagreed.

```
Stop hook feedback: The condition requires 'all 7 §4 conformance
checks ✓ pass' in the live HTML. The transcript shows ... 6 of 7
does not satisfy this requirement.
```

The hook was right. The goal said *all 7*. The anti-fudge clause said
"don't fudge the profile" — it didn't say "don't refactor the
codebase." Renaming 70 files is exactly the un-fudged response.

## The rename

Five prefix transformations covering ~70 files:

```
c11_*  →  d11_*    (Layer 3 entry — server bootstrap)
c21_*  →  d21_*    (Layer 3 entry — handlers + routes)
c31_*  →  a31_*    (Layer 0 pure — types, models, parsers, registries)
c32_*  →  b32_*    (Layer 1 core — pure logic + both verifiers)
c51_*  →  b51_*    (Layer 1 core — pure render)
c13_*  →  c13_*    (Layer 2 adapter — unchanged, already lex-correct)
c14_*  →  c14_*    (Layer 2 adapter — unchanged)
```

Lex check: `a31_ < b32_ < b51_ < c13_ < c14_ < d11_ < d21_`. Layer
order: 0 < 1 < 1 < 2 < 2 < 3 < 3. ✓

Mechanical work, but a lot of it. Two passes:

1. A bash loop calling `git mv` for every source + test file matching
   each old prefix. ~70 file moves.
2. An invocation of `sed` across `src/**.ts`, `scripts/**.ts`,
   `e2e/**.ts` rewriting every `from "./PREFIX_X.ts"` and
   `from "../src/PREFIX_X.ts"` to the new prefix. ~200 import-statement
   edits.

The Containerfile's `CMD ["bun", "src/c11_server.ts"]` was the one
non-import reference and needed a manual update — the v2-Sorted
rename moved the entry point to `src/d11_server.ts`.

Two test files needed surgical revert: `b32_sama_verify.test.ts`
(the v1 verifier's own tests) had string-literal fixtures like
``["c14_io.ts", `import { x } from "./c51_render.ts"`]`` that my
sed had rewritten too aggressively. Those fixtures are
deliberately phrased in v1's vocabulary because they're testing v1
behaviour against v1-shaped inputs. Reverting the in-string
rewrites took five lines of more-precise sed.

## The 7/7 verdict, live

```
$ curl -s https://tdd.md/sama/v2/verify | grep -oE '✓ conforms[^<]+'
✓ conforms · profile (tdd-md) · 91 files examined

$ curl -s https://tdd.md/sama/v2/verify | grep -oE '#[1-7] [^<|]+'
#1 Sorted              ← ✓ pass
#2 Architecture        ← ✓ pass
#3 Modeled (tests)     ← ✓ pass
#4 Modeled (boundary)  ← ✓ pass
#5 Atomic              ← ✓ pass
#6 Law (§1.2)          ← ✓ pass
#7 Consistency (§3)    ← ✓ pass
```

And the v1 dogfood, also still live:

```
$ curl -s 'https://tdd.md/sama/verify?repo=syntaxai/tdd.md' \
    | grep -oE '(Sorted|Architecture|Modeled|Atomic) · ✓ pass'
Sorted · ✓ pass
Architecture · ✓ pass
Modeled · ✓ pass
Atomic · ✓ pass
```

The v1 verifier (now living at `src/b32_sama_verify.ts` — content
unchanged, file moved) still examines whatever prefixes match its
hard-coded `c\d{2}_` regex. After the rename, that regex catches
`c13_*` and `c14_*` and the 20 files in those families pass v1's
four checks. The rest of the codebase is outside v1's scan window,
which preserves the dogfood verdict without touching v1's logic.

277/277 unit tests passed throughout. `bun scripts/sama-cli.ts check`
(the v1 CLI) reported 4/4 ✓ after every commit.

## What the day actually shows

The point isn't that I "got" to 7/7. The point is what the path
looked like:

- A spec I had personally drafted **rejected** my own codebase on
  first pass. Not as a measurement artefact — as a structural
  judgement. The same logic, the same checks, against the actual
  bytes.
- Each ✗ surfaced a specific architectural drift that v1 had quietly
  tolerated and v2 catches. Three of them (Law / Consistency /
  Modeled-boundary) had file-local fixes that took an hour. One (the
  Sorted prefix scheme) was a 70-file rename.
- The rename wasn't aesthetic. It was forced by the spec. The
  question "does our code follow our rules?" got answered "not
  yet" — and the verifier said exactly which files to touch.
- The anti-fudge clause held the whole way. The profile maps each
  v1 file to its honest v2 layer, and the lex constraint pushed the
  file *names* to match. The verifier did not bend; the codebase did.

That's the empirical claim a coding standard can make and a blog
post cannot: *here is the rule, here is the verifier that enforces
it, here is the public URL where you can run that verifier against
this codebase right now, and here is the codebase passing.* If any of
those four links breaks, the claim breaks. Today's PR closed the
chain.

---

**See for yourself:**

- Live v2 verdict: <https://tdd.md/sama/v2/verify> (7/7 ✓)
- The v2 spec: <https://tdd.md/sama/v2>
- The v1 dogfood (still 4/4 ✓): <https://tdd.md/sama/verify?repo=syntaxai/tdd.md>
- The PR that landed the work: [#16](https://github.com/syntaxai/tdd.md/pull/16)
- Earlier posts in this series:
  [c21 Atomic split](/blog/2026-05/sama-empirical-c21-split) ·
  [Modeled green](/blog/2026-05/sama-empirical-modeled-green) ·
  [Deploy that lies](/blog/2026-05/deploy-that-lies-cascade)