Merge branch 'code-extractors'

Author: sroussey

src/task/spac/ProcessSpacTimelineTask.test.ts

@@ -14,6 +14,7 @@ import { setupAllDatabases } from "../../config/setupAllDatabases";
 import { SEC_DRY_RUN, SEC_RAW_DATA_FOLDER } from "../../config/tokens";
 import { ExtractionDeadLetterRepo } from "../../storage/dead-letter/ExtractionDeadLetterRepo";
 import { FILING_REPOSITORY_TOKEN } from "../../storage/filing/FilingSchema";
+import { SPAC_CANDIDATE_REPOSITORY_TOKEN } from "../../storage/spac/SpacCandidateSchema";
 import { SpacReportWriter } from "../../storage/spac/SpacReportWriter";
 import { SpacRepo } from "../../storage/spac/SpacRepo";
 import { ExtractorRunRepo } from "../../storage/versioning/ExtractorRunRepo";
@@ -63,6 +64,23 @@ async function seedFiling(
   });
 }
 
+async function seedSpacCandidate(): Promise<void> {
+  await globalServiceRegistry.get(SPAC_CANDIDATE_REPOSITORY_TOKEN).put({
+    cik: CIK,
+    name: "Screened Acquisition Corp",
+    current_sic: 6770,
+    signal_sic_6770: true,
+    signal_name_match: true,
+    signal_renamed_from: null,
+    first_reg_form: "S-1",
+    first_reg_date: "2020-11-01",
+    reg_while_spac_named: true,
+    confidence: "high",
+    identified_at: "2026-01-01T00:00:00.000Z",
+    signal_filed_sic_6770: null,
+  });
+}
+
 async function seedSuccessfulRun(
   accession: string,
   form: string,
@@ -268,6 +286,15 @@ describe("ProcessSpacTimelineTask", () => {
     // dead-letter under `redemption` / `loi` as well as `8-K`. Counting triage
     // without naming those ids left the operator with a placeholder.
     await seedFiling("0000000000-26-000001", "8-K", "2021-01-04", "d8k.htm");
+    await new SpacReportWriter().recordRegistration({
+      cik: CIK,
+      accession_number: "0000000000-26-000000",
+      filing_date: "2021-01-01",
+      form: "S-1",
+      primary_document: "s1.htm",
+      spac_name: "Gated SPAC",
+      spac_sic: 6770,
+    });
 
     const proto = ProcessAccessionDocFormTask.prototype;
     const real = proto.execute;
@@ -485,6 +512,50 @@ describe("ProcessSpacTimelineTask", () => {
     expect(out.skipped).toBe(0);
   });
 
+  it("does not process gated 8-Ks or Form 15s while the issuer has no spac row", async () => {
+    // `sync spacs` worklist IS high/medium candidates, so the handler's
+    // `isSpacCandidate` warning fires on every milestone 8-K / Form 15 of a
+    // false-positive operating company (VolitionRx, CIK 93314) that will never
+    // mint a row. Date-order replay plus the repair pass already handle a real
+    // SPAC: skip the gated extractors until the row exists, then pick them up.
+    await seedSpacCandidate();
+    await seedFiling("0000000000-26-000001", "8-K", "2011-03-01", "d8k.htm", "1.01");
+    await seedFiling("0000000000-26-000002", "15-12B", "2011-04-01", null);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const spy = vi
+      .spyOn(ProcessAccessionDocFormTask.prototype, "execute")
+      .mockResolvedValue({ success: true });
+    try {
+      const out = await new ProcessSpacTimelineTask().run({ cik: CIK });
+
+      expect(spy).not.toHaveBeenCalled();
+      expect(warn).not.toHaveBeenCalled();
+      expect(out.matched).toBe(2);
+      expect(out.skipped).toBe(2);
+      expect(out.processed).toBe(0);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("repair-passes a never-processed 8-K dated before the S-1 that mints the row", async () => {
+    // First-time replay (no success row) used to process the 8-K in the first
+    // pass because shouldReplay said "unprocessed". Date order then ran it
+    // before the S-1, dropped the milestone, and warned. The repair pass is
+    // how gated filings wait for the row — including ones never processed.
+    await seedFiling("0000000000-26-000001", "8-K", "2020-12-01", "d8k.htm", "5.07");
+    await seedFiling("0000000000-26-000002", "S-1", "2021-01-04", "s1.htm");
+    const spy = mockFormProcessor();
+
+    const out = await new ProcessSpacTimelineTask().run({ cik: CIK });
+
+    const accessions = spy.mock.calls.map((c) => c[0]?.accessionNumber);
+    expect(accessions).toEqual(["0000000000-26-000002", "0000000000-26-000001"]);
+    expect(out.matched).toBe(2);
+    expect(out.skipped).toBe(0);
+  });
+
   it("reaches a fixpoint: a second invocation processes nothing", async () => {
     // The invariant every gated predicate must hold: processing a filing writes
     // the artifact the predicate keys on, so it leaves the selected set. This

src/task/spac/ProcessSpacTimelineTask.ts

@@ -17,12 +17,14 @@ import { SecCliConfigurationError } from "../../config/EnvToDI";
 import { TypeSecCik } from "../../sec/submissions/EnititySubmissionSchema";
 import { EXTRACTION_DEAD_LETTER_REPOSITORY_TOKEN } from "../../storage/dead-letter/ExtractionDeadLetterSchema";
 import { type Filing, FILING_REPOSITORY_TOKEN } from "../../storage/filing/FilingSchema";
+import { SpacRepo } from "../../storage/spac/SpacRepo";
 import { COMPONENT_VERSION_REPOSITORY_TOKEN } from "../../storage/versioning/ComponentVersionSchema";
 import { ExtractorRunRepo } from "../../storage/versioning/ExtractorRunRepo";
 import { EXTRACTOR_RUN_REPOSITORY_TOKEN } from "../../storage/versioning/ExtractorRunSchema";
 import {
   formToExtractorId,
   isNonfatalTimelineExtractor,
+  isSpacRowGatedExtractor,
 } from "../../storage/versioning/extractorIds";
 import { getActiveSlot } from "../../storage/versioning/getActiveSlot";
 import { VersionRegistry } from "../../storage/versioning/VersionRegistry";
@@ -116,15 +118,16 @@ export type ProcessSpacTimelineTaskOutput = Static<ReturnType<typeof OutputSchem
  * Serial and in date order, all three disappear — the state machine simply
  * replays history in the order it happened.
  *
- * Case 1 also needs a second, capped pass. The filings gated by a missing SPAC
- * row are selected by {@link loadGatedNoOpAccessions}, which answers the empty
- * set while the row is absent — and the S-1 that mints it is normally on this
- * very timeline, replayed moments after the set was computed. So the run that
- * creates the row is also the run whose gated 8-Ks were all filtered out of it.
- * The set is recomputed after the replay and whatever it still names, minus
- * what this invocation already processed, is replayed once more, serially, in
- * timeline order. One extra pass, never a loop: the gated predicates are
- * monotone, so a filing that is processed leaves the set.
+ * Case 1 also needs a second, capped pass. Gated extractors are omitted from
+ * the first pass while the `spac` row is missing: otherwise a candidate that
+ * never mints (or an 8-K dated before the S-1) no-ops, records success, and
+ * warns. {@link loadGatedNoOpAccessions} then selects them once the row exists,
+ * including ones a prior sweep already no-op'd. The S-1 that mints the row is
+ * normally on this very timeline, so the set is empty when first computed and
+ * is recomputed after the replay. Whatever it still names, minus what this
+ * invocation already processed, is replayed once more, serially, in timeline
+ * order. One extra pass, never a loop: the gated predicates are monotone, so
+ * a filing that is processed leaves the set.
  *
  * Concurrency belongs BETWEEN issuers, not within one: SPACs are independent and
  * the writer already serializes per-CIK via `withCikLock`. Run this task once
@@ -226,20 +229,38 @@ export class ProcessSpacTimelineTask extends Task<
     const activeVersions = await loadActiveExtractorVersions(timeline);
     const successfulKeys = await loadSuccessfulKeys(activeVersions);
     const gatedNoOpAccessions = await loadGatedNoOpAccessions(cik, timeline);
-    const toProcess = timeline.filter(
-      (f) =>
-        f.form !== null &&
-        filingMeetsDateFloor(f.filing_date, filedOnOrAfter) &&
-        shouldReplaySpacFiling({
-          form: f.form,
-          items: f.items,
-          cik,
-          accession_number: f.accession_number,
-          force,
-          successfulKeys,
-          gatedNoOpAccessions,
-        })
-    );
+    // Gated extractors (8-K, merger-proxy, 25-15) no-op — and warn — when the
+    // `spac` row is missing. `sync spacs` worklist *is* high/medium candidates,
+    // so that warning fires on every milestone 8-K of a false-positive
+    // operating company that will never mint a row. A real SPAC's S-1 is on
+    // this timeline; skip the gated filings until it runs, then the repair
+    // pass below picks them up. `loadGatedNoOpAccessions` is empty while the
+    // row is absent, so it cannot be the skip.
+    const hasSpacRow = (await new SpacRepo().getSpac(cik)) !== undefined;
+    const toProcess = timeline.filter((f) => {
+      if (f.form === null) return false;
+      if (!filingMeetsDateFloor(f.filing_date, filedOnOrAfter)) return false;
+      const extractorId = formToExtractorId(f.form);
+      // `--force 8-K` / `--force redemption` is an explicit request to run the
+      // gated handler anyway; `--force all` still waits so the S-1 can mint.
+      if (
+        !hasSpacRow &&
+        force.kind !== "extractors" &&
+        extractorId !== undefined &&
+        isSpacRowGatedExtractor(extractorId)
+      ) {
+        return false;
+      }
+      return shouldReplaySpacFiling({
+        form: f.form,
+        items: f.items,
+        cik,
+        accession_number: f.accession_number,
+        force,
+        successfulKeys,
+        gatedNoOpAccessions,
+      });
+    });
     const skipped = timeline.length - toProcess.length;
 
     // `--dry-run` already no-ops writes via ReadOnlyTabularStorage. Replaying