@@ -0,0 +1,54 @@
+---
+---
+
+Internal instrument only (objectui#9870): `scripts/changeset-polarity-census.mjs` and its
+pin. No published package changes, no schema change, no runtime behaviour change.
+
+**A TABLE OF SUPERSEDED READINGS.** A pending entry may carry a table whose first column is
+a reading it is RETIRING and whose later columns say what falsified it and when. The census
+read that first column as a present-tense claim about today's tree, with its own correction
+one cell to the right and unread. Quotation position could not reach it, because the retired
+reading is not quoted — it is tabulated. It was the last entry on the instrument's own limits
+list still marked unrepaired as a false-positive SOURCE.
+
+Measuring it first moved the repair. The limits entry said the cells of one ROW were joined
+into one sentence and called that join deliberate; the code doing the joining carried the
+opposite intent in its own comment and achieved neither. `. ` cuts a sentence only before a
+character that is not lower-case, and a row's last cell got no terminator at all — so an
+entire table, header and delimiter row included, collapsed into ONE sentence, and every key
+in it was offered to every schema named anywhere in it. That is the cartesian window
+objectui#9754 closed at the sentence level, rebuilt one level up.
+
+A table is therefore read as structure rather than flattened into wrapped prose: a cell is
+its own unit of text, the delimiter row is dropped as syntax, and the header row is kept —
+it is what lets a column be read as a position. POSITION gains a third value, `superseded`:
+a cell in a column the table's OWN HEADER retires (the column a later one declares it was
+«falsified by») is counted, reported under its own name, and never flagged.
+
+Of the three directions the card offered, this is the narrow one, and the other two were
+refused for the same reason: excluding table rows from assertion position as a class, or
+widening quotation to cover every tabulated reading, are both cheap against this corpus and
+both buy a false negative in the shape this family has already paid for — a table that
+ASSERTS is the ordinary case here, and a claim silently never judged is the failure that
+does not ring.
+
+READINGS, taken on `.changeset/` at the parent commit and again after, with the instrument's
+controls passing on both runs:
+
+- candidate contradictions: 40 before, 40 after — the SAME 40 rows. No row stops being
+  flagged, so no row needs adjudicating as a dropped false positive or a lost true positive.
+- sentences scanned 18412 → 19104, assertions 226 → 225, and a new bucket reporting 2
+  readings in superseded position (both from the entry the card names).
+- «a schema whose symbol resolves nowhere this run can reach»: 3 → 2. The dropped row is a
+  retired reading whose own row records the card that retired that symbol — a candidate
+  whose adjudication was already written beside it. Correctly dropped.
+- the fixture corpus, where the shape and its three counter-shapes are pinned: 5 flags → 2.
+  Four false positives dropped (two retired readings, two cross-ROW pairings) and one true
+  positive FOUND — the falsifier column is a claim about today, and the collapse had
+  swallowed it.
+
+RESIDUE, named rather than discovered later: a `before | after` table retires its first
+column by MEANING and not by a word in its header, and is not read here; the header match is
+a word list with this file's usual cost; and a claim whose subject sits in one column and its
+verb in another is now two sentences and pairs with nothing — it was reachable only through
+the cross-row collapse that also paired it with every other row.
@@ -31,6 +31,7 @@ import {
   runControls,
   segmentClauses,
   segmentSentences,
+  supersededColumns,
 } from '../changeset-polarity-census.mjs';
 
 /**
@@ -1122,3 +1123,151 @@ describe('objectui#9754 pin 12 -- the window is the declaration clause, not the
 function namesSchemaIn(text: string) {
   return [...new Set([...text.matchAll(/\b([A-Z][A-Za-z0-9_]*Schema)\b/g)].map((m) => m[1]))];
 }
+
+
+describe('objectui#9870 pin 13 -- a table is read as structure, and a retired reading is not a claim', () => {
+  /**
+   * The last entry on the instrument's own limits list that still said
+   * `⛔ unrepaired` about a false-positive SOURCE: an entry may carry a table
+   * whose first column is a reading it is RETIRING and whose later columns are
+   * what falsified it. Quotation cannot reach that reading -- it is not quoted,
+   * it is TABULATED -- so it stood in ASSERTION position with its own correction
+   * one cell to the right, unread.
+   *
+   * ⭐ Measuring it first moved the repair. The entry said the cells of one ROW
+   * were joined into one sentence and called that join deliberate; the code
+   * doing the joining carried the OPPOSITE intent in its own comment, and
+   * achieved neither. `. ` cuts only before a character that is not lower-case,
+   * and a row's last cell got no terminator at all -- so an entire table,
+   * header and delimiter row included, collapsed into ONE sentence, and every
+   * key in it was offered to every schema named anywhere in it. That is
+   * objectui#9754's cartesian window rebuilt one level up.
+   *
+   * `12-superseded-readings-table.md` carries the shape and the three ways the
+   * repair could have been bought with blindness, so one run reads them all.
+   * The readings this pin is judged against, taken on the fixture corpus with
+   * the instrument as it stood at the parent commit and again after:
+   *
+   *   BEFORE  ObjectKanbanSchema.swimlaneWidth   FLAG  (retired reading)
+   *           SpinnerSchema.size                 FLAG  (retired reading)
+   *           LaneSchema.titleField              FLAG  (cross-ROW pairing)
+   *           ObjectKanbanSchema.cards           FLAG  (cross-ROW pairing)
+   *           LaneSchema.laneWidth               FLAG  (an ordinary table asserts)
+   *           ObjectKanbanSchema.dragHandle      --    (missed: the collapse hid it)
+   *   AFTER   LaneSchema.laneWidth               FLAG
+   *           ObjectKanbanSchema.dragHandle      FLAG
+   *
+   * ⭐ Four false positives dropped and a true positive FOUND: the falsifier
+   * column is a claim about today, and the collapse had swallowed it.
+   */
+  const flags = flagsFor('12-superseded-readings-table');
+  const superseded = fixtureRun.superseded.filter((s: { entry: string }) =>
+    s.entry.startsWith('12-superseded-readings-table'),
+  );
+
+  it('a reading in a column the table retires is not an assertion', () => {
+    // Both retired readings contradict the fixture faces, which is what a
+    // retired reading DOES -- that is why it was retired. Read as assertions
+    // they were two candidates whose adjudication was already written beside
+    // them.
+    expect(flags.map((f) => f.key)).not.toContain('swimlaneWidth');
+    expect(flags.map((f) => f.key)).not.toContain('size');
+  });
+
+  it('⛔ they are SET ASIDE, not dropped -- the count is reported under its own name', () => {
+    // DARK LEG. A rule whose cost nobody can read is how a false negative hides:
+    // these are still read, still resolved to schema and key, and still counted.
+    // If this pin passed while the sentences went missing, the repair would be
+    // deleting evidence instead of positioning it.
+    expect(superseded.map((s: { claim: { keys: string[] } }) => s.claim.keys).flat().sort()).toEqual([
+      'size',
+      'swimlaneWidth',
+    ]);
+    expect(fixtureRun.matchedSuperseded).toBe(superseded.length);
+    expect(fixtureRun.matchedSuperseded).toBeGreaterThan(0);
+    // And they are not in the quoted bucket either: the reason differs, so the
+    // name differs, or the report cannot say which rule set a reading aside.
+    expect(
+      fixtureRun.quoted.some((q: { entry: string }) =>
+        q.entry.startsWith('12-superseded-readings-table'),
+      ),
+    ).toBe(false);
+  });
+
+  it('⛔ did NOT buy it with blindness -- a table that ASSERTS is still read and still flagged', () => {
+    // The false negative that excluding table rows as a class, or widening
+    // quotation to cover every tabulated reading, would have bought. An
+    // ordinary table -- one whose header retires nothing -- is the common case
+    // in this corpus, and its rows are claims about today.
+    const laneWidth = flags.filter((f) => f.key === 'laneWidth');
+    expect(laneWidth.map((f) => f.schema)).toEqual(['LaneSchema']);
+    expect(laneWidth[0].polarity).toBe('positive');
+  });
+
+  it('only the retired COLUMN is set aside -- the falsifier column is a claim about today', () => {
+    // `objectui#0001 -- ... `ObjectKanbanSchema` declares `dragHandle` for that
+    // job today` sits in the `falsified by` column of the SAME row as a retired
+    // reading. It is the live half of that row and it is flagged: the fixture
+    // face declares no such member. Before this repair the collapse had folded
+    // it into the row-wide sentence and it was never judged at all.
+    const dragHandle = flags.filter((f) => f.key === 'dragHandle');
+    expect(dragHandle.map((f) => f.schema)).toEqual(['ObjectKanbanSchema']);
+    expect(dragHandle[0].polarity).toBe('positive');
+    expect(dragHandle[0].memberPresent).toBe(false);
+  });
+
+  it('the rows of a table are not one sentence, and neither are the cells of a row', () => {
+    // The cartesian window one level up. `ObjectKanbanSchema declares titleField`
+    // and `on LaneSchema, cards is declared` are rows 1 and 2 of one table, and
+    // the second opens with a lower-case word -- which is exactly where `. `
+    // failed to cut. Joined, each key was offered to BOTH schemas and both
+    // claims were flagged against the schema they were never made about.
+    expect(flags.map((f) => `${f.schema}.${f.key}`)).not.toContain('LaneSchema.titleField');
+    expect(flags.map((f) => `${f.schema}.${f.key}`)).not.toContain('ObjectKanbanSchema.cards');
+    // The mechanism, asserted rather than inferred from the verdict: no emitted
+    // sentence carries the text of two different cells.
+    const sentences = segmentSentences(
+      fs.readFileSync(path.join(FIXTURE_CORPUS, '12-superseded-readings-table.md'), 'utf8'),
+    );
+    expect(sentences.some((s) => /titleField/.test(s.text) && /cards/.test(s.text))).toBe(false);
+    expect(sentences.some((s) => /swimlaneWidth/.test(s.text) && /dragHandle/.test(s.text))).toBe(
+      false,
+    );
+  });
+
+  it('the delimiter row is syntax and the header row is text', () => {
+    const sentences = segmentSentences(
+      ['| reading below | falsified by | landed |', '| --- | :---: | ---: |', '| `S` declares `k` | objectui#1 -- it does not | 2026-09-11 |'].join('\n'),
+    );
+    // What the delimiter row carries is WHICH row was the header. Its dashes are
+    // not a sentence, and they used to be three.
+    expect(sentences.map((s) => s.text)).toEqual([
+      'reading below',
+      'falsified by',
+      'landed',
+      '`S` declares `k`',
+      'objectui#1 -- it does not',
+      '2026-09-11',
+    ]);
+    expect(sentences.map((s) => s.position)).toEqual([
+      'superseded',
+      'assertion',
+      'assertion',
+      'superseded',
+      'assertion',
+      'assertion',
+    ]);
+  });
+
+  it('the rule is the header the table WROTE, not a shape this reader guesses at', () => {
+    // A header that declares nothing retires nothing -- the default is the empty
+    // set, so every ordinary table keeps every column in assertion position.
+    expect([...supersededColumns(['face', 'what it declares today'])]).toEqual([]);
+    expect([...supersededColumns(null)]).toEqual([]);
+    // The falsifier declares the columns BEFORE it retired, and it has to point
+    // BACK at something: a first column that falsifies has nothing behind it.
+    expect([...supersededColumns(['reading below', 'falsified by', 'landed'])]).toEqual([0]);
+    expect([...supersededColumns(['id', 'reading', 'superseded by'])]).toEqual([0, 1]);
+    expect([...supersededColumns(['falsified by', 'reading'])]).toEqual([]);
+  });
+});
@@ -0,0 +1,27 @@
+---
+'@object-ui/types': patch
+---
+
+The superseded-readings pin (objectui#9870). An entry may carry a table whose
+first column is a reading it is RETIRING, and whose later columns say what
+falsified it and when. The table declares that itself, in its header.
+
+| reading below | falsified by | landed |
+| --- | --- | --- |
+| `ObjectKanbanSchema` declares `swimlaneWidth` | objectui#0001 — no face ever declared it; `ObjectKanbanSchema` declares `dragHandle` for that job today | 2026-09-11 |
+| `SpinnerSchema` declares no `size` | objectui#0002 — `size` is declared on `SpinnerSchema`, as the protocol has it | 2026-09-12 |
+
+A table whose header retires NOTHING is an ordinary table and asserts:
+
+| face | what it declares today |
+| --- | --- |
+| the board | `ObjectKanbanSchema` declares `allowCollapse` |
+| the lane | `LaneSchema` declares `laneWidth` |
+
+And the rows of one table are not one sentence, which is what the collapse made
+them:
+
+| face | the reading |
+| --- | --- |
+| board | `ObjectKanbanSchema` declares `titleField` |
+| lane | on `LaneSchema`, `cards` is declared |