agentic-workflow-manager 9.19.0 → 9.20.1

package/dist/tests/core/changes/list-paging.test.js

@@ -0,0 +1,511 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const helpers_1 = require("./helpers");
+const list_fixtures_1 = require("./list-fixtures");
+const list_1 = require("../../../src/core/changes/list");
+let repo;
+let template;
+beforeAll(() => { template = (0, helpers_1.makeRepo)(); });
+afterAll(() => template.cleanup());
+beforeEach(() => { repo = (0, helpers_1.cloneRepo)(template); });
+afterEach(() => { jest.restoreAllMocks(); repo.cleanup(); });
+const list = (opts = {}) => (0, list_fixtures_1.listIn)(repo, opts);
+const listed = (opts = {}) => (0, list_fixtures_1.ok)(list(opts));
+const adopt = (id) => (0, list_fixtures_1.adoptIn)(repo, id);
+const history = () => (0, list_fixtures_1.historyIn)(repo);
+describe('listChanges: window and bounds (R5.2, R5.5, R5.7)', () => {
+    test('the window start is inclusive and a commit one second older is out', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: before', '2026-10-15T11:59:59Z');
+        repo.commit({ 'b.ts': '1' }, 'fix: at start', '2026-10-15T12:00:00Z');
+        repo.commit({ 'c.ts': '1' }, 'fix: after', '2026-10-15T12:00:01Z');
+        expect((0, list_fixtures_1.subjects)(listed())).toEqual(['fix: after', 'fix: at start']);
+    });
+    test('a future-dated commit is included', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: future', '2030-01-01T00:00:00Z');
+        const r = listed();
+        expect((0, list_fixtures_1.subjects)(r)).toEqual(['fix: future']);
+        expect(r.changes[0].merged_at).toBe('2030-01-01T00:00:00.000Z');
+    });
+    test('each commit is tested individually: an old-dated commit between two in-window ones does not stop the walk', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: x', '2026-10-16T10:00:00Z');
+        repo.commit({ 'b.ts': '1' }, 'fix: y old', '2026-10-01T10:00:00Z');
+        repo.commit({ 'c.ts': '1' }, 'fix: z', '2026-10-16T12:00:00Z');
+        expect((0, list_fixtures_1.subjects)(listed())).toEqual(['fix: z', 'fix: x']);
+    });
+    test('merged_at is the committer date, not the author date', () => {
+        adopt();
+        repo.gitAt('2026-10-16T12:00:00Z', 'commit', '--allow-empty', '-q', '-m', 'fix: dates', '--date=2020-01-01T00:00:00Z');
+        expect(repo.git('log', '-1', '--format=%at')).toBe(String(Date.parse('2020-01-01T00:00:00Z') / 1000));
+        const r = listed();
+        expect(r.changes[0].merged_at).toBe('2026-10-16T12:00:00.000Z');
+    });
+    test('the window start is reported as an ISO instant', () => {
+        adopt();
+        expect(listed().since).toBe('2026-10-15T12:00:00.000Z');
+    });
+    test('beyond the limit the newest entries are kept and the rest are counted', () => {
+        adopt();
+        for (let i = 1; i <= 5; i++)
+            repo.commit({ [`f${i}.ts`]: '1' }, `fix: n${i}`, `2026-10-16T0${i}:00:00Z`);
+        const r = listed({ limit: 3 });
+        expect((0, list_fixtures_1.subjects)(r)).toEqual(['fix: n5', 'fix: n4', 'fix: n3']);
+        expect(r).toMatchObject({ truncated: true, omitted: 2 });
+    });
+    test('exactly at the limit is not truncated', () => {
+        adopt();
+        for (let i = 1; i <= 3; i++)
+            repo.commit({ [`f${i}.ts`]: '1' }, `fix: n${i}`, `2026-10-16T0${i}:00:00Z`);
+        expect(listed({ limit: 3 })).toMatchObject({ truncated: false, omitted: 0 });
+    });
+    test('the limit counts window entries only, not older commits', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: old', '2026-10-01T00:00:00Z');
+        repo.commit({ 'b.ts': '1' }, 'fix: new', '2026-10-16T00:00:00Z');
+        expect(listed({ limit: 1 })).toMatchObject({ truncated: false, omitted: 0 });
+    });
+    test('a limit above 200 is capped at 200: 205 window entries give 200 listed and 5 omitted', () => {
+        expect(list_1.DEFAULT_LIMIT).toBe(200);
+        expect(list_1.MAX_RECORDS_PER_ENTRY).toBe(50);
+        expect(list_1.MAX_RECORDS_PER_RUN).toBe(500);
+        adopt();
+        (0, helpers_1.importCommits)(repo, Array.from({ length: 205 }, (_, i) => ({ message: `fix: n${i}`, files: { [`f${i}.ts`]: '1' }, date: new Date(Date.UTC(2026, 9, 16, 0, 0, 0) + i * 60_000).toISOString() })));
+        const r = listed({ limit: 100_000 });
+        expect(r.changes).toHaveLength(200);
+        expect(r).toMatchObject({ truncated: true, omitted: 5 });
+        expect(r.changes[0].subject).toBe('fix: n204');
+    });
+    const files = (n, from = 0) => Object.fromEntries(Array.from({ length: n }, (_, i) => {
+        const id = `2026-10-16-r${String(from + i).padStart(3, '0')}`;
+        return [(0, list_fixtures_1.recordPath)(id), (0, list_fixtures_1.record)(id)];
+    }));
+    test('a commit adding more records than the per-commit bound is not read: one too-many-records diagnostic stands for it', () => {
+        adopt();
+        repo.commit(files(list_1.MAX_RECORDS_PER_ENTRY + 1), 'feat: many', '2026-10-16T20:00:00Z');
+        const spy = (0, helpers_1.spyOnGit)();
+        const entry = listed().changes[0];
+        spy.restore();
+        expect(entry.classification).toBe('invalid-record');
+        expect(entry.records).toEqual([{ path: 'docs/changes', diagnostics: [expect.objectContaining({ code: 'too-many-records' })] }]);
+        expect(spy.calls.filter((a) => a.includes('ls-tree') || a.includes('show'))).toEqual([]);
+    });
+    test('a commit adding exactly the per-commit bound of valid records is recorded and all are read', () => {
+        adopt();
+        repo.commit(files(list_1.MAX_RECORDS_PER_ENTRY), 'feat: many', '2026-10-16T20:00:00Z');
+        const entry = listed().changes[0];
+        expect(entry.classification).toBe('recorded');
+        expect(entry.records).toHaveLength(list_1.MAX_RECORDS_PER_ENTRY);
+        expect(entry.records.every((r) => 'schema' in r)).toBe(true);
+    });
+    test('the per-commit bound can be lowered, and the commit is then not read at all', () => {
+        adopt();
+        repo.commit(files(2), 'feat: two', '2026-10-16T20:00:00Z');
+        const entry = listed({ maxRecordsPerEntry: 1 }).changes[0];
+        expect(entry.classification).toBe('invalid-record');
+        expect(entry.records).toEqual([{ path: 'docs/changes', diagnostics: [expect.objectContaining({ code: 'too-many-records' })] }]);
+        expect(listed({ maxRecordsPerEntry: 2 }).changes[0].classification).toBe('recorded');
+    });
+    test('the per-run budget fails closed on the commits that come after it is spent', () => {
+        adopt();
+        for (let i = 1; i <= 3; i++)
+            repo.commit({ [(0, list_fixtures_1.recordPath)(`2026-10-16-r${i}`)]: (0, list_fixtures_1.record)(`2026-10-16-r${i}`) }, `feat: r${i}`, `2026-10-16T0${i}:00:00Z`);
+        const r = listed({ maxRecords: 2 });
+        expect((0, list_fixtures_1.byClass)(r)).toEqual({ 'feat: r3': 'recorded', 'feat: r2': 'recorded', 'feat: r1': 'invalid-record' });
+        expect(r.changes[2].records).toEqual([{ path: 'docs/changes', diagnostics: [expect.objectContaining({ code: 'too-many-records' })] }]);
+    });
+    test('the per-run budget is spent on records actually read: a commit refused for being too large does not use it up', () => {
+        adopt();
+        repo.commit(files(1, 100), 'feat: small', '2026-10-16T01:00:00Z');
+        repo.commit(files(3, 200), 'feat: big', '2026-10-16T02:00:00Z');
+        repo.commit(files(2, 300), 'feat: medium', '2026-10-16T03:00:00Z');
+        const r = listed({ maxRecords: 3 });
+        expect((0, list_fixtures_1.byClass)(r)).toEqual({ 'feat: medium': 'recorded', 'feat: big': 'invalid-record', 'feat: small': 'recorded' });
+        expect(r.changes.find((c) => c.subject === 'feat: big')?.records).toHaveLength(1);
+    });
+    test('a budget of exactly the records of the run reads them all', () => {
+        adopt();
+        repo.commit(files(2, 100), 'feat: a', '2026-10-16T01:00:00Z');
+        repo.commit(files(1, 200), 'feat: b', '2026-10-16T02:00:00Z');
+        expect(Object.values((0, list_fixtures_1.byClass)(listed({ maxRecords: 3 })))).toEqual(['recorded', 'recorded']);
+        expect(Object.values((0, list_fixtures_1.byClass)(listed({ maxRecords: 2 })))).toEqual(['recorded', 'invalid-record']);
+    });
+});
+describe('listChanges: subjects and tags beyond their caps are clipped, never an error (R5.5, R5.7)', () => {
+    const bigMessage = (first) => { const file = path_1.default.join(repo.home, 'message.txt'); fs_1.default.writeFileSync(file, `${first}\n`); return file; };
+    test('a 17 MB subject is clipped to the cap and the run succeeds', () => {
+        adopt();
+        repo.gitAt('2026-10-16T10:00:00Z', 'commit', '--allow-empty', '-q', '-F', bigMessage(`feat: ${'x'.repeat(17_000_000)}`));
+        repo.commit({ 'b.ts': '1' }, 'fix: next', '2026-10-16T11:00:00Z');
+        const r = listed();
+        expect((0, list_fixtures_1.subjects)(r)[0]).toBe('fix: next');
+        expect(r.changes[1].subject.length).toBe(list_1.MAX_SUBJECT);
+        expect(r.changes[1].subject.startsWith('feat: xxxx')).toBe(true);
+        expect(r.changes[1].subject.endsWith('…')).toBe(true);
+    }, 120_000);
+    test('the subject is asked from git bounded, so that git never prints all of it', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: a', '2026-10-16T10:00:00Z');
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        const call = spy.calls.find((a) => a.some((x) => x.startsWith('--format=%H%x1f%<(')));
+        expect(call).toBeDefined();
+        expect(call?.some((x) => /%<\(\d+,trunc\)%s/.test(x))).toBe(true);
+    });
+    test('a short subject is returned without the padding git adds', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: a', '2026-10-16T10:00:00Z');
+        expect((0, list_fixtures_1.subjects)(listed())).toEqual(['fix: a']);
+    });
+    test('R5.5 a commit whose subject cannot be read still lists: its pr is null (the tail fallback), never a failure', () => {
+        adopt();
+        const file = path_1.default.join(repo.home, 'message.txt');
+        fs_1.default.writeFileSync(file, `fix: ${'\u0301'.repeat(9_000_000)} (#12)\n`);
+        repo.gitAt('2026-10-16T10:00:00Z', 'commit', '--allow-empty', '-q', '-F', file);
+        const r = listed();
+        expect(r.changes).toHaveLength(1);
+        expect(r.changes[0]).toMatchObject({ subject: '<subject unavailable>', pr: null });
+    });
+    test('one bad subject among many is found by halving the batch: a logarithmic number of calls, not one per commit', () => {
+        adopt();
+        for (let i = 1; i <= 7; i++)
+            repo.commit({ [`f${i}.ts`]: '1' }, `fix: n${i}`, '2026-10-16T10:00:00Z');
+        repo.gitAt('2026-10-16T10:00:00Z', 'commit', '--allow-empty', '-q', '-F', bigMessage(`fix: ${'\u0301'.repeat(9_000_000)}`));
+        for (let i = 8; i <= 15; i++)
+            repo.commit({ [`f${i}.ts`]: '1' }, `fix: n${i}`, '2026-10-16T11:00:00Z');
+        const spy = (0, helpers_1.spyOnGit)();
+        const r = listed();
+        spy.restore();
+        const asked = (needle) => spy.calls.filter((a) => a.some((x) => x.startsWith('--format=%H%x1f%<(') && x.includes(needle))).length;
+        expect((0, list_fixtures_1.subjects)(r).filter((s) => s === '<subject unavailable>')).toHaveLength(1);
+        expect((0, list_fixtures_1.subjects)(r).filter((s) => /^fix: n\d+$/.test(s))).toHaveLength(15);
+        // 16 commits: the whole batch, then one failing half and one good half per level (4 levels); asking each one took 17.
+        expect(asked(',trunc)')).toBeLessThanOrEqual(9);
+        expect(asked(',ltrunc)')).toBeLessThanOrEqual(9);
+        expect(asked(',trunc)')).toBeGreaterThan(1);
+    }, 120_000);
+    (0, helpers_1.posixOnly)('a tag name longer than 255 characters is clipped, never git-failed', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: a', '2026-10-16T10:00:00Z');
+        repo.git('tag', `${'a'.repeat(120)}/${'b'.repeat(200)}`);
+        const release = listed().changes[0].release;
+        expect(release?.length).toBe(255);
+        expect(release?.startsWith('aaaa')).toBe(true);
+        expect(release?.endsWith('…')).toBe(true);
+    });
+});
+describe('listChanges: the first-parent scan is read in pages (R5.7)', () => {
+    const isScan = (a) => a.includes('log') && a.some((x) => x === '--format=%H%x1f%ct%x1f%P');
+    const isAdoptionPage = (a) => a.includes('log') && a.some((x) => x.startsWith(':(top,glob)docs/changes/'));
+    /** `n` commits in the window, `fix: n1` oldest. */
+    const commits = (n, from = 1) => { for (let i = from; i < from + n; i++)
+        repo.commit({ [`f${i}.ts`]: '1' }, `fix: n${i}`, '2026-10-16T10:00:00Z'); };
+    const countCalls = (pred, opts) => { const spy = (0, helpers_1.spyOnGit)(); listed(opts); spy.restore(); return spy.calls.filter(pred).length; };
+    test('the real page size is 10 000 commits and is what a default run asks git for', () => {
+        expect(list_1.PAGE_SIZE).toBe(10_000);
+        adopt();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        expect(spy.calls.filter(isScan).every((a) => a.includes('--max-count=10000'))).toBe(true);
+        expect(spy.calls.filter(isAdoptionPage).every((a) => a.includes('--max-count=10000'))).toBe(true);
+    });
+    test('a page size above the real one is capped to it', () => {
+        adopt();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed({ pageSize: 1_000_000 });
+        spy.restore();
+        expect(spy.calls.filter(isScan).every((a) => a.includes('--max-count=10000'))).toBe(true);
+    });
+    test.each([0, -1, 1.5, Number.NaN, '3', null])('the page size %j is invalid-input', (pageSize) => {
+        expect(list({ pageSize })).toMatchObject({ ok: false, failure: { code: 'invalid-input' } });
+    });
+    test('entries across page boundaries are listed exactly as with one page', () => {
+        adopt();
+        commits(8);
+        const paged = listed({ pageSize: 3 });
+        expect(paged.changes).toHaveLength(8);
+        expect(paged).toEqual(listed());
+        expect((0, list_fixtures_1.subjects)(paged)[0]).toBe('fix: n8');
+        expect((0, list_fixtures_1.subjects)(paged)[7]).toBe('fix: n1');
+    });
+    test('a page size of 1 gives the same answer', () => {
+        adopt();
+        commits(4);
+        expect(listed({ pageSize: 1 })).toEqual(listed());
+    });
+    test('the scan stops at the adoption point: no page is read beyond the one holding it', () => {
+        repo.commit({ 'old.ts': '1' }, 'feat: before', '2026-10-16T09:00:00Z');
+        repo.commit({ 'old2.ts': '1' }, 'feat: before too', '2026-10-16T09:30:00Z');
+        adopt('2026-10-16-first');
+        commits(5);
+        const r = listed({ pageSize: 2 });
+        expect((0, list_fixtures_1.subjects)(r)).toEqual(['fix: n5', 'fix: n4', 'fix: n3', 'fix: n2', 'fix: n1']);
+        expect(countCalls(isScan, { pageSize: 2 })).toBe(3);
+    });
+    test('the scan stops at the first page without a commit in the window', () => {
+        adopt();
+        for (let i = 1; i <= 6; i++)
+            repo.commit({ [`o${i}.ts`]: '1' }, `fix: old${i}`, '2026-10-01T10:00:00Z');
+        commits(2);
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 2 }))).toEqual(['fix: n2', 'fix: n1']);
+        expect(countCalls(isScan, { pageSize: 2 })).toBe(2);
+    });
+    test('a window with no commit in it reads one page only', () => {
+        adopt();
+        for (let i = 1; i <= 6; i++)
+            repo.commit({ [`o${i}.ts`]: '1' }, `fix: old${i}`, '2026-10-01T10:00:00Z');
+        expect(listed({ pageSize: 2 })).toMatchObject({ adopted: true, changes: [], truncated: false, omitted: 0 });
+        expect(countCalls(isScan, { pageSize: 2 })).toBe(1);
+    });
+    test('a page that holds some commits of the window and some older ones is followed by one more page', () => {
+        adopt();
+        for (let i = 1; i <= 4; i++)
+            repo.commit({ [`o${i}.ts`]: '1' }, `fix: old${i}`, '2026-10-01T10:00:00Z');
+        commits(1);
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 2 }))).toEqual(['fix: n1']);
+        expect(countCalls(isScan, { pageSize: 2 })).toBe(2);
+    });
+    test('a commit dated inside the window beyond a page with none is not listed (dates are assumed not to decrease)', () => {
+        adopt();
+        commits(1);
+        for (let i = 1; i <= 3; i++)
+            repo.commit({ [`o${i}.ts`]: '1' }, `fix: old${i}`, '2026-10-01T10:00:00Z');
+        commits(1, 2);
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 2 }))).toEqual(['fix: n2']);
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 10 }))).toEqual(['fix: n2', 'fix: n1']);
+    });
+    test('an unusable date counts as inside the window when it decides whether to read on', () => {
+        adopt();
+        for (let i = 1; i <= 4; i++)
+            repo.commit({ [`o${i}.ts`]: '1' }, `fix: old${i}`, '2026-10-01T10:00:00Z');
+        (0, list_fixtures_1.commitLiterally)(repo, '');
+        repo.commit({ 'o5.ts': '1' }, 'fix: old5', '2026-10-01T10:00:00Z');
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 2 }))).toEqual(['fix: odd date']);
+        expect(countCalls(isScan, { pageSize: 2 })).toBe(2);
+    });
+    test('the omitted entries are counted over every page', () => {
+        adopt();
+        commits(8);
+        expect(listed({ pageSize: 3, limit: 3 })).toMatchObject({ truncated: true, omitted: 5 });
+        expect(listed({ pageSize: 3, limit: 3 })).toEqual(listed({ limit: 3 }));
+    });
+    test('merge commits count as one commit of the first-parent chain, across pages', () => {
+        adopt();
+        repo.git('checkout', '-q', '-b', 'side1');
+        repo.commit({ [(0, list_fixtures_1.recordPath)(list_fixtures_1.FIRST)]: (0, list_fixtures_1.record)(list_fixtures_1.FIRST) }, 'feat: side1', '2026-10-16T08:00:00Z');
+        repo.git('checkout', '-q', 'main');
+        repo.gitAt('2026-10-16T09:00:00Z', 'merge', '--no-ff', '-q', 'side1', '-m', 'Merge side1');
+        repo.git('checkout', '-q', '-b', 'side2');
+        repo.commit({ 's2.ts': '1' }, 'chore: side2\n\nChange-Record: none', '2026-10-16T10:00:00Z');
+        repo.git('checkout', '-q', 'main');
+        repo.gitAt('2026-10-16T11:00:00Z', 'merge', '--no-ff', '-q', 'side2', '-m', 'Merge side2');
+        commits(1);
+        const paged = listed({ pageSize: 2 });
+        expect((0, list_fixtures_1.byClass)(paged)).toEqual({ 'fix: n1': 'missing', 'Merge side2': 'exempt', 'Merge side1': 'recorded' });
+        expect(paged).toEqual(listed());
+    });
+    test('the adoption search is paged too: the oldest commit that touched docs/changes is found across pages', () => {
+        repo.commit({ 'old.ts': '1' }, 'feat: before', '2026-10-16T09:00:00Z');
+        for (let i = 1; i <= 7; i++)
+            repo.commit({ [`docs/changes/2026-10-16-n${i}.md`]: '1' }, `docs: note ${i}`, '2026-10-16T10:00:00Z');
+        const paged = listed({ pageSize: 3 });
+        expect((0, list_fixtures_1.subjects)(paged)).toEqual(Array.from({ length: 7 }, (_, i) => `docs: note ${7 - i}`));
+        expect(paged).toEqual(listed());
+        expect(countCalls(isAdoptionPage, { pageSize: 3 })).toBe(3);
+    });
+    test('the adoption search reads one more, empty, page when the last one was full', () => {
+        for (let i = 1; i <= 6; i++)
+            repo.commit({ [`docs/changes/2026-10-16-n${i}.md`]: '1' }, `docs: note ${i}`, '2026-10-16T10:00:00Z');
+        expect((0, list_fixtures_1.subjects)(listed({ pageSize: 3 }))).toHaveLength(6);
+        expect(countCalls(isAdoptionPage, { pageSize: 3 })).toBe(3);
+    });
+    test('the adoption search skips commits that did not touch docs/changes between two pages', () => {
+        for (let i = 1; i <= 3; i++) {
+            repo.commit({ [`docs/changes/2026-10-16-n${i}.md`]: '1' }, `docs: note ${i}`, '2026-10-16T10:00:00Z');
+            commits(2, i * 10);
+        }
+        const r = listed({ pageSize: 2 });
+        expect(r.changes.map((c) => c.subject).filter((x) => x.startsWith('docs:'))).toEqual(['docs: note 3', 'docs: note 2', 'docs: note 1']);
+        expect(r).toEqual(listed());
+    });
+    test('a root commit that adopts ends the paging', () => {
+        repo.git('checkout', '-q', '--orphan', 'orph');
+        repo.git('rm', '-rfq', '.');
+        repo.commit({ [(0, list_fixtures_1.recordPath)(list_fixtures_1.FIRST)]: (0, list_fixtures_1.record)(list_fixtures_1.FIRST) }, 'feat: root record', '2026-10-16T20:00:00Z');
+        repo.commit({ 'z.ts': '1' }, 'fix: after root', '2026-10-16T21:00:00Z');
+        expect(listed({ base: 'orph', pageSize: 1 })).toEqual(listed({ base: 'orph' }));
+        expect((0, list_fixtures_1.subjects)(listed({ base: 'orph', pageSize: 1 }))).toEqual(['fix: after root', 'feat: root record']);
+    });
+    test('a git failure on a later page is a git-failed failure, not a partial list', () => {
+        adopt();
+        commits(6);
+        let seen = 0;
+        const spy = (0, helpers_1.spyOnGit)((args) => { if (isScan(args) && ++seen === 2)
+            throw new Error('boom'); });
+        const outcome = list({ pageSize: 2 });
+        spy.restore();
+        expect(outcome).toMatchObject({ ok: false, failure: { code: 'git-failed' } });
+    });
+    test('a git failure on a later page of the adoption search is a git-failed failure', () => {
+        for (let i = 1; i <= 6; i++)
+            repo.commit({ [`docs/changes/2026-10-16-n${i}.md`]: '1' }, `docs: note ${i}`, '2026-10-16T10:00:00Z');
+        let seen = 0;
+        const spy = (0, helpers_1.spyOnGit)((args) => { if (isAdoptionPage(args) && ++seen === 2)
+            throw new Error('boom'); });
+        const outcome = list({ pageSize: 2 });
+        spy.restore();
+        expect(outcome).toMatchObject({ ok: false, failure: { code: 'git-failed' } });
+    });
+});
+describe('listChanges: the pr comes from the true end of the full subject (R5.5)', () => {
+    const prOf = (subject) => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, subject, '2026-10-16T10:00:00Z');
+        return listed().changes[0].pr;
+    };
+    test.each([
+        ['5000 characters long', `fix: ${'a'.repeat(5000)} (#12)`, 12],
+        ['1030 characters long (just beyond the subject cap)', `fix: ${'a'.repeat(1030 - 12)} (#12)`, 12],
+        ['exactly the width of the tail', `${'x'.repeat(64 - 6)} (#12)`, 12],
+        ['one column beyond the width of the tail', `${'x'.repeat(65 - 6)} (#12)`, 12],
+        ['one column short of the width of the tail', `${'x'.repeat(63 - 6)} (#12)`, 12],
+        ['shorter than the tail', 'fix: x (#3)', 3],
+        ['with (#12) glued to a longer token at the end', `fix: ${'a'.repeat(300)}tok(#12)`, 12],
+        ['with (#12) followed by more text', `fix: ${'a'.repeat(300)} (#12)x`, null],
+        ['with (#12) early and a long tail after it', `fix: (#12) ${'a'.repeat(5000)}`, null],
+        ['with a pr number longer than the tail would keep', `fix: ${'a'.repeat(300)} (#${'9'.repeat(60)})`, null],
+        ['with the largest safe number at the end', `fix: ${'a'.repeat(300)} (#9007199254740991)`, 9007199254740991],
+        ['with wide characters at the cut', `${'\u6f22'.repeat(100)} (#12)`, 12],
+        ['with accented characters at the cut', `${'\u00e9'.repeat(100)} (#12)`, 12],
+        ['with astral characters at the cut', `${'\u{1F600}'.repeat(100)} (#12)`, 12],
+        ['with two (#n) at the end', `fix: ${'a'.repeat(300)} (#1) (#2)`, 2],
+    ])('a subject %s', (_label, subject, pr) => {
+        expect(prOf(subject)).toBe(pr);
+    });
+    test('the end of the subject is asked from git bounded to the tail width', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: a', '2026-10-16T10:00:00Z');
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        expect(spy.calls.some((a) => a.includes('--format=%H%x1f%<(64,ltrunc)%s'))).toBe(true);
+    });
+    test('the subject itself is still clipped while the pr is read from its end', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, `fix: ${'a'.repeat(5000)} (#12)`, '2026-10-16T10:00:00Z');
+        const entry = listed().changes[0];
+        expect(entry.subject.length).toBe(list_1.MAX_SUBJECT);
+        expect(entry.pr).toBe(12);
+    });
+    test('the tail never leaks into the subject', () => {
+        adopt();
+        repo.commit({ 'a.ts': '1' }, 'fix: short (#4)', '2026-10-16T10:00:00Z');
+        expect(listed().changes[0].subject).toBe('fix: short (#4)');
+    });
+});
+describe('listChanges: read-only and bounded (R5.7)', () => {
+    // The whole tree is hashed, .git/objects included: reading must not add an object, a pack or a lock either.
+    const snapshot = () => `${(0, list_fixtures_1.snapshotDir)(repo.root)}\n${repo.git('--no-optional-locks', 'status', '--porcelain', '--ignored')}\n${repo.git('for-each-ref')}`;
+    test('writes nothing: files, index, refs and ignored files are byte-identical afterwards', () => {
+        history();
+        fs_1.default.writeFileSync(path_1.default.join(repo.root, 'untracked.txt'), 'u');
+        fs_1.default.mkdirSync(path_1.default.join(repo.root, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo.root, '.awm', 'ignored.txt'), 'i');
+        const before = snapshot();
+        listed();
+        listed({ limit: 2 });
+        expect(snapshot()).toBe(before);
+    });
+    // GIT_NO_LAZY_FETCH is honoured from git 2.43 on; an older git would fetch the blobs, so the test is reported as skipped there.
+    const needsGit243 = (0, helpers_1.gitAtLeast)(2, 43) ? test : test.skip;
+    needsGit243('a partial clone fails closed instead of fetching the blobs it lacks: nothing is written and nothing is fetched (needs git 2.43+)', () => {
+        adopt();
+        repo.commit({ [(0, list_fixtures_1.recordPath)(list_fixtures_1.FIRST)]: (0, list_fixtures_1.record)(list_fixtures_1.FIRST) }, 'feat: first', '2026-10-16T10:00:00Z');
+        repo.commit({ 'b.ts': '1' }, 'fix: next', '2026-10-16T11:00:00Z');
+        repo.git('config', 'uploadpack.allowFilter', 'true');
+        repo.git('config', 'uploadpack.allowAnySHA1InWant', 'true');
+        const dest = path_1.default.join(repo.home, 'partial');
+        repo.git('clone', '-q', '--filter=blob:none', '--no-checkout', (0, url_1.pathToFileURL)(repo.root).href, dest);
+        const missing = () => repo.git('-C', dest, 'rev-list', '--objects', '--all', '--missing=print').split('\n').filter((l) => l.startsWith('?')).length;
+        const packs = () => fs_1.default.readdirSync(path_1.default.join(dest, '.git', 'objects', 'pack')).sort();
+        const before = { tree: (0, list_fixtures_1.snapshotDir)(dest), missing: missing(), packs: packs() };
+        expect(before.missing).toBeGreaterThan(0);
+        const r = (0, list_fixtures_1.ok)((0, list_1.listChanges)(dest, { since: list_fixtures_1.SINCE_48H }));
+        expect({ tree: (0, list_fixtures_1.snapshotDir)(dest), missing: missing(), packs: packs() }).toEqual(before);
+        expect((0, list_fixtures_1.byClass)(r)).toEqual({ 'fix: next': 'missing', 'feat: first': 'invalid-record' });
+        expect(r.changes[1].records).toEqual([{ path: (0, list_fixtures_1.recordPath)(list_fixtures_1.FIRST), diagnostics: [expect.objectContaining({ code: 'git-failed' })] }]);
+    });
+    test('every git call is read-only', () => {
+        history();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        const subcommands = new Set(spy.calls.map((a) => a.find((x) => !x.startsWith('-') && x !== 'diff.relative=false') ?? ''));
+        expect([...subcommands].sort()).toEqual(expect.arrayContaining(['log']));
+        for (const name of subcommands)
+            expect(['rev-parse', 'log', 'diff', 'ls-tree', 'show', 'for-each-ref', 'config']).toContain(name);
+    });
+    test('every git log carries the safety flags', () => {
+        history();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        const logs = spy.calls.filter((a) => a.includes('log'));
+        expect(logs.length).toBeGreaterThanOrEqual(3);
+        for (const call of logs) {
+            expect(call).toContain('--no-show-signature');
+            expect(call).toContain('--encoding=UTF-8');
+            expect(call).toContain('--end-of-options');
+        }
+    });
+    test('pathspecs are literal and follow a --', () => {
+        history();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        const withPath = spy.calls.filter((a) => a.some((x) => x.includes('docs/changes')));
+        expect(withPath.length).toBeGreaterThan(0);
+        for (const call of withPath) {
+            const dash = call.indexOf('--');
+            expect(dash).toBeGreaterThan(-1);
+            expect(call.slice(dash + 1).every((x) => x.startsWith(':(top,literal)') || x.startsWith(':(top,glob)docs/changes/') || /^docs\/changes\/[a-z0-9-]+\.md$/.test(x))).toBe(true);
+        }
+    });
+    test('the history is read along the first parent only, in pages', () => {
+        history();
+        const spy = (0, helpers_1.spyOnGit)();
+        listed();
+        spy.restore();
+        const scans = spy.calls.filter((a) => a.includes('log') && a.some((x) => x.startsWith('--max-count=')));
+        expect(scans.length).toBeGreaterThanOrEqual(2);
+        for (const call of scans) {
+            expect(call).toContain('--first-parent');
+            expect(call).toContain(`--max-count=${list_1.PAGE_SIZE}`);
+        }
+    });
+    test('git calls per entry are constant: recorded entries cost the same however long the history', () => {
+        adopt();
+        const add = (from, to) => {
+            for (let i = from; i <= to; i++) {
+                const id = `2026-10-16-r${String(i).padStart(3, '0')}`;
+                repo.commit({ [(0, list_fixtures_1.recordPath)(id)]: (0, list_fixtures_1.record)(id) }, `feat: r${i}`, '2026-10-16T10:00:00Z');
+            }
+        };
+        const count = () => { const spy = (0, helpers_1.spyOnGit)(); const r = listed(); spy.restore(); expect(r.changes.length).toBeGreaterThan(0); return spy.calls.length; };
+        add(1, 5);
+        const small = count();
+        add(6, 25);
+        const large = count();
+        expect((large - small) / 20).toBeLessThanOrEqual(5);
+        expect(large - small).toBeGreaterThan(0);
+    });
+});

package/dist/tests/core/changes/list-parse.test.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+const list_fixtures_1 = require("./list-fixtures");
+const list_parse_1 = require("../../../src/core/changes/list-parse");
+// Repo-free tests of the pure parsing of `awm changes list`: nothing here starts git.
+describe('parseSince (R5.2)', () => {
+    test.each([
+        ['24h', '2026-10-16T12:00:00.000Z'],
+        ['7d', '2026-10-10T12:00:00.000Z'],
+        ['1h', '2026-10-17T11:00:00.000Z'],
+        ['3650d', '2016-10-19T12:00:00.000Z'],
+        ['87600h', '2016-10-19T12:00:00.000Z'],
+        ['3651d', '2016-10-18T12:00:00.000Z'],
+        ['87601h', '2016-10-19T11:00:00.000Z'],
+        ['99999d', '1753-01-02T12:00:00.000Z'],
+        ['12345h', '2025-05-21T03:00:00.000Z'],
+        ['2026-10-01', '2026-10-01T00:00:00.000Z'],
+        ['2026-02-28', '2026-02-28T00:00:00.000Z'],
+        ['2028-02-29', '2028-02-29T00:00:00.000Z'],
+    ])('accepts %s', (value, iso) => {
+        expect((0, list_parse_1.parseSince)(value, list_fixtures_1.NOW)?.toISOString()).toBe(iso);
+    });
+    test.each(['', '0h', '0d', '00d', '-1h', '+1h', '1.5h', '24', 'h', '24x', '24H', '24 h', ' 24h', '24h ', '24h\n', '1234567890h', '1234567890d', '0000000000h', '999999999d',
+        '2026-02-30', '2026-13-01', '2026-00-10', '2026-1-1', '2026-10-1', '2026-10-01T00:00:00Z', '2026-10-01 ', 'soon', 'now', '\u0661\u0662h', '1e3h', '0x10h',
+    ])('rejects %j', (value) => {
+        expect((0, list_parse_1.parseSince)(value, list_fixtures_1.NOW)).toBeNull();
+    });
+    test('a count of 9 digits is valid while the resulting instant is a valid date', () => {
+        expect((0, list_parse_1.parseSince)('999999999h', list_fixtures_1.NOW)).toBeInstanceOf(Date);
+        expect((0, list_parse_1.parseSince)('100000000d', list_fixtures_1.NOW)).toBeInstanceOf(Date);
+        expect((0, list_parse_1.parseSince)('999999999d', list_fixtures_1.NOW)).toBeNull();
+    });
+    test('rejects a very long text without scanning it more than once', () => {
+        expect((0, list_parse_1.parseSince)(`${'9'.repeat(1_000_000)}h`, list_fixtures_1.NOW)).toBeNull();
+        expect((0, list_parse_1.parseSince)('x'.repeat(1_000_000), list_fixtures_1.NOW)).toBeNull();
+        (0, helpers_1.expectLinearScaling)((n) => { (0, list_parse_1.parseSince)(`${'9'.repeat(n)}h`, list_fixtures_1.NOW); (0, list_parse_1.parseSince)('x'.repeat(n), list_fixtures_1.NOW); }, 100_000);
+    });
+    test.each([undefined, null, 24, {}, [], true])('rejects the non-string %j without throwing', (value) => {
+        expect((0, list_parse_1.parseSince)((0, helpers_1.bad)(value), list_fixtures_1.NOW)).toBeNull();
+    });
+    test.each([undefined, null, 'x', 5, new Date(Number.NaN), {}])('rejects the unusable clock %j', (clock) => {
+        expect((0, list_parse_1.parseSince)('24h', (0, helpers_1.bad)(clock))).toBeNull();
+    });
+});
+describe('parsePr (R5.5)', () => {
+    test.each([
+        ['feat: x', null],
+        ['feat: x (#12) more', null],
+        ['feat: (#12) x', null],
+        ['feat: x (#)', null],
+        ['feat: x (#1a)', null],
+        ['feat: x (# 12)', null],
+        ['feat: x (#-5)', null],
+        ['feat: x #12', null],
+        ['feat: x (#12', null],
+        ['feat: x (#99999999999999999999)', null],
+        ['feat: x (#9007199254740993)', null],
+        ['feat: x (#9007199254740991)', 9007199254740991],
+        ['feat: x (#123)', 123],
+        ['feat: x (#007)', 7],
+        ['feat: x (#12)   ', 12],
+        ['feat: x (#12)\t\r\n', 12],
+        ['feat: x (#1) (#2)', 2],
+        ['(#3)', 3],
+        ['(#)', null],
+        ['', null],
+    ])('the PR of %j is %j', (subject, pr) => {
+        expect((0, list_parse_1.parsePr)(subject)).toBe(pr);
+    });
+    test.each([undefined, null, 5, {}, []])('the non-string %j is null, not a throw', (value) => {
+        expect((0, list_parse_1.parsePr)((0, helpers_1.bad)(value))).toBeNull();
+    });
+    test('a very long run of digits or of blanks after (# is parsed in linear time', () => {
+        expect((0, list_parse_1.parsePr)(`feat: x (#${'9'.repeat(1_000_000)}`)).toBeNull();
+        expect((0, list_parse_1.parsePr)(`feat: y (#${' '.repeat(1_000_000)}1)`)).toBeNull();
+        expect((0, list_parse_1.parsePr)(`feat: z ${'(#'.repeat(500_000)})`)).toBeNull();
+        expect((0, list_parse_1.parsePr)(`${' '.repeat(1_000_000)}`)).toBeNull();
+        (0, helpers_1.expectLinearScaling)((n) => {
+            (0, list_parse_1.parsePr)(`feat: x (#${'9'.repeat(n)}`);
+            (0, list_parse_1.parsePr)(`feat: y (#${' '.repeat(n)}1)`);
+            (0, list_parse_1.parsePr)(`feat: z ${'(#'.repeat(n / 2)})`);
+            (0, list_parse_1.parsePr)(`${' '.repeat(n)}`);
+        }, 100_000);
+    });
+});
+describe('cleanLine', () => {
+    test.each([undefined, null, 5, {}])('the non-string %j is a placeholder, not a throw', (value) => {
+        expect((0, list_parse_1.cleanLine)((0, helpers_1.bad)(value), 10)).toBe('<non-string>');
+    });
+    test('a clean line within the limit is returned as it is', () => {
+        expect((0, list_parse_1.cleanLine)('fix: a', 10)).toBe('fix: a');
+        expect((0, list_parse_1.cleanLine)('1234567890', 10)).toBe('1234567890');
+    });
+    test('a line one unit over the limit is cut and ends with an ellipsis, within the limit', () => {
+        expect((0, list_parse_1.cleanLine)('12345678901', 10)).toBe('123456789\u2026');
+    });
+    test('control characters and line breaks are escaped', () => {
+        const out = (0, list_parse_1.cleanLine)('a\u001b[31m\nb\u2028c\u0085d\u007fe', 100);
+        expect(out).toBe('a\\u001b[31m\\u000ab\\u2028c\\u0085d\\u007fe');
+        expect(out).not.toMatch(list_fixtures_1.UNSAFE);
+    });
+    test('bidi marks are escaped', () => {
+        expect((0, list_parse_1.cleanLine)('a\u202eb\u2066c', 100)).toBe('a\\u202eb\\u2066c');
+    });
+    test('the escapes count against the limit: the result never exceeds it', () => {
+        const out = (0, list_parse_1.cleanLine)('\u001b'.repeat(50), 20);
+        expect(out.length).toBe(20);
+        expect(out.endsWith('\u2026')).toBe(true);
+    });
+    test('a surrogate pair is never split by the cut', () => {
+        const out = (0, list_parse_1.cleanLine)(`${'x'.repeat(8)}\u{1F600}\u{1F600}`, 9);
+        expect(Buffer.from(out, 'utf8').toString('utf8')).toBe(out);
+        expect(out.length).toBeLessThanOrEqual(9);
+    });
+    test('a very long text is cut in linear time', () => {
+        expect((0, list_parse_1.cleanLine)('\u001b'.repeat(5_000_000), 1024).length).toBe(1024);
+        (0, helpers_1.expectLinearScaling)((n) => { (0, list_parse_1.cleanLine)('\u001b'.repeat(n), 1024); (0, list_parse_1.cleanLine)('a\u202e'.repeat(n / 2), 1024); }, 200_000);
+    });
+});