agentic-workflow-manager 9.19.0 → 9.20.1

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+const render_list_1 = require("../../../src/core/changes/render-list");
+const UNSAFE = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+const change = (o = {}) => ({
+    sha: 'abcdef0123456789abcdef0123456789abcdef01', subject: 'feat: x', classification: 'missing', merged_at: '2026-10-16T20:00:00.000Z', pr: null, release: null, records: [], ...o,
+});
+const result = (o = {}) => ({
+    repo: 'github.com/Kodria/belanz', base: 'main', since: '2026-10-15T12:00:00.000Z', adopted: true, truncated: false, omitted: 0, changes: [], ...o,
+});
+const rec = (o = {}) => ({
+    path: 'docs/changes/2026-10-16-first.md', schema: 'awm.change-record/v1', id: '2026-10-16-first', title: 'Primer', summary_short: 'Primer cambio.', type: 'feat',
+    scope: null, semver: 'minor', breaking: false, modules: ['cli'], verification: { commit: 'a'.repeat(40), overall: 'pass', sensors: { lint: 'pass' }, receipt_digest: `sha256:${'b'.repeat(64)}` },
+    manual_validation: [{ step: 's1', expected: 'e1' }, { step: 's2', expected: 'e2' }], risks: [], rollback: 'revert', ...o,
+});
+const recorded = (o = {}, c = {}) => change({ classification: 'recorded', records: [rec(o)], ...c });
+const lines = (text) => text.split('\n').slice(0, -1);
+describe('renderJson (R5.6)', () => {
+    test('is one line ending in a newline', () => {
+        const out = (0, render_list_1.renderJson)(result({ changes: [recorded()] }));
+        expect(out.endsWith('\n')).toBe(true);
+        expect(lines(out)).toHaveLength(1);
+    });
+    test('has exactly the documented keys, in order', () => {
+        expect(Object.keys(JSON.parse((0, render_list_1.renderJson)(result())))).toEqual(['schema', 'repo', 'base', 'since', 'adopted', 'truncated', 'omitted', 'changes']);
+        expect(JSON.parse((0, render_list_1.renderJson)(result())).schema).toBe('awm.changes-list/v1');
+    });
+    test('each change has exactly the documented keys, in order', () => {
+        const out = JSON.parse((0, render_list_1.renderJson)(result({ changes: [change()] })));
+        expect(Object.keys(out.changes[0])).toEqual(['sha', 'subject', 'classification', 'merged_at', 'pr', 'release', 'records']);
+    });
+    test('carries the values through', () => {
+        const out = JSON.parse((0, render_list_1.renderJson)(result({ truncated: true, omitted: 4, changes: [change({ pr: 10, release: 'v1.0.0', classification: 'exempt' })] })));
+        expect(out).toMatchObject({ repo: 'github.com/Kodria/belanz', base: 'main', since: '2026-10-15T12:00:00.000Z', truncated: true, omitted: 4 });
+        expect(out.changes[0]).toMatchObject({ classification: 'exempt', merged_at: '2026-10-16T20:00:00.000Z', pr: 10, release: 'v1.0.0', records: [] });
+    });
+    test('a recorded entry holds the path and the full frontmatter', () => {
+        const out = JSON.parse((0, render_list_1.renderJson)(result({ changes: [recorded()] })));
+        expect(out.changes[0].records[0]).toMatchObject({ path: 'docs/changes/2026-10-16-first.md', summary_short: 'Primer cambio.', verification: { overall: 'pass' } });
+    });
+    test('an invalid-record entry holds the path and the diagnostics', () => {
+        const diagnostics = [{ code: 'name-invalid', message: 'm' }];
+        const out = JSON.parse((0, render_list_1.renderJson)(result({ changes: [change({ classification: 'invalid-record', records: [{ path: 'docs/changes/x.md', diagnostics }] })] })));
+        expect(out.changes[0].records).toEqual([{ path: 'docs/changes/x.md', diagnostics }]);
+    });
+    test('a repository that has not adopted records is still a valid document with no changes', () => {
+        const out = JSON.parse((0, render_list_1.renderJson)(result({ adopted: false })));
+        expect(out).toMatchObject({ adopted: false, changes: [], truncated: false, omitted: 0 });
+    });
+    test('an adopted repository says so, with or without changes', () => {
+        expect(JSON.parse((0, render_list_1.renderJson)(result())).adopted).toBe(true);
+        expect(JSON.parse((0, render_list_1.renderJson)(result({ changes: [change()] }))).adopted).toBe(true);
+    });
+    test('a change whose date is unusable keeps merged_at null', () => {
+        expect(JSON.parse((0, render_list_1.renderJson)(result({ changes: [change({ merged_at: null })] }))).changes[0].merged_at).toBeNull();
+    });
+    test('an invalid-record entry lists every added record, the valid ones with empty diagnostics', () => {
+        const records = [{ path: 'docs/changes/a.md', diagnostics: [] }, { path: 'docs/changes/z.md', diagnostics: [{ code: 'name-invalid', message: 'm' }] }];
+        expect(JSON.parse((0, render_list_1.renderJson)(result({ changes: [change({ classification: 'invalid-record', records })] }))).changes[0].records).toEqual(records);
+    });
+    test('a null repo stays null', () => {
+        expect(JSON.parse((0, render_list_1.renderJson)(result({ repo: null }))).repo).toBeNull();
+    });
+    test.each([undefined, null, 5, 'x', [], {}, { changes: 'x' }])('an unusable result %j yields an error document, not a throw', (value) => {
+        const out = (0, render_list_1.renderJson)((0, helpers_1.bad)(value));
+        expect(lines(out)).toHaveLength(1);
+        expect(JSON.parse(out)).toEqual({ error: 'invalid-input' });
+    });
+});
+describe('renderText (R5.6)', () => {
+    test('a repository without records says so in one line, naming the repo and the base', () => {
+        expect((0, render_list_1.renderText)(result({ adopted: false }), 'fallback')).toBe('belanz has not adopted Change Records (no record under docs/changes/ on main).\n');
+    });
+    test('without a remote the fallback name is used', () => {
+        expect((0, render_list_1.renderText)(result({ adopted: false, repo: null }), 'my-dir')).toBe('my-dir has not adopted Change Records (no record under docs/changes/ on main).\n');
+    });
+    test('an empty window says so', () => {
+        expect((0, render_list_1.renderText)(result(), 'f')).toBe('No changes on main since 2026-10-15T12:00:00.000Z.\n');
+    });
+    test('has a header and one row per change', () => {
+        const out = lines((0, render_list_1.renderText)(result({ changes: [recorded({}, { pr: 10, release: 'v1.0.0' }), change({ subject: 'fix: no record' })] }), 'f'));
+        expect(out).toHaveLength(3);
+        expect(out[0]).toMatch(/^WHEN\s+CLASSIFICATION\s+SHA\s+PR\s+CHANGE/);
+    });
+    test('a row has the time, classification, short sha, PR, title and release', () => {
+        const out = lines((0, render_list_1.renderText)(result({ changes: [recorded({}, { pr: 10, release: 'v1.0.0' })] }), 'f'))[1];
+        expect(out).toBe('2026-10-16 20:00  recorded        abcdef01  #10     Primer  [v1.0.0]');
+    });
+    test('a change without a record shows its subject; a missing PR and release show a dash and nothing', () => {
+        const out = lines((0, render_list_1.renderText)(result({ changes: [change({ subject: 'fix: no record' })] }), 'f'))[1];
+        expect(out).toBe('2026-10-16 20:00  missing         abcdef01  -       fix: no record');
+    });
+    test('an invalid record shows the code of its first diagnostic', () => {
+        const entry = change({ classification: 'invalid-record', subject: 'feat: bad', records: [{ path: 'docs/changes/x.md', diagnostics: [{ code: 'name-invalid', message: 'm' }, { code: 'other', message: 'm' }] }] });
+        expect(lines((0, render_list_1.renderText)(result({ changes: [entry] }), 'f'))[1]).toBe('2026-10-16 20:00  invalid-record  abcdef01  -       feat: bad  (name-invalid)');
+    });
+    test('a mixed invalid-record commit shows the first FAILING record, not the first record', () => {
+        const entry = change({ classification: 'invalid-record', subject: 'feat: mixed', records: [{ path: 'docs/changes/a.md', diagnostics: [] }, { path: 'docs/changes/z.md', diagnostics: [{ code: 'name-invalid', message: 'm' }, { code: 'other', message: 'm' }] }] });
+        expect(lines((0, render_list_1.renderText)(result({ changes: [entry] }), 'f'))[1]).toBe('2026-10-16 20:00  invalid-record  abcdef01  -       feat: mixed  (name-invalid)');
+    });
+    test('a change whose date is unusable shows unknown in place of the time', () => {
+        expect(lines((0, render_list_1.renderText)(result({ changes: [change({ merged_at: null })] }), 'f'))[1]).toBe('unknown           missing         abcdef01  -       feat: x');
+    });
+    test('a truncated list ends with a notice naming how many were left out', () => {
+        const out = lines((0, render_list_1.renderText)(result({ truncated: true, omitted: 7, changes: [change()] }), 'f'));
+        expect(out[out.length - 1]).toBe('... 7 older change(s) not shown; narrow --since to see them.');
+    });
+    test('a list that is not truncated has no notice', () => {
+        expect((0, render_list_1.renderText)(result({ changes: [change()] }), 'f')).not.toMatch(/not shown/);
+    });
+    test('hostile text in every field stays on its own clean, bounded line', () => {
+        const hostile = `\u001b[31mred\u001b[0m\nsecond \u202eevil\u2028${'x'.repeat(1000)}`;
+        const entry = recorded({ title: hostile }, { release: hostile, pr: 3 });
+        const out = (0, render_list_1.renderText)(result({ base: hostile, repo: hostile, changes: [entry, change({ subject: hostile, classification: 'invalid-record', records: [{ path: hostile, diagnostics: [{ code: hostile, message: hostile }] }] })] }), hostile);
+        for (const line of lines(out)) {
+            expect(line).not.toMatch(UNSAFE);
+            expect(line.length).toBeLessThanOrEqual(300);
+        }
+        expect(lines(out)).toHaveLength(3);
+        expect(lines((0, render_list_1.renderText)(result({ adopted: false, base: hostile, repo: hostile }), hostile))).toHaveLength(1);
+        expect(lines((0, render_list_1.renderText)(result({ base: hostile }), hostile))).toHaveLength(1);
+        for (const line of lines((0, render_list_1.renderText)(result({ adopted: false, base: hostile, repo: hostile }), hostile))) {
+            expect(line).not.toMatch(UNSAFE);
+            expect(line.length).toBeLessThanOrEqual(300);
+        }
+    });
+    test.each([undefined, null, 5, 'x', [], {}, { changes: 'x' }])('an unusable result %j yields one line, not a throw', (value) => {
+        expect(lines((0, render_list_1.renderText)((0, helpers_1.bad)(value), 'f'))).toHaveLength(1);
+    });
+    test('an unusable fallback name does not throw', () => {
+        expect(lines((0, render_list_1.renderText)(result({ adopted: false, repo: null }), (0, helpers_1.bad)(undefined)))).toHaveLength(1);
+    });
+});
+describe('renderVoice (R5.6)', () => {
+    test('one sentence per recorded change, then the closing count', () => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [recorded(), change({ subject: 'fix: no record' }), change({ classification: 'invalid-record' })] }), 'f');
+        expect(lines(out)).toEqual([
+            'belanz: Primer cambio. feat, verificado, 2 validaciones manuales pendientes.',
+            'Además: 1 cambio(s) sin record y 1 con record inválido.',
+        ]);
+    });
+    test('the closing count is always given when there are changes', () => {
+        expect(lines((0, render_list_1.renderVoice)(result({ changes: [recorded()] }), 'f'))[1]).toBe('Además: 0 cambio(s) sin record y 0 con record inválido.');
+    });
+    test.each(['fail', 'skipped', 'not_certified'])('overall %s is sin verificar', (overall) => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [recorded({ verification: { overall } })] }), 'f');
+        expect(lines(out)[0]).toBe('belanz: Primer cambio. feat, sin verificar, 2 validaciones manuales pendientes.');
+    });
+    test('a record with no manual validation reports zero pending', () => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [recorded({ manual_validation: { none: 'nothing to check' } })] }), 'f');
+        expect(lines(out)[0]).toBe('belanz: Primer cambio. feat, verificado, 0 validaciones manuales pendientes.');
+    });
+    test('one pending validation is reported with the same wording', () => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [recorded({ manual_validation: [{ step: 'a', expected: 'b' }] })] }), 'f');
+        expect(lines(out)[0]).toContain('1 validaciones manuales pendientes.');
+    });
+    test.each([
+        ['Primer cambio.', 'Primer cambio.'],
+        ['Primer cambio', 'Primer cambio.'],
+        ['Funciona!', 'Funciona!'],
+        ['¿Funciona?', '¿Funciona?'],
+    ])('the summary %j is spoken as %j followed by the type', (summary, spoken) => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [recorded({ summary_short: summary, type: 'fix' })] }), 'f');
+        expect(lines(out)[0]).toBe(`belanz: ${spoken} fix, verificado, 2 validaciones manuales pendientes.`);
+    });
+    test('a mixed invalid-record commit is counted, not spoken', () => {
+        const entry = change({ classification: 'invalid-record', records: [{ path: 'docs/changes/a.md', diagnostics: [] }, { path: 'docs/changes/z.md', diagnostics: [{ code: 'x', message: 'm' }] }] });
+        expect(lines((0, render_list_1.renderVoice)(result({ changes: [entry] }), 'f'))).toEqual(['Además: 0 cambio(s) sin record y 1 con record inválido.']);
+    });
+    test('a change whose date is unusable is spoken like any other', () => {
+        expect(lines((0, render_list_1.renderVoice)(result({ changes: [recorded({}, { merged_at: null })] }), 'f'))[0]).toBe('belanz: Primer cambio. feat, verificado, 2 validaciones manuales pendientes.');
+    });
+    test('only recorded changes get a sentence; exempt ones are silent', () => {
+        const out = (0, render_list_1.renderVoice)(result({ changes: [change({ classification: 'exempt' }), recorded()] }), 'f');
+        expect(lines(out)).toHaveLength(2);
+    });
+    test('a change with two records gets one sentence for each', () => {
+        const entry = change({ classification: 'recorded', records: [rec({ summary_short: 'Uno.' }), rec({ summary_short: 'Dos.' })] });
+        const out = lines((0, render_list_1.renderVoice)(result({ changes: [entry] }), 'f'));
+        expect(out.slice(0, 2).map((l) => l.split(' ')[1])).toEqual(['Uno.', 'Dos.']);
+    });
+    test('the name falls back to the directory name without a remote', () => {
+        expect(lines((0, render_list_1.renderVoice)(result({ repo: null, changes: [recorded()] }), 'my-dir'))[0].startsWith('my-dir: ')).toBe(true);
+    });
+    test('a repository without records is told in one sentence', () => {
+        expect((0, render_list_1.renderVoice)(result({ adopted: false }), 'f')).toBe('belanz: todavía no usa Change Records.\n');
+    });
+    test('an empty window is told in one sentence', () => {
+        expect((0, render_list_1.renderVoice)(result(), 'f')).toBe('belanz: sin cambios desde 2026-10-15.\n');
+    });
+    test('a truncated list ends with a notice', () => {
+        const out = lines((0, render_list_1.renderVoice)(result({ truncated: true, omitted: 3, changes: [recorded()] }), 'f'));
+        expect(out[out.length - 1]).toBe('Hay 3 cambio(s) más antiguo(s) sin mostrar; acota el período.');
+    });
+    test('a list that is not truncated has no notice', () => {
+        expect((0, render_list_1.renderVoice)(result({ changes: [recorded()] }), 'f')).not.toMatch(/acota/);
+    });
+    test('hostile text stays on clean, bounded lines', () => {
+        const hostile = `\u001b[31mred\u001b[0m\nsecond \u202eevil\u2028${'x'.repeat(1000)}`;
+        const out = (0, render_list_1.renderVoice)(result({ repo: hostile, changes: [recorded({ summary_short: hostile, type: hostile })] }), hostile);
+        expect(lines(out)).toHaveLength(2);
+        for (const line of lines(out)) {
+            expect(line).not.toMatch(UNSAFE);
+            expect(line.length).toBeLessThanOrEqual(600);
+        }
+        expect(lines((0, render_list_1.renderVoice)(result({ adopted: false, repo: hostile }), hostile))).toHaveLength(1);
+    });
+    test.each([undefined, null, 5, 'x', [], {}, { changes: 'x' }])('an unusable result %j yields one line, not a throw', (value) => {
+        expect(lines((0, render_list_1.renderVoice)((0, helpers_1.bad)(value), 'f'))).toHaveLength(1);
+    });
+});

package/dist/tests/core/changes/render.test.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const helpers_1 = require("./helpers");
+const parse_1 = require("../../../src/core/changes/parse");
+const render_1 = require("../../../src/core/changes/render");
+const validate_shape_1 = require("../../../src/core/changes/validate-shape");
+// Pure functions: no repository, no filesystem.
+const frontmatter = (text) => {
+    const split = (0, parse_1.splitRecord)(text);
+    if (!split.ok)
+        throw new Error('not a record');
+    const loaded = (0, parse_1.loadFrontmatter)(split.frontmatterText);
+    if (!loaded.ok)
+        throw new Error('bad yaml');
+    return loaded.value;
+};
+describe('render: renderSkeleton', () => {
+    const fields = { type: 'feat', scope: null, semver: 'minor', breaking: false, modules: ['cli/src'] };
+    const verification = { commit: 'a'.repeat(40), overall: 'pass', sensors: { lint: 'pass' }, receipt_digest: `sha256:${'b'.repeat(64)}` };
+    test('renders frontmatter and the four body sections', () => {
+        const text = (0, render_1.renderSkeleton)({ id: '2026-10-17-x', fields, verification });
+        expect(text.startsWith('---\nschema: awm.change-record/v1\nid: 2026-10-17-x\n')).toBe(true);
+        expect((0, validate_shape_1.validateRecordShape)('2026-10-17-x.md', text).diagnostics.map((d) => d.code)).toEqual(['pending-content']);
+    });
+    test('hostile provenance and link values survive a YAML round trip as plain strings', () => {
+        const nasty = 'a: b # c\n- d';
+        const text = (0, render_1.renderSkeleton)({ id: '2026-10-17-x', fields, verification, provenance: { model: nasty, session: '&anchor *alias !!tag' }, links: { issue: 'https://e.com/?a=b#c' } });
+        expect(text).not.toBeNull();
+        const fm = frontmatter(text);
+        expect(fm.provenance).toEqual({ model: nasty, session: '&anchor *alias !!tag' });
+        expect(fm.links).toEqual({ issue: 'https://e.com/?a=b#c' });
+        expect(Object.keys(fm)).toEqual(['schema', 'id', 'title', 'summary_short', 'type', 'scope', 'semver', 'breaking', 'modules', 'links', 'verification', 'manual_validation', 'risks', 'rollback', 'provenance']);
+    });
+    const circular = {};
+    circular.self = circular;
+    test.each([
+        ['a null input', () => (0, render_1.renderSkeleton)(null)],
+        ['an undefined verification', () => (0, render_1.renderSkeleton)({ id: '2026-10-17-x', fields, verification: undefined })],
+        ['a numeric id', () => (0, render_1.renderSkeleton)({ id: 5, fields, verification })],
+        ['a circular provenance', () => (0, render_1.renderSkeleton)({ id: '2026-10-17-x', fields, verification, provenance: circular })],
+    ])('yields null for %s instead of throwing', (_name, call) => {
+        expect(call()).toBeNull();
+    });
+});
+describe('render: refreshDerived', () => {
+    const FRESH = { type: 'feat', scope: 'core', semver: 'minor', breaking: false, modules: ['cli/src/core'] };
+    const FRESH_V = { commit: 'c'.repeat(40), overall: 'pass', sensors: { lint: 'pass' }, receipt_digest: `sha256:${'d'.repeat(64)}` };
+    const OLD = [
+        '---', 'schema: awm.change-record/v1', 'id: 2026-10-17-x', '# derived fields follow', 'type: fix', 'scope: null', 'semver: patch', 'breaking: false',
+        'modules:', '- old/a', '- old/b', '# a comment after the list', '', 'links:', '  plan: docs/plans/p.md', 'verification:', `  commit: ${'0'.repeat(40)}`,
+        '  overall: fail', '  sensors:', '    lint: fail', `  receipt_digest: sha256:${'0'.repeat(64)}`, 'title: Hello', '---', '', 'body text', '',
+    ];
+    const NEW_BLOCKS = [
+        '---', 'schema: awm.change-record/v1', 'id: 2026-10-17-x', '# derived fields follow', 'type: feat', 'scope: core', 'semver: minor', 'breaking: false',
+        'modules:', '  - cli/src/core', '# a comment after the list', '', 'links:', '  plan: docs/plans/p.md', 'verification:', `  commit: ${'c'.repeat(40)}`,
+        '  overall: pass', '  sensors:', '    lint: pass', `  receipt_digest: sha256:${'d'.repeat(64)}`, 'title: Hello', '---', '', 'body text', '',
+    ];
+    const lf = (lines) => lines.join('\n');
+    const crlf = (lines) => lines.join('\r\n');
+    test('replaces exactly the derived blocks, keeping comments, blank lines, other keys and the body', () => {
+        expect((0, render_1.refreshDerived)(lf(OLD), FRESH, FRESH_V)).toBe(lf(NEW_BLOCKS));
+    });
+    test('a column-0 list is replaced as one block and the key after it is untouched', () => {
+        const old = ['---', 'type: fix', 'scope: x', 'semver: none', 'breaking: false', 'modules:', '- a', '- b', 'verification: {}', 'title: T', '---', 'b', ''];
+        const out = (0, render_1.refreshDerived)(lf(old), FRESH, FRESH_V);
+        expect(out.endsWith('title: T\n---\nb\n')).toBe(true);
+        expect(frontmatter(out).modules).toEqual(['cli/src/core']);
+        expect(frontmatter(out).title).toBe('T');
+    });
+    test('CRLF files keep CRLF', () => {
+        expect((0, render_1.refreshDerived)(crlf(OLD), FRESH, FRESH_V)).toBe(crlf(NEW_BLOCKS));
+    });
+    test('mixed line endings keep each untouched line ending', () => {
+        const old = OLD.map((l, i) => (i % 2 === 0 ? `${l}\r` : l));
+        const out = (0, render_1.refreshDerived)(old.join('\n'), FRESH, FRESH_V);
+        expect(out.split('\n').find((l) => l.startsWith('title:'))).toBe(old.find((l) => l.startsWith('title:')));
+        expect(out.endsWith(old.slice(-2).join('\n'))).toBe(true);
+        expect(frontmatter(out).modules).toEqual(['cli/src/core']);
+    });
+    test('the body is preserved byte for byte, even when it looks like frontmatter', () => {
+        const tail = '\n\n---\ntype: nope\n---\nmodules:\n- z\n';
+        const out = (0, render_1.refreshDerived)(lf(OLD) + tail, FRESH, FRESH_V);
+        expect(out.endsWith(tail)).toBe(true);
+    });
+    test('trailing whitespace after the closing delimiter content and a missing final newline survive', () => {
+        const out = (0, render_1.refreshDerived)(lf(OLD).replace(/\n$/, '') + '  ', FRESH, FRESH_V);
+        expect(out.endsWith('body text  ')).toBe(true);
+    });
+    test('a scalar with a trailing comment on the key line is replaced as a unit', () => {
+        const old = lf(OLD).replace('type: fix', 'type: fix # why');
+        expect((0, render_1.refreshDerived)(old, FRESH, FRESH_V)).toBe(lf(NEW_BLOCKS));
+    });
+    test('a null scope round-trips as null', () => {
+        const out = (0, render_1.refreshDerived)(lf(OLD), { ...FRESH, scope: null }, FRESH_V);
+        expect(frontmatter(out).scope).toBeNull();
+    });
+    test('hostile sensor names and module names are quoted so they parse back unchanged', () => {
+        const v = { ...FRESH_V, sensors: { 'a: b': 'pass', '# x': 'fail', 'yes': 'skipped', '-': 'pass' } };
+        const out = (0, render_1.refreshDerived)(lf(OLD), { ...FRESH, modules: ['a b', 'c#d', '*x', 'y:z'] }, v);
+        expect(frontmatter(out).verification).toEqual(v);
+        expect(frontmatter(out).modules).toEqual(['a b', 'c#d', '*x', 'y:z']);
+        expect(strip2(out)).toBe(strip2(lf(NEW_BLOCKS)));
+    });
+    // The title/id/links/body lines, which a refresh never touches.
+    const strip2 = (s) => s.split('\n').filter((l) => /^(schema|id|title|links|  plan|#|body)/.test(l)).join('\n');
+    test.each([
+        ['no frontmatter', 'type: fix\n'],
+        ['unclosed frontmatter', '---\ntype: fix\n'],
+        ['unparseable yaml', '---\n: : :\n---\n'],
+        ['a missing derived key', lf(OLD).replace('semver: patch\n', '')],
+        ['a missing verification', lf(OLD).replace(/^verification:[\s\S]*?(?=^title)/m, '')],
+        ['a non-mapping frontmatter', '---\n- a\n- b\n---\n'],
+        ['a duplicated key', lf(OLD).replace('title: Hello', 'type: fix\ntitle: Hello')],
+        ['an anchor', lf(OLD).replace('title: Hello', 'title: &a Hello')],
+        ['a key the line scan cannot recognise, right after a replaced block', lf(OLD).replace('title: Hello', 'odd key: 1\ntitle: Hello')],
+        ['an escaped spelling of a derived key next to the bare one', lf(OLD).replace('title: Hello', '"\\u0074ype": x\ntitle: Hello')],
+        ['an escaped spelling of a derived key instead of the bare one', lf(OLD).replace('type: fix\n', '"\\u0074ype": fix\n')],
+        ['an empty string', ''],
+    ])('returns null for %s', (_name, raw) => {
+        expect((0, render_1.refreshDerived)(raw, FRESH, FRESH_V)).toBeNull();
+    });
+    const circular = {};
+    circular.self = circular;
+    test.each([
+        ['raw text that is not a string', () => (0, render_1.refreshDerived)(undefined, FRESH, FRESH_V)],
+        ['fields that are null', () => (0, render_1.refreshDerived)(lf(OLD), null, FRESH_V)],
+        ['verification that is undefined', () => (0, render_1.refreshDerived)(lf(OLD), FRESH, undefined)],
+        ['a derived field that is undefined', () => (0, render_1.refreshDerived)(lf(OLD), { ...FRESH, scope: undefined }, FRESH_V)],
+        ['a circular verification', () => (0, render_1.refreshDerived)(lf(OLD), FRESH, circular)],
+    ])('returns null for %s, never throws', (_name, call) => {
+        expect(call()).toBeNull();
+    });
+    test('a block scalar after the derived keys is carried over byte for byte', () => {
+        const raw = lf(OLD).replace('title: Hello', 'title: >\n  one\n  two\nrollback: kept');
+        const out = (0, render_1.refreshDerived)(raw, FRESH, FRESH_V);
+        expect(frontmatter(out).title).toBe('one two\n');
+        expect(frontmatter(out).rollback).toBe('kept');
+        expect(out).toContain('title: >\n  one\n  two\nrollback: kept');
+    });
+    test('never alters a key that is not derived, whatever follows a replaced block', () => {
+        const raw = lf(OLD).replace('breaking: false\n', 'breaking: false\nrisks:\n- r1\n- r2\n');
+        const out = (0, render_1.refreshDerived)(raw, FRESH, FRESH_V);
+        expect(frontmatter(out).risks).toEqual(['r1', 'r2']);
+        expect(out).toContain('risks:\n- r1\n- r2\n');
+    });
+    describe('recomputed keys written other than bare', () => {
+        const SPELLINGS = [
+            ['double-quoted', (k) => `"${k}":`],
+            ['single-quoted', (k) => `'${k}':`],
+            ['bare with a space before the colon', (k) => `${k} :`],
+            ['bare with a tab before the colon', (k) => `${k}\t:`],
+            ['double-quoted with spaces before the colon', (k) => `"${k}"  :`],
+            ['single-quoted with a tab before the colon', (k) => `'${k}'\t:`],
+        ];
+        const spell = (lines, key, fn) => lines.map((l) => (l.startsWith(`${key}:`) ? fn(key) + l.slice(key.length + 1) : l));
+        const KEYS = ['type', 'scope', 'semver', 'breaking', 'modules', 'verification'];
+        test.each(SPELLINGS.flatMap(([name, fn]) => KEYS.map((key) => [name, key, fn])))('%s %s is recomputed like a bare key', (_name, key, fn) => {
+            const old = spell(OLD, key, fn);
+            expect(old).not.toEqual(OLD);
+            expect((0, render_1.refreshDerived)(lf(old), FRESH, FRESH_V)).toBe(lf(NEW_BLOCKS));
+        });
+        test.each(SPELLINGS)('%s keys keep CRLF', (_name, fn) => {
+            const old = KEYS.reduce((lines, key) => spell(lines, key, fn), OLD);
+            expect((0, render_1.refreshDerived)(crlf(old), FRESH, FRESH_V)).toBe(crlf(NEW_BLOCKS));
+        });
+        test('a spelled key is also found in the middle of a file next to other keys', () => {
+            const old = lf(OLD).replace('title: Hello', '"title": Hello');
+            expect((0, render_1.refreshDerived)(old, FRESH, FRESH_V)).toBe(lf(NEW_BLOCKS).replace('title: Hello', '"title": Hello'));
+        });
+        test('a quoted key with an escaped quote is kept, never taken for a derived key', () => {
+            const line = '"sem\\"ver": 1';
+            const out = (0, render_1.refreshDerived)(lf(OLD).replace('title: Hello', `${line}\ntitle: Hello`), FRESH, FRESH_V);
+            expect(out).toBe(lf(NEW_BLOCKS).replace('title: Hello', `${line}\ntitle: Hello`));
+            expect(frontmatter(out)['sem"ver']).toBe(1);
+        });
+        test('a single-quoted key with a doubled quote is kept, never taken for a derived key', () => {
+            const line = "'it''s': 1";
+            const out = (0, render_1.refreshDerived)(lf(OLD).replace('title: Hello', `${line}\ntitle: Hello`), FRESH, FRESH_V);
+            expect(out).toBe(lf(NEW_BLOCKS).replace('title: Hello', `${line}\ntitle: Hello`));
+            expect(frontmatter(out)["it's"]).toBe(1);
+        });
+        test('a quoted key that merely contains a derived name is not recomputed', () => {
+            const line = '"type extra": 1';
+            const out = (0, render_1.refreshDerived)(lf(OLD).replace('title: Hello', `${line}\ntitle: Hello`), FRESH, FRESH_V);
+            expect(out).toContain(`${line}\ntitle: Hello`);
+        });
+        test('a hostile very long quoted line is scanned in linear time', () => {
+            const hostile = (n) => lf(OLD).replace('title: Hello', `"${'\\'.repeat(n)}\ntitle: Hello`);
+            expect((0, render_1.refreshDerived)(hostile(200000), FRESH, FRESH_V)).toBeNull();
+            (0, helpers_1.expectLinearScaling)((n) => { (0, render_1.refreshDerived)(hostile(n), FRESH, FRESH_V); }, 50_000);
+        });
+    });
+    test('the dumped blocks use the core schema (what the validator parses)', () => {
+        const out = (0, render_1.refreshDerived)(lf(OLD), { ...FRESH, scope: 'null' }, FRESH_V);
+        expect(out).toContain("scope: 'null'");
+        expect(js_yaml_1.default.load(out.split('\n---')[0].slice(4), { schema: js_yaml_1.default.CORE_SCHEMA })).toMatchObject({ scope: 'null' });
+    });
+});