test(parity): sectioned-skill parity capability — guards the carve (T9)

Carved skills (skeleton + sections/*.md) need parity checks that see relocated
content, or moving a phrase into a section reads as 'lost':
- readSkillForParity(): union skeleton + all sections/*.md
- checkSkillParity sectioned mode: content checks against the union; minBytes/
  maxSizeRatio against union bytes (total behavior preserved); maxSkeletonBytes
  asserts the always-loaded skeleton actually shrank. Lowering minBytes to fit a
  small skeleton would otherwise make the size floor toothless [Codex #12].

Built + tested BEFORE the carve so ship's invariant can flip to sectioned in the
same commit it lands. Monolith path byte-identical (verified: pre-existing
investigate 1.053 ratio drift fails the same with this change stashed).

7 sectioned-parity tests + existing parity tests green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

test/parity-sectioned.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Unit coverage for the sectioned-parity capability (v2 plan T9, guards the
+ * carve). Proves that a carved skill's relocated content still counts (union of
+ * skeleton + sections), the always-loaded skeleton shrink is asserted
+ * separately (maxSkeletonBytes), and size floors run against the union so they
+ * stay meaningful (Codex outside-voice #12). Synthetic fixture — no ship carve
+ * needed to validate the logic.
+ */
+
+import { describe, test, expect, afterAll } from 'bun:test';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { checkSkillParity, readSkillForParity, type ParityInvariant } from './helpers/parity-harness';
+import type { SkillBaselineEntry } from './helpers/capture-parity-baseline';
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'parity-sectioned-'));
+afterAll(() => { try { fs.rmSync(root, { recursive: true, force: true }); } catch { /* noop */ } });
+
+// Carved "ship": a small skeleton + two sections holding the relocated prose.
+fs.mkdirSync(path.join(root, 'ship', 'sections'), { recursive: true });
+fs.writeFileSync(path.join(root, 'ship', 'SKILL.md'),
+  '## Preamble\nskeleton body, decision tree, VERSION bump step calls the CLI.\n## When to invoke\n');
+fs.writeFileSync(path.join(root, 'ship', 'sections', 'changelog.md'), '# Changelog\nWrite the CHANGELOG entry here.\n');
+fs.writeFileSync(path.join(root, 'ship', 'sections', 'review-army.md'), '# Review\nDispatch the pre-landing review army.\n');
+
+// A monolith control skill.
+fs.mkdirSync(path.join(root, 'mono'), { recursive: true });
+fs.writeFileSync(path.join(root, 'mono', 'SKILL.md'), '## Preamble\nVERSION CHANGELOG review all inline here.\n');
+
+const skeletonBytes = Buffer.byteLength(fs.readFileSync(path.join(root, 'ship', 'SKILL.md'), 'utf-8'), 'utf-8');
+const unionBytes = readSkillForParity(root, 'ship', true).unionBytes;
+const baseline: SkillBaselineEntry = { skillMdBytes: unionBytes } as SkillBaselineEntry;
+
+describe('readSkillForParity', () => {
+  test('unions skeleton + sections for carved skills', () => {
+    const r = readSkillForParity(root, 'ship', true);
+    expect(r.text).toContain('CHANGELOG');       // from changelog.md
+    expect(r.text).toContain('review army');      // from review-army.md
+    expect(r.skeletonBytes).toBe(skeletonBytes);
+    expect(r.unionBytes).toBeGreaterThan(r.skeletonBytes);
+  });
+  test('monolith text == skeleton, union == skeleton', () => {
+    const r = readSkillForParity(root, 'mono', false);
+    expect(r.unionBytes).toBe(r.skeletonBytes);
+  });
+});
+
+describe('checkSkillParity (sectioned)', () => {
+  test('finds phrases that moved into sections (union content check)', () => {
+    const inv: ParityInvariant = {
+      skill: 'ship', sectioned: true,
+      mustContain: ['VERSION', 'CHANGELOG', 'review army'],
+      mustHaveHeadings: ['## Preamble', '## When to invoke'],
+    };
+    const res = checkSkillParity(inv, { skillMdBytes: skeletonBytes } as SkillBaselineEntry, baseline, root);
+    expect(res.passed).toBe(true);
+  });
+
+  test('maxSkeletonBytes catches a skeleton that did not shrink', () => {
+    const inv: ParityInvariant = { skill: 'ship', sectioned: true, maxSkeletonBytes: 10 };
+    const res = checkSkillParity(inv, { skillMdBytes: skeletonBytes } as SkillBaselineEntry, baseline, root);
+    expect(res.passed).toBe(false);
+    expect(res.failures.join()).toContain('maxSkeletonBytes');
+  });
+
+  test('minBytes runs against the union, not the skeleton (content preserved)', () => {
+    // A floor between skeletonBytes and unionBytes must PASS for sectioned skills,
+    // because the union (total behavior) is what must not shrink.
+    const floor = Math.floor((skeletonBytes + unionBytes) / 2);
+    const inv: ParityInvariant = { skill: 'ship', sectioned: true, minBytes: floor };
+    const res = checkSkillParity(inv, { skillMdBytes: skeletonBytes } as SkillBaselineEntry, baseline, root);
+    expect(res.passed).toBe(true);
+  });
+
+  test('flags a phrase that truly went missing', () => {
+    const inv: ParityInvariant = { skill: 'ship', sectioned: true, mustContain: ['this-phrase-is-not-anywhere'] };
+    const res = checkSkillParity(inv, { skillMdBytes: skeletonBytes } as SkillBaselineEntry, baseline, root);
+    expect(res.passed).toBe(false);
+    expect(res.failures.join()).toContain('missing required phrase');
+  });
+
+  test('maxSizeRatio uses union bytes vs baseline (carve preserves ~total size)', () => {
+    const inv: ParityInvariant = { skill: 'ship', sectioned: true, maxSizeRatio: 1.05 };
+    const res = checkSkillParity(inv, { skillMdBytes: skeletonBytes } as SkillBaselineEntry, baseline, root);
+    expect(res.passed).toBe(true); // union == baseline here → ratio 1.0
+  });
+});