Files
gstack/test/review-packets-removed.test.ts
T
Garry Tanandcapy-ai[bot] 03900fc133 v1.94.12.0 fix(review-depth): character references and HTML comment ends no longer hide SVG style CSS (GST-940) (#3866)
* test(review-depth): style-body character references and HTML comment ends keep an SVG code (GST-940, failing)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(review-depth): walk SVG style bodies as written and read their comments as CSS (GST-940)

No-loss replay GST-940: 62,805 unique SVG files give the same verdict as main at 4bbad2422, and the planner over the last 100 first-parent main commits changes no depth, class or risk class. Repins lib/review-depth.ts on GST-940.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(review-depth): a quoted > on the style tag keeps an SVG code; plain style comments stay a drawing (GST-940, failing)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(review-depth): read the SVG style tag quote by quote (GST-940 red-team#1)

No-loss replay GST-940 rerun: 62,805 unique SVG files keep main's verdict and the planner over 100 main commits changes nothing. Repins lib/review-depth.ts on GST-940.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* docs(changelog): GST-940 lead names the three shapes

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(review-depth): non-ASCII spaces in </style> and non-ASCII name prefixes keep an SVG code (GST-940 fix-check, failing)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(review-depth): ASCII whitespace in SVG style tags, refuse non-ASCII element and attribute names (GST-940 fix-check)

Fixes round-2 red-team#1 and targeted#1 under the Captain's scoped fix-check grant. No-loss replay GST-940 rerun: 62,805 unique SVG files keep main's verdict; the planner over 100 main commits changes nothing. Repins lib/review-depth.ts on GST-940.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(review-packets-removed): repin lib/review-depth.ts on GST-940 after the main merge

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

---------

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>
2026-11-03 10:46:14 +00:00

242 lines
15 KiB
TypeScript

/**
* The reviewer-packet path from #3621 and #3636 was reverted after no-loss round 3
* (GSTA-167): packet reviewers found 10 of the 19 blockers the pre-#3621 reviewers find.
* This keeps the removed commands and modules gone and unreferenced, so a branch cut
* before the revert cannot bring back a dangling call to them through a merge.
*/
import { describe, test, expect } from 'bun:test';
import { spawnSync } from 'child_process';
import { createHash } from 'crypto';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import { sectionTexts } from '../lib/review-brief';
import { mergePinEdits, type PinMerge } from './helpers/pin-merge-fixture';
const ROOT = path.join(import.meta.dir, '..');
const REMOVED = [
'bin/gstack-review-packet',
'lib/review-packet.ts',
'lib/review-packet-collect.ts',
'lib/review-plan-live.ts',
'lib/review-prompts.ts',
];
const NAMES = /gstack-review-packet|review-packet-collect|review-plan-live|lib\/review-prompts|review-packet\.ts|READ_BUDGET|reviewer-packets|review-packets-fc|REVIEW_COVERAGE_INCOMPLETE|review-coverage-incomplete/;
const SELF = path.relative(ROOT, import.meta.path);
describe('reviewer packets stay reverted (GSTA-167)', () => {
test('the removed packet files do not exist', () => {
expect(REMOVED.filter(f => fs.existsSync(path.join(ROOT, f)))).toEqual([]);
});
test('no tracked file outside CHANGELOG.md names a removed packet file, the packet read rule or a packet-only anchor or code', () => {
const ls = spawnSync('git', ['ls-files', '-z'], { cwd: ROOT, encoding: 'utf8', timeout: 30_000, maxBuffer: 64 * 1024 * 1024 });
expect(ls.status).toBe(0);
const files = ls.stdout.split('\0').filter(f => f && f !== 'CHANGELOG.md' && f !== SELF && fs.existsSync(path.join(ROOT, f)));
expect(files.length).toBeGreaterThan(1000);
const hits = files.filter(f => {
const full = path.join(ROOT, f);
if (!fs.statSync(full).isFile()) return false;
return NAMES.test(fs.readFileSync(full, 'utf8'));
});
expect(hits).toEqual([]);
});
});
/**
* The reviewer briefs main restored in #3638 (v1.91.331.0), pinned by content: the rendered
* specialist, Red Team, adversarial and outside-voice prompts, the checklists they read, the
* fix-check prompt and the depth rules that pick reviewers. A change to any of them changes what a
* reviewer sees or how its findings rate, so it merges only after its preregistered no-loss replay
* passes (GStack Minder crew rule, 2026-10-30); a cost replay alone is not enough (#3621 passed its
* cost replay, then its no-loss replay found 11 of 30 blockers). Every pin names the replay that
* admits its bytes: repin with that replay's id in the pin file and in the commit message, and merge only on
* its passing result.
*
* The pins live one file per pin under test/fixtures/review-pins (GST-1084), so two PRs that repin
* different files, or add different replays, never edit the same lines and merge without a conflict:
* files/<pinned path>.json {"sha", "replay"}: the sha256 of the file's LF-normalized bytes and the replay that admits them
* replays/<slug>.json {"replay", "justification"}: one replay id and its written no-loss justification,
* where <slug> is replaySlug(replay)
* brief-bodies/<name>.json {"sha"}: one brief body lib/review-brief.ts cuts from the ship sections (below)
*/
const PINS = path.join(ROOT, 'test/fixtures/review-pins');
const replaySlug = (replay: string) => replay.replace(/[^A-Za-z0-9+-]+/g, '-').replace(/^-+|-+$/g, '');
/** Every pin file under dir, keyed by its path below dir without `.json`; any other file is an error. */
function readPinDir(dir: string): Record<string, unknown> {
const out: Record<string, unknown> = {};
for (const rel of (fs.readdirSync(dir, { recursive: true }) as string[]).map(f => f.split(path.sep).join('/')).sort()) {
if (fs.statSync(path.join(dir, rel)).isDirectory()) continue;
if (!rel.endsWith('.json')) throw new Error(`${dir}/${rel}: every pin file is <name>.json`);
try {
out[rel.slice(0, -'.json'.length)] = JSON.parse(fs.readFileSync(path.join(dir, rel), 'utf8'));
} catch (e) {
throw new Error(`${dir}/${rel}: ${(e as Error).message}`);
}
}
return out;
}
/** The pin store at pins, with every file that is not exactly its kind's fields as non-empty strings, or is misnamed. */
function readPins(pins: string) {
const malformed: string[] = [];
const kind = <K extends string>(sub: string, keys: readonly K[]) => {
const out: Record<string, Record<K, string>> = {};
for (const [name, value] of Object.entries(readPinDir(path.join(pins, sub)))) {
const fields = typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
if (Object.keys(fields).sort().join() === [...keys].sort().join() && keys.every(k => typeof fields[k] === 'string' && fields[k] !== '')) out[name] = fields as Record<K, string>;
else malformed.push(`${sub}/${name}.json (expected exactly ${keys.join(', ')})`);
}
return out;
};
const replayFiles = kind('replays', ['replay', 'justification']);
for (const [name, r] of Object.entries(replayFiles)) if (name !== replaySlug(r.replay)) malformed.push(`replays/${name}.json (replay ${r.replay} belongs in replays/${replaySlug(r.replay)}.json)`);
return {
malformed,
replays: Object.fromEntries(Object.values(replayFiles).map(r => [r.replay, r.justification])),
files: kind('files', ['sha', 'replay']),
bodies: Object.fromEntries(Object.entries(kind('brief-bodies', ['sha'])).map(([name, body]) => [name, body.sha])),
};
}
type Pins = ReturnType<typeof readPins>;
/** Every source a reviewer brief, checklist or depth rule comes from: deleting one of these pins fails, never drops the check. */
const MUST_PIN = [
'lib/review-depth.ts',
'lib/review-risk.ts',
'review/checklist.md',
'review/design-checklist.md',
'review/gate-integrity.md',
'review/sections/adversarial.md',
'review/sections/review-army.md',
'scripts/resolvers/fix-check.ts',
'ship/sections/adversarial.md',
'ship/sections/review-army.md',
];
/** MUST_PIN entries and specialist checklists under root with no pin. */
const unpinned = (pins: Pins, root: string) => [...MUST_PIN, ...fs.readdirSync(path.join(root, 'review/specialists')).filter(f => f.endsWith('.md')).map(f => `review/specialists/${f}`)]
.filter(f => !Object.hasOwn(pins.files, f));
/** Pinned files whose LF-normalized bytes under root no longer hash to their pin. */
const stalePins = (pins: Pins, root: string) => Object.entries(pins.files).filter(([file, pin]) => {
const text = fs.readFileSync(path.join(root, file), 'utf8').replace(/\r\n/g, '\n');
return createHash('sha256').update(text).digest('hex') !== pin.sha;
}).map(([file, pin]) => `${file} (a repin needs a passing no-loss replay; the current pin names ${pin.replay})`);
/** Pins naming no replay in the store, and replays whose justification names no no-loss replay or re-score. */
const unadmitted = (pins: Pins) => [
...Object.entries(pins.files).filter(([, pin]) => !Object.hasOwn(pins.replays, pin.replay)).map(([file, pin]) => `${file} names unknown replay ${pin.replay}`),
...Object.entries(pins.replays).filter(([, what]) => !/no-loss|re-score/.test(what)).map(([replay]) => `replay ${replay} is not a no-loss replay or re-score`),
];
const PINNED = readPins(PINS);
describe('reviewer briefs stay at their no-loss-tested bytes (GSTA-167)', () => {
// Value: protects=the GST-986 repin of ship/sections/adversarial.md admits only a lead-instruction edit: every brief a reviewer
// reads renders byte-identical to the no-loss-tested bodies; fails_when=an edit inside a cut span changes a brief while the
// section pin moves; seam=sectionTexts, the function every render uses; no_claim=the checklists (pinned by file hash below)
test('every reviewer brief cut from the ship sections is byte-identical to its pinned body', () => {
const hashes = (root: string) => Object.fromEntries(Object.entries(sectionTexts(root)).map(([k, v]) => [k, createHash('sha256').update(v).digest('hex')]));
expect(hashes(ROOT)).toEqual(PINNED.bodies);
const copy = fs.mkdtempSync(path.join(os.tmpdir(), 'brief-bodies-'));
try {
fs.cpSync(path.join(ROOT, 'ship', 'sections'), path.join(copy, 'ship', 'sections'), { recursive: true });
const adversarial = path.join(copy, 'ship', 'sections', 'adversarial.md');
fs.writeFileSync(adversarial, fs.readFileSync(adversarial, 'utf8').replace('Recommendation:', 'Recommendation (short):'));
expect(hashes(copy)).not.toEqual(PINNED.bodies);
} finally {
fs.rmSync(copy, { recursive: true, force: true });
}
});
test('every pinned reviewer brief, checklist and depth rule hashes to its pin', () => {
expect(PINNED.malformed).toEqual([]);
expect(stalePins(PINNED, ROOT)).toEqual([]);
});
test('every pin names the preregistered no-loss replay that admits its bytes', () => {
expect(unadmitted(PINNED)).toEqual([]);
});
test('the pins cover every specialist checklist', () => {
const specialists = fs.readdirSync(path.join(ROOT, 'review/specialists')).filter(f => f.endsWith('.md')).map(f => `review/specialists/${f}`);
expect(specialists.filter(f => !Object.hasOwn(PINNED.files, f))).toEqual([]);
});
test('every source a reviewer brief, checklist or depth rule comes from has a pin (GST-1084)', () => {
expect(unpinned(PINNED, ROOT)).toEqual([]);
});
// Value: protects=the one-file-per-pin layout keeps every check the in-file table had; fails_when=a stale sha, an unknown or
// unjustified replay, a malformed or misnamed pin file, or a stray file passes; seam=readPins, stalePins and unadmitted, the
// functions the checks above call; no_claim=that a repin's replay actually passed (the commit and PR carry that)
test('a stale pin, an unknown or unjustified replay and a malformed pin file each fail (GST-1084)', () => {
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'review-pins-'));
try {
const src = path.join(tmp, 'src'), pins = path.join(tmp, 'pins');
for (const file of Object.keys(PINNED.files)) fs.cpSync(path.join(ROOT, file), path.join(src, file));
fs.cpSync(PINS, pins, { recursive: true });
expect(stalePins(readPins(pins), src)).toEqual([]);
fs.writeFileSync(path.join(src, 'review/checklist.md'), fs.readFileSync(path.join(src, 'review/checklist.md'), 'utf8').replace(/\n/g, '\r\n'));
expect(stalePins(readPins(pins), src)).toEqual([]);
fs.appendFileSync(path.join(src, 'review/checklist.md'), 'One more rule.\r\n');
expect(stalePins(readPins(pins), src)).toEqual([`review/checklist.md (a repin needs a passing no-loss replay; the current pin names ${PINNED.files['review/checklist.md']!.replay})`]);
const pin = (file: string, value: unknown) => fs.writeFileSync(path.join(pins, 'files', `${file}.json`), `${JSON.stringify(value)}\n`);
pin('review/design-checklist.md', { sha: PINNED.files['review/design-checklist.md']!.sha, replay: 'GST-0000' });
pin('lib/review-risk.ts', { sha: PINNED.files['lib/review-risk.ts']!.sha, replay: 'toString' });
fs.writeFileSync(path.join(pins, 'replays', 'GST-0001.json'), `${JSON.stringify({ replay: 'GST-0001', justification: 'reviewed by hand' })}\n`);
expect(unadmitted(readPins(pins))).toEqual(['lib/review-risk.ts names unknown replay toString', 'review/design-checklist.md names unknown replay GST-0000',
'replay GST-0001 is not a no-loss replay or re-score']);
expect(unpinned(readPins(pins), ROOT)).toEqual([]);
fs.rmSync(path.join(pins, 'files', 'lib/review-risk.ts.json'));
fs.rmSync(path.join(pins, 'files', 'review/specialists/testing.md.json'));
expect(unpinned(readPins(pins), ROOT)).toEqual(['lib/review-risk.ts', 'review/specialists/testing.md']);
pin('review/gate-integrity.md', { ...PINNED.files['review/gate-integrity.md'], note: 'extra' });
fs.writeFileSync(path.join(pins, 'replays', 'GST-0002.json'), `${JSON.stringify({ replay: 'GST-0003', justification: 'a no-loss replay' })}\n`);
expect(readPins(pins).malformed).toEqual(['replays/GST-0002.json (replay GST-0003 belongs in replays/GST-0003.json)',
'files/review/gate-integrity.md.json (expected exactly sha, replay)']);
fs.writeFileSync(path.join(pins, 'files', 'review/gate-integrity.md.json'), '<<<<<<< a\n{}\n');
expect(() => readPins(pins)).toThrow('files/review/gate-integrity.md.json: ');
fs.rmSync(path.join(pins, 'files', 'review/gate-integrity.md.json'));
fs.writeFileSync(path.join(pins, 'brief-bodies', 'specialist.txt'), 'stray\n');
expect(() => readPins(pins)).toThrow('every pin file is <name>.json');
} finally {
fs.rmSync(tmp, { recursive: true, force: true });
}
});
// Value: protects=PRs that repin different review files merge without a conflict (five main-merge conflicts on 2026-11-02 came
// from the in-file table); fails_when=two repins of adjacent pins, each with its own new replay, conflict in a real merge, or
// two repins of one pin merge silently; seam=git merge-tree --write-tree on two branches; no_claim=semantic merge correctness
test('repins of two different files, each with its own new replay, merge cleanly in a real git merge (GST-1084)', () => {
const repin = (file: string, sha: string, replay: string) => (root: string) => {
fs.writeFileSync(path.join(root, 'files', `${file}.json`), `${JSON.stringify({ sha, replay })}\n`);
fs.writeFileSync(path.join(root, 'replays', `${replaySlug(replay)}.json`), `${JSON.stringify({ replay, justification: `${replay} no-loss replay` })}\n`);
};
const seed = (root: string) => fs.cpSync(PINS, root, { recursive: true });
const army = 'ship/sections/review-army.md', adversarial = 'ship/sections/adversarial.md';
const merges: PinMerge[] = [];
try {
const clean = mergePinEdits(seed, repin(army, 'a'.repeat(64), 'GST-9001+GST-967'), repin(adversarial, 'b'.repeat(64), 'GST-9002'));
merges.push(clean);
const conflict = mergePinEdits(seed, repin(army, 'a'.repeat(64), 'GST-9001'), repin(army, 'c'.repeat(64), 'GST-9003'));
merges.push(conflict);
expect(clean.output).not.toContain('CONFLICT');
expect(clean.clean).toBe(true);
expect(JSON.parse(clean.read(`files/${army}.json`))).toEqual({ sha: 'a'.repeat(64), replay: 'GST-9001+GST-967' });
expect(JSON.parse(clean.read(`files/${adversarial}.json`))).toEqual({ sha: 'b'.repeat(64), replay: 'GST-9002' });
expect(JSON.parse(clean.read('replays/GST-9001+GST-967.json')).replay).toBe('GST-9001+GST-967');
expect(JSON.parse(clean.read('replays/GST-9002.json')).replay).toBe('GST-9002');
expect(conflict.clean).toBe(false);
expect(conflict.output).toContain(`CONFLICT (content): Merge conflict in files/${army}.json`);
} finally {
for (const merge of merges) fs.rmSync(merge.root, { recursive: true, force: true });
}
});
});