gstack/test/ceo-section-loading-fixture.test.ts

import lifetimeFixture from './fixtures/ceo-fill-lifetime.json';
import { describe, expect, test } from 'bun:test';
import { readFileSync } from 'node:fs';
import { join } from 'node:path';
import {
  CACHE_READ_WRITE_SKETCH,
  CEO_SECTION_CACHE_PLAN,
  hasStaleFillRaceFinding,
} from './helpers/ceo-section-loading-fixture';
import captured_sdk_columnar_af from './fixtures/sdk-columnar-af.json';
import captured_sdk_compact_sequence_aj from './fixtures/sdk-compact-sequence-aj.json';
import captured_sdk_order_b_ag from './fixtures/sdk-order-b-ag.json';
import fs_sdk_ordered_schedule_ar from 'node:fs';
import fixture_sdk_ordering_ae from './fixtures/sdk-ordering-ae.json';
import captured_sdk_original_order_ai from './fixtures/sdk-original-order-ai.json';
import fixture_sdk_schedule_continuation_ah from './fixtures/sdk-schedule-continuation-ah.json';
import fixture_sdk_stale_table_ad_v3 from './fixtures/sdk-stale-table-ad-v3.json';

describe('future-reader vocabulary in the actual AA finding', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-aa-report.md'), 'utf8');
  const paragraph = report.slice(report.indexOf('**S4-1 (CRITICAL'), report.indexOf('\n\nNo UI scope.', report.indexOf('**S4-1 (CRITICAL')));

  test('recognizes the exact complete report and its same-paragraph post-write consequence', () => {
    expect(paragraph).toContain('A read in-flight when a write');
    expect(paragraph).toContain('stale snapshot after `cache.delete` fires');
    expect(paragraph).toContain('future callers with stale data');
    expect(hasStaleFillRaceFinding(paragraph)).toBe(true);
    expect(hasStaleFillRaceFinding(report)).toBe(true);
    expect(hasStaleFillRaceFinding(paragraph.replace('future callers', 'subsequent callers'))).toBe(true);
  });

  test.each(['future reads', 'future requests', 'future callers'])('recognizes a later consumer: %s', reader => {
    expect(hasStaleFillRaceFinding(`An in-flight read inserts a stale snapshot after write invalidation, leaving ${reader} with stale data.`)).toBe(true);
  });

  test.each([
    'An in-flight read inserts a stale snapshot after write invalidation. Future work documents the cache.',
    'An in-flight read inserts a fresh snapshot after write invalidation, leaving future callers with fresh data.',
    'An in-flight read inserts a stale snapshot before write invalidation, leaving future callers with stale data.',
    'A completed read inserts a stale snapshot after write invalidation, leaving future callers with stale data.',
    'An in-flight read returns a stale snapshot after write invalidation to its original pending caller.',
    'An in-flight read inserts a stale snapshot after write invalidation. Future callers seeing stale data is allowed behavior.',
    'An in-flight read inserts a stale snapshot after write invalidation, leaving future callers with stale data. This is the accepted consistency model.',
    'An in-flight read cannot refill stale data after write invalidation. Future callers observe committed data.',
    'An in-flight read inserts a stale snapshot after write invalidation, leaving future callers with stale data. This is not a bug; no guard is required.',
    '> An in-flight read inserts a stale snapshot after write invalidation, leaving future callers with stale data.',
    '```text\nAn in-flight read inserts a stale snapshot after write invalidation, leaving future callers with stale data.\n```',
    'An in-flight read inserts a stale snapshot after write invalidation.\n\n## A different section\nFuture callers need documentation.',
    '* An in-flight read inserts a stale snapshot after write invalidation.\n* Future callers need documentation.',
  ])('retains ordering, stale-value, source and dismissal boundaries: %s', text => {
    expect(hasStaleFillRaceFinding(text)).toBe(false);
  });

  test('the original-caller exception cannot permit the same stale value for future callers', () => {
    expect(hasStaleFillRaceFinding('An in-flight read refills stale data after write invalidation, so new reads see old data. The original pending caller may receive an old snapshot and future callers observe it; this is permitted. Guard cache fills with a generation token.')).toBe(false);
    expect(hasStaleFillRaceFinding('The original pending caller may receive an old snapshot; that return is permitted. However, an in-flight read refills stale data after write invalidation, so future callers violate the contract. Guard cache fills with a generation token.')).toBe(true);
  });
});

describe('restore vocabulary in the actual Y finding', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-y-report.md'), 'utf8');
  const amendment = report.slice(report.indexOf('**AMENDMENT (Finding 1'), report.indexOf('```javascript')).trim();

  test('recognizes the delivered report and its explicit original-invariant failure', () => {
    expect(amendment).toContain('original pseudocode did not satisfy');
    expect(amendment).toContain('in-flight read from restoring a stale cache entry');
    expect(hasStaleFillRaceFinding(amendment)).toBe(true);
    expect(hasStaleFillRaceFinding(report)).toBe(true);
  });

  test.each(['can restore', 'restores', 'restored', 'is restoring'])('recognizes the cache-fill verb %s', verb => {
    expect(hasStaleFillRaceFinding(`An in-flight read ${verb} stale data after write invalidation. A subsequent read sees the old value, violating the contract.`)).toBe(true);
  });

  test.each(['cannot restore', "can't restore", 'never restores', 'does not restore', "doesn't restore", 'will not restore', "won't restore", 'did not restore', "didn't restore", 'is not restoring', "isn't restoring", 'was not restoring', 'has not restored', "hasn't restored", 'had not restored'])('rejects a current prevention assertion: %s', denied => {
    expect(hasStaleFillRaceFinding(`An in-flight read ${denied} stale data after write invalidation. A subsequent read observes the committed value.`)).toBe(false);
  });

  test.each([
    'An in-flight read restores stale data after write invalidation. This is not a defect; no guard is required.',
    'An in-flight read restores stale data after write invalidation. Subsequent stale reads are permitted by the contract.',
    'An in-flight read restores stale data after write invalidation. This is the accepted consistency model.',
    'An in-flight read restores the committed new value after write invalidation. A subsequent read observes it.',
    'The original pending caller receives an old snapshot after the write; that return is permitted.',
    'If deletion throws after a write, a restore operation leaves stale cache data. Log and bypass the adapter.',
    '> An in-flight read restores stale data after write invalidation; a subsequent read violates the contract.',
    '```text\nAn in-flight read restores stale data after write invalidation; a subsequent read violates the contract.\n```',
    '* An in-flight read restores stale data after write invalidation.\n* Telemetry has a bug.',
  ])('preserves dismissal, source and separate-finding boundaries: %s', text => {
    expect(hasStaleFillRaceFinding(text)).toBe(false);
  });
});

describe('pre-write snapshot vocabulary in the actual U finding', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-u-report.md'), 'utf8');
  const paragraph = report.slice(report.indexOf('After T4 the cache correctly reflects'), report.indexOf('**Recommended fix (auto-decided):**')).trim();

  test('recognizes the exact delivered report and its complete asserted paragraph independently of the bad remedy', () => {
    expect(paragraph).toContain('re-populates the cache with the pre-write snapshot');
    expect(paragraph).toContain('This violates the invariant:');
    expect(hasStaleFillRaceFinding(paragraph)).toBe(true);
    expect(hasStaleFillRaceFinding(report)).toBe(true);
  });

  test.each(['pre-write snapshot', 'pre write snapshot', 'pre-write value', 'pre-write data', 'pre-write version'])('recognizes an old snapshot synonym: %s', value => {
    expect(hasStaleFillRaceFinding(`An in-flight read re-populates the cache with the ${value} after write invalidation. A new reader sees it, violating the contract.`)).toBe(true);
  });

  test.each([
    'A pending read returns the pre-write snapshot to its original caller; that return is permitted.',
    'An in-flight read re-populates the cache with the post-write snapshot after invalidation.',
    'The pre-write snapshot expires after 30 seconds. The LRU byte cap is adequate.',
    'If invalidation throws after a write, the cache retains the pre-write snapshot. Log the failure and bypass the cache.',
    'An in-flight read re-populates the cache with the pre-write snapshot after invalidation. This is allowed behavior for subsequent reads.',
    'An in-flight read re-populates the cache with the pre-write snapshot after invalidation. This is the accepted consistency model.',
    'An in-flight read re-populates the cache with the pre-write snapshot after invalidation, so a new reader receives that version. This is the accepted consistency model.',
    'An in-flight read re-populates the cache with the pre-write snapshot after invalidation. It is not a bug; no guard is required.',
    'An in-flight read cannot re-populate the cache with the pre-write snapshot after invalidation. No race remains.',
    '> An in-flight read re-populates the pre-write snapshot after write invalidation; a new read sees it, violating the contract.',
    '```text\nAn in-flight read re-populates the pre-write snapshot after write invalidation; a new read sees it, violating the contract.\n```',
    '* An in-flight read re-populates the pre-write snapshot after invalidation.\n* Telemetry retry handling has a bug.',
  ])('retains original-caller, freshness, dismissal and source boundaries: %s', value => {
    expect(hasStaleFillRaceFinding(value)).toBe(false);
  });

  test('permission for the original caller still cannot excuse a later-reader violation', () => {
    expect(hasStaleFillRaceFinding('The original pending caller may receive the pre-write snapshot; that return is permitted. However, an in-flight read refills the cache with the pre-write snapshot after write invalidation, so a new reader violates the contract. Guard cache fills with a generation token.')).toBe(true);
  });
});

describe('CEO section-loading cache fixture', () => {
  test.each([
    { retires: false, rejects: false },
    { retires: true, rejects: false },
    { retires: true, rejects: true },
  ])('cohort admission is distinct from the actual wrapper fill: %j', async ({ retires, rejects }) => {
    const pending: Array<{ value: string; finish: () => void }> = [];
    const flights = new Map<string, Promise<string>>();
    let stored = 'old';
    const failure = new Error('rolled back');
    const repository = {
      read(key: string) {
        if (flights.has(key)) return flights.get(key)!;
        const value = stored;
        let finish!: () => void;
        const flight = new Promise<string>(resolve => { finish = () => resolve(value); })
          .finally(() => { if (flights.get(key) === flight) flights.delete(key); });
        pending.push({ value, finish }); flights.set(key, flight);
        return flight;
      },
      async write(key: string, value: string) {
        if (rejects) throw failure;
        stored = value;
        if (retires) flights.delete(key);
        return value;
      },
    };
    const cache = new Map<string, string>();
    const { readProfile, writeProfile } = new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    const earlier = readProfile('tenant:profile');
    if (rejects) await expect(writeProfile('tenant:profile', 'new')).rejects.toBe(failure);
    else await writeProfile('tenant:profile', 'new');
    const later = readProfile('tenant:profile');
    expect(pending).toHaveLength(retires && !rejects ? 2 : 1);
    if (retires && !rejects) {
      pending[1]!.finish();
      expect(await later).toBe('new');
    }
    pending[0]!.finish();
    expect(await earlier).toBe('old');
    if (!retires || rejects) expect(await later).toBe('old');
    // Even correct repository admission cannot stop this exact new sketch
    // from caching its older result after the committed write. Keep that gap.
    expect(await readProfile('tenant:profile')).toBe('old');
    expect(stored).toBe(rejects ? 'old' : 'new');
    expect(CEO_SECTION_CACHE_PLAN).toContain('single-flight wrapper sits inside\n  repository.read');
    expect(CEO_SECTION_CACHE_PLAN).toContain('A committed repository.write retires');
    expect(CEO_SECTION_CACHE_PLAN).toContain('This admission rule does not inspect cache fills');
    expect(CEO_SECTION_CACHE_PLAN).toContain(CACHE_READ_WRITE_SKETCH);
    expect(hasStaleFillRaceFinding(CEO_SECTION_CACHE_PLAN)).toBe(false);
  });

  test('author bounds implementation depth without preapproving the wrapper or weakening required proof', () => {
    expect(CEO_SECTION_CACHE_PLAN).toContain('wrapper itself remains unapproved');
    expect(CEO_SECTION_CACHE_PLAN).toContain('actual\ncontradiction or missing proof must be reported and resolved');
    expect(CEO_SECTION_CACHE_PLAN).toContain('exact data\nstructures, full function bodies and executable test code belong to subsequent\nengineering planning');
    expect(CEO_SECTION_CACHE_PLAN).toContain('not tests already\nimplemented or passing');
    expect(CEO_SECTION_CACHE_PLAN).toContain('Preserve all 11 review outcomes');
    expect(CEO_SECTION_CACHE_PLAN).toContain('full GSTACK REVIEW REPORT');
  });

  test('declared absence decoding and atomic write failure do not add independent wrapper defects', async () => {
    const missing = Object.freeze({ found: false });
    const absent = Symbol('adapter-private absence');
    const stored = new Map<string, unknown>();
    const cache = {
      get: (key: string) => stored.get(key) === absent ? missing : stored.get(key),
      set: (key: string, value: unknown) => stored.set(key, value === missing ? absent : value),
      delete: (key: string) => stored.delete(key),
    };
    const rejected = new Error('atomic write rejected before commit');
    let reads = 0;
    const repository = {
      read: async () => { reads++; return missing; },
      write: async () => { throw rejected; },
    };
    const { readProfile, writeProfile } = new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    expect(await readProfile('tenant:missing')).toBe(missing);
    expect(stored.get('tenant:missing')).toBe(absent);
    expect(await readProfile('tenant:missing')).toBe(missing);
    expect(reads).toBe(1);
    await expect(writeProfile('tenant:missing', { found: true })).rejects.toBe(rejected);
    expect(await readProfile('tenant:missing')).toBe(missing);
    expect(reads).toBe(1);
    expect(CEO_SECTION_CACHE_PLAN).toContain('every\n  rejected promise guarantees no commit');
    expect(CEO_SECTION_CACHE_PLAN).toContain('cache.get decodes it back to the same absent-result DTO');
    expect(CEO_SECTION_CACHE_PLAN).toContain('cannot fill the new one');
    expect(CEO_SECTION_CACHE_PLAN).toContain('does not coordinate\nan ordinary DB write');
  });

  test.each([false, true])('rollout publication fences admitted old writes: %s', async (fenceWrites) => {
    let stored = 'old';
    let releaseWrite!: () => void;
    const gate = new Promise<void>(resolve => { releaseWrite = resolve; });
    const repository = {
      read: async () => stored,
      write: async (_key: string, value: string) => { await gate; stored = value; return value; },
    };
    const instance = () => new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(new Map(), repository);
    const old = instance();
    const writing = old.writeProfile('tenant:profile', 'new');
    let published = false;
    const publish = async () => {
      if (fenceWrites) await writing;
      published = true;
      return instance();
    };
    const publishing = publish();
    await Promise.resolve();
    expect(published).toBe(!fenceWrites);
    if (!fenceWrites) {
      const next = await publishing;
      expect(await next.readProfile('tenant:profile')).toBe('old');
      releaseWrite(); await writing;
      // The initial isolation-only contract still permits a stale new cache.
      expect(await next.readProfile('tenant:profile')).toBe('old');
    } else {
      releaseWrite(); await writing;
      const next = await publishing;
      expect(await next.readProfile('tenant:profile')).toBe('new');
    }
    expect(CEO_SECTION_CACHE_PLAN).toContain('awaits every admitted old-instance write');
    expect(CEO_SECTION_CACHE_PLAN).toContain('fresh single-flight cohort before admitting new work');
  });

  test('an internal store commit still overlaps the unfinished public wrapper write', async () => {
    let stored = 'old';
    let commitWrite!: () => void;
    let wrapperReturned = false;
    const cache = new Map([['tenant:profile', 'old']]);
    const repository = {
      read: async () => stored,
      write: () => new Promise<string>(resolve => {
        commitWrite = () => { stored = 'new'; resolve('new'); };
      }),
    };
    const { readProfile, writeProfile } = new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    const writing = writeProfile('tenant:profile', 'new').then((value: string) => {
      wrapperReturned = true;
      return value;
    });
    commitWrite();
    expect(stored).toBe('new');
    expect(wrapperReturned).toBe(false);
    // Invocation precedes the wrapper's invalidation/return continuation.
    // Its old cache hit is permitted; a later caller is still protected.
    const overlappingRead = readProfile('tenant:profile');
    await writing;
    expect(wrapperReturned).toBe(true);
    expect(cache.has('tenant:profile')).toBe(false);
    expect(await overlappingRead).toBe('old');
    expect(await readProfile('tenant:profile')).toBe('new');
    const contract = CEO_SECTION_CACHE_PLAN.replace(/\s+/g, ' ');
    expect(contract).toContain("when writeProfile's promise fulfills after cache.delete, not when repository.write commits or resolves");
    expect(contract).toContain('Reads that overlap an unfinished writeProfile may return an earlier snapshot');
  });

  test('an old miss filled before the completed write is correctly invalidated', async () => {
    let stored = 'old';
    let releaseRead!: () => void;
    let first = true;
    const cache = new Map<string, string>();
    const repository = {
      read: () => {
        if (!first) return Promise.resolve(stored);
        first = false;
        const snapshot = stored;
        return new Promise<string>(resolve => { releaseRead = () => resolve(snapshot); });
      },
      write: async (_key: string, value: string) => { stored = value; return value; },
    };
    const { readProfile, writeProfile } = new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    const earlierRead = readProfile('tenant:profile');
    releaseRead();
    expect(await earlierRead).toBe('old');
    expect(cache.get('tenant:profile')).toBe('old');
    await writeProfile('tenant:profile', 'new');
    expect(stored).toBe('new');
    expect(cache.has('tenant:profile')).toBe(false);
    expect(await readProfile('tenant:profile')).toBe('new');
  });

  test('the exact proposed wrapper retains a reproducible stale-fill race', async () => {
    let releaseRead!: (value: string) => void;
    let stored = 'old';
    const cache = new Map<string, string>();
    const repository = {
      read: () => new Promise<string>((resolve) => { releaseRead = resolve; }),
      write: async (_key: string, value: string) => { stored = value; return value; },
    };
    // Execute the same sketch the live reviewer receives, not a second model
    // of its ordering. Holding the old read exposes the intended interleaving.
    const { readProfile, writeProfile } = new Function('cache', 'repository',
      CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    const pending = readProfile('tenant:profile');
    await writeProfile('tenant:profile', 'new');
    releaseRead('old');
    const earlierResult = await pending;
    expect(stored).toBe('new');
    // Returning the earlier snapshot to the already-pending caller is
    // explicitly permitted. Reusing it for this new reader is the defect.
    expect(earlierResult).toBe('old');
    expect(CEO_SECTION_CACHE_PLAN).toContain('Every read begun after that write completes must');
    expect(await readProfile('tenant:profile')).toBe('old');
    expect(CEO_SECTION_CACHE_PLAN).toContain(CACHE_READ_WRITE_SKETCH);
    expect(hasStaleFillRaceFinding(CEO_SECTION_CACHE_PLAN)).toBe(false);
  });

  test.each([
    // Actual finding in the unchanged fixture's successful 38 KB live report.
    '**Missing: What happens to in-flight requests during invalidation?** If a write invalidates a key and 10 requests are simultaneously loading it (cache miss, in-flight DB fetch), all 10 will cache the same value after the invalidation. The invalidated key may get re-populated with a stale value if any of those fetches started before the write. No mention of this race.',
    'P1: An in-flight read can repopulate stale data after a committed write invalidates the key. Guard fills with a generation token.',
    '| Cache fill race | An older value fetched before the write is inserted after eviction, so the next read is stale. | Add a per-key epoch. |',
    '**Invalidation race:** the pending fetch stores an outdated snapshot after cache.delete. Serialize the fill with mutation.',
  ])('recognizes the actual ordering defect: %s', (report) => {
    expect(hasStaleFillRaceFinding(report)).toBe(true);
  });

  test.each([
    'The full review is complete. No issues found.',
    'A stale value expires after 30 seconds. The LRU byte cap is adequate.',
    'If invalidation throws after a write, the cache retains stale data. Log the failure and bypass the cache.',
    'Read and write concurrency is covered. No stale data can be returned.',
    '| Reads | Coalesced concurrent misses |\n| Writes | Invalidation failure leaves stale data |',
    '```javascript\n// An in-flight read can cache stale data after invalidation.\n```',
    '> An in-flight read can cache stale data after invalidation.',
  ])('rejects completion, unrelated text, and quoted source: %s', (report) => {
    expect(hasStaleFillRaceFinding(report)).toBe(false);
  });
});


const CAPTURED_ACCEPTED_RACE_REPORT = `**Shadow paths:**
1. Nil key: Programming error — caught by auth/key-validation before wrapper.
2. Empty key: Same — upstream validation gate.
3. Upstream error: Single-flight releases all waiters with the error. Cache
   not populated. Next request retries DB. Correct.
4. Concurrent write during read in-flight: The plan documents this explicitly.
   The stale read is an accepted invariant, bounded by 30s TTL.

**Async ordering — critical race:**
\`\`\`
  1. Request A: cache.get(key) → miss → enters single-flight
  2. Request B: cache.get(key) → miss → joins single-flight (awaiting)
  3. fn: repository.read(key) → suspend (await)
  4. Write commits → cache.delete(key) [nothing to delete — key not set yet]
  5. repository.read(key) returns OLD snapshot (pre-write)
  6. cache.set(key, OLD_VALUE) ← stale value in cache for up to 30s
  7. Requests A and B both return OLD_VALUE ← accepted by plan
\`\`\`

This is the one documented asymmetry. It is not a gap — it is a named invariant.
The TTL bounds the stale window to 30 seconds.

`;


describe('CEO concurrency finding requires a violation, not an accepted trace', () => {
  test('rejects the captured accepted-invariant report that passed the old keyword oracle', () => {
    expect(hasStaleFillRaceFinding(CAPTURED_ACCEPTED_RACE_REPORT)).toBe(false);
  });

  test.each([
    'An in-flight fetch can refill the cache with old data after a write invalidates it. The next read sees that stale snapshot, violating the post-write contract.',
    'The pending read stores an older value after invalidation.\n\nGuard cache fills with a version check so a later request cannot observe pre-write state.',
    'Returning the old snapshot to the pending caller is permitted. But a late cache.set after concurrent write invalidation exposes stale data to a new reader. Serialize mutation and cache fills.',
    'Returning an old snapshot to the original pending caller is an accepted invariant. But an in-flight read can repopulate stale cache data after write invalidation, so a new reader violates the post-write contract. Guard cache fills with a generation token.',
    'The original caller may receive the old snapshot; that return is permitted. However, a pending fetch refills stale data after write invalidation, breaking consistency for a later reader. Skip the cache fill when its version changed.',
    'An in-flight read can repopulate stale data after write invalidation, so a new reader gets the old value. This is not permitted by the contract. Guard cache fills with a version check.',
    '| Late cache fill | A concurrent read repopulates an outdated result after eviction. | Reject the fill when its generation token changed. |',
  ])('accepts the later-reader consequence or a concrete ordering remedy: %s', report => {
    expect(hasStaleFillRaceFinding(report)).toBe(true);
  });

  test.each([
    'An in-flight read repopulates stale data after write invalidation. This is an accepted invariant bounded by the TTL.',
    'An in-flight read repopulates stale data after write invalidation. This is permitted by the contract; a later read may be stale for 30 seconds.',
    'An in-flight read refills stale data after write invalidation. This is allowed behavior for the next read because the TTL bounds it.',
    'The original caller and the new reader may both observe the old snapshot as an accepted invariant. A pending read refills stale data after write invalidation; no guard is required.',
    'An in-flight read repopulates stale data after write invalidation.\n\nIt is not a gap. No change is needed.',
    'No race: a pending read cannot repopulate stale cache data after write invalidation; the existing version check rejects it.',
    'An in-flight read repopulates stale data after write invalidation, but does not violate the contract. No guard is required.',
    '1. Cache population after a miss is safe.\n2. Concurrent writes can return an older snapshot to their original pending reader.\n3. Guard unrelated network retries.',
    'An in-flight read stores stale data after write invalidation.\n\n**Finding S9:** Guard telemetry delivery with a version token.',
    'An in-flight read stores stale data after write invalidation.\n\nGuard unrelated telemetry delivery with a version token.',
    '1. An in-flight read repopulates stale data after write invalidation.\n2. Telemetry retry handling has a bug.',
    'An in-flight read repopulates stale data after write invalidation.\n\n#2 — Unrelated telemetry delivery bug',
    '* An in-flight read repopulates stale data after write invalidation.\n* Telemetry retry handling has a bug.',
    '> P1: An in-flight read refills stale data after invalidation; a new read gets the old value.',
    '```text\nP1: An in-flight read refills stale data after invalidation; a new read gets the old value.\n```',
  ])('rejects dismissals, negations, unrelated findings and quoted examples: %s', report => {
    expect(hasStaleFillRaceFinding(report)).toBe(false);
  });
});


describe('proposed cache-fill prevention remains an unresolved finding', () => {
  test('an imperative remedy describes the behavior it must prevent', () => {
    expect(hasStaleFillRaceFinding('An in-flight read repopulates stale data after write invalidation. Guard cache fills so pending reads cannot repopulate stale values after invalidation.')).toBe(true);
  });

  test('an existing guard remains a dismissal, not a proposed fix', () => {
    expect(hasStaleFillRaceFinding('An in-flight read cannot repopulate stale data after write invalidation because the existing guard rejects that fill. No race remains.')).toBe(false);
  });

  test('an imperative does not erase a separate explicit dismissal', () => {
    expect(hasStaleFillRaceFinding('An in-flight read repopulates stale data after write invalidation. Guard cache fills so pending reads cannot repopulate stale values after invalidation. This is not a bug; no fix is needed.')).toBe(false);
  });
});


// The native report separates an asserted finding, its ordered trace and its
// explicit contract violation. Detection does not certify the offered fix.
describe('structured native stale-fill finding', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-loading-l-report.md'), 'utf8');
  const finding = report.slice(report.indexOf('**CRITICAL FINDING — Write-then-read stale-set race**'), report.indexOf('**Required fix:**'));
  test('retains the exact positive later-reader finding even though the proposed mitigation is wrong', () => {
    expect(hasStaleFillRaceFinding(report)).toBe(true);
    expect(hasStaleFillRaceFinding(finding)).toBe(true);
  });
  test.each([
    ['standalone trace', finding.slice(finding.indexOf('```'), finding.lastIndexOf('```') + 3)],
    ['quoted finding', finding.split('\n').map((line: string) => '> ' + line).join('\n')],
    ['source example', 'Example of report format:\n' + finding],
    ['outer fenced source', '````text\n' + finding + '\n````'],
    ['explicit accepted trace', finding.replace('This violates the stated invariant:', 'This is not a gap. The following behavior is accepted:')],
    ['negated violation', finding.replace('This violates the stated invariant:', 'This does not violate the stated invariant:')],
    ['separate dismissal', finding + '\nThis is not a defect; no fix is required.\n'],
    ['no new reader', finding.replace(/T3: readProfile[\s\S]*?\n```/, '```')],
    ['reverse ordering', finding.replace('cache.delete(key)', 'cache.get(key)')],
    ['unrelated heading', finding.replace('CRITICAL FINDING', 'EXAMPLE')],
    ...['~~~', '````'].map(fence => ['nontriple fenced violation', finding.replace(/This violates[\s\S]*$/, text => fence + 'text\n' + text + '\n' + fence)]),
    ['unclosed fenced violation', finding.replace('This violates', '```text\nThis violates')],
    ['later named finding', finding.replace('This violates', '**CRITICAL FINDING — unrelated documentation defect**\nThis violates')],
    ['later heading', finding.replace('This violates', '## Unrelated finding\nThis violates')],

  ])('rejects %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(false));
});


// Actual Q report amended the original contract to accept later stale reads.
// The oracle must not count that permission paragraph as an unresolved defect.
describe('accepted consistency model is not a stale-fill finding', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-loading-q-report.md'), 'utf8');
  const accepted = report.slice(report.indexOf('- **AMENDED (stale-fill race):**'), report.indexOf('\n\n', report.indexOf('- **AMENDED (stale-fill race):**')));
  test('rejects the exact amended consistency paragraph', () => {
    expect(accepted).toMatch(/accepted consistency\s+model/);
    expect(hasStaleFillRaceFinding(accepted)).toBe(false);
  });
  test('rejects the complete Q report that accepts the late-fill race', () => {
    expect(hasStaleFillRaceFinding(report)).toBe(false);
  });
  test.each([
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. This is the accepted consistency model; TTL expiry is the consistency deadline.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. This remains the documented consistency contract.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. This is an intentional consistency policy.',
  ])('rejects a declared consistency allowance: %s', text => {
    expect(hasStaleFillRaceFinding(text)).toBe(false);
  });
  test.each([
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. Every later read must observe the committed version; this is the accepted consistency model. The stale refill violates that contract.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. Every later read must observe the committed version. This is the accepted consistency model. The stale refill violates that contract.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value, violating the accepted consistency model.',
    'An in-flight read refills stale data after write invalidation. The accepted consistency model requires a subsequent read to observe the committed version; this violates that contract.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. This is not the accepted consistency model.',
    'An in-flight read refills stale data after write invalidation. A subsequent read sees the old value. This is not an accepted consistency model.',
  ])('retains an unresolved later-reader violation without demanding a correct remedy: %s', text => {
    expect(hasStaleFillRaceFinding(text)).toBe(true);
  });
});


describe('CEO R report requirement weakening remains rejected', () => {
  test('a race trace followed by acceptance and a weaker guarantee is not an unresolved defect', async () => {
    // Exact delivered R retry report; the existing oracle already rejects it.
    // This pins the policy failure without changing the paid fixture or oracle.
    const report = await Bun.file(new URL('./fixtures/ceo-section-r-rejected-report.md', import.meta.url)).text();
    expect(report).toContain('Every read begun after that write completes must');
    expect(report).toContain('this is an accepted design choice, not a quality gap');
    expect(report).toContain('Verify: new reads see stale value until TTL');
    expect(hasStaleFillRaceFinding(report)).toBe(false);
  });
});

// Exact S output names the original-contract defect but proposes an ineffective
// guard. Detection and remedy correctness remain separate assertions.
describe('S native same-finding ordered trace', () => {
  const report = require('node:fs').readFileSync(require('node:path').join(import.meta.dir, 'fixtures/ceo-section-s-trace-report.md'), 'utf8');
  const finding = report.slice(report.indexOf('### Critical Finding: Stale Re-insertion After Write Invalidation'), report.indexOf('### State Machine: Cache Entry'));
  test('recognizes the exact delivered S finding without certifying its remedy', () => {
    expect(hasStaleFillRaceFinding(report)).toBe(true);
    expect(hasStaleFillRaceFinding(finding)).toBe(true);
    expect(report).toContain('if (cache.get(key) === undefined)');
  });
  test('the same ordered evidence tolerates whitespace and a consistent key name', () => {
    expect(hasStaleFillRaceFinding(finding.replaceAll('(key', '(accountKey').replaceAll('  t', '    t'))).toBe(true);
    expect(hasStaleFillRaceFinding(finding.replaceAll('(key', '($key'))).toBe(true);
  });
  test.each([
    ['optional single-flight label', finding.replace('single-flight → ', '')],
    ['old/stale value vocabulary', finding.replace('OLD snapshot', 'stale value').replace('OLD_VALUE', 'STALE_VALUE').replace('stale value re-inserted', 'old snapshot refilled').replace('next readProfile', 'subsequent readProfile')],
    ['prose payload vocabulary', finding.replace('OLD_VALUE', 'old value').replace('returns stale value', 'returns old snapshot')],
    ['ASCII arrows and compact spacing', finding.replaceAll(' → ', '->').replaceAll(' ← ', '<-')],
    ['trace keyword case', finding.replace(/t[1-6]:[^\n]*/g, (event: string) => event.toLowerCase())],
    ['call whitespace and optional suspension annotation', finding.replaceAll('(key)', '( key )').replace('(key, OLD_VALUE)', '( key , OLD_VALUE )').replaceAll(' (suspends)', '')],
  ])('accepts equivalent %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(true));
  test.each([
    ['only the trace', finding.slice(finding.indexOf('```'), finding.indexOf('```', finding.indexOf('```') + 3) + 3)],
    ['quoted whole finding', finding.split('\n').map((line: string) => '> ' + line).join('\n')],
    ['indented whole finding', finding.split('\n').map((line: string) => '    ' + line).join('\n')],
    ['source format preface', 'Example of report format:\n' + finding],
    ['outer fenced source', '````text\n' + finding + '\n````'],
    ['missing independent violation', finding.replace('The proposed wrapper violates this invariant.', '')],
    ['negated independent violation', finding.replace('The proposed wrapper violates this invariant.', 'The proposed wrapper does not violate this invariant.')],
    ['unrelated heading', finding.replace('### Critical Finding:', '### Example:')],
    ['separate named finding', finding.replace('Race sequence', '### Another finding\nRace sequence')],
    ['separate bold finding', finding.replace('Race sequence', '**HIGH FINDING — unrelated issue**\nRace sequence')],
    ['missing write completion', finding.replace('DB write completes', 'DB write remains pending')],
    ['no invalidation', finding.replace('cache.delete(key) → writeProfile returns', 'cache.get(key) → writeProfile returns')],
    ['missing late old fill', finding.replace('cache.set(key, OLD_VALUE)', 'cache.set(key, NEW_VALUE)')],
    ['different filled key', finding.replace('cache.set(key, OLD_VALUE)', 'cache.set(otherKey, OLD_VALUE)')],
    ['case-distinct filled key', finding.replace('cache.set(key, OLD_VALUE)', 'cache.set(KEY, OLD_VALUE)')],
    ['different later key', finding.replace('next readProfile(key)', 'next readProfile(otherKey)')],
    ['only original pending reader', finding.replace('next readProfile(key)', 'original pending readProfile(key)')],
    ['later reader misses', finding.replace('cache HIT → returns stale value', 'cache MISS → returns committed value')],
    ['nonviolating trace', finding.replace('← INVARIANT VIOLATED', '← INVARIANT PRESERVED')],
    ['reverse order labels', finding.replace('t3:', 't4:').replace('t4: DB read', 't3: DB read')],
    ['missing event', finding.replace(/^.*t4:.*\n/m, '')],
    ['unclosed trace', finding.replace('```\n\nThe plan says', '\nThe plan says')],
    ['source-code trace fence', finding.replace('```\n  t1:', '```javascript\n  t1:')],
    ['split traces', finding.replace('  t4:', '```\n\n```\n  t4:')],
    ['accepted stale trace', finding + '\nThis stale-read behavior is accepted; no guard is required.\n'],
    ['allowed new-reader consequence', finding + '\nA subsequent stale read is permitted by the amended contract.\n'],
    ['explicit defect dismissal', finding + '\nThis is not a defect; no fix is required.\n'],
  ])('rejects %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(false));
});

// Actual v2 SDK review identifies the missing fill/write coordination directly.
// The full delivered report is retained in run evidence; this is its exact finding.
describe('explicit uncoordinated cache-fill freshness violation', () => {
  const finding = [
    "**[Amended: D2, D3, D4, D5]** The original sketch had no coordination between a",
    "cache fill and a write and omitted the single-flight wrapper and the absence",
    "sentinel; finding F1 showed that violates the read-after-write rule. The",
    "ordering rules below replace it. `flight` is the existing per-key single-flight",
    "wrapper extended with `invalidate(key)` and `invalidateAll()`; a fill ticket is",
    "`live()` until its key is invalidated. `ProfileNotFound` stands for the",
    "repository's existing typed not-found error class.",
  ].join('\n');
  test('accepts the actual finding without requiring its separate execution diagram', () => {
    expect(hasStaleFillRaceFinding(finding)).toBe(true);
    expect(hasStaleFillRaceFinding('## Proposed wrapper integration\nKeep the current read-through repository interface and shared adapters.\n' + finding)).toBe(true);
  });
  test.each([
    ['current wrapper', finding.replace('original sketch had', 'current wrapper has')],
    ['proposed implementation', finding.replace('original sketch had', 'proposed implementation has')],
    ['freshness contract', finding.replace('read-after-write rule', 'read-after-write contract')],
  ])('recognizes equivalent %s evidence', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(true));
  test.each([
    ['no violation asserted', finding.replace('finding F1 showed that violates the read-after-write rule.', '')],
    ['negated violation', finding.replace('that violates', 'that does not violate')],
    ['uncertain violation', finding.replace('that violates', 'that might violate')],
    ['conditional premise', 'If ' + finding],
    ['coordination exists', finding.replace('had no coordination', 'had coordination')],
    ['different operations', finding.replace('cache fill and a write', 'cache hit and a read')],
    ['wrong contract', finding.replace('read-after-write', 'read-before-write')],
    ['dismissed defect', finding + '\n\nThis is not a defect; no fix is required.'],
    ['accepted stale consequence', finding + '\n\nA subsequent stale read is permitted by the amended contract.'],
    ['quoted finding', finding.split('\n').map(line => '> ' + line).join('\n')],
    ['indented finding', finding.split('\n').map(line => '    ' + line).join('\n')],
    ['quoted paragraph', '"' + finding + '"'],
    ['source preface', 'Example of report format:\n' + finding],
    ['separate source preface', 'Example of report format:\n\n' + finding],
    ['backtick source fence', '````text\n' + finding + '\n````'],
    ['tilde source fence', '~~~text\n' + finding + '\n~~~'],
    ['unclosed source fence', '```text\n' + finding],
    ['split unrelated paragraphs', finding.replace('sentinel; finding', 'sentinel.\n\n### Separate issue\nFinding')],
  ])('rejects %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(false));
});

// Peer counterexamples: embedded, uncertain and hypothetical assertions stay closed.
describe('coordination findings require directly asserted premises and conclusions', () => {
  const premise = 'The original sketch had no coordination between a cache fill and a write. ';
  const claim = 'This violates the read-after-write rule.';
  test('accepts a direct assertion', () => expect(hasStaleFillRaceFinding(premise + claim)).toBe(true));
  test.each([
    ['negated embedded conclusion', premise + 'It is false that this violates the read-after-write rule.'],
    ['unproven conclusion', premise + 'We have not shown that it violates the read-after-write rule.'],
    ['uncertain conclusion', premise + 'It is unclear whether this violates the read-after-write rule.'],
    ['question rather than assertion', premise + claim.replace('.', '?')],
    ['separate issue without blank line', premise + '\n## A different issue\nReplica lag is high. ' + claim],
    ['hypothetical premise', 'Suppose ' + premise + claim],
    ['suggested report', 'A suggested report sentence: ' + premise + claim],
    ['nested unmatched fence', '````text\n' + premise + claim + '\n```\n' + premise + claim + '\n````'],
    ['mismatched fence', '~~~text\n' + premise + claim + '\n```\n' + premise + claim],
  ])('rejects %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(false));
});

// AM first SDK report, exact public Write53 acknowledged by native result54.
// The original report remains in run evidence; this is its complete asserted paragraph.
describe('reported original coordination violation with an owned finding citation', () => {
  const finding = "`[Amended: F1, F2, F3, F6]` The original sketch stated that no coordination\nbetween a cache fill and a write was proposed. Review showed that sketch\nviolates the retained read-after-write invariant (see F1). The ordering rules\nbelow replace it. They are the complete new read/write ordering rules.";
  test('accepts the exact owned paragraph without requiring its separate amended diagram', () => {
    expect(hasStaleFillRaceFinding(finding)).toBe(true);
    expect(hasStaleFillRaceFinding('## Proposed wrapper integration\n\n' + finding)).toBe(true);
  });
  test('binds the named violation to its original subject and finding identity', () => {
    expect(hasStaleFillRaceFinding(finding.replaceAll('F1', 'F7'))).toBe(true);
    expect(hasStaleFillRaceFinding(finding.replaceAll('sketch', 'wrapper'))).toBe(true);
    expect(hasStaleFillRaceFinding('## Historical example\n\nA copied example.\n\n## Current review\n\n' + finding)).toBe(true);
    expect(hasStaleFillRaceFinding(finding + '\n\n## Assessment of F2\nF2 is rejected.')).toBe(true);
    expect(hasStaleFillRaceFinding(finding + '\n\n## Assessment of F1\n> F1 is rejected.')).toBe(true);
  });
  test.each([
    ['negated missing coordination', finding.replace('no coordination', 'coordination')],
    ['unrelated operations', finding.replace('cache fill and a write', 'cache hit and a read')],
    ['uncertain absence', finding.replace('stated that no', 'might have stated that no')],
    ['unproven violation', finding.replace('Review showed', 'Review may show')],
    ['negated violation', finding.replace('sketch\nviolates', 'sketch\ndoes not violate')],
    ['hypothetical violation', finding.replace('sketch\nviolates', 'sketch\nmight violate')],
    ['wrong contract', finding.replace('read-after-write', 'read-before-write')],
    ['different subject', finding.replace('Review showed that sketch', 'Review showed that wrapper')],
    ['missing finding identity', finding.replace(' (see F1)', '')],
    ['question rather than conclusion', finding.replace('(see F1).', '(see F1)?')],
    ['conditional finding', 'If approved: ' + finding],
    ['historical owner', '## Historical example\n\n' + finding],
    ['source owner', '## Quoted source\n\n' + finding],
    ['hypothetical owner', '## Hypothetical example\n\n' + finding],
    ['explicit source preface', 'The following is a quoted source excerpt.\n\n' + finding],
    ['quoted paragraph', '"' + finding + '"'],
    ['block quote', finding.split('\n').map(line => '> ' + line).join('\n')],
    ['fenced source', '````text\n' + finding + '\n````'],
    ['literal assertion', finding.replace('The original sketch', '`The original sketch').replace('(see F1).', '(see F1).`')],
    ['split unrelated section', finding.replace('Review showed', '\n\n## Another finding\nReview showed')],
    ['direct same-finding withdrawal', finding + '\n\nF1 is rejected.'],
    ['later named same-finding withdrawal', finding + '\n\n## Assessment of F1\nF1 is withdrawn.'],
    ['dismissed defect', finding + '\n\nThis is not a defect; no fix is required.'],
    ['accepted stale consequence', finding + '\n\nA subsequent stale read is permitted by the amended contract.'],
  ])('rejects %s', (_name, text) => expect(hasStaleFillRaceFinding(text)).toBe(false));
});

// Exact public Write at d30620e8, session 59f999d1-de6b-4c67-ae6c-210efa05f0cc,
// toolu_01CWeW6wi4V6YEMNtd5dVdz2 acknowledged at native line 3343.
// PLAN.md SHA-256 577b669134977a17c779765c4a979a5fc1e9bc672cd77948d04d6bf066bfd7ff:
// retained requirement lines 38-40, current amendment 45-50, earlier-caller allowance 229.
// The recorded paid failure remains a failure; these are free detector regressions.
describe('attributed original coordination premise with a current freshness finding', () => {
  const evidence = "- A read already in progress when a write commits may return its earlier DB\n  snapshot to that caller. Every read begun after that write completes must\n  observe the committed version. TTL expiry is not a substitute for this rule.\n\n## Proposed wrapper integration\nKeep the current read-through repository interface and shared adapters.\n**[Amended: D1]** The original sketch stated \"no additional version checks or\ncoordination between a cache fill and a write\". That is withdrawn: the review\nshowed it violates the freshness invariant above (schedule in Section 4). The\naccepted ordering rules are:";
  const allowance = "Waiters coalesced on R1 receive V1 \u2014 permitted by PLAN.md:27-28 (they began before W completed)";
  const withAllowance = (claim = allowance) => evidence + '\n\n## Assessment of D1\n' + claim + '.';
  test('accepts the captured current assertion against its retained requirement', () => {
    expect(hasStaleFillRaceFinding(evidence)).toBe(true);
    expect(hasStaleFillRaceFinding(withAllowance())).toBe(true);
  });
  test('preserves premise ownership through equivalent labels, quotes and rule wording', () => {
    for (const text of [
      evidence.replaceAll('D1', 'F7'),
      evidence.replace('original sketch', 'original wrapper'),
      evidence.replace('original sketch', 'original implementation'),
      evidence.replace('"no additional', '“no additional').replace('a write"', 'a write”'),
      evidence.replace('no additional version checks or\ncoordination', 'no coordination'),
      evidence.replace('That is withdrawn: the review\nshowed it violates', 'This is withdrawn: the review shows it breaks'),
      evidence.replace('freshness invariant above', 'retained read-after-write contract above'),
      evidence.replace('Every read begun', 'Every read started').replace('that write completes', 'the write returns').replace('committed version', 'committed value'),
      evidence.replace(' (schedule in Section 4)', ''),
    ]) expect(hasStaleFillRaceFinding(text)).toBe(true);
  });
  test('requires the original missing coordination and the reviewer current assertion together', () => {
    for (const text of [
      evidence.replace('no additional version checks or\ncoordination', 'coordination'),
      evidence.replace('cache fill and a write', 'cache hit and a read'),
      evidence.replace('original sketch stated', 'original sketch may have stated'),
      evidence.replace('That is withdrawn:', 'That is retained:'),
      evidence.replace('showed it violates', 'did not show it violates'),
      evidence.replace('showed it violates', 'showed another wrapper violates'),
      evidence.replace('showed it violates', 'showed it might violate'),
      evidence.replace('freshness invariant', 'formatting invariant'),
      evidence.replace('Section 4).', 'Section 4)?'),
      evidence.replace('That is withdrawn:', '\n\n## Other finding\nThat is withdrawn:'),
      evidence.replace('That is withdrawn:', '| That is withdrawn:'),
      evidence.replace('**[Amended: D1]**', 'If approved: **[Amended: D1]**'),
    ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
  });
  test('requires a retained current requirement from this plan', () => {
    const finding = evidence.slice(evidence.indexOf('## Proposed wrapper integration'));
    for (const text of [
      finding,
      evidence.replace('Every read begun after that write completes must\n  observe the committed version.', 'Later reads may observe an earlier value.'),
      evidence.replace('must\n  observe', 'might\n  observe'),
      evidence.replace('Every read begun', 'Not every read begun'),
      evidence.replace('## Proposed wrapper integration', 'This rule is withdrawn.\n\n## Proposed wrapper integration'),
      '## Finding F9: unrelated cache\n' + evidence,
      '## Historical source\n' + evidence.slice(0, evidence.indexOf('## Proposed wrapper integration')) + '\n## Current review\n' + finding,
      '> Every read begun after that write completes must observe the committed version.\n\n' + finding,
      '"Every read begun after that write completes must observe the committed version."\n\n' + finding,
      'For another cache. Every read begun after that write completes must observe the committed version.\n\n' + finding,
    ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
  });
  test('does not promote copied, fenced or quoted review assertions', () => {
    for (const text of [
      'Source:\n\n' + evidence,
      'Earlier review:\n\n' + evidence,
      '## Hypothetical example\n' + evidence,
      'The following is a quoted source excerpt.\n\n' + evidence,
      evidence.split('\n').map(line => '> ' + line).join('\n'),
      evidence.split('\n').map(line => '    ' + line).join('\n'),
      '````text\n' + evidence + '\n````',
      '~~~text\n' + evidence + '\n~~~',
      evidence.replace('**[Amended: D1]**', '"Copied sentence. **[Amended: D1]**') + '"',
      evidence.replace('**[Amended: D1]**', 'Example of report format:\n\n**[Amended: D1]**'),
      evidence.replace('That is withdrawn:', '"That is withdrawn:').replace('Section 4).', 'Section 4)."'),
      evidence.replace('The original sketch', '`The original sketch').replace('Section 4).', 'Section 4).`'),
    ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
  });
  test('same-finding rejection and stale-result permission remain failures', () => {
    for (const tail of [
      'D1 is rejected.', 'D1 is "withdrawn".', 'This finding is dismissed.',
      '| D1 | Withdrawn |', '| D1 | "rejected" |',
      'A subsequent stale read is permitted by the amended contract.',
      'This stale-fill behavior is accepted.', 'No coordination is required.',
    ]) expect(hasStaleFillRaceFinding(withAllowance() + '\n\n## Assessment of D1\n' + tail)).toBe(false);
  });
  test('foreign or copied rejections do not override the current finding', () => {
    for (const tail of [
      '## Assessment of D2\nD2 is rejected.',
      '## Assessment of D2\n| D2 | Withdrawn |',
      '## Historical assessment\nD1 is withdrawn.',
      '## Assessment of D1\n> D1 is rejected.',
    ]) expect(hasStaleFillRaceFinding(evidence + '\n\n' + tail)).toBe(true);
  });
  test('coalesced earlier callers may use different symbolic writer and snapshot names', () => {
    for (const text of [
      allowance.replaceAll('R1', 'R17').replaceAll('V1', 'snapshot-A').replaceAll('W ', 'W9 '),
      allowance.replace('Waiters', 'Readers').replace('began', 'started').replace('W completed', 'the write returned'),
      allowance.replace('Waiters coalesced on R1', 'Callers').replace('receive', 'observe').replace('permitted by PLAN.md:27-28', 'allowed'),
    ]) expect(hasStaleFillRaceFinding(withAllowance(text))).toBe(true);
  });
  test('earlier-call allowance cannot credit a later reader, uncertain ordering or a fill', () => {
    for (const text of [
      allowance.replace('before W', 'after W'),
      allowance.replace('they began', 'they never began'),
      allowance.replace('they began', 'they may have begun'),
      allowance.replace('they began', 'another reader began'),
      allowance.replace('before W completed', 'before R2 completed'),
      allowance.replace('Waiters', 'Later readers'),
      allowance.replace('receive V1', 'fill the cache with V1'),
      allowance.replace('receive V1', 'return V1 to later callers'),
      allowance.replace('W completed)', 'W completed only if the write failed)'),
      allowance + ' and later readers may reuse V1',
      allowance + '. A subsequent stale read is permitted',
      allowance + '. The stale cache fill is acceptable',
    ]) expect(hasStaleFillRaceFinding(withAllowance(text))).toBe(false);
  });
});


describe('attributed coordination phrase classes and ownership', () => {
  // Independently written forms: no captured sentence, schedule schema or fixed parenthetical.
  const reports = [
    `## Retained contract
  Any request started after the write returns shall receive the committed value.

  ## Wrapper review
  [Amended: F8] Our original wrapper assumed “cache population proceeds without synchronization with writes”.
  We reject that assumption. Our review established that this approach contradicts the existing freshness guarantee.`,
    `## Existing contract
  All reads that begin after write completion must return the newly committed version.

  ## Implementation review
  [Amended: D4] The proposed implementation specifies "no coordination for writes and cache fills".
  This proposal was rejected. Review found it fails to preserve the read-after-write requirement.`,
    `## Contract retained
  Once a write has completed, new reads must see the value it committed.

  ## Current review
  [Amended: F3] The current sketch states "cache fills and writes run without coordination".
  That sketch breaks the current freshness rule.`,
    `## Required behavior
  The retained requirement: all requests that start after that write finishes are required to receive the committed snapshot.

  ## Current review
  [Amended: D17] Our original implementation assumed "cache repopulation and writes lacked ordering guards".
  That assumption has been retracted. The implementation does not preserve the existing freshness contract.`,
  ];

  for (const [index, report] of reports.entries()) {
    test(`phrase classes recognize independent current review form ${index + 1}`, () => expect(hasStaleFillRaceFinding(report)).toBe(true));
  }

  test('the attributed premise and direct violation need no fixed rejection sentence or above reference', () => {
    expect(hasStaleFillRaceFinding(reports[0]!.replace('We reject that assumption. ', ''))).toBe(true);
    expect(hasStaleFillRaceFinding(reports[1]!.replace('This proposal was rejected. ', ''))).toBe(true);
    expect(hasStaleFillRaceFinding(reports[2]!.replace('That sketch breaks', 'We found that this sketch violates'))).toBe(true);
  });

  test('different finding and artifact subjects cannot borrow the attributed premise', () => {
    for (const text of [
      reports[0]!.replace('We reject that assumption.', 'Another unrelated finding concerns replica lag.'),
      reports[0]!.replace('this approach contradicts', 'another approach contradicts'),
      reports[0]!.replace('this approach contradicts', 'the implementation contradicts'),
      reports[1]!.replace('Review found it fails', 'Review found another issue fails'),
      reports[2]!.replace('That sketch breaks', 'It is unclear whether that sketch breaks'),
      reports[2]!.replace('That sketch breaks', 'It is false that that sketch breaks'),
      reports[2]!.replace('That sketch breaks', 'That sketch does not break'),
    ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
  });

  test('normative freshness rules cannot be replaced by conditional or permissive statements', () => {
    for (const report of reports) {
      for (const text of [
        report.replace(/shall receive|must return|must see|are required to receive/, 'may receive'),
        report.startsWith('## Contract retained') ? report.replace('Once a write has completed', 'Before a write has completed') : report.replace('after', 'before'),
        report.replace('committed value', 'earlier value').replace('newly committed version', 'old version').replace('the value it committed', 'an older snapshot').replace('committed snapshot', 'stale snapshot'),
      ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
    }
  });

  test('quoted current assertions, source owners and split findings remain closed across phrase forms', () => {
    for (const report of reports) {
      const assertion = report.slice(report.lastIndexOf('\n') + 1);
      for (const text of [
        '> ' + report.replaceAll('\n', '\n> '),
        '````text\n' + report + '\n````',
        '## Historical source\n' + report.replaceAll('## ', '### '),
        report.replace(assertion, '"' + assertion + '"'),
        report.replace(assertion, '### Unrelated finding F99\n' + assertion),
      ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
    }
  });

  const finding = reports[0]!;
  const withAllowance = (claim: string) => finding + '\n\n## Assessment of F8\n' + claim;
  const earlierAllowances = [
    'The coalesced readers receive their earlier snapshot; that return is permitted because they started before the write completed.',
    'Readers coalesced on R8 return SNAPSHOT_X (allowed, because each call began before W9 returned).',
    'Waiters that began before write completion are permitted to receive V7.',
  ];

  test('earlier-group permission depends on ownership and chronology rather than exact punctuation', () => {
    for (const claim of earlierAllowances) expect(hasStaleFillRaceFinding(withAllowance(claim))).toBe(true);
  });

  test('earlier-group phrases cannot permit a fill, another caller or uncertain start', () => {
    for (const claim of [
      earlierAllowances[0]!.replace('before the write completed', 'after the write completed'),
      earlierAllowances[0]!.replace('they started', 'another reader started'),
      earlierAllowances[0]!.replace('they started', 'they might have started'),
      earlierAllowances[0]!.replace('receive their earlier snapshot', 'store their earlier snapshot in the cache'),
      earlierAllowances[1]!.replace('each call began', 'some other call began'),
      earlierAllowances[1]!.replace('W9 returned', 'R3 returned'),
      earlierAllowances[2]!.replace('before write completion', 'before another write completed'),
      earlierAllowances[2]!.replace('receive V7', 'return V7 to future callers'),
      earlierAllowances[0]!.replace(/\.$/, ' and future consumers may reuse that snapshot.'),
    ]) expect(hasStaleFillRaceFinding(withAllowance(claim))).toBe(false);
  });

  test('a legitimate earlier group never overrides a same-finding rejection or accepted stale fill', () => {
    for (const allowance of earlierAllowances) {
      expect(hasStaleFillRaceFinding(withAllowance(allowance) + '\nF8 is rejected.')).toBe(false);
      expect(hasStaleFillRaceFinding(withAllowance(allowance) + '\nA later stale read is permitted.')).toBe(false);
      expect(hasStaleFillRaceFinding(withAllowance(allowance) + '\nThis stale-fill behavior is accepted.')).toBe(false);
      expect(hasStaleFillRaceFinding(withAllowance(allowance) + '\n\n## Assessment of F9\nF9 is rejected.')).toBe(true);
    }
  });


  test('current assertions cannot attribute the retained-rule violation to a different finding', () => {
    const report = reports[2]!;
    expect(hasStaleFillRaceFinding(report.replace('freshness rule.', 'freshness rule (see F3).'))).toBe(true);
    expect(hasStaleFillRaceFinding(report.replace('freshness rule.', 'freshness rule (see F9).'))).toBe(false);
    expect(hasStaleFillRaceFinding(report.replace('freshness rule.', 'freshness rule (see D3).'))).toBe(false);
  });
});

describe('current fill-lifetime overlap', () => {
  const lifetime = 'a fill that started before a write and stored after it caches the pre-write snapshot';
  const current = (text: string, suffix = '') => `### Current findings\n\nWithout coordination, ${text}, violating the retained read-after-write rule. ${suffix}`;

  test('captured current lifetime claim is independent of the ambiguous inline schedule', () => {
    expect(hasStaleFillRaceFinding(lifetimeFixture.claim)).toBe(true);
    expect(hasStaleFillRaceFinding(lifetimeFixture.ambiguousFinding)).toBe(false);
  });

  test.each([
    lifetime,
    'the cache fill which began before the write and completed after that write, storing the old value',
    'a fill that begins before a write and finishes after the same write stores the stale data',
    'the original fill starts before this write and completes after that same write caches the pre-write snapshot',
    'the fill began before the write completes and stored after it settles caches the pre-write value',
  ])('recognizes an explicit same-fill lifetime: %s', text => {
    expect(hasStaleFillRaceFinding(current(text))).toBe(true);
  });

  test.each(['F1', 'R7', 'BUG-cache', '17'])('current ownership does not depend on row-ID spelling: %s', id => {
    expect(hasStaleFillRaceFinding(`### Current findings\n\n| ${id} | CRITICAL GAP | ${current(lifetime).split('\n\n')[1]} |`)).toBe(true);
  });

  test.each([
    ['starts after the write', lifetime.replace('started before', 'started after')],
    ['stores before the write', lifetime.replace('stored after', 'stored before')],
    ['different writer', lifetime.replace('after it', 'after another write')],
    ['different filling actor', lifetime.replace('and stored', 'and another fill stored')],
    ['foreign key', lifetime.replace('a fill', 'a fill for another key')],
    ['return to original caller only', lifetime.replace('stored after it caches', 'returned after it with')],
    ['fresh value', lifetime.replace('pre-write snapshot', 'committed snapshot')],
    ['missing start', lifetime.replace('that started before a write and ', '')],
    ['missing late storage', lifetime.replace('and stored after it ', '')],
    ['missing cache storage', lifetime.replace('caches the pre-write snapshot', 'returns the pre-write snapshot')],
    ['explicit conditional', 'if ' + lifetime],
    ['explicit hypothesis', 'hypothetical execution: ' + lifetime],
    ['possible execution only', 'it might be that ' + lifetime],
    ['negated execution', 'it is not true that ' + lifetime],
    ['prevented execution', 'the guard prevents ' + lifetime],
    ['impossible execution', 'it is impossible that ' + lifetime],
    ['quoted execution', '"' + lifetime + '"'],
    ['code literal execution', '`' + lifetime + '`'],
    ['quote cannot join phase fragments', lifetime.replace('and stored after it', 'and "stored after it"')],
    ['second subject cannot inherit write', lifetime.replace('after it', 'after a separate write')],
  ])('rejects incomplete or unasserted overlap: %s', (_name, text) => {
    expect(hasStaleFillRaceFinding(current(text))).toBe(false);
  });

  test.each([
    ['quoted block', current(lifetime).split('\n').map(line => '> ' + line).join('\n')],
    ['fenced block', '```text\n' + current(lifetime) + '\n```'],
    ['unclosed fence', '~~~text\n' + current(lifetime)],
    ['source heading', current(lifetime).replace('Current findings', 'Quoted source')],
    ['historical owner', current(lifetime).replace('Current findings', 'Historical review')],
    ['source introduction', 'Source:\n' + current(lifetime).replace('Current findings', 'Findings')],
    ['accepted staleness', current(lifetime, 'This staleness is the accepted consistency model.')],
    ['later stale read permitted', current(lifetime, 'Later stale reads are permitted by the contract.')],
    ['current prevention', current(lifetime, 'The current wrapper cannot refill old data after invalidation.')],
    ['finding withdrawn', current(lifetime, 'This finding is withdrawn.')],
    ['finding rejected', current(lifetime, 'This finding is rejected.')],
    ['no repair required', current(lifetime, 'No guard is required.')],
  ])('preserves current ownership and dismissal: %s', (_name, text) => {
    expect(hasStaleFillRaceFinding(text)).toBe(false);
  });

  const seeded = () => {
    const events: string[] = [];
    let cached: string | undefined;
    let releaseRead!: () => void;
    const pendingRead = new Promise<string>(resolve => { releaseRead = () => { events.push('DB read v1 completes'); resolve('v1'); }; });
    const cache = {
      get: () => cached,
      set: (_key: string, value: string) => { events.push('cache set ' + value); cached = value; },
      delete: () => { events.push('cache delete'); cached = undefined; },
    };
    const repository = {
      read: () => pendingRead,
      write: async () => { events.push('DB write commits v2'); return 'v2'; },
    };
    const functions = new Function('cache', 'repository', CACHE_READ_WRITE_SKETCH + '\nreturn { readProfile, writeProfile };')(cache, repository);
    return { events, releaseRead, ...functions } as { events: string[]; releaseRead: () => void; readProfile: (key: string) => Promise<string>; writeProfile: (key: string, update: unknown) => Promise<string> };
  };

  test('the actual seeded wrapper can fill a pre-write snapshot when its pending read completes after the writer', async () => {
    const fixture = seeded();
    const original = fixture.readProfile('profile');
    await fixture.writeProfile('profile', {});
    fixture.releaseRead();
    expect(await original).toBe('v1');
    expect(await fixture.readProfile('profile')).toBe('v1');
    expect(fixture.events).toEqual(['DB write commits v2', 'cache delete', 'DB read v1 completes', 'cache set v1']);
  });

  test('the seeded await continuation stores synchronously before a later writer invalidates it', async () => {
    const fixture = seeded();
    const original = fixture.readProfile('profile');
    fixture.releaseRead();
    expect(await original).toBe('v1');
    await fixture.writeProfile('profile', {});
    expect(fixture.events).toEqual(['DB read v1 completes', 'cache set v1', 'DB write commits v2', 'cache delete']);
  });
});


describe('section fixture rollout metrics retain final acceptance without an impossible early-stage gate',()=>{
  test('early-stage hit rate counts admitted requests while aggregate metrics use baseline limits',()=>{
    const requests=9000, admitted=requests*0.1, hits=admitted*0.6;
    const cohortHitRate=hits/admitted, aggregateHitRate=hits/requests;
    expect(cohortHitRate).toBe(0.6); expect(aggregateHitRate).toBe(0.06);
    expect(70*(1-aggregateHitRate)).toBeCloseTo(65.8); // uniform traffic, linear read CPU: above final 50%, below baseline 70%
    expect(CEO_SECTION_CACHE_PLAN).toContain('among requests admitted to the cache path');
    expect(CEO_SECTION_CACHE_PLAN).toContain('tracked separately, not as misses');
    expect(CEO_SECTION_CACHE_PLAN).toContain('DB CPU and read p95 are service-wide metrics, including bypassed requests');
    expect(CEO_SECTION_CACHE_PLAN).toContain('At the 10% and 50% stages');
    expect(CEO_SECTION_CACHE_PLAN).toContain('no worse than their 70%/120 ms pre-rollout baselines');
    expect(CEO_SECTION_CACHE_PLAN).not.toContain('A healthy hour means the stated hit-rate, CPU, latency and error targets hold');
  });
  test('full rollout keeps all original absolute targets and the seeded race still needs repair',()=>{
    expect(CEO_SECTION_CACHE_PLAN).toContain('At 100%, the original');
    expect(CEO_SECTION_CACHE_PLAN).toContain('absolute acceptance targets (DB CPU below 50%, read p95 below 60 ms, hits at');
    expect(CEO_SECTION_CACHE_PLAN).toContain('least 60%) must all hold with unchanged correctness/error SLOs and no alerts');
    expect(CEO_SECTION_CACHE_PLAN).toContain('Every read begun after that write completes must');
    expect(CEO_SECTION_CACHE_PLAN).toContain('TTL expiry is not a substitute for this rule');
    expect(CEO_SECTION_CACHE_PLAN).toContain('no additional version checks or');
    expect(CEO_SECTION_CACHE_PLAN).toContain(CACHE_READ_WRITE_SKETCH);
    expect(CEO_SECTION_CACHE_PLAN).toContain('repository.read returns\n  an immutable absent-result DTO for a missing record, never undefined');
  });
});

describe('sdk-columnar-af', () => {
const captured = captured_sdk_columnar_af;
const evidence = () => captured.retryFinding + '\n\n' + captured.retrySchedule;
function replace(text: string, before: string, after: string) {
  expect(text).toContain(before);
  return text.replace(before, after);
}

test('AF exact retry columnar schedule establishes a post-write stale reader', () => {
  expect(hasStaleFillRaceFinding(captured.retryReport)).toBe(true);
  expect(hasStaleFillRaceFinding(captured.firstGuardedEvidence)).toBe(false);
});

test('AF columnar evidence binds named actors, keys and distinct versions independently of their spelling', () => {
  expect(hasStaleFillRaceFinding(evidence())).toBe(true);
  const varied = evidence().replace(/\bR1\b/g, 'R4').replace(/\bR2\b/g, 'R8').replace(/\bW\b/g, 'W3')
    .replace(/\bK\b/g, 'profileKey').replace(/\bv1\b/g, 'oldVersion').replace(/\bv2\b/g, 'newVersion')
    .replace(/->/g, '→');
  expect(hasStaleFillRaceFinding(varied)).toBe(true);
  expect(hasStaleFillRaceFinding(evidence().replace(/\bv2\b/g, 'v1'))).toBe(false);
});

test('AF every ordered operation and version witness is required', () => {
  for (const [before, after] of [
    ['get(K) -> undefined', 'get(K) -> v1'],
    ['await repository.read -> v1', 'await repository.read -> v2'],
    ['await write commits v2', 'await write fails'],
    ['delete(K) (no entry)', 'keep(K)'],
    ['| returns                   |', '| still pending             |'],
    ['resume: set(K, v1); return v1', 'resume: set(K, v2); return v2'],
    ['get(K) -> v1; return v1', 'get(K) -> v2; return v2'],
    ['v1 STALE  | v2', 'v1 STALE  | v1'],
    ['6 | resume:', '8 | resume:'],
  ]) expect(hasStaleFillRaceFinding(replace(evidence(), before!, after!))).toBe(false);
  for (let event = 1; event <= 7; event++) {
    expect(hasStaleFillRaceFinding(evidence().split('\n').filter(line => !line.trim().startsWith(`${event} |`)).join('\n'))).toBe(false);
  }
});

test('AF a different key, reader, write or column cannot lend ownership', () => {
  for (const [before, after] of [
    ['cache[K]  | DB[K]', 'cache[K]  | DB[J]'],
    ['delete(K) (no entry)', 'delete(J) (no entry)'],
    ['set(K, v1)', 'set(J, v1)'],
    ['get(K) -> v1; return v1', 'get(J) -> v1; return v1'],
    ['R2 read (begins after W)', 'R1 read (begins after W)'],
    ['R2 read (begins after W)', 'R2 read (begins after W2)'],
    ['R2 began after W completed (t5)', 'R1 began after W completed (t5)'],
    ['R2 began after W completed (t5)', 'R2 began before W completed (t5)'],
    ['R2 began after W completed (t5)', 'R2 began after W completed (t6)'],
    ['observes v1 for up to 30 s.', 'observes v2 for up to 30 s.'],
  ]) expect(hasStaleFillRaceFinding(replace(evidence(), before!, after!))).toBe(false);
});

test('AF current declarative execution cannot borrow a conditional, negated or quoted schedule', () => {
  for (const [before, after] of [
    ['await write commits v2', 'write might commit v2'],
    ['resume: set(K, v1); return v1', 'resume: no set(K, v1); return v1'],
    ['VIOLATION t7:', 'If VIOLATION t7:'],
    ['VIOLATION t7:', 'Quoted VIOLATION t7:'],
    ['observes v1 for up to 30 s.', 'observes v1 for up to 30 s.?'],
  ]) expect(hasStaleFillRaceFinding(replace(evidence(), before!, after!))).toBe(false);
});

test('AF the same named finding and a real top-level fence own the schedule', () => {
  const text = evidence();
  for (const value of [
    captured.retrySchedule,
    text.replace('(F1 evidence)', '(F2 evidence)'),
    text.replace('Schedule S1 below', 'Schedule S2 below'),
    captured.retryFinding + '\n' + text,
    text.split('\n').map(line => '> ' + line).join('\n'),
    '````text\n' + text + '\n````',
    text.replace('```\n t |', '```javascript\n t |'),
    text.slice(0, text.lastIndexOf('```')),
    'Example:\n\n' + text,
    captured.retryFinding + '\n\nTemplate:\n' + captured.retrySchedule,
  ]) expect(hasStaleFillRaceFinding(value)).toBe(false);
});

test('AF an original-caller allowance cannot excuse a stale cache or later caller', () => {
  const allowed = 'Allowed by contract: R1 itself returns v1 (read in progress when write committed).';
  for (const value of [
    replace(evidence(), allowed, 'Allowed by contract: R2 itself returns v1 (read in progress when write committed).'),
    replace(evidence(), allowed, 'The stale-fill behavior is accepted.'),
    replace(evidence(), allowed, 'There is no stale-fill race.'),
    replace(evidence(), allowed, 'The trace is impossible.'),
    evidence() + '\n\nThis is not a violation. No guard is required.',
  ]) expect(hasStaleFillRaceFinding(value)).toBe(false);
});
test('AF every same-row assessment and an unproven source frame remain authoritative', () => {
  for (const [cell, value] of [
    [6, 'Rejected: there is no stale-fill race.'],
    [5, 'The stale-fill behavior is accepted. No guard is required.'],
    [6, 'Rejected: “There is no stale-fill race.”'],
    [6, 'Rejected: "The stale-fill behavior is accepted. No guard is required."'],
  ] as const) {
    const cells = captured.retryFinding.split('|'); cells[cell] = value;
    expect(hasStaleFillRaceFinding(cells.join('|') + '\n\n' + captured.retrySchedule)).toBe(false);
  }
  expect(hasStaleFillRaceFinding('An unproven hypothesis:\n\n' + evidence())).toBe(false);
});
});

describe('sdk-compact-sequence-aj', () => {
const captured = captured_sdk_compact_sequence_aj;
const sequence = 'fill starts, write commits, write deletes (no-op), fill sets pre-commit v1, later read hits v1.';
const report = captured.finding;

test('recognizes the captured current original-plan sequence without borrowing the amended diagram', () => {
  expect(hasStaleFillRaceFinding(report)).toBe(true);
  expect(hasStaleFillRaceFinding(report.replaceAll('v1', 'snapshot_A'))).toBe(true);
  expect(hasStaleFillRaceFinding(report.replace('Schedule Diagram 2b: ', ''))).toBe(true);
});

test('requires the ordered original fill, commit, invalidation, old cache value and same later value', () => {
  for (const changed of [
    sequence.replace('fill starts, ', ''),
    sequence.replace('write commits, ', ''),
    sequence.replace('write deletes (no-op), ', ''),
    sequence.replace('fill sets pre-commit v1, ', ''),
    sequence.replace(', later read hits v1', ''),
    sequence.replace('later read hits v1', 'later read hits v2'),
    sequence.replace('pre-commit v1', 'post-commit v1'),
    sequence.replace('fill starts, write commits', 'write commits, fill starts'),
    sequence.replace('write deletes (no-op), fill sets pre-commit v1', 'fill sets pre-commit v1, write deletes (no-op)'),
    sequence.replace('later read hits', 'another key later read hits'),
  ]) expect(hasStaleFillRaceFinding(report.replace(sequence, changed))).toBe(false);
  expect(hasStaleFillRaceFinding(report.replace('Original plan', 'Amended plan'))).toBe(false);
  expect(hasStaleFillRaceFinding(report.replace(sequence, '"' + sequence + '"'))).toBe(false);
});

test('preserves accepted-staleness and explicit dismissal boundaries', () => {
  for (const suffix of [
    'This is not a gap; no guard is needed.',
    'This staleness is the accepted consistency model.',
    'This finding is withdrawn.',
    'F1 is rejected.',
  ]) expect(hasStaleFillRaceFinding(report.trimEnd() + '\n\n' + suffix)).toBe(false);
  expect(hasStaleFillRaceFinding(report.replace('fill starts', 'fill never starts'))).toBe(false);
});

test('source, quotes and hypothetical framing cannot supply current coverage', () => {
  for (const text of [
    '```text\n' + report + '```',
    report.split('\n').map(line => '> ' + line).join('\n'),
    report.split('\n').map(line => '    ' + line).join('\n'),
    '## Historical example\n\n' + report,
    '## Quoted source\n\n' + report,
    'An unproven hypothesis.\n\n' + report,
    'The following is a hypothetical example.\n\n' + report,
  ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
  expect(hasStaleFillRaceFinding('## Historical example\nOld material.\n\n## Current review\n' + report)).toBe(true);
  expect(hasStaleFillRaceFinding(report + '\n## Unrelated issue\nF2 is rejected.')).toBe(true);
});

test('source framing remains attached to descendant registry headings', () => {
  for (const prefix of [
    '## Copied material\nThe following subsections reproduce source examples, not current findings.\n\n',
    '## Input material\nThe following sections quote historical examples.\n\n',
    'The following subsections reproduce source examples, not current findings.\n\n',
  ]) expect(hasStaleFillRaceFinding(prefix + report)).toBe(false);
  expect(hasStaleFillRaceFinding('## Source notes\nThe following material quotes historical examples.\n\n## Current findings\n' + report)).toBe(true);
});

test('same finding assessments retain identity across sections and unrelated findings', () => {
  for (const suffix of [
    '## F1 assessment\nThis finding is withdrawn.',
    '## Final assessment\nF1 is rejected.',
    '## F2\nUnrelated issue accepted.\n\n## Final assessment\nF1 is dismissed.',
  ]) expect(hasStaleFillRaceFinding(report + '\n\n' + suffix)).toBe(false);
  for (const suffix of [
    '## F2 assessment\nThis finding is withdrawn.',
    '## Final assessment\nF2 is rejected.',
    '## Quoted source\nF1 is rejected.',
    '## Source notes\nThe following subsections quote historical examples.\n\n### F1 assessment\nThis finding is withdrawn.',
  ]) expect(hasStaleFillRaceFinding(report + '\n\n' + suffix)).toBe(true);
});
});

describe('sdk-order-b-ag', () => {
const captured = captured_sdk_order_b_ag;
const compactFirst = () => `${captured.first.finding}\n\n${captured.first.heading}\n\`\`\`\n${captured.first.trace}\n\`\`\``;
const compactRetry = () => `${captured.retry.finding}\n\n${captured.retry.heading}\n\`\`\`\n${captured.retry.trace}\n\`\`\``;

test('actual first completed report proves a later stale cache hit', () => {
  expect(hasStaleFillRaceFinding(captured.first.report)).toBe(true);
});

test('isolated Order B proves a later stale cache hit', () => {
  expect(hasStaleFillRaceFinding(compactFirst())).toBe(true);
});

test('actual retry and its explicit original-sketch override establish the unsafe execution', () => {
  expect(hasStaleFillRaceFinding(captured.retry.report)).toBe(true);
  expect(hasStaleFillRaceFinding(compactRetry())).toBe(true);
});

function replaceOnce(text: string, before: string, after: string): string {
  expect(text.includes(before)).toBe(true);
  return text.replace(before, after);
}

test('original-caller return or flight joining alone cannot supply the later cache reader', () => {
  for (const [before, after] of [
    ['  Order B: R2 begins after t5 -> cache hit v1  VIOLATION (until TTL or next write)\n', ''],
    ['Order B: R2 begins after t5', 'Order B: R1 begins after t5'],
    ['Order B: R2 begins after t5', 'Order B: R2 begins before t3'],
    ['Order B: R2 begins after t5', 'Order B: R2 begins after t2'],
    ['cache hit v1  VIOLATION', 'fresh DB read v2'],
    ['cache hit v1  VIOLATION', 'cache hit v2  SAFE'],
  ]) expect(hasStaleFillRaceFinding(replaceOnce(compactFirst(), before!, after!))).toBe(false);
});

test('all read, commit, invalidation and late-fill operations retain shared key and version ownership', () => {
  for (const [before, after] of [
    ['R1 readProfile(k)', 'R1 readProfile(other)'],
    ['W writeProfile(k, v2)', 'W writeProfile(other, v2)'],
    ['R2 readProfile(k)', 'R2 readProfile(other)'],
    ['cache[k]', 'cache[other]'],
    ['inflight[k]', 'inflight[other]'],
    ['set(k, v1)', 'set(other, v1)'],
    ['set(k, v1)', 'set(k, v2)'],
    ['read resolves v1; set(k, v1)', 'read resolves v2; set(k, v1)'],
    ['miss; flight f1; await read', 'cache hit v1; return'],
    ['await write ... commit v2', 'await write ... abort'],
    ['delete(k) no-op; return', 'delete(other) no-op; return'],
    ['delete(k) no-op; return', 'write still pending'],
    ['read resolves v1; set(k, v1)', 'read resolves v1; return to R1 only'],
    ['v1  BAD  | -', 'v2  SAFE | -'],
  ]) expect(hasStaleFillRaceFinding(replaceOnce(compactFirst(), before!, after!))).toBe(false);
});

test('quoted, conditional and impossible schedules are not actual asserted execution', () => {
  const report = compactFirst();
  for (const changed of [
    report.split('\n').map(line => `> ${line}`).join('\n'),
    `\`\`\`markdown\n${report}\n\`\`\``,
    `An unproven hypothesis:\n${report}`,
    replaceOnce(report, 'Schedule below shows', 'An unproven hypothesis: Schedule below shows'),
    replaceOnce(report, 'Order B: R2 begins', 'Order B: If R2 begins'),
    replaceOnce(report, 'Order B: R2 begins', 'Order B: R2 never begins'),
    replaceOnce(report, 'Order B: R2 begins after t5 -> cache hit v1  VIOLATION', 'Order B: R2 begins after t5 -> cache hit v1  VIOLATION?'),
    report + '\nThis trace is impossible.',
    report + '\n\nThe trace is impossible.',
  ]) expect(hasStaleFillRaceFinding(changed)).toBe(false);
});

test('one finding owns the original trace and every same-row assessment', () => {
  const report = compactFirst();
  for (const changed of [
    replaceOnce(report, 'Async schedule (F1)', 'Async schedule (F9)'),
    replaceOnce(report, '| F1 |', '| F9 |'),
    replaceOnce(report, 'Fills overlapping a write are not cached (bounded hit-rate cost, visible in metric)', 'There is no stale-fill race.'),
    replaceOnce(report, 'Fills overlapping a write are not cached (bounded hit-rate cost, visible in metric)', 'Rejected: "There is no stale-fill race."'),
    replaceOnce(report, 'D3: single-flight `invalidate(key)` before and after the write; invalidated fills never `set`; `fill_discarded` metric', 'The stale-fill behavior is accepted. No guard is required.'),
  ]) expect(hasStaleFillRaceFinding(changed)).toBe(false);
});

test('retry amendment alone and unasserted original-sketch annotations cannot prove a stale fill', () => {
  const original = 'Original sketch: step 6 fills v1 after step 4 → R2 hits v1 → VIOLATION (S1).';
  for (const replacement of [
    '',
    `"${original}"`,
    `> ${original}`,
    `If ${original}`,
    `Example: ${original}`,
    original.replace('fills v1', 'does not fill v1'),
    original.replace('VIOLATION (S1).', 'VIOLATION (S1)?'),
    original.replace('fills v1', 'fills v2'),
    original.replace('after step 4', 'before step 4'),
    original.replace('after step 4', 'after step 3'),
    original.replace('step 6 fills', 'step 7 fills'),
    original.replace('R2 hits v1', 'R1 receives v1'),
    original.replace('R2 hits v1', 'R2 hits v2'),
    original.replace('(S1)', '(S9)'),
  ]) expect(hasStaleFillRaceFinding(replaceOnce(compactRetry(), original, replacement))).toBe(false);
  expect(hasStaleFillRaceFinding(compactRetry() + '\n\nThe trace is impossible.')).toBe(false);
});

test('retry original override is bound to the same actors, cancelled token and completed write', () => {
  for (const [before, after] of [
    ['R1 read (began before commit)', 'R1 read (began after commit)'],
    ['R2 read (began after W resolves)', 'R2 read (began before W resolves)'],
    ['R2 read (began after W resolves)', 'R2 read (other key, began after W resolves)'],
    ['invalidate: cancel t1, detach, delete', 'invalidate: cancel other, detach, delete'],
    ['writeProfile resolves (write "complete")', 'writeProfile still pending'],
    ['await repo.write → v2 committed', 'await repo.write → aborted'],
    ['read resolves v1; t1✗ → no fill', 'read resolves v2; t1✗ → no fill'],
    ['read resolves v1; t1✗ → no fill', 'read resolves v1; other✗ → no fill'],
    ['S1: R1 misses, W commits and deletes, R1 fills stale v1, R2 hits v1.', 'S1: R1 misses, W commits and deletes, R1 fills stale v1, R1 receives v1.'],
    ['### 4. Async schedule (F1)', '### 4. Async schedule (F9)'],
  ]) expect(hasStaleFillRaceFinding(replaceOnce(compactRetry(), before!, after!))).toBe(false);
});

test('consistent actor, key, version and pending-identity renaming preserves each causal proof', () => {
  const names: Record<string, string> = {
    R1: 'R7', R2: 'R8', W: 'W9', k: 'profile_key', v1: 'oldValue', v2: 'newValue',
    f1: 'flight_old', f2: 'flight_new', t1: 'token_old', t2: 'token_new',
  };
  for (const report of [compactFirst(), compactRetry()]) {
    const renamed = report.replace(/\b(?:R1|R2|W|k|v1|v2|f1|f2|t1|t2)\b/g, token => names[token]!);
    expect(hasStaleFillRaceFinding(renamed)).toBe(true);
  }
});

test('current findings cannot borrow assertion authority from a hypothetical preceding frame', () => {
  for (const report of [compactFirst(), compactRetry()]) {
    for (const prefix of ['An unproven hypothesis.', 'Historical example only.', 'The following is a hypothetical example.']) {
      expect(hasStaleFillRaceFinding(`${prefix}\n\n${report}`)).toBe(false);
    }
    expect(hasStaleFillRaceFinding(`## Prior example\nA completed historical illustration.\n\n## Current findings\n${report}`)).toBe(true);
  }
});
});

describe('sdk-ordered-schedule-ar', () => {
const fs = fs_sdk_ordered_schedule_ar;
const report = fs.readFileSync(new URL('./fixtures/sdk-ordered-schedule-ar.md', import.meta.url), 'utf8');
const row = report.split('\n').find(line => line.startsWith('| F1 |'))!;
const schedule = 'Schedule: read misses, write commits and deletes (no-op), read resolves and stores the pre-write snapshot. A later read hits the stale value';

test('an actual review supplies the stale-fill ordering without a concurrency keyword', () => {
  expect(row).toContain(schedule);
  expect(row).not.toMatch(/\b(?:race|concurrent|in-flight|pending)\b/i);
  expect(hasStaleFillRaceFinding(row)).toBe(true);
  expect(hasStaleFillRaceFinding(report)).toBe(true);
  expect(hasStaleFillRaceFinding(row.replace('Original sketch', 'Original wrapper'))).toBe(true);
  expect(hasStaleFillRaceFinding(row.replace('pre-write snapshot', 'old value'))).toBe(true);
  expect(hasStaleFillRaceFinding(row.replace('A later read', 'The subsequent read'))).toBe(true);
  expect(hasStaleFillRaceFinding(row.replaceAll('"', ''))).toBe(true);
});

test('every operation and the stale value observed by a later read are required', () => {
  for (const [from, to] of [
    ['read misses, ', ''],
    ['write commits and deletes (no-op), ', ''],
    ['write commits and deletes', 'write rolls back and deletes'],
    ['write commits and deletes', 'write commits without deleting'],
    ['read resolves and stores the pre-write snapshot', 'read resolves and skips the fill'],
    ['read resolves and stores the pre-write snapshot', 'read resolves and stores the fresh snapshot'],
    ['A later read hits the stale value', 'The original read returns its own pre-write snapshot'],
    ['A later read hits the stale value', 'A later read hits the fresh value'],
    ['write commits and deletes (no-op), read resolves and stores the pre-write snapshot', 'read resolves and stores the pre-write snapshot, write commits and deletes (no-op)'],
    ['write commits and deletes (no-op), read resolves', 'write commits and deletes (no-op) | read resolves'],
    ['read resolves and stores', 'another reader resolves and stores'],
    ['write commits and deletes (no-op)', 'write commits and deletes another key'],
  ]) {
    expect(row).toContain(from);
    expect(hasStaleFillRaceFinding(row.replace(from, to))).toBe(false);
  }
});

test('copied, conditional, quoted and hypothetical schedules cannot supply current evidence', () => {
  for (const text of [
    '> ' + row,
    '```text\n' + row + '\n```',
    '## Historical example\n' + row,
    'Source:\n' + row,
    'Earlier review:\n' + row,
    row.replace('Original sketch fills', 'Original sketch source excerpt only: fills'),
    row.replace('Original sketch fills', 'Original sketch from an earlier review fills'),
    row.replace('Schedule:', '\nFinding F2. Schedule:'),
    '## Source notes\nThe following material is copied from a template.\n' + row,
    row.replace('Original sketch', 'Quoted original sketch'),
    row.replace('Schedule: read misses', 'Schedule: if a read misses'),
    row.replace('Schedule: read misses', 'Hypothetical schedule: read misses'),
    row.replace('read resolves and stores', 'read never resolves and stores'),
    row.replace(schedule, '"' + schedule + '"'),
    row.replace(schedule, '`' + schedule + '`'),
    row.replace('read resolves and stores the pre-write snapshot', '`read resolves and stores the pre-write snapshot`'),
    row.replace('Flag flip mid-read has the same shape.', 'This sequence is impossible.'),
  ]) expect(hasStaleFillRaceFinding(text)).toBe(false);
});

test('a current dismissal stays a dismissal even when the original schedule is complete', () => {
  for (const suffix of [
    'F1 is withdrawn.',
    'F1 is "withdrawn".',
    'F1 is “withdrawn”.',
    'F1 is rejected.',
    'This finding is dismissed.',
    'This is not a bug; no fix is needed.',
    'The stale-fill behavior is permitted.',
  ]) expect(hasStaleFillRaceFinding(row + '\n\n' + suffix)).toBe(false);
  expect(hasStaleFillRaceFinding(row + '\n\nF2 is rejected.')).toBe(true);
  expect(hasStaleFillRaceFinding('## Historical example\nOld material.\n\n## Current findings\n' + row)).toBe(true);
});
});

describe('sdk-ordering-ae', () => {
const fixture = fixture_sdk_ordering_ae;
const found = hasStaleFillRaceFinding;
const trace = fixture.f1.split('|')[4]!.trim();
function withTrace(value: string): string {
  const cells = fixture.f1.split('|');
  cells[4] = ` ${value} `;
  return cells.join('|');
}

test('actual completed F1 report row supplies ordered stale-fill evidence without a race keyword', () => {
  expect(found(fixture.f1)).toBe(true);
  expect(fixture.provenance.historicalOutcome).toContain('timeout480032ms');
  expect(trace).not.toMatch(/\b(?:race|in-flight|concurrent|pending)\b/i);
  expect(found(`F1 — P1: ${trace}`)).toBe(true);
});

test('ordering evidence requires miss, committed invalidation, stale refill and later stale readers', () => {
  for (const value of [
    'Reader fills the pre-commit snapshot; write commits and deletes; read misses; every later reader sees stale data.',
    'Read misses; reader then fills the pre-commit snapshot; write commits and deletes; every later reader sees stale data.',
    'Write commits and deletes; read misses; reader then fills the pre-commit snapshot; every later reader sees stale data.',
    'Read misses; reader then fills the pre-commit snapshot; every later reader sees stale data.',
    'Read misses, write commits; reader then fills the pre-commit snapshot; every later reader sees stale data.',
    'Read misses, write commits and deletes; every later reader sees stale data.',
    'Read misses, write commits and deletes; reader then fills the post-commit snapshot; every later reader sees fresh data.',
    'Read misses, write commits and deletes; the original reader returns its pre-commit snapshot to its own caller; every later reader sees fresh data.',
  ]) expect(found(withTrace(value))).toBe(false);
});

test('explicit other cache, key or reader references cannot borrow the anonymous same-read trace', () => {
  for (const value of [
    'Read misses cache A, write commits and deletes cache B, reader then fills cache A with the pre-commit snapshot; every later reader sees stale data in cache A.',
    'Read misses key u1, write commits and deletes key u2, reader then fills key u1 with the pre-commit snapshot; every later reader sees stale data for key u1.',
    'Read R1 misses, write commits and deletes, reader R2 then fills the pre-commit snapshot; every later reader sees stale data.',
  ]) expect(found(withTrace(value))).toBe(false);
});

test('hypothetical, negated and unestablished traces do not assert a current defect', () => {
  for (const value of [
    `If ${trace[0]!.toLowerCase()}${trace.slice(1)}`,
    `A hypothetical example: ${trace}`,
    `An unproven hypothesis: ${trace}`,
    `The following trace is impossible: ${trace}`,
    `An unrelated illustration: ${trace}`,
    `It is unclear whether this happens: ${trace}`,
    `This trace did not occur: ${trace}`,
    trace.replace('Read misses', 'Read may miss'),
    trace.replace('write commits and deletes', 'write does not commit or delete'),
    trace.replace('reader then fills', 'reader never fills'),
    trace.replace('every later reader sees stale data', 'every later reader never sees stale data'),
    'Read misses, write commits and deletes, reader then fills the pre-commit snapshot; every later reader sees stale data?',
    'Read misses, write commits and deletes, reader then fills the pre-commit snapshot; every later reader sees stale data. This scenario is impossible.',
  ]) expect(found(withTrace(value))).toBe(false);
});

test('copied source and independent rows or cells cannot supply missing ordered operations', () => {
  for (const value of [`> ${fixture.f1}`, `    ${fixture.f1}`, `\t${fixture.f1}`,
    `\`\`\`text\n${fixture.f1}\n\`\`\``, `~~~text\n${fixture.f1}\n~~~`]) expect(found(value)).toBe(false);
  const first = withTrace('Read misses; write commits and deletes.');
  const last = withTrace('Reader then fills the pre-commit snapshot; every later reader sees stale data.').replace('| F1 |', '| F2 |');
  expect(found(first + '\n' + last)).toBe(false);
  const cells = fixture.f1.split('|');
  cells[4] = ' Read misses; write commits and deletes. ';
  cells[6] = ' Reader then fills the pre-commit snapshot; every later reader sees stale data. ';
  expect(found(cells.join('|'))).toBe(false);
  expect(found(first + '\n\n> ' + trace)).toBe(false);
  expect(found(withTrace(`"${trace}" is a copied source example, not an observed defect.`))).toBe(false);
});

test('a real trace still rejects dismissal or acceptance of the later stale consequence', () => {
  for (const suffix of [' No fix is required.', ' This stale-read behavior is accepted.', ' There is no stale-fill race.',
    ' Later readers may return stale data and that is permitted.']) expect(found(withTrace(trace + suffix))).toBe(false);
  expect(found(withTrace(trace + ' Original reader returns v1 to its own caller (allowed: it began before commit).'))).toBe(true);
  expect(found(withTrace(trace + ' Later reader returns v1 to its own caller (allowed: it began after commit).'))).toBe(false);
});
});

describe('sdk-original-order-ai', () => {
const captured = captured_sdk_original_order_ai;
const compact = () => `### Findings registry\n\n${captured.finding}\n\n${captured.heading}\n\`\`\`\n${captured.trace}\n\`\`\``;
const rejects = (changes: Array<[string, string]>) => {
  for (const [before, after] of changes) {
    expect(compact()).toContain(before);
    expect(hasStaleFillRaceFinding(compact().replace(before, after))).toBe(false);
  }
};

describe('asserted original order beside an amended cache schedule', () => {
  test('exact completed report and its owned finding/schedule show the original late-fill violation', () => {
    expect(hasStaleFillRaceFinding(captured.report)).toBe(true);
    expect(hasStaleFillRaceFinding(compact())).toBe(true);
  });

  test('amended behavior or the original caller allowance cannot replace the original stale-fill evidence', () => {
    const original = 'Original sketch, order A: fill V1 at 6 after delete at 4 -> R2 reads V1 for <=30 s  VIOLATION';
    rejects([
      [original, ''], [original, 'Not ' + original], [original, '> ' + original],
      [original, '"' + original + '"'], [original, 'If ' + original],
      [original, original.replace('VIOLATION', 'PERMITTED')],
      [original, original.replace('R2 reads', 'R1 reads')],
      [original, original.replace('fill V1', 'skip fill V1')],
      [original, original.replace('after delete at 4', 'before delete at 4')],
    ]);
  });

  test('reader, writer, cache key, versions and completion order must all refer to the same execution', () => {
    rejects([
      ['inflight[k]', 'inflight[foreign]'], ['R1 (began before W)', 'R1 (began after W)'],
      ['DB write commits V2', 'DB write commits V1'], ['DB returns V1', 'DB returns V2'],
      ['resume: invalidate(E1), delete', 'resume: invalidate(E9), delete'],
      ['settles -> W complete', 'settles -> W pending'],
      ['resume: E1.stale -> skip fill', 'resume: E9.stale -> skip fill'],
      ['7 | R2 begins:', '4.5 | R2 begins:'], ['R2 reads V1 for', 'R2 reads V2 for'],
      ['fill V1 at 6 after delete at 4', 'fill V1 at 3 after delete at 4'],
      ['cache[k]', 'cache[foreign]'],
    ]);
  });

  test('the current finding owns the trace and must independently assert the invariant violation', () => {
    rejects([
      ['schedule (F1,', 'schedule (F2,'], ['| F1 | CRITICAL |', '| F2 | CRITICAL |'],
      ['| F1 | CRITICAL |', '| F1 | LOW |'],
      ['Schedule in Section 4 shows', 'A hypothetical Schedule in Section 4 shows'],
      ['filled after `cache.delete`', 'filled before `cache.delete`'],
      ['every read begun after that write completes must observe the committed version', 'earlier values are accepted for later readers'],
    ]);
    expect(hasStaleFillRaceFinding(compact().replace(captured.finding, captured.finding + '\n' + captured.finding))).toBe(false);
  });

  test('source and hypothetical framing cannot supply the assertion', () => {
    for (const prefix of ['An unproven hypothesis.', 'Historical example only.', 'The following is a hypothetical example.']) {
      expect(hasStaleFillRaceFinding(prefix + '\n' + compact())).toBe(false);
      expect(hasStaleFillRaceFinding(compact().replace(captured.heading, prefix + '\n' + captured.heading))).toBe(false);
    }
    expect(hasStaleFillRaceFinding(compact().split('\n').map(line => '> ' + line).join('\n'))).toBe(false);
    expect(hasStaleFillRaceFinding('````text\n' + compact() + '\n````')).toBe(false);
    expect(hasStaleFillRaceFinding(compact().replace('### Findings registry', '### Quoted source'))).toBe(false);
  });

  test('same-finding direct and quoted withdrawals remain authoritative inside or after the trace', () => {
    for (const withdrawal of ['F1 is withdrawn.', 'F1 is rejected.', 'The original schedule is impossible.', 'There is no stale-fill race.', 'Rejected: "There is no stale-fill race."']) {
      expect(hasStaleFillRaceFinding(compact() + '\n\n' + withdrawal)).toBe(false);
      expect(hasStaleFillRaceFinding(compact().replace(captured.trace, captured.trace + '\n' + withdrawal))).toBe(false);
      expect(hasStaleFillRaceFinding(compact().replace('Ordering tests, both orders + late joiner + sentinel variant', withdrawal))).toBe(false);
    }
    expect(hasStaleFillRaceFinding(compact().replace('Readers that began before the write may still see the old snapshot (permitted by contract)', 'Later readers may see old snapshots; this stale-fill behavior is accepted.'))).toBe(false);
  });

  test('unrelated sections and consistently renamed identities do not change valid evidence', () => {
    expect(hasStaleFillRaceFinding('### Prior example\nHistorical example only.\n\n### Current review\n' + compact())).toBe(true);
    expect(hasStaleFillRaceFinding(compact() + '\n\n### Other finding\nF2 is rejected.')).toBe(true);
    const renamed = compact().replaceAll('R1', 'R7').replaceAll('R2', 'R8').replaceAll('R3', 'R9')
      .replaceAll('V1', 'oldSnapshot').replaceAll('V2', 'newSnapshot').replaceAll('E1', 'pendingA').replaceAll('E2', 'pendingB')
      .replaceAll('[k]', '[profileKey]').replace(/\bW\b/g, 'W2');
    expect(hasStaleFillRaceFinding(renamed)).toBe(true);
  });

  test('owning source headings and same-finding assessments survive intervening structure', () => {
    for (const heading of ['## Hypothetical example', '## Quoted source', '## Historical example only']) {
      expect(hasStaleFillRaceFinding(heading + '\n' + compact())).toBe(false);
    }
    expect(hasStaleFillRaceFinding(compact().replace(captured.heading,
      'F1 is rejected.\n\nUnrelated diagram:\n```\nA -> B\n```\n\n' + captured.heading))).toBe(false);
    expect(hasStaleFillRaceFinding(compact() + '\n\n### Assessment of F1\nF1 is rejected.')).toBe(false);
  });
});

const retry = () => `## Findings Registry\n\n${captured.retry.finding}\n\n${captured.retry.heading}\n\`\`\`\n${captured.retry.trace}\n\`\`\``;
describe('version-labelled original prose with its owned schedule', () => {
  test('the exact retry and compact evidence require the original sequence, not amended prevention', () => {
    expect(hasStaleFillRaceFinding(captured.retry.report)).toBe(true);
    expect(hasStaleFillRaceFinding(retry())).toBe(true);
  });

  test('each version and shared key must agree, with write completion before the later reader', () => {
    for (const [before, after] of [
      ['DB returns v1', 'DB returns v2'], ['write commits v2 and', 'write commits v1 and'],
      ['read then fills v1;', 'read then fills v2;'], ['every later read gets v1', 'every later read gets v2'],
      ['write commits v2 and', 'write commits v3 and'], ['writeGen[key]', 'writeGen[foreign]'],
      ['cache[key]', 'cache[foreign]'], ['R2 (read, began after W)', 'R2 (read, began before W)'],
      ['delete (no-op), return', 'delete (no-op), pending'], ['DB SELECT -> v1', 'DB SELECT -> v2'],
      ['DB UPDATE commits v2', 'DB UPDATE commits v3'], ['promise resolves, set(v1)', 'promise resolves, set(v2)'],
      ['get -> v1  VIOLATION', 'get -> v2  VIOLATION'], ['6 sketch', '3 sketch'],
      ['3                                                     DB UPDATE commits v2', '3                       DB UPDATE commits v2'],
    ]) {
      expect(retry()).toContain(before);
      expect(hasStaleFillRaceFinding(retry().replace(before, after))).toBe(false);
    }
    expect(hasStaleFillRaceFinding(retry().replace(captured.retry.trace, captured.retry.trace.split('\n').filter(line => !/\b[456] sketch\b/.test(line)).join('\n')))).toBe(false);
  });

  test('conditional, quoted, obsolete or withdrawn evidence cannot become a current finding', () => {
    for (const prefix of ['An unproven hypothesis.', 'Historical example only.', 'The following is a hypothetical example.']) {
      expect(hasStaleFillRaceFinding(prefix + '\n' + retry())).toBe(false);
      expect(hasStaleFillRaceFinding(retry().replace('Late fill after write.', prefix + ' Late fill after write.'))).toBe(false);
    }
    for (const heading of ['## Hypothetical example', '## Quoted source', '## Historical example only']) {
      expect(hasStaleFillRaceFinding(heading + '\n' + retry().replace('## Findings Registry', '### Findings Registry'))).toBe(false);
    }
    for (const withdrawal of ['F1 is rejected.', 'S1 is withdrawn.', 'The original schedule is impossible.', 'There is no stale-fill race.', 'Rejected: "There is no stale-fill race."']) {
      expect(hasStaleFillRaceFinding(retry() + '\n\n' + withdrawal)).toBe(false);
      expect(hasStaleFillRaceFinding(retry() + '\n\n### Assessment of F1\n' + withdrawal)).toBe(false);
      expect(hasStaleFillRaceFinding(retry().replace(' S2 join stale flight', withdrawal + '\n S2 join stale flight'))).toBe(false);
    }
    for (const withdrawal of ['S1 is withdrawn.', 'F1 is rejected.']) {
      expect(hasStaleFillRaceFinding(retry().replace(captured.retry.trace, captured.retry.trace + '\n' + withdrawal))).toBe(false);
    }
    expect(hasStaleFillRaceFinding(retry().split('\n').map(line => '> ' + line).join('\n'))).toBe(false);
    expect(hasStaleFillRaceFinding('````\n' + retry() + '\n````')).toBe(false);
    expect(hasStaleFillRaceFinding(retry().replace('Late fill after write.', 'If a late fill happens after write.'))).toBe(false);
  });

  test('consistent versions and independent later findings remain valid', () => {
    expect(hasStaleFillRaceFinding(retry().replaceAll('v1', 'v7').replaceAll('v2', 'v8').replaceAll('[key]', '[profileKey]').replaceAll('key#1', 'profileKey#1'))).toBe(true);
    expect(hasStaleFillRaceFinding('## Prior example\nHistorical only.\n\n## Current review\n' + retry().replace('## Findings Registry', '### Findings Registry'))).toBe(true);
    expect(hasStaleFillRaceFinding(retry() + '\n\n### Other finding\nF9 is rejected.')).toBe(true);
  });
});
});

describe('sdk-reported-coordination-ar', () => {
const fs = fs_sdk_ordered_schedule_ar;
const report = fs.readFileSync(new URL('./fixtures/sdk-reported-coordination-ar.md', import.meta.url), 'utf8');
const paragraph = report.split('\n\n').find(text => text.startsWith('## Proposed wrapper integration'))!.split('\n').slice(1).join('\n');
const matches = (text = paragraph) => hasStaleFillRaceFinding(text);

test('the actual retry independently reports the original coordination violation', () => {
  expect(paragraph).toContain('review found that this violates the read-after-write rule above (F1)');
  expect(paragraph).not.toMatch(/stale|in-flight|race|pending/);
  expect(matches()).toBe(true);
  expect(matches(report)).toBe(true);
  expect(matches(paragraph.replace('proposed no coordination', 'had no coordination'))).toBe(true);
  expect(matches(paragraph.replace('proposed no coordination', 'has no coordination'))).toBe(true);
  expect(matches(paragraph.replace('sketch', 'wrapper'))).toBe(true);
  expect(matches(paragraph.replace('rule above', 'contract'))).toBe(true);
  expect(matches(paragraph.replace(/ and omits[\s\S]*/, '.'))).toBe(true);
});

test('missing or hypothetical premise and conclusion cannot become findings', () => {
  for (const [from, to] of [
    ['proposed no coordination', 'proposed coordination'],
    ['proposed no coordination', 'may propose no coordination'],
    ['review found that this violates', 'review may find that this violates'],
    ['review found that this violates', 'review found that this does not violate'],
    ['review found that this violates', 'review hypothesized that this violates'],
    ['review found that this violates', 'review found that another wrapper violates'],
    ['read-after-write rule above', 'formatting rule'],
    ['(F1)', '(unknown)'],
    ['; the\nreview found', '. Another unrelated finding. The\nreview found'],
    ['; the\nreview found', '\n\nThe\nreview found'],
    ['; the\nreview found', ' | The\nreview found'],
  ]) {
    expect(paragraph).toContain(from);
    expect(matches(paragraph.replace(from, to))).toBe(false);
  }
});

test('source and quoted evidence cannot assert the current violation', () => {
  for (const text of [
    'Source:\n\n' + paragraph,
    'Hypothetical scenario. ' + paragraph,
    'Earlier review:\n\n' + paragraph,
    '## Historical example\n' + paragraph,
    '> ' + paragraph.replaceAll('\n', '\n> '),
    '```text\n' + paragraph + '\n```',
    '~~~text\n' + paragraph + '\n~~~',
    paragraph.replace('original sketch proposed no coordination between a cache fill and a write', '`original sketch proposed no coordination between a cache fill and a write`'),
    paragraph.replace('review found that this violates the read-after-write rule above (F1)', '"review found that this violates the read-after-write rule above (F1)"'),
  ]) expect(matches(text)).toBe(false);
});

test('the referenced finding owns its later assessment', () => {
  for (const tail of ['F1 is withdrawn.', 'F1 is "withdrawn".', 'F1 is rejected.', 'This finding is dismissed.', 'No coordination is required.', '| ID | Assessment |\n| F1 | Withdrawn: no coordination is required. |', '| F1 | Withdrawn |', '| F1 | "rejected" |']) {
    expect(matches(paragraph + '\n\n' + tail)).toBe(false);
  }
  expect(matches(paragraph + '\n\nF2 is withdrawn.')).toBe(true);
  expect(matches(paragraph + '\n\n| F2 | Withdrawn |')).toBe(true);
  expect(matches(paragraph + '\n\n## Historical assessment\n| F1 | Withdrawn |')).toBe(true);
  expect(matches('## Earlier material\nSource:\nOld source.\n\n## Current findings\n' + paragraph)).toBe(true);
});
});

describe('sdk-schedule-continuation-ah', () => {
const fixture = fixture_sdk_schedule_continuation_ah;
const frame = fixture.compact;
function replace(from: string, to: string, input = frame): string {
  expect(input.includes(from)).toBe(true);
  return input.replace(from, to);
}
const originalRows = '  S2*   | await read ...             | write commits, delete(noop) |                     | -          |\n'
  + '        | resolves V0 → set V0       |                             | hit → V0            | V0 (30 s)  | VIOLATION\n';

test('retains both exact public report forms as affirmative original-race findings', () => {
  expect(hasStaleFillRaceFinding(fixture.report)).toBe(true);
  expect(hasStaleFillRaceFinding(frame)).toBe(true);
  expect(fixture.report.includes(frame.trim())).toBe(true);
});

test('binds consistently renamed actors, shared key, versions and finding/schedule IDs', () => {
  const renamed = frame.replace(/\bR1\b/g, 'R7').replace(/\bR2\b/g, 'R8').replace(/\bW\b/g, 'W9')
    .replace(/\bV0\b/g, 'oldValue').replace(/\bV1\b/g, 'freshValue')
    .replace(/\bkey\b/g, 'profile_key').replace(/\bF1\b/g, 'F9').replace(/\bS2\b/g, 'S9');
  expect(hasStaleFillRaceFinding(renamed)).toBe(true);
  expect(hasStaleFillRaceFinding(frame.replace(/→/g, '->'))).toBe(true);
  const unrelated = '## Historical example\nAn unrelated old example.\n\n## Current findings\n\n';
  expect(hasStaleFillRaceFinding(unrelated + frame)).toBe(true);
});

test('amendments, permitted earlier readers and missing continuation do not supply the original race', () => {
  for (const changed of [
    replace(originalRows, ''),
    replace('S2*   | await read', 'S2 A1 | await read'),
    replace(originalRows, '  S2* | begins before W, joins | delete + forget | — | — | OK: R1 began before W completed (permitted clause)\n'),
    replace('resolves V0 → set V0', 'resolves V0, slot gone→drop'),
    replace('hit → V0', 'miss→read V1→set'),
    replace('hit → V0', ''),
    replace('VIOLATION\n  S2 A1', 'OK (permitted earlier return)\n  S2 A1'),
    replace('VIOLATION\n  S2 A1', 'VIOLATION\n        | already guarded | | | | OK\n  S2 A1'),
  ]) expect(hasStaleFillRaceFinding(changed)).toBe(false);
});

test('requires the original schedule citation, legend and explicit post-completion boundary', () => {
  for (const changed of [
    replace('Schedule S2 makes', 'Schedule S9 makes'),
    replace('`*` = original sketch.', '`*` = amended sketch.'),
    replace('`*` = original sketch.', ''),
    replace('`*` = original sketch.', 'Hypothetically, `*` = original sketch.'),
    replace('CRITICAL GAP | 1, 2, 4, 5, 6', 'CRITICAL GAP | 1, 2, 5, 6'),
    replace('Violates retained invariant.', 'No defect in the retained invariant.'),
    replace('R2 (begins after W)', 'R2 (begins before W)'),
    replace('after `writeProfile` resolves', 'before `writeProfile` resolves'),
    replace('after `writeProfile` resolves', 'after `writeProfile` begins'),
    replace('after `writeProfile` resolves', 'after `readProfile` resolves'),
  ]) expect(hasStaleFillRaceFinding(changed)).toBe(false);
});

test('rejects actor, key, value, invalidation and ordering mismatches', () => {
  for (const changed of [
    replace('R2 (begins after W)', 'R1 (begins after W)'),
    replace('R2 (begins after W)', 'R2 (begins after W9)'),
    replace('`inflight[key]`', '`inflight[other_key]`'),
    replace('| cache[key] | Result', '| cache[other_key] | Result'),
    replace('W (commits V1)', 'W (commits V0)'),
    replace('resolves V0 → set V0', 'resolves V1 → set V0'),
    replace('resolves V0 → set V0', 'resolves V0 → set V1'),
    replace('hit → V0', 'hit → V1'),
    replace('write commits, delete(noop)', 'write begins, delete(noop)'),
    replace('write commits, delete(noop)', 'write commits'),
    replace('await read ...', 'await write ...'),
    replace(originalRows, originalRows.split('\n').slice(0, 2).reverse().join('\n') + '\n'),
    replace('V0 (30 s)  | VIOLATION', 'V1 (30 s)  | VIOLATION'),
    replace('see V0 for 30 s;', 'see V1 for 30 s;'),
  ]) expect(hasStaleFillRaceFinding(changed)).toBe(false);
});

test('quotes, source introductions and withdrawn findings remain negative', () => {
  for (const prefix of ['An unproven hypothesis.', 'Historical example only.', 'The following is a hypothetical example.']) {
    expect(hasStaleFillRaceFinding(prefix + '\n\n' + frame)).toBe(false);
    expect(hasStaleFillRaceFinding(replace('### Async Ordering Record', prefix + '\n\n### Async Ordering Record'))).toBe(false);
    expect(hasStaleFillRaceFinding(replace('### Findings Registry\n', '### Findings Registry\n\n' + prefix))).toBe(false);
  }
  expect(hasStaleFillRaceFinding(frame.split('\n').map(line => '> ' + line).join('\n'))).toBe(false);
  expect(hasStaleFillRaceFinding('````text\n' + frame + '\n````')).toBe(false);
  expect(hasStaleFillRaceFinding(replace('```\n  Sched', '```javascript\n  Sched'))).toBe(false);
  for (const dismissal of [
    'The original trace is impossible.', 'This schedule is not a bug.',
    'The original race is permitted.', 'The stale fill is accepted.',
    'No coordination is required.',
  ]) {
    expect(hasStaleFillRaceFinding(frame + '\n' + dismissal)).toBe(false);
    expect(hasStaleFillRaceFinding(replace('Violates retained invariant.', 'Violates retained invariant. ' + dismissal))).toBe(false);
  }
});


test('completed prior decision section is independent; spoofed or withdrawn framing is not', () => {
  const close = '### Decision Registry (all auto-resolved to recommended option)\n\n| D1 | A | B |\n\nLake Score: 7/7 recommendations chose the complete option.\n\n';
  expect(hasStaleFillRaceFinding(close + frame)).toBe(true);
  expect(hasStaleFillRaceFinding(close.replace('### Decision Registry (all auto-resolved to recommended option)', '### Historical example') + frame)).toBe(false);
  expect(hasStaleFillRaceFinding(close.replace('Lake Score: 7/7 recommendations chose the complete option.', 'An unproven hypothesis.') + frame)).toBe(false);
  const row = frame.split('\n').find(line => line.startsWith('| F1 |'))!;
  expect(hasStaleFillRaceFinding(replace(row, row + '\n' + row))).toBe(false);
});
test('same finding or schedule tail withdrawals remain authoritative', () => {
  for (const tail of ['S2 is impossible.', 'F1 is rejected. The original trace is impossible.', 'F1 is rejected.', 'S2 is withdrawn.']) {
    expect(hasStaleFillRaceFinding(frame + '\n' + tail)).toBe(false);
  }
  expect(hasStaleFillRaceFinding(frame + '\nF2 is rejected. The original trace is impossible.')).toBe(true);
  expect(hasStaleFillRaceFinding(frame + '\nS3 is impossible.')).toBe(true);
});
});

describe('sdk-stale-table-ad-v3', () => {
const fixture = fixture_sdk_stale_table_ad_v3;
const found = hasStaleFillRaceFinding;
const allowance='Original reader still returns v1 to its own caller (allowed: it began before commit)';
test('actual table finding distinguishes forbidden later stale reads from the permitted original caller',()=>{
 expect(found(fixture.report)).toBe(true);
 expect(found(fixture.table)).toBe(true);
 expect(fixture.provenance.noRetroactivePass).toBe(true);
});
test('the already-started original read may use a version label without changing ownership',()=>{
 for(const token of ['v17','VERSION_A','snapshot-A'])expect(found(fixture.table.replaceAll('v1',token))).toBe(true);
});
test('allowance cannot migrate to later readers, a post-commit start, or a cache fill',()=>{
 for(const changed of [
  'Later readers return v1 (allowed: they began after commit)',
  'Original reader still returns v1 to its own caller (allowed: it began after commit)',
  'Original reader still returns v1 to its own caller (allowed: it never began before commit)',
  'Original reader fills the cache with v1 (allowed: it began before commit)',
  'Original reader still returns v1 to later readers (allowed: it began before commit)',
 ])expect(found(fixture.table.replace(allowance,changed))).toBe(false);
});
test('a permitted original caller cannot hide acceptance of later stale reads or no required fix',()=>{
 for(const suffix of [' This stale-read behavior is accepted.',' No fix is required.',' Later readers may return stale data; this is the accepted consistency model.'])
  expect(found(fixture.table.replace('None against the invariant.','None against the invariant.'+suffix))).toBe(false);
});
test('copied table source and absent late-fill evidence cannot provide coverage',()=>{
 expect(found('```text\n'+fixture.table+'\n```')).toBe(false);
 expect(found(fixture.table.split('\n').map(x=>'> '+x).join('\n'))).toBe(false);
 expect(found(fixture.table.split('\n').map(x=>'    '+x).join('\n'))).toBe(false);
 const rows=fixture.table.split('\n'),cells=rows[2]!.split('|');
 cells[4]=' There is no stale-fill race; later reads observe the committed value. ';
 rows[2]=cells.join('|');expect(found(rows.join('\n'))).toBe(false);
});


test('original-caller exception requires asserted chronology for that reader',()=>{
 for(const changed of [
  'Original reader still returns v1 to its own caller (allowed: it may have begun before commit)',
  'Original reader still returns v1 to its own caller (allowed: it did not begin before commit)',
  'Original reader still returns v1 to its own caller (allowed: it began before commit only if the write failed)',
  'Original reader still returns v1 to its own caller (allowed: another reader began before commit)',
  'Original reader still returns v1 to its own caller (allowed: the write began before commit)',
  'If the original reader still returns v1 to its own caller, that is allowed: it began before commit',
 ])expect(found(fixture.table.replace(allowance,changed))).toBe(false);
});

test('an original-return allowance cannot erase another allowed stale consequence',()=>{
 for(const changed of [
  allowance+' and stores that v1 in the cache for later readers',
  allowance+'; later readers may reuse this old value and that is allowed',
  allowance+'. New readers may reuse this old value and that is permitted',
  allowance+'. The stale cache refill is acceptable',
 ])expect(found(fixture.table.replace(allowance,changed))).toBe(false);
});

test('table rows cannot borrow an ordering defect from another issue or from quoted source',()=>{
 const rows=fixture.table.split('\n'),cells=rows[2]!.split('|');
 const originalFailure=cells[4]!;
 cells[4]=' The original reader receives its pre-commit snapshot; later reads observe the committed version. ';
 const missing=rows.slice(0,2).concat(cells.join('|')).join('\n');
 expect(found(missing)).toBe(false);
 const other=cells.slice();other[1]=' D2 ';other[4]=originalFailure;
 other[5]=' This stale-read behavior is accepted; no fix is required. ';
 expect(found(missing+'\n'+other.join('|'))).toBe(false);
 expect(found('> '+originalFailure+'\n\n'+missing)).toBe(false);
 expect(found('```text\n'+originalFailure+'\n```\n\n'+missing)).toBe(false);
});
});

// Census 36597762183 slice 3: the final PLAN.md (rebuilt from the captured Edits)
// traced the race as an arrow-ordered execution in its WR-1 ledger row.
describe('arrow-ordered stale-fill execution', () => {
  const report = readFileSync(join(import.meta.dir, 'fixtures/ceo-section-loading-36597762183-report.md'), 'utf8');
  const trace = 'R1 miss -> R1 store read (v1) -> W commit v2 -> W cache.delete -> W fulfills -> R1 cache.set(v1) -> R2 (begun after W) hits v1.';
  test('the captured report identifies the seeded race', () => {
    expect(report).toContain(trace);
    expect(hasStaleFillRaceFinding(report)).toBe(true);
  });
  test.each([
    ['fill before invalidation', trace.replace('W cache.delete -> W fulfills -> R1 cache.set(v1)', 'R1 cache.set(v1) -> W cache.delete -> W fulfills')],
    ['later reader is the filling reader', trace.replace('R2 (begun after W)', 'R1 (begun after W)')],
    ['later reader began before the write', trace.replace('begun after W', 'begun before W')],
    ['fill stores the committed version', trace.replace('R1 cache.set(v1)', 'R1 cache.set(v2)')],
    ['later reader sees the committed version', trace.replace('hits v1.', 'hits v2.')],
    ['trace declared impossible', trace + ' This order is impossible here.'],
  ])('%s is not the seeded race', (_name, mutated) => {
    expect(hasStaleFillRaceFinding(report.replace(trace, mutated))).toBe(false);
  });
});