@productbrain/cli 0.1.0-beta.14 → 0.1.0-beta.14010

package/dist/__tests__/entryAccept.test.js

@@ -0,0 +1,573 @@
+/**
+ * pb entry accept (formerly pb promote, DEC-1578) — verify kernelCallWithSession sequence and args.
+ * Covers: happy path (direct commit), governance proposal, no session, empty entryId,
+ * and the SERVER-side auto-verify receipt (WP-B, attestation-model spec §4.3 — the
+ * old client-side verify-then-retry on QUALITY_GATE_BLOCKED is deleted dead code).
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { runEntryAccept, missingFieldsLine, spineNextLine } from '../commands/entryAccept.js';
+import { LINK_REFUSAL_WORDS, renderChecklist, rungLine } from '../lib/checklist.js';
+const kernelCallWithSessionMock = vi.fn();
+// TASK-1040: an accept calls no quality.* route; this mock catches one if it ever does.
+const qualityRouteMock = vi.fn();
+// Hoist McpError so it's available both in the mock factory and in test bodies.
+// The client mock must export the same class other lib consumers import; the
+// tests use it to shape server-thrown errors (WP-B deleted entryAccept.ts's own
+// McpError-instanceof retry, so only the mock factory needs the class now).
+const { MockMcpError } = vi.hoisted(() => {
+    class MockMcpError extends Error {
+        code;
+        details;
+        constructor(message, code, details) {
+            super(message);
+            this.name = 'McpError';
+            this.code = code;
+            this.details = details;
+        }
+    }
+    return { MockMcpError };
+});
+vi.mock('../lib/client.js', async () => ({
+    kernelCallWithSession: (...args) => String(args[0]).startsWith('quality.') ? qualityRouteMock(...args) : kernelCallWithSessionMock(...args),
+    McpError: MockMcpError,
+    // WP-753 O5a fix round 2: real implementation, not a stub — entryAccept.ts's abort predicate
+    // depends on its actual per-entry-code classification, not a mocked always-true/false.
+    isPerEntryAuthorizationRefusal: (await vi.importActual('../lib/client.js')).isPerEntryAuthorizationRefusal,
+}));
+vi.mock('../lib/config.js', () => ({
+    getConfigOrGuide: vi.fn(() => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
+}));
+// Output mode is controllable per-test via runnerState.jsonMode (defaults to pretty,
+// so existing formatEntryAcceptReceipt assertions keep working). The mock runCliCommand
+// mirrors the real one: JSON.stringify in json mode, formatPretty otherwise.
+const { runnerState } = vi.hoisted(() => ({ runnerState: { jsonMode: false } }));
+vi.mock('../lib/runner.js', () => ({
+    isJsonMode: () => runnerState.jsonMode,
+    runCliCommand: vi.fn(async ({ fn, formatPretty }) => {
+        const data = await fn();
+        if (runnerState.jsonMode) {
+            process.stdout.write(JSON.stringify(data) + '\n');
+        }
+        else {
+            process.stdout.write(formatPretty(data) + '\n');
+        }
+    }),
+}));
+let mockSession = { sessionId: 'sess-test' };
+vi.mock('../lib/session.js', () => ({
+    readSession: () => mockSession,
+}));
+describe('runEntryAccept', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        qualityRouteMock.mockReset();
+        qualityRouteMock.mockResolvedValue(null);
+        mockSession = { sessionId: 'sess-test' };
+        runnerState.jsonMode = false;
+    });
+    it('accept is one call: no entry read, no conflict detection and no wait for the quality judge', async () => {
+        kernelCallWithSessionMock.mockResolvedValueOnce({ _id: 'j1', entryId: 'VIS-1', versionId: 'v1', version: 1, status: 'current', statusLabels: { from: 'Draft', to: 'Accepted' } });
+        const write = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        try {
+            await runEntryAccept({ entryId: 'VIS-1' });
+            expect(kernelCallWithSessionMock.mock.calls.map((c) => c[0])).toEqual(['chain.commitEntry']);
+            expect(qualityRouteMock).not.toHaveBeenCalled();
+            expect(write.mock.calls.map((c) => String(c[0])).join('')).not.toMatch(/Judged in/);
+        }
+        finally {
+            write.mockRestore();
+        }
+    });
+    it("prints the kernel's line when the draft's own conflict check had not finished", async () => {
+        const line = 'Conflicts not checked at accept; the check that runs after it flags any it finds on the entry.';
+        kernelCallWithSessionMock.mockResolvedValueOnce({ _id: 'j1', entryId: 'DEC-9', versionId: 'v1', version: 1, statusLabels: { from: 'Draft', to: 'Decided' }, conflictCheck: line });
+        const write = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        try {
+            await runEntryAccept({ entryId: 'DEC-9' });
+            expect(write.mock.calls.map((c) => String(c[0])).join('')).toContain(`\n  ${line}\n`);
+        }
+        finally {
+            write.mockRestore();
+        }
+    });
+    it('a stale verdict (a spine child accepted after its parent) relays the kernel hold and its refresh hint, in one call', async () => {
+        const hold = 'The judgment is being refreshed; accept again once it lands.';
+        kernelCallWithSessionMock.mockRejectedValueOnce(new MockMcpError(`The stored quality verdict does not cover the current content.\n${hold}`, 'SEMANTIC_QUALITY_GATE_BLOCKED'));
+        const thrown = await runEntryAccept({ entryId: 'OBJ-2' }).catch((e) => e);
+        expect(thrown.message).toContain(hold);
+        expect(thrown.message).not.toContain('Edit the entry');
+        expect(kernelCallWithSessionMock.mock.calls.map((c) => c[0])).toEqual(['chain.commitEntry']);
+    });
+    it('relays the kernel hold line for a conflict check still running, word for word', async () => {
+        const hold = 'Not accepted yet: the conflict check is running on what changed since this draft was checked. Accept again in a minute or two; once the check has run, the accept lands.';
+        kernelCallWithSessionMock.mockRejectedValueOnce(new MockMcpError(hold, 'VALIDATION_FAILED'));
+        const thrown = await runEntryAccept({ entryId: 'DEC-HOLD' }).catch((e) => e);
+        expect(thrown.message).toBe(hold);
+    });
+    it('calls chain.commitEntry with correct args (happy path)', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'TEN-951',
+            versionId: 'v123',
+            version: 1,
+            status: 'current',
+            statusLabels: { from: 'Draft', to: 'Open' },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'TEN-951' });
+        writeSpy.mockRestore();
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
+            entryId: 'TEN-951',
+            author: 'agent:sess-test',
+            sessionId: 'sess-test',
+        });
+    });
+    // TASK-1095 round 4 (DEC-2006): --reason rides beside --replaces; without it the CLI sends none and the kernel refuses by name.
+    it('with --replaces, --reason is sent as replacesReason, and no --reason sends none', async () => {
+        const commit = { _id: 'j571abc', entryId: 'STR-5', versionId: 'v1', version: 1, status: 'current', statusLabels: { from: 'Draft', to: 'Decided' } };
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallWithSessionMock.mockResolvedValueOnce(commit);
+        await runEntryAccept({ entryId: 'STR-5', replaces: 'STR-3', reason: 'Founders keep the books.' });
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', expect.objectContaining({ entryId: 'STR-5', replaces: 'STR-3', replacesReason: 'Founders keep the books.' }));
+        kernelCallWithSessionMock.mockClear();
+        kernelCallWithSessionMock.mockResolvedValueOnce(commit);
+        await runEntryAccept({ entryId: 'STR-5', replaces: 'STR-3' });
+        writeSpy.mockRestore();
+        const sent = kernelCallWithSessionMock.mock.calls.find((c) => c[0] === 'chain.commitEntry')?.[1];
+        expect(sent).toMatchObject({ replaces: 'STR-3' });
+        expect(sent).not.toHaveProperty('replacesReason');
+    });
+    it('passes commitMessage when --message is provided', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'TEN-951',
+            versionId: 'v123',
+            version: 1,
+            status: 'current',
+            statusLabels: { from: 'Draft', to: 'Open' },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'TEN-951', message: 'Validated and ready' });
+        writeSpy.mockRestore();
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
+            entryId: 'TEN-951',
+            author: 'agent:sess-test',
+            sessionId: 'sess-test',
+            commitMessage: 'Validated and ready',
+        });
+    });
+    it('displays version result for direct commit', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'TEN-951',
+            name: 'Wave 2 smoke test',
+            versionId: 'v123',
+            version: 1,
+            status: 'current',
+            statusLabels: { from: 'Draft', to: 'Open' },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'TEN-951' });
+        const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Accepted TEN-951');
+        expect(output).toContain('Draft → Open'); // TASK-889: the kernel's Rail words, never the stored trust word
+        expect(output).not.toContain('current');
+        expect(output).toContain('v1');
+    });
+    // 'displays proposal result for governance mode' deleted (WP-776 S2a, DEC-1771): chain.
+    // commitEntry never returns `status: 'proposal_created'` anymore — the relation-consent
+    // proposal system it named is deleted (see formatters/entryAccept.ts's CommitEntryResult).
+    it('displays quality warnings when present', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'BET-151',
+            name: 'Test Bet',
+            versionId: 'v123',
+            version: 1, statusLabels: { from: 'Draft', to: 'Open' },
+            qualityVerdict: {
+                verdict: 'warn',
+                violations: ['Missing done-when criteria', 'No appetite set'],
+            },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'BET-151' });
+        const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Quality warnings');
+        expect(output).toContain('Missing done-when criteria');
+        expect(output).toContain('No appetite set');
+    });
+    it('throws CLIError with no active session', async () => {
+        mockSession = null;
+        await expect(runEntryAccept({ entryId: 'TEN-951' })).rejects.toThrow('No active session');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+    });
+    it('throws CLIError with empty entryId', async () => {
+        await expect(runEntryAccept({ entryId: '  ' })).rejects.toThrow('Entry ID is required');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+    });
+    it('handles server errors thrown during commit', async () => {
+        kernelCallWithSessionMock.mockRejectedValue(new Error('Entry not found.'));
+        await expect(runEntryAccept({ entryId: 'TEN-999' })).rejects.toThrow('Entry not found.');
+    });
+    // WP-485 Slice 2b (R3, FEAT-1370): the commit succeeded — the advisory is informational,
+    // rendered from the server's single verdict, never re-derived client-side.
+    it('renders a contradictionAdvisory in the receipt when the server attaches one', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'DEC-100',
+            name: 'Advisory entry',
+            versionId: 'v123',
+            version: 1, statusLabels: { from: 'Draft', to: 'Open' },
+            contradictionAdvisory: {
+                reason: 'Advisory only — a contradiction never blocks.',
+                blockingCount: 1,
+                conflictDetails: [
+                    {
+                        chainEntryId: 'DEC-42',
+                        chainEntryName: 'Existing decision',
+                        type: 'contradiction',
+                        confidence: 0.9,
+                        explanation: 'Directly contradicts the approved baseline.',
+                    },
+                ],
+            },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'DEC-100' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Accepted DEC-100');
+        expect(output).toContain('Contradiction advisory');
+        expect(output).toContain('Advisory only — a contradiction never blocks.');
+        expect(output).toContain('DEC-42');
+    });
+    // WP-B (attestation-model spec §4.3): the server auto-verifies as part of the
+    // promote itself. The CLI never verifies-and-retries — it renders the receipt.
+    it('renders the server auto-verify receipt (no client-side verify, single commit call)', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc', entryId: 'INS-100', versionId: 'v1', version: 1, statusLabels: { from: 'Draft', to: 'Open' },
+            autoVerified: { strength: 'delegated', basis: 'attested', context: 'promote-gate', verifiedBy: 'agent for Randy Test' },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'INS-100' });
+        const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
+        writeSpy.mockRestore();
+        // THE RECEIPT SAYS SO (spec §4.3) — silence here is a structural regression.
+        expect(output).toContain('Accepted INS-100');
+        expect(output).toContain('Auto-verified as part of accept — delegated (agent for Randy Test)');
+        // The client-side verify-then-retry is dead code: verifyEntry never called,
+        // commitEntry called exactly once.
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.verifyEntry', expect.anything());
+        const commitCalls = kernelCallWithSessionMock.mock.calls.filter(c => c[0] === 'chain.commitEntry');
+        expect(commitCalls).toHaveLength(1);
+    });
+    it('surfaces ANY QUALITY_GATE_BLOCKED as a legible error — no verify-retry, even for a verification-shaped block from an old server (spec §11 rollout rule)', async () => {
+        kernelCallWithSessionMock
+            .mockRejectedValueOnce(new MockMcpError('Agent-origin entry requires verification before it is accepted', 'QUALITY_GATE_BLOCKED'));
+        await expect(runEntryAccept({ entryId: 'INS-100' })).rejects.toThrow('requires verification');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.verifyEntry', expect.anything());
+        const commitCalls = kernelCallWithSessionMock.mock.calls.filter(c => c[0] === 'chain.commitEntry');
+        expect(commitCalls).toHaveLength(1);
+    });
+    // TASK-1038: a not-verified accept names its fix as data; pb prints what stayed, the kernel's sentence and its own Next.
+    it.each([
+        ['verify', 'This entry is not verified yet. Verify it, then accept it again.', 'Next: pb verify INS-200, then pb entry accept INS-200.'],
+        ['person', 'Only a person can accept this entry; a person accepts it in Product Brain.', undefined],
+    ])('a GROUNDING_GATE_BLOCKED accept whose fix is %s prints its signed Next', async (fix, reason, next) => {
+        kernelCallWithSessionMock
+            .mockRejectedValueOnce(new MockMcpError(reason, 'GROUNDING_GATE_BLOCKED', [{ refusalFix: fix }]));
+        const thrown = await runEntryAccept({ entryId: 'INS-200' }).catch((e) => e);
+        expect(thrown.message).toBe(`INS-200 was not accepted and stays a draft. ${reason}`);
+        expect(thrown.guidance).toBe(next);
+    });
+    it('surfaces other QUALITY_GATE_BLOCKED reasons unchanged', async () => {
+        kernelCallWithSessionMock
+            .mockRejectedValueOnce(new MockMcpError('Entry missing required fields', 'QUALITY_GATE_BLOCKED'));
+        await expect(runEntryAccept({ entryId: 'BET-200' })).rejects.toThrow('Entry missing required fields');
+        // verifyEntry must never have been called
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.verifyEntry', expect.anything());
+    });
+    // TASK-888 (RULE-660): a refused vision or strategy prints the same rung checklist shape as a refused
+    // objective — the kernel sentence verbatim, its lines from the one checklist this CLI ships.
+    it.each([
+        ['OBJ-9', 'objective', 'strategy'],
+        ['STR-9', 'strategy', 'vision'],
+        ['VIS-9', 'vision', 'purpose'],
+    ])('prints the spine rung checklist for a refused %s unchanged', async (entryId, subject, rung) => {
+        const line = renderChecklist('strategy_link', [{ id: rung, passed: false }], false)[0];
+        const sentence = `Cannot accept this ${subject} without a strategy link. Fix each [ ] line, then try again.\n${line}`;
+        kernelCallWithSessionMock
+            .mockRejectedValueOnce(new MockMcpError(sentence, 'VALIDATION_FAILED'));
+        await expect(runEntryAccept({ entryId })).rejects.toThrow(sentence);
+        expect(line).toBe(`[ ] ${rungLine(rung)}`); // TASK-1026: the one rung sentence
+    });
+    // ── WP-465 slice ⑤ (Finding #25): structured coherency refusal in --json mode ──
+    it('emits machine-readable refusal routes to stdout on a Standard/Strict coherency refusal (--json)', async () => {
+        runnerState.jsonMode = true;
+        const refusal = {
+            outcome: 'refused',
+            code: 'COHERENCY_REFUSED',
+            disposition: 'acknowledge',
+            effectiveDisposition: 'acknowledge-required',
+            overridable: true,
+            mode: 'standard',
+            reason: 'This entry links to nothing it serves. Link it to what it serves, or answer why it stands alone.',
+            fix: 'link',
+            subject: { entryId: 'DEC-500', name: 'Standalone decision' },
+            routes: {
+                link: { description: LINK_REFUSAL_WORDS.linkRoute },
+                acknowledge: {
+                    param: 'coherencyAcknowledgement',
+                    responses: ['linked', 'accepted-fix', 'diverged'],
+                    minReasonChars: 12,
+                    description: LINK_REFUSAL_WORDS.answerRoute,
+                },
+                override: { param: 'steeringOverrideReason', minChars: 12, description: LINK_REFUSAL_WORDS.reasonRoute },
+            },
+        };
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ status: 'coherency_refused', refusal });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        // TASK-1038: the throw says what stayed, then the kernel's sentence; its guidance is pb's command for each route.
+        const thrown = await runEntryAccept({ entryId: 'DEC-500' }).catch((e) => e);
+        expect(thrown.message).toBe('DEC-500 was not accepted and stays a draft. This entry links to nothing it serves. Link it to what it serves, or answer why it stands alone.');
+        expect(thrown.guidance.split('\n').slice(0, 3)).toEqual([
+            'Next: pb relate DEC-500 informs <what it serves>, then pb entry accept DEC-500.',
+            'Or answer: pb entry accept DEC-500 --acknowledge diverged --ack-reason "<why>".',
+            'Or keep it as it is: pb entry accept DEC-500 --override-reason "<why>".',
+        ]);
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        // The structured { outcome: 'refused', refusal } envelope reached stdout (machine-readable),
+        // carrying the subject + the retry routes the agent needs to populate the controls.
+        const parsed = JSON.parse(output.trim());
+        expect(parsed.outcome).toBe('refused');
+        expect(parsed.refusal.subject.entryId).toBe('DEC-500');
+        expect(parsed.refusal.routes.acknowledge.param).toBe('coherencyAcknowledgement');
+        expect(parsed.refusal.routes.override.param).toBe('steeringOverrideReason');
+    });
+    it('does not emit a refusal JSON line in human (pretty) mode', async () => {
+        runnerState.jsonMode = false;
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            status: 'coherency_refused',
+            refusal: { reason: LINK_REFUSAL_WORDS.unlinked },
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await expect(runEntryAccept({ entryId: 'DEC-500' })).rejects.toThrow(LINK_REFUSAL_WORDS.unlinked);
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).not.toContain('"outcome":"refused"');
+    });
+    // TASK-736 (DEC-2019): the accept of a held draft prints the kernel's flag sentence unchanged.
+    it('shows the held-draft flag the server returns', async () => {
+        const heldFlag = "Accepted over the atom check's hold (p 0.97). Recorded as an override by Randy.";
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ _id: 'j571abd', entryId: 'DEC-601', name: 'Bundled', versionId: 'v124', version: 1, statusLabels: { from: 'Draft', to: 'Open' }, heldFlag });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'DEC-601' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain(`  ⚠ ${heldFlag}`);
+    });
+    // DEC-2129: a draft both checks held returns one line per check; each prints with its own marker.
+    it('marks every line of a flag from a draft two checks held', async () => {
+        const heldFlag = "Accepted over the atom check's hold (p 0.97). Recorded as an override by Randy.\nAccepted over the role check's hold (p 0.96). Recorded as an override by Randy.";
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ _id: 'j571abd', entryId: 'DEC-602', name: 'Bundled', versionId: 'v125', version: 1, statusLabels: { from: 'Draft', to: 'Open' }, heldFlag });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'DEC-602' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain("  ⚠ Accepted over the atom check's hold (p 0.97). Recorded as an override by Randy.\n  ⚠ Accepted over the role check's hold (p 0.96). Recorded as an override by Randy.");
+    });
+    // TASK-1159 (TEN-5703): the reason given prints once, after the held lines; a result without one prints as before.
+    it('prints the reason given after the held lines', async () => {
+        const heldFlag = "Accepted over the atom check's hold (p 0.97). Recorded as an override by Randy.";
+        const heldReason = "Reason given: The two claims share one owner and ship together.";
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ _id: 'j571abd', entryId: 'DEC-603', name: 'Bundled', versionId: 'v126', version: 1, statusLabels: { from: 'Draft', to: 'Open' }, heldFlag, heldReason });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'DEC-603', overrideReason: 'The two claims share one owner and ship together.' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain(`  ⚠ ${heldFlag}\n    ${heldReason}`);
+    });
+    it('prints the overlap line a role accept carries, as the held lines print', async () => {
+        const overlap = "This role overlaps Kitchen Manager (ROL-51): both decide which dishes are on the menu. Move that decision into one role's Decides line if you agree.";
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ _id: 'j571abe', entryId: 'ROL-50', name: 'Menu Chef', versionId: 'v127', version: 1, statusLabels: { from: 'Draft', to: 'Accepted' }, overlap });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'ROL-50' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain(`\n  ⚠ ${overlap}`);
+    });
+    // TASK-1169 (DEC-2275): the reason rides as the override reason; the why judge's refusal prints as the kernel's signed sentence alone.
+    it('relays the override reason and prints the why judge refusal unchanged', async () => {
+        const sentence = 'Not accepted: the reason does not say why the hold is wrong here. Why do the parts stand together? Say why the fix does not apply, or keep it as a draft.';
+        kernelCallWithSessionMock
+            .mockRejectedValueOnce(new MockMcpError(sentence, 'VALIDATION_FAILED'));
+        const err = await runEntryAccept({ entryId: 'DEC-604', overrideReason: 'intentional, keeping as is' }).catch((e) => e);
+        expect(err.message).toBe(sentence);
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', expect.objectContaining({
+            entryId: 'DEC-604', qualityOverrideReason: 'intentional, keeping as is', steeringOverrideReason: 'intentional, keeping as is',
+        }));
+    });
+    // ── WP-465 slice ⑤ (Finding #9): Light-mode steering advisory in the receipt ──
+    it('surfaces a non-blocking steeringAdvisory in the promote receipt when present', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({
+            _id: 'j571abc',
+            entryId: 'DEC-600',
+            name: 'Misaligned decision',
+            versionId: 'v123',
+            version: 1, statusLabels: { from: 'Draft', to: 'Open' },
+            steeringAdvisory: 'This entry links to nothing it serves yet; it was saved anyway.',
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryId: 'DEC-600' });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Accepted DEC-600');
+        expect(output).toContain('  ⚠ This entry links to nothing it serves yet; it was saved anyway.');
+    });
+    // WP-485 Slice 2b round 2 (Codex P1, FEAT-1370): batch --json used to reduce every success
+    // to `{entryId, ok:true}`, discarding the server's entire contradictionAdvisory — a detected
+    // contradiction could commit while `pb promote ID1 ID2 --json` gave automated callers no
+    // trace it happened. The single-id JSON path already returns the full result object; batch
+    // must not throw the advisory away just because it takes a different output branch.
+    it('preserves contradictionAdvisory in batch --json output (not reduced to {entryId, ok:true})', async () => {
+        runnerState.jsonMode = true;
+        const advisory = {
+            reason: '1 possible contradiction(s) with existing Chain entries (advisory).',
+            blockingCount: 1,
+            conflictDetails: [
+                { chainEntryId: 'DEC-42', chainEntryName: 'Existing decision', type: 'contradiction', confidence: 0.9, explanation: 'Directly contradicts the approved baseline.' },
+            ],
+        };
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ _id: 'j1', entryId: 'TEN-951', versionId: 'v1', version: 1, statusLabels: { from: 'Draft', to: 'Open' } })
+            .mockResolvedValueOnce({ _id: 'j2', entryId: 'DEC-100', versionId: 'v1', version: 1, statusLabels: { from: 'Draft', to: 'Open' }, contradictionAdvisory: advisory });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runEntryAccept({ entryIds: ['TEN-951', 'DEC-100'] });
+        const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+        writeSpy.mockRestore();
+        const parsed = JSON.parse(output.trim());
+        expect(parsed).toHaveLength(2);
+        expect(parsed[0]).toEqual({ entryId: 'TEN-951', ok: true });
+        expect(parsed[1].contradictionAdvisory).toEqual(advisory);
+    });
+});
+// TASK-889 (TEN-4610, RULE-664): the receipt names the move in the kernel's words, the ones the Rail
+// header shows, never the stored trust word.
+describe('formatEntryAcceptReceipt', () => {
+    it('prints the kernel status labels from the commit result', async () => {
+        const { formatEntryAcceptReceipt } = await import('../formatters/entryAccept.js');
+        const out = formatEntryAcceptReceipt({
+            entryId: 'ROL-8',
+            name: 'Product Management',
+            result: { _id: 'j571abc', entryId: 'ROL-8', versionId: 'v1', version: 1, statusLabels: { from: 'Draft', to: 'Accepted' } },
+        });
+        expect(out.split('\n')[0]).toBe('Accepted ROL-8: Draft → Accepted (v1)');
+        expect(out).not.toContain('current');
+    });
+    // Version skew (Codex P2 on #1866): a backend older than TASK-889 sends no labels; the receipt names no state, never the stored word.
+    it('names no state when the backend sends no labels', async () => {
+        const { formatEntryAcceptReceipt } = await import('../formatters/entryAccept.js');
+        const out = formatEntryAcceptReceipt({
+            entryId: 'ROL-8',
+            name: 'Product Management',
+            result: { _id: 'j571abc', entryId: 'ROL-8', versionId: 'v1', version: 1, status: 'current' },
+        });
+        expect(out.split('\n')[0]).toBe('Accepted ROL-8 (v1)');
+        expect(out).not.toContain('current');
+    });
+});
+// TASK-692 (DEC-1998): the kernel's sentence as-is, then the CLI's pb update hint from the fields as data.
+describe('missingFieldsLine', () => {
+    it('prints the kernel sentence, then pb update with one -f per missing field', () => {
+        expect(missingFieldsLine('ROL-8', 'Add a body before accepting.', ['body'])).toBe('Add a body before accepting.\n  pb update ROL-8 -f body=...');
+        expect(missingFieldsLine('TASK-1', 'Add a body and a why before accepting.', ['body', 'why'])).toBe('Add a body and a why before accepting.\n  pb update TASK-1 -f body=... -f why=...');
+    });
+});
+// TASK-1027 (DEC-1994): the kernel names the blocking entry; the CLI writes its own Next from the IDs as data.
+describe('spineNextLine', () => {
+    it('a draft key result: accept it; at its cap, accept it in an accepted one\'s place (TASK-1028)', () => {
+        expect(spineNextLine([{ spineNext: { action: 'accept', entryId: 'KR-7' } }])).toBe('Next: pb entry accept KR-7');
+        expect(spineNextLine([{ spineNext: { action: 'accept', entryId: 'KR-7', replaces: '<KEY-RESULT-ID>' } }]))
+            .toBe('Next: pb entry accept KR-7 --replaces <KEY-RESULT-ID> --reason "<why>"');
+        expect(spineNextLine([{ spineNext: { action: 'accept', entryId: 'STR-5', replaces: 'STR-3' } }])).toBe('Next: pb entry accept STR-5 --replaces STR-3 --reason "<why>"');
+    });
+    it('a wrong verb or a replaced parent: the link to write; a missing one names the kind', () => {
+        expect(spineNextLine([{ spineNext: { action: 'relate', from: 'STR-5', type: 'part_of', to: 'VIS-1', toKind: 'vision' } }])).toBe('Next: pb relate STR-5 part_of VIS-1');
+        expect(spineNextLine([{ spineNext: { action: 'relate', from: 'WP-56', type: 'validates', toKind: 'key_result' } }])).toBe('Next: pb relate WP-56 validates <KEY-RESULT-ID>');
+    });
+    it('TASK-1163: two spine details are two Next lines, in order', () => {
+        expect(spineNextLine([{ spineNext: { action: 'accept', entryId: '<NEW-KEY-RESULT-ID>', replaces: 'KR-1' } }, { spineNext: { action: 'relate', from: 'WP-1', type: 'validates', toKind: 'key_result' } }]))
+            .toBe('Next: pb entry accept <NEW-KEY-RESULT-ID> --replaces KR-1 --reason "<why>"\nNext: pb relate WP-1 validates <KEY-RESULT-ID>');
+    });
+    it('no spine detail: nothing to add', () => {
+        expect(spineNextLine(undefined)).toBeNull();
+        expect(spineNextLine([{ fieldKey: 'body', errorType: 'required' }])).toBeNull();
+    });
+});
+describe('pb entry accept --override-reason help (TEN-5338)', () => {
+    it('names the failed checklist as well as the entry that stands alone', async () => {
+        const { Command } = await import('commander');
+        const { registerEntryCommands } = await import('../registerEntryCommands.js');
+        const program = new Command();
+        registerEntryCommands(program);
+        const accept = program.commands.find((c) => c.name() === 'entry').commands.find((c) => c.name() === 'accept');
+        expect(accept.options.find((o) => o.long === '--override-reason')?.description).toBe('Why it stands alone, at least 12 characters, or why a text passes after its checklist failed. Your name is kept with it.');
+    });
+});
+// TASK-1028: the accept receipt of a replace prints the kernel's line and the next accept; the relate receipt names its rung.
+describe('replace and relate receipts (TASK-1028, TEN-5450)', () => {
+    it('a replace prints the kernel line, then Next: the draft that hangs on it', async () => {
+        const { replacedLines } = await import('../commands/entryAccept.js');
+        expect(replacedLines({ _id: 'x', versionId: 'v', version: 1, replaced: { line: 'Rest days (KR-3) is archived, replaced by this one.', nextAccept: 'WP-1' } }))
+            .toBe('\n\n  Rest days (KR-3) is archived, replaced by this one.\nNext: pb entry accept WP-1');
+        expect(replacedLines({ _id: 'x', versionId: 'v', version: 1 })).toBe('');
+    });
+    it('a written rung link names its rung and the accept it unblocks', async () => {
+        const { relateSpineLines } = await import('../commands/relate.js');
+        expect(relateSpineLines({ spineLink: { line: 'A strategy hangs on an accepted vision with part_of.', nextAccept: 'STR-2' } }))
+            .toBe('\n  A strategy hangs on an accepted vision with part_of.\nNext: pb entry accept STR-2');
+        expect(relateSpineLines({ spineLink: { line: 'A strategy hangs on an accepted vision with part_of.' } })).toBe('\n  A strategy hangs on an accepted vision with part_of.');
+    });
+});
+// The prompt the kernel composed rides the refusal; pb prints it after the refusal's own lines, as the MCP does.
+describe('the accept prompt on a refusal', () => {
+    const PROMPT = 'Fix this Product Brain entry so it can be accepted.\nWorkspace: Acme. Entry: [TASK-1].\nNot yet: Add a Done When item before accepting.';
+    const carried = [{ acceptRefusal: { rows: [], prompt: PROMPT } }];
+    beforeEach(() => { vi.clearAllMocks(); qualityRouteMock.mockResolvedValue(null); mockSession = { sessionId: 'sess-test' }; runnerState.jsonMode = false; });
+    it('prints the missing-field refusal, its command, then a blank line and the prompt', async () => {
+        const refused = Object.assign(new MockMcpError('Add a Done When item before accepting.', 'VALIDATION_FAILED', carried), { missingRequiredFields: ['doneWhen'] });
+        kernelCallWithSessionMock.mockRejectedValueOnce(refused);
+        const err = await runEntryAccept({ entryId: 'TASK-1' }).catch((e) => e);
+        expect(err.message).toBe('Add a Done When item before accepting.\n  pb update TASK-1 -f doneWhen=...');
+        expect(err.guidance).toBe(`Then run pb entry accept TASK-1 again.\n\n${PROMPT}`);
+    });
+    it('prints a returned refusal\'s prompt the same way', async () => {
+        kernelCallWithSessionMock
+            .mockResolvedValueOnce({ status: 'coherency_refused', refusal: { reason: 'This decision names nothing it serves.', acceptRefusal: { rows: [], prompt: PROMPT } } });
+        const err = await runEntryAccept({ entryId: 'DEC-1' }).catch((e) => e);
+        expect(err.guidance?.endsWith(`\n\n${PROMPT}`)).toBe(true);
+    });
+    it('prints nothing more when the refusal carries no prompt', async () => {
+        const refused = Object.assign(new MockMcpError('Add a body before accepting.', 'VALIDATION_FAILED'), { missingRequiredFields: ['body'] });
+        kernelCallWithSessionMock.mockRejectedValueOnce(refused);
+        const err = await runEntryAccept({ entryId: 'TASK-2' }).catch((e) => e);
+        expect(err.guidance).toBe('Then run pb entry accept TASK-2 again.');
+    });
+});
+//# sourceMappingURL=entryAccept.test.js.map