feat(okf): enforce §3 okf_version shape, bump convention 0.1 -> 0.2

The 2026-07-23 reservation said enforcement waits until "the emitters have
migrated". Measured rather than assumed, and the emitter set turned out to be
TWO, not three:

  okr @0059da7       okf_version: 0.1 + okf_layout: kb-layout-2026-06. Migrated.
  linkedin-studio    scaffold.ts:38 -> okf_version: 0.1. Never carried a layout
                     string; has no okf_layout and needs none.
  ms-ai-architect    NOT an emitter. Zero index.md in the repo; okf_version
                     appears in one planning doc. The status table already said
                     "designed, not built" -- only the word "emitters" implied it.

Swept the whole marketplace plus the sibling consumer repos: every live
okf_version value is 0.1. The flip is a no-op today and locks the invariant.

The gate checks SHAPE (/^\d+(\.\d+)*$/), never membership: the upstream value
set is Google's (spec §12), so a bundle targeting a newer version passes. A
membership check would be the convention claiming a set it says it does not own
-- the over-reach class this round has corrected three times. Presence stays
unenforced (reported, not failed) as a separate §3 MUST.

Convention bumped 0.1 -> 0.2 by this log's own criterion: the set of conforming
bundles changed (the spec explicitly said a layout string "conforms today", and
rollout rule 6 defines conformance as gate output). The §12 per-plugin re-check
is pre-measured as finding zero violations.

Also closes a parity blind spot found while landing this: check-okf-parity
compared the okf_version VALUE, which is identical exactly when two impls
disagree about whether it is acceptable -- a false "agree" on the axis the gate
exists to watch. The signature now carries a boolean shape verdict, with
red-marker-layout as the committed red proof. Its "diverge" expectation encodes
okr's lag (they still pure-echo) and flips to "agree" when they mirror it.

And a correction the round earned: portfolio-optimiser enumerated their own
bundle surface and it is four, not three. The dormant fourth
(reference_domain.py:49 -> package data at :70) has no flag form at all, so our
published claim that the re-measurement surfaced "one" unreported entry was
itself one-of-two. Sharpens the standing rule: a search shaped like one entry
type cannot see another; install-vs-fixture is one instance, not the class.

Suite 73 -> 78. coord: PO replied, okr + llm-ingestion-okf notified (the latter
under the standing promise to flag any okf-check.mjs change).

scripts/okf-check.test.mjs

@@ -102,3 +102,66 @@ test('checkBundle(): recommended-field gaps are warnings, not failures', () => {
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// --- spec §3 okf_version shape enforcement (the reservation lifted 2026-07-25) ---
+// The catalog owns the SEPARATION of the two markers (§12), not the upstream value set
+// (owned by Google). So the gate checks that the value is version-SHAPED — never that it
+// is a version that exists upstream.
+
+test('okf_version carrying a layout string -> exit != 0 and points at okf_layout', () => {
+  const dir = tmpRoot();
+  try {
+    writeValidBundle(dir);
+    writeFileSync(join(dir, 'index.md'), 'okf_version: kb-layout-2026-06\n\n# Bundle\n');
+    const { status, stdout } = runCheck(dir);
+    assert.notEqual(status, 0, 'a layout snapshot in okf_version must fail the gate');
+    assert.match(stdout, /okf_layout/, 'the failure must name the marker it belongs in');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('a version-shaped okf_version passes, including multi-component', () => {
+  for (const value of ['0.1', '1.0', '0.1.2', '12']) {
+    const dir = tmpRoot();
+    try {
+      writeValidBundle(dir);
+      writeFileSync(join(dir, 'index.md'), `okf_version: ${value}\n\n# Bundle\n`);
+      const { status } = runCheck(dir);
+      assert.equal(status, 0, `"${value}" is upstream-version-shaped and must pass`);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});
+
+// Scope guard: the reservation covered the value's SHAPE. Presence is a separate §3 MUST
+// that this gate still does not enforce — absent stays a non-failing echo, as before.
+test('absent okf_version is unchanged by shape enforcement (still exit 0 + MISSING echo)', () => {
+  const dir = tmpRoot();
+  try {
+    writeValidBundle(dir);
+    writeFileSync(join(dir, 'index.md'), '# Bundle\n'); // no marker at all
+    const { status, stdout } = runCheck(dir);
+    assert.equal(status, 0, 'absence must not become an error in this step');
+    assert.match(stdout, /MISSING/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('checkBundle(): the shape verdict is on the return object', () => {
+  const bad = tmpRoot();
+  const good = tmpRoot();
+  try {
+    writeValidBundle(bad);
+    writeFileSync(join(bad, 'index.md'), 'okf_version: kb-layout-2026-06\n');
+    assert.ok(checkBundle(bad).okfVersionError, 'layout string -> an error string');
+
+    writeValidBundle(good);
+    assert.equal(checkBundle(good).okfVersionError, null, '0.1 -> no error');
+  } finally {
+    rmSync(bad, { recursive: true, force: true });
+    rmSync(good, { recursive: true, force: true });
+  }
+});