fix(pm): the clause-2 correction note READS the claim comment's two stamps instead of vouching it was never edited (#19298)

Fixes #18892

Clause-②: no

The `--pair` green line and the `C2-CORRECTION` note under it both
testified that the claim comment 「is NOT edited and still reads as it
was written」. Nothing in this file had ever read an edit. `created_at`
and `updated_at` both arrive on the `/issues/comments` row
`applicableCorrection` already holds, so the reading cost no request —
it simply was not taken.

Triage's grading (5725446014) chose option **A** over the card's B and
C: read the two fields, say it in the message, ⛔ never fail on it.

## What changed — `scripts/pm/check-clause2-carriers.mjs` only

- **`claimEditReading(row)`** — module-local, ⛔ no new `export` and no
registration (Clause-② declared `no`). It turns the claim comment's own
two stamps into **three** readings, never two:
- `updated_at` differs from `created_at` ⇒ **WAS EDITED**, naming the
instant so a reader can open that comment's edit history;
- the two are equal ⇒ a **measured UNEDITED**, naming both stamps it
compared;
- a row carrying neither stamp ⇒ **NOT READ**, said as a gap — ⛔ never
as "unedited", which is the sentence this card was filed against.
- **The correction note states that reading** in place of the assertion.
**Report-only**, per the ruling: no exit moves, and an edited claim
still reads `declared` at the seat's own value. An edit is a legitimate
act; the silence was the defect.
- **The green line's parenthetical** now describes what the reading
above actually states, and names the stream that reading prints on.

## The pin was proven red BEFORE the fix existed

Two commits, in that order, exactly as the card required (「⛔ 先让 pin 红」).

`0d29892` — the pin alone, against the unfixed message:

```
$ node scripts/pm/check-clause2-carriers.mjs --self-test          # exit 1
  ✗ ⭐ the EDITED specimen is REPORTED in the note, in as many words
  ✗ …naming the edit instant beside the creation one, so a reader can open that comment's history
  ✗ ⭐ an UNEDITED claim reads as a MEASURED unedited, naming both stamps it compared
  ✗ ⭐ a row carrying NO `updated_at` reads NOT READ — ⛔ never "unedited", which is this defect one room over
  ✗ ⭐ the three readings are three DIFFERENT sentences — one sentence for all three was the defect
  ✗ ⭐ the green line points at that reading and says what it STATES, ⛔ never testifying to the edit itself
  ✗ ⛔ …and the clause that asserted an unread fact is gone from the printed line
  ✗ ⛔ NEGATIVE, on the SOURCE: no branch of this file asserts the unread 「NOT edited」 any more
  ✗ ⛔ CONTROL — the same source read is not empty or misdirected: it reaches the reader this card added
✗ check-clause2-carriers self-test: 9 of 1071 case(s) failed.
```

`0128cbb` — the reader:

```
$ node scripts/pm/check-clause2-carriers.mjs --self-test          # exit 0
✓ check-clause2-carriers self-test: 1071 cases pass (…)
```

The unedited control and the three report-only cases pass on **both**
commits, so the battery is not a one-sided pin. The source-scan negative
and its control are assembled at runtime (the #16770 idiom), because a
literal would have made the scan hit itself — the first draft did
exactly that and passed vacuously; it is fixed and the control now
proves the read reaches the file.

## Measured on the specimen the card names — offline, via `--pair-json`

objectui's claim `5724909959` on card #9764: `created_at`
`2026-09-18T03:54:37Z`, `updated_at` `2026-09-18T04:23:23Z`. Replayed
with the real API payloads, thread truncated to the instant the card
measured:

**Before** (`adf4b18`):

```
ℹ️  C2-CORRECTION — … And it supersedes claim comment 5724909959's own declaration,
    which is NOT edited and still reads as it was written.
```

**After** (`0128cbb`):

```
ℹ️  C2-CORRECTION — … And it supersedes claim comment 5724909959's own declaration,
    and ⚠️ it WAS EDITED at `2026-09-18T04:23:23Z` (`created_at` `2026-09-18T03:54:37Z`)
    — REPORTED and ⛔ never a failure: read its edit history before taking the
    declaration under it for the one the seat first wrote.
```

And the sharper half — two `--pair-json` documents differing **only** in
`updated_at`, both reaching exit 0:

| | before | after |
|---|---|---|
| edited claim | exit 0, note says `NOT edited` | exit 0, note says `WAS
EDITED at …` |
| unedited claim | exit 0, note says `NOT edited` | exit 0, note says
`reads UNEDITED — … both …` |

Before this PR the two runs were **byte-identical on every stream**.
That identity is now impossible, and the exit register did not move in
either row.

## Acceptance notes

- **The PM's mechanism assumption 3 is REFUTED, and measured so.** The
pass path does **not** print three lines with no per-item readings:
`renderPair`'s `rows.length === 0` branch prints every note (`ℹ️
C2-CORRECTION — …`) immediately above the green line. So 「the reading
above」 resolves today and was ⛔ not dropped. What is true is that the
**note goes to stderr while the green line goes to stdout**, so a seat
capturing stdout alone holds the pointer without its referent — which is
the likeliest reading of the card's 「只打三行」. The parenthetical now names
the stream, which is the cheapest thing that makes the pointer
executable. No reading was deleted.
- **A `--pair-json` document that omits `updated_at` changes reading**,
from a silent "unedited" to an explicit NOT READ. That is the intended
direction (absence must be loud) and affects hand-written fixture
documents only; the live `/issues/comments` rows always carry both
fields, unprojected — `readCardComments` hands the raw rows through.
- **noted, not filed** — the *plain* branch of the green line
(declaration read from the claim comment itself) states nothing about
editing, so nothing false lives there and no reading was added to it. A
claim comment could still have been edited into carrying its own
declaration; the gate says nothing about that in either direction today.
Extending the reading to that branch is a capability decision this card
did not rule on, and adding it would have meant a new note on every
corrected-free pair. Succeeding reader: whoever takes the escalation
condition triage recorded on this card (a pair whose claim was edited
*into* carrying the declaration ⇒ p1).
- **noted, not filed** — the shallow checkout (`git rev-parse
--is-shallow-repository` ⇒ `true`, 116 commits; this file reads as
`+9132` insertions at the boundary commit) makes `git log -S` unable to
answer whether the pass path ever failed to print its notes. Stated
rather than answered; nothing in this PR rests on it.
- **Net +39 lines** (9,925 → 9,964) against the card's +40 ceiling. One
file. No changeset: `scripts/pm/**` publishes nothing, hence
`skip-changeset`.
- `scripts/pm/**` is not a governed path, so no 维护者速读 section is owed.

## Gates

Derived from the worktree after the last commit, no paths passed:
`node scripts/pm/dispatch-gates.mjs --commands --repo
objectstack-ai/objectstack` at `0128cbb` ⇒ **34 commands**, matching the
dispatch-time derivation. Each is run with its exit code captured
**before** any pipe; the full table, its `--ran` reconciliation and the
head sha it was taken on are in this card's `os-dev-report` comment,
which is the machine-read record.

---
_Generated by [Claude
Code](https://claude.ai/code/session_017ETYWqMQD4qMtZzAGovWNi)_

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: os-steve

scripts/pm/check-clause2-carriers.mjs

@@ -838,6 +838,7 @@ const SELF_TEST_BATTERIES = Object.freeze({
   '#18536: the lane-keyed owed population — spec and skills owe the record on EVERY round, other lanes owe none, a `yes` outside them is spec-lane work': 30,
   '#18862: cross-author LIVE claims with no `Release:` between — the hand-over the protocol never wrote, named; judged only after its effective instant': 52,
   '#16770: the exit-0 line says which carriers agreed — LABEL carriers — and that the PR body was not read': 14,
+  '#18892: the claim comment\'s EDIT reading — taken from the two stamps already in hand, reported and never failed': 10,
 });
 
 // DELETING an entry silences that battery's floor exactly as effectively as
@@ -851,8 +852,8 @@ const SELF_TEST_BATTERIES = Object.freeze({
 // by the one #16833 adds, and by the one #18456 adds, and by the one #18719
 // adds, and by the one #18683 adds, and by the one #18764 adds, and by the one
 // #18828 adds, and by the one #18536 adds, and by the one #18862 adds, and by
-// the one #16770 adds.
-const SELF_TEST_BATTERY_FLOOR = 35;
+// the one #16770 adds, and by the one #18892 adds.
+const SELF_TEST_BATTERY_FLOOR = 36;
 
 // The key an assertion is filed under when no battery is open. It is not a
 // declared battery, so it reds by the same set difference rather than silently
@@ -1458,6 +1459,20 @@ function newestFirst(a, b) {
   return b.index - a.index;
 }
 
+/**
+ * The claim comment's own EDIT reading, from the two stamps ALREADY on the row
+ * this reader holds — ⛔ never asserted, which is what #18892 measured: the note
+ * below testified 「NOT edited」 about objectui#9764's claim 5724909959, whose
+ * `updated_at` is 29 min past its `created_at`. THREE readings, ⛔ never two — a
+ * missing stamp is a GAP, ⛔ not an unedited; ⛔ report-only per that ruling, an
+ * edit is legitimate and moves no exit. The untaken testimony was the defect. */
+function claimEditReading(row) {
+  const [c, u] = [row?.created_at, row?.updated_at].map((v) => (typeof v === 'string' ? v : null));
+  if (c === null || u === null) return 'whether it has been EDITED is NOT READ — its row carries no `created_at`/`updated_at` pair to compare, so ⛔ read that as a gap and never as "unedited"';
+  if (c === u) return `it reads UNEDITED — its \`created_at\` and \`updated_at\` are both \`${c}\``;
+  return `⚠️ it WAS EDITED at \`${u}\` (\`created_at\` \`${c}\`) — REPORTED and ⛔ never a failure: read its edit history before taking the declaration under it for the one the seat first wrote`;
+}
+
 /**
  * Which correction, if any, governs this card's declaration — and when none
  * does, WHY, in a sentence that names an act the claiming seat can perform.
@@ -1467,8 +1482,8 @@ function newestFirst(a, b) {
  * here that a seat cannot answer would rebuild that door one room over, so the
  * note always names what to post next.
  *
- * @param {{ id?: number|string, body?: string, created_at?: string }[]} commentRows
- * @param {{ id?: number|string, body?: string }[]} pool — the governing claim rows.
+ * @param {{ id?: number|string, body?: string, created_at?: string, updated_at?: string }[]} commentRows
+ * @param {{ id?: number|string, body?: string, created_at?: string, updated_at?: string }[]} pool — the governing claim rows.
  * @returns {{ state: 'none' }
  *   | { state: 'applies', value: 'yes'|'no', detail?: string, note: string }
  *   | { state: 'ignored', note: string }}
@@ -1520,8 +1535,8 @@ function applicableCorrection(commentRows, pool) {
   const claimRow = claimById.get(chosen.claimId);
   const claimSession = readSessionId(claimRow?.body);
   const shared =
-    `it supersedes claim comment ${chosen.claimId}'s own declaration, which is NOT edited and ` +
-    'still reads as it was written. ⛔ Nothing was filled in on the seat\'s behalf: the value is ' +
+    `it supersedes claim comment ${chosen.claimId}'s own declaration, and ${claimEditReading(claimRow)}. ` +
+    '⛔ Nothing was filled in on the seat\'s behalf: the value is ' +
     'the seat\'s, in the fixed spelling, and this script still writes nothing.';
 
   if (claimSession === null) {
@@ -4796,8 +4811,8 @@ export function pairRows(pair, pairs = null) {
  * a pair that answers 0 because a CORRECTION comment carries its declaration is
  * answering about a carrier the claim comment does not hold, and a seat reading
  * only `$?` must be able to find out from the run which comment was read. The
- * row also states, in as many words, that the claim comment was NOT edited —
- * because the whole value of the shape is that nothing had to be.
+ * shape's whole value is that nothing had to be EDITED, so the row states that
+ * as a reading it takes from the claim's two stamps, ⛔ never as one it assumes.
  */
 export function c2CorrectionNote(pair) {
   const d = cardDeclaration(pair?.cardComments ?? null);
@@ -6490,9 +6505,9 @@ export function greenPairLine({ pr, card, sibling = false, corrected = false, re
       ? 'readable in the fixed spelling on a SIBLING card this same PR delivers rather than on ' +
         `this card (the reading above names which, and what it says), ${LABEL_CARRIERS_AGREE}`
       : corrected
-        ? 'readable in the fixed spelling on a CORRECTION comment superseding the claim\'s own ' +
-          'line (the reading above names which comment, and says the claim was not edited), ' +
-          LABEL_CARRIERS_AGREE
+        ? 'readable in the fixed spelling on a CORRECTION comment superseding the claim\'s own line ' +
+          '(the ℹ️ reading printed above on stderr names which comment, and states what that claim ' +
+          'comment\'s own `created_at`/`updated_at` say about whether it was edited), ' + LABEL_CARRIERS_AGREE
         : `readable in the fixed spelling, ${LABEL_CARRIERS_AGREE}`) +
     (record
       ? ', and a review of record names this head (the note above says which comment it is, and ' +
@@ -7944,6 +7959,8 @@ export async function selfTest() {
   const CLAIMED = (extra, o = {}) => ({
     id: o.id ?? C_CLAIM_ID,
     created_at: o.created_at ?? '2026-09-12T00:41:08Z',
+    // ⭐ EQUAL on a comment nobody edited: the default is the unedited control, and an edited fixture names `updated_at` alone (#18892).
+    updated_at: o.updated_at ?? o.created_at ?? '2026-09-12T00:41:08Z',
     body:
       `Claim: PM loop round 1\n` +
       (o.session === null ? '' : `Session: \`${o.session ?? C_SESSION}\`\n`) +
@@ -8027,7 +8044,7 @@ export async function selfTest() {
   t('⛔ …so the governing claim does not move, and the card is not re-claimed', governingClaim(REPAIRED_THREAD)?.createdAt === governingClaim(BROKEN_THREAD)?.createdAt);
   t('⛔ nor is the correction read as a MISPLACED declaration — it is the designated second carrier', cardDeclaration(REPAIRED_THREAD).state !== 'misplaced');
   t('the reading PRINTS: a note names the correction rather than answering 0 in silence', typeof c2CorrectionNote(repairedPair) === 'string');
-  t('…and says the claim comment was NOT edited', says(c2CorrectionNote(repairedPair), 'NOT edited'));
+  t('…and STATES the claim comment\'s edit reading, measured from its own two stamps (#18892)', says(c2CorrectionNote(repairedPair), 'UNEDITED'));
   t('…and names the comment id it corrects, so a reader can find it', says(c2CorrectionNote(repairedPair), String(C_CLAIM_ID)));
   t('…and states the attribution ceiling rather than claiming a verification', says(c2CorrectionNote(repairedPair), 'DECLARED identity, never a verified one'));
   t('…and it rides as a NOTE, never as a finding — pairNotes carries it, pairRows does not', pairNotes(repairedPair).some((n) => n.code === 'C2-CORRECTION') && pairRows(repairedPair).every((r) => r.code !== 'C2-CORRECTION'));
@@ -9422,6 +9439,28 @@ export async function selfTest() {
   t('⛔ CONTROL: the label the line names is the constant C1 compares, ⛔ not a second spelling of it', says(LABEL_CARRIERS_AGREE, CONTRACT_REVIEW_LABEL) && CONTRACT_REVIEW_LABEL === 'needs:contract-review');
   t('the pair is still identified in the line, in the spelling the round reports paste', says(G_BRANCHES[0][1], '✓ check-clause2-carriers: PR #16761 / card #16568 — the clause-② declaration is readable in the fixed spelling'));
 
+  // -- #18892: the EDIT reading, taken rather than asserted. ⭐ Measured specimen:
+  // objectui#9764's claim 5724909959 was EDITED (`created_at` 2026-09-18T03:54:37Z
+  // vs `updated_at` 04:23:23Z) and the note testified 「NOT edited」 anyway. The
+  // retired sentence is ASSEMBLED below, or the source pin hits itself (#16770).
+  battery('#18892: the claim comment\'s EDIT reading — taken from the two stamps already in hand, reported and never failed');
+  const E_EDITED = [CLAIMED(MEASURED_PROSE[1], { updated_at: '2026-09-18T04:23:23Z' }), FIXED_CORRECTION('no')];
+  const E_UNEDITED = [CLAIMED(MEASURED_PROSE[1]), FIXED_CORRECTION('no')];
+  const E_NOSTAMP = [{ ...CLAIMED(MEASURED_PROSE[1]), updated_at: undefined }, FIXED_CORRECTION('no')];
+  const E_NOTE = (thread) => c2CorrectionNote(pair({ cardComments: thread }));
+  const E_SRC = readFileSync(SELF_PATH, 'utf8');
+  t('⭐ the EDITED specimen is REPORTED in the note, in as many words', says(E_NOTE(E_EDITED), 'WAS EDITED'));
+  t('…naming the edit instant beside the creation one, so a reader can open that comment\'s history', says(E_NOTE(E_EDITED), '2026-09-18T04:23:23Z') && says(E_NOTE(E_EDITED), '2026-09-12T00:41:08Z'));
+  t('⭐ an UNEDITED claim reads as a MEASURED unedited, naming both stamps it compared', says(E_NOTE(E_UNEDITED), 'UNEDITED') && says(E_NOTE(E_UNEDITED), 'created_at') && says(E_NOTE(E_UNEDITED), 'updated_at'));
+  t('⭐ a row carrying NO `updated_at` reads NOT READ — ⛔ never "unedited", which is this defect one room over', says(E_NOTE(E_NOSTAMP), 'NOT READ') && says(E_NOTE(E_NOSTAMP), 'never as "unedited"'));
+  t('⭐ the three readings are three DIFFERENT sentences — one sentence for all three was the defect', new Set([E_NOTE(E_EDITED), E_NOTE(E_UNEDITED), E_NOTE(E_NOSTAMP)]).size === 3);
+  t('⛔ REPORT-ONLY: an edited claim raises NO C2 finding, so the exit register does not move', pairRows(pair({ cardComments: E_EDITED })).every((r) => r.code !== 'C2'));
+  t('⛔ …and reads DECLARED at the seat\'s own value, exactly as the unedited thread does', cardDeclaration(E_EDITED).state === cardDeclaration(E_UNEDITED).state && cardDeclaration(E_EDITED).value === 'no');
+  t('⭐ the green line points at that reading and says what it STATES, ⛔ never testifying to the edit itself', says(greenPairLine({ pr: 1, card: 2, corrected: true }), '`created_at`/`updated_at`'));
+  t('⛔ …and the clause that asserted an unread fact is gone from the printed line', !says(greenPairLine({ pr: 1, card: 2, corrected: true }), 'says the claim was not edited'));
+  t('⛔ NEGATIVE, on the SOURCE: no branch of this file asserts the unread 「NOT edited」 any more', !E_SRC.includes(['still reads as', 'it was written'].join(' ')));
+  t('⛔ CONTROL — the same source read is not empty or misdirected: it reaches the reader this card added', E_SRC.includes(['function claimEdit', 'Reading('].join('')));
+
   // -- The floor: every declared battery RAN, and ran its cases (#13489) -----
   //
   // Evaluated after every battery has had its chance and BEFORE the verdict, so