Re-express the two storage tests against the row-completeness contract

Both pinned the preemption rule the previous commit replaced, and both were
mirror images of what the rule now says. `preempts()` used to authorize a
model-free parse on column coverage alone, so `spac-sponsors` and
`beneficial-ownership` stood in for the model; requiring a row-completeness
claim retires both, because two prose patterns cannot report that the section
named no other sponsor and a walk that filters its own rows cannot tell a row
it dropped from a row the table never had. The destination is cleared before
persist, so a subset there is filed data lost with no dead letter — the model
call is the cheaper side of that trade.

So the assertions flip rather than relax. Each test now proves the section
reaches the model and that the entity is still persisted through it: the
section's prompt appears in the recorded calls, and the observation's
provenance carries the model's id instead of `deterministic`. Each also opens
by running the deterministic parse over the same section text and requiring it
to read the filing outright, which is what makes the filing the case that
demonstrates the rule — coverage is not the question, and a parse that handles
the section perfectly still does not get to answer for it.

The ownership resale test keeps every assertion and gains an accurate name: it
no longer discriminates preemption from non-preemption, since no ownership
section preempts now, and what it verifies is that the class, offered and
after-offering figures the table states survive the model path — the three the
walk would have written null.

Verified on this branch: `bun run test` 428 files / 3885 tests passed, 3
files / 20 tests skipped, 0 failed; `bun run format-check` and `bun run build`
clean. The two tests were confirmed to pass on `code-extractors` and fail at
this branch's head before the change, and the replacements fail on
`code-extractors` and pass here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ske1Jwk7fDFxHykfZGEzce

Author: claude

src/sec/forms/registration-statements/Form_S_1.storage.ownership.test.ts

@@ -9,7 +9,14 @@ import { resetDependencyInjectionsForTesting } from "../../../config/TestingDI";
 import { setupAllDatabases } from "../../../config/setupAllDatabases";
 import { BeneficialOwnershipRepo } from "../../../storage/beneficial-ownership/BeneficialOwnershipRepo";
 import { CompanyObservationRepo } from "../../../storage/observation/CompanyObservationRepo";
+import { ObservationProvenanceRepo } from "../../../storage/provenance/ObservationProvenanceRepo";
+import { parseEdgarHtml } from "../../html/parseEdgarHtml";
 import { processFormS1 } from "./Form_S_1.storage";
+import { S1_SECTIONS } from "./s1/DocumentSegmenter";
+import { DocumentTreeSegmenter } from "./s1/DocumentTreeSegmenter";
+import { parseBeneficialOwnership } from "./s1/parseBeneficialOwnership";
+import { DETERMINISTIC_MODEL_ID } from "./s1/parseOfferingTables";
+import { resolveModelId } from "./s1/s1Model";
 import { fakeS1Model, registerFakeStructuredProvider } from "./s1/testing/fakeStructuredProvider";
 
 const HTML_PARSEABLE = [
@@ -56,6 +63,44 @@ const MANAGEMENT_PAYLOAD = {
   ],
 };
 
+const SPAC_OWNERS_PAYLOAD = {
+  owners: [
+    {
+      name: "Halyard Sponsor III LLC",
+      owner_kind: "company",
+      security_class: null,
+      shares_owned: 4312500,
+      percent_owned: 100,
+      shares_offered: null,
+      shares_after: null,
+      percent_after: null,
+      is_selling_stockholder: false,
+      footnote: null,
+      confidence: 0.9,
+      source_span: "Halyard Sponsor III LLC",
+    },
+    {
+      name: "Eleanor Vasquez",
+      owner_kind: "person",
+      security_class: null,
+      shares_owned: 4312500,
+      percent_owned: 100,
+      shares_offered: null,
+      shares_after: null,
+      percent_after: null,
+      is_selling_stockholder: false,
+      footnote: null,
+      confidence: 0.9,
+      source_span: "Eleanor Vasquez",
+    },
+  ],
+};
+
+function ownershipSectionText(html: string): string {
+  const segmented = new DocumentTreeSegmenter().segment(parseEdgarHtml(html, "s1.htm"));
+  return segmented.find((s) => s.name === S1_SECTIONS.BENEFICIAL_OWNERSHIP)?.text ?? "";
+}
+
 let cleanup: (() => void) | undefined;
 
 describe("processFormS1 beneficial ownership", () => {
@@ -69,8 +114,30 @@ describe("processFormS1 beneficial ownership", () => {
     resetDependencyInjectionsForTesting();
   });
 
-  it("persists a SPAC ownership table with no offered/after columns as deterministic", async () => {
-    const { unregister } = registerFakeStructuredProvider([MANAGEMENT_PAYLOAD]);
+  // The table walk covers every column this table prints — a SPAC's pre-IPO
+  // table states one class and no offered/after position, so the six columns
+  // the parse hardcodes null are the disclosure — and it still does not stand
+  // in for the model. `ownershipCoverage` answers the COLUMN question only; the
+  // walk drops a stub failing `looksLikeOwner` and truncates one carrying a
+  // street number, so it cannot report that these two are the whole roster, and
+  // `beneficial_ownership` is cleared before persist. This filing is the case
+  // that makes the rule visible: the parse reads the table outright and the
+  // model runs anyway.
+  it("sends a fully covered SPAC ownership table to the model, because the walk cannot claim it read every row", async () => {
+    expect(
+      parseBeneficialOwnership(ownershipSectionText(HTML_PARSEABLE)).map((r) => [
+        r.owner_kind,
+        r.shares_owned,
+      ])
+    ).toEqual([
+      ["company", 4312500],
+      ["person", 4312500],
+    ]);
+
+    const { calls, unregister } = registerFakeStructuredProvider([
+      MANAGEMENT_PAYLOAD,
+      SPAC_OWNERS_PAYLOAD,
+    ]);
     cleanup = unregister;
 
     await processFormS1({
@@ -89,23 +156,31 @@ describe("processFormS1 beneficial ownership", () => {
       model: fakeS1Model(),
     });
 
+    expect(calls.some((p) => /Extract every beneficial owner/.test(p))).toBe(true);
+
     const rows = await new BeneficialOwnershipRepo().queryByAccession("acc-own-1");
     expect(rows.map((r) => [r.owner_kind, r.shares_owned])).toEqual([
       ["company", 4312500],
       ["person", 4312500],
     ]);
     const companies = await new CompanyObservationRepo().listAll();
     expect(companies.some((c) => /Halyard Sponsor/i.test(c.name ?? ""))).toBe(true);
-    // The table prints one class, no offered/after columns and no selling
-    // stockholders, so the six columns the parse hardcodes null are what this
-    // filing actually discloses — nothing is lost by writing them.
     expect(rows[0]!.security_class).toBeNull();
     expect(rows[0]!.shares_after).toBeNull();
     expect(rows[0]!.is_selling_stockholder).toBe(false);
+    // The rows are the model's, not the walk's, and provenance says so.
+    const provenance = await new ObservationProvenanceRepo().get(
+      "company",
+      rows[0]!.observation_id!
+    );
+    expect(provenance?.model_id).not.toBe(DETERMINISTIC_MODEL_ID);
+    expect(provenance?.model_id).toBe(resolveModelId(fakeS1Model()));
   });
 
-  it("does not preempt the ownership model on a resale table with Shares Offered / Shares After columns", async () => {
-    // The same parse, the same table shape, the opposite verdict: here the
+  it("persists the class / offered / after figures a resale table states, which the walk would have written null", async () => {
+    // The row half above already sends every ownership section to the model, so
+    // this filing gets there for a second, independent reason: `ownershipCoverage`
+    // declines the column half outright, and the walk never even runs. Here the
     // filing DOES state a class, an offered count and an after-offering
     // position, so the parse's hardcoded nulls would delete three disclosed
     // figures — and `is_selling_stockholder: false` would assert this holder

src/sec/forms/registration-statements/Form_S_1.storage.sponsors.test.ts

@@ -9,14 +9,22 @@ import { resetDependencyInjectionsForTesting } from "../../../config/TestingDI";
 import { setupAllDatabases } from "../../../config/setupAllDatabases";
 import { CompanyObservationRepo } from "../../../storage/observation/CompanyObservationRepo";
 import { ObservationProvenanceRepo } from "../../../storage/provenance/ObservationProvenanceRepo";
+import { parseEdgarHtml } from "../../html/parseEdgarHtml";
 import { processFormS1 } from "./Form_S_1.storage";
+import { S1_SECTIONS } from "./s1/DocumentSegmenter";
+import { DocumentTreeSegmenter } from "./s1/DocumentTreeSegmenter";
 import { DETERMINISTIC_MODEL_ID } from "./s1/parseOfferingTables";
+import { parseSpacSponsors } from "./s1/parseSpacSponsors";
+import { resolveModelId } from "./s1/s1Model";
 import { fakeS1Model, registerFakeStructuredProvider } from "./s1/testing/fakeStructuredProvider";
 
+const SPONSOR_SENTENCE =
+  "Our sponsor, Acme Sponsor LLC, is a Delaware limited liability company and was formed to invest in us.";
+
 const HTML_PARSEABLE = [
   "<h1>MANAGEMENT</h1><p>x</p>",
   "<h1>THE SPONSOR</h1>",
-  "<p>Our sponsor, Acme Sponsor LLC, is a Delaware limited liability company and was formed to invest in us.</p>",
+  `<p>${SPONSOR_SENTENCE}</p>`,
   "<h1>LEGAL MATTERS</h1><p>x</p>",
 ].join("");
 
@@ -28,6 +36,13 @@ const HEADER_6770 = {
   filingDate: null,
 };
 
+const SPONSOR_SPAN = "Our sponsor, Acme Sponsor LLC, is a Delaware limited liability company";
+
+function sponsorSectionText(html: string): string {
+  const segmented = new DocumentTreeSegmenter().segment(parseEdgarHtml(html, "s1.htm"));
+  return segmented.find((s) => s.name === S1_SECTIONS.THE_SPONSOR)?.text ?? "";
+}
+
 let cleanup: (() => void) | undefined;
 
 describe("processFormS1 spac-sponsors", () => {
@@ -41,7 +56,18 @@ describe("processFormS1 spac-sponsors", () => {
     resetDependencyInjectionsForTesting();
   });
 
-  it("persists a parseable sponsor sentence as deterministic without calling the sponsor model", async () => {
+  // The sponsor pass is two prose patterns, both requiring `our|the` immediately
+  // before `sponsor`. Reading THIS sentence says nothing about whether the
+  // section introduced a second sponsor some other way ("our co-sponsor, Beta
+  // Holdings LLC, is …"), and `spac_sponsor_link` is cleared before persist — so
+  // the pass declares no completeness and never stands in for the model, however
+  // cleanly it reads the prose. This filing is the case that makes the rule
+  // visible: the parse handles the sentence outright and the model runs anyway.
+  it("sends a parseable sponsor sentence to the model, because the prose parse cannot claim the section named no one else", async () => {
+    expect(parseSpacSponsors(sponsorSectionText(HTML_PARSEABLE)).map((r) => r.legal_name)).toEqual([
+      "Acme Sponsor LLC",
+    ]);
+
     const { calls, unregister } = registerFakeStructuredProvider([
       {
         focus: [],
@@ -50,11 +76,14 @@ describe("processFormS1 spac-sponsors", () => {
         team: null,
         url_spac: null,
         confidence: 0.9,
-        source_span: "Our sponsor, Acme Sponsor LLC, is a Delaware limited liability company",
+        source_span: SPONSOR_SPAN,
       },
       { people: [] },
       { owners: [] },
       { parties: [] },
+      {
+        sponsors: [{ legal_name: "Acme Sponsor LLC", confidence: 0.9, source_span: SPONSOR_SPAN }],
+      },
     ]);
     cleanup = unregister;
 
@@ -74,13 +103,15 @@ describe("processFormS1 spac-sponsors", () => {
       model: fakeS1Model(),
     });
 
+    expect(calls.some((p) => /Identify each sponsor entity/.test(p))).toBe(true);
+
     const companies = (await new CompanyObservationRepo().listAll()).filter((c) =>
       /s1:spac-sponsor/.test(c.source_context ?? "")
     );
     expect(companies.some((c) => /Acme Sponsor/i.test(c.name ?? ""))).toBe(true);
-    expect(calls.some((p) => /Identify each sponsor entity/.test(p))).toBe(false);
     const party = companies.find((c) => /Acme Sponsor/i.test(c.name ?? ""));
     const provenance = await new ObservationProvenanceRepo().get("company", party!.observation_id);
-    expect(provenance?.model_id).toBe(DETERMINISTIC_MODEL_ID);
+    expect(provenance?.model_id).not.toBe(DETERMINISTIC_MODEL_ID);
+    expect(provenance?.model_id).toBe(resolveModelId(fakeS1Model()));
   });
 });