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

package/dist/__tests__/capture.test.js

@@ -1,10 +1,13 @@
 /**
  * pb capture extensions — --link, --json flags, WP-319 grounding.
- * TEN-341 test contract: capture --link calls createEntryRelation, capture --json outputs JSON.
- * WP-319 S3: grounding fires in parallel, fail-open, --suggest-only, --strict, PB_GROUNDING_MODE.
+ * TASK-897 (DEC-2113): capture --link rides in the one chain.createEntry request as links[]; the reply's outcomes print.
+ * TASK-894 (DEC-2113): one chain.createEntry per capture; the kernel's verdict rides the reply.
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runCapture } from '../commands/capture.js';
+import { formatCaptureReceipt } from '../formatters/capture.js';
+import { CLIError, ErrorCode } from '../lib/errors.js';
+import { setOutputMode } from '../lib/runner.js';
 const kernelCallWithSessionMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
     kernelCallWithSession: (...args) => kernelCallWithSessionMock(...args),
@@ -17,59 +20,145 @@ vi.mock('../lib/session.js', () => ({
     readSession: () => mockSession,
     addCapturedEntry: vi.fn(),
 }));
-describe('runCapture --link', () => {
+// TASK-897 (DEC-2113): a linked capture is ONE request. The --link/--link-type pairs ride in chain.createEntry as
+// links[]; the kernel judges each in the transaction that lands the entry and answers per link, in its own words
+// (`line`, RULE-664). A refused link never fails the capture (exit 0, the entry landed); a pair the kernel could never
+// judge (no type, an empty id) is refused before anything is sent, so nothing is half-done.
+describe('runCapture --link (TASK-897)', () => {
     beforeEach(() => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
-    it('creates entry then links to target with default relation type', async () => {
-        // Prefix "TEN:" is extracted → skips classification, routes directly to tensions
+    const LINKS = [
+        { toEntryId: 'DEC-29', type: 'related_to', outcome: 'written', line: 'linked related_to DEC-29' },
+        { toEntryId: 'WP-29', type: 'part_of', outcome: 'refused', reason: 'A work package is never part_of another work package.', line: 'link refused: A work package is never part_of another work package.' },
+    ];
+    async function captureWithTwoLinks(json) {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry' ? Promise.resolve({ docId: 'doc-1', entryId: 'TEN-710', collection: 'tensions', links: LINKS }) : Promise.resolve({})));
+        let out = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out += String(chunk); return true; });
+        const errSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        setOutputMode(json ? 'json' : 'pretty');
+        try {
+            await runCapture({ text: 'TEN: missing validation', link: ['DEC-29', 'WP-29'], linkType: ['related_to', 'part_of'], json });
+        }
+        finally {
+            setOutputMode('auto');
+            writeSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+        return out;
+    }
+    it('two --link pairs send ONE request carrying links[], and the receipt prints the kernel line per link; a refused link exits 0', async () => {
+        const out = await captureWithTwoLinks(false);
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+        expect(kernelCallWithSessionMock.mock.calls[0][1]).toMatchObject({
+            name: 'TEN: missing validation', links: [{ toEntryId: 'DEC-29', type: 'related_to' }, { toEntryId: 'WP-29', type: 'part_of' }],
+        });
+        expect(kernelCallWithSessionMock.mock.calls[0][1]).not.toHaveProperty('deferLLMSchedule');
+        expect(out).toContain('→ TEN-710 captured');
+        expect(out).toContain('  linked related_to DEC-29');
+        expect(out).toContain('  link refused: A work package is never part_of another work package.');
+    });
+    it('--json carries the links as the kernel answered them', async () => {
+        const out = await captureWithTwoLinks(true);
+        const output = JSON.parse(out.trim().split('\n').pop());
+        expect(output).toMatchObject({ id: 'TEN-710', collection: 'tensions', links: LINKS });
+        expect(output).not.toHaveProperty('relationType');
+    });
+    it('no --link: the request carries no links field and no defer flag', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry' ? Promise.resolve({ docId: 'doc-2', entryId: 'TEN-711' }) : Promise.resolve({})));
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runCapture({ text: 'TEN: plain', json: true });
+        writeSpy.mockRestore();
+        const args = kernelCallWithSessionMock.mock.calls[0][1];
+        expect(args).not.toHaveProperty('links');
+        expect(args).not.toHaveProperty('deferLLMSchedule');
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+    });
+    // WP-688 S4 (element 11): no default verb, ever. TASK-897: the refusal comes before the request, so nothing is captured.
+    it('--link without --link-type is refused before anything is sent', async () => {
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: missing validation', link: ['BET-151'] });
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught).toBeInstanceOf(CLIError);
+        expect(caught?.code).toBe(ErrorCode.VALIDATION_FAILED);
+        expect(caught?.message).toContain('--link BET-151 requires --link-type');
+        expect(caught?.guidance).toContain('Nothing was captured');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+    });
+    it('a second --link without its own --link-type is refused before anything is sent', async () => {
+        await expect(runCapture({ text: 'TEN: two links one type', link: ['DEC-29', 'WP-29'], linkType: ['related_to'] })).rejects.toThrow('--link WP-29 requires --link-type');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+    });
+    // WP-688 S4 review round 5 (bcRUML, bcRpJQ): an empty or whitespace-only --link never silently no-ops.
+    it.each(['', '   '])('--link %j is refused before anything is sent', async (link) => {
+        await expect(runCapture({ text: 'TEN: empty link', link: [link], linkType: ['related_to'] })).rejects.toThrow('--link requires a non-empty entry ID');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+    });
+    // TASK-584 (WP-802, TEN-4312): a dropped field is a warning on the landed reply; with a refused link both reach the operator and the command exits 0.
+    it('prints the dropped-field warning AND the refused link on one landed capture, exit 0', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry'
+            ? Promise.resolve({ docId: 'doc-5', entryId: 'TEN-21', normalization: { remapped: {}, rejected: ['badField'], accepted: [] }, links: [LINKS[1]] })
+            : Promise.resolve({})));
+        let out = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out += String(chunk); return true; });
+        await runCapture({ text: 'TEN: both at once', link: ['WP-29'], linkType: ['part_of'], json: true });
+        writeSpy.mockRestore();
+        expect(JSON.parse(out.trim())).toMatchObject({ id: 'TEN-21', droppedFields: ['badField'], links: [{ outcome: 'refused' }] });
+    });
+});
+// WP-684 TASK-77 (E1.3): one-step typed create — --entry-type forwards to chain.createEntry's
+// existing `canonicalKey` arg. Named --entry-type since -t/--type is the --link relation type.
+describe('runCapture --entry-type', () => {
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+    });
+    it('forwards --entry-type as canonicalKey on the chain.createEntry payload', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-710' });
-            if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+                return Promise.resolve({ docId: 'doc-3', entryId: 'OBJ-1' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: missing validation', link: 'BET-151' });
-        // Verify classification was skipped (no resolveCollection call)
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        // Verify prefix was stripped from entry name and routed to correct collection
+        await runCapture({ text: 'the objective', collection: 'key-results', entryType: 'objective' });
         expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'tensions',
-            name: 'missing validation',
+            collectionSlug: 'key-results',
+            canonicalKey: 'objective',
         }));
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
-            fromEntryId: 'TEN-710',
-            toEntryId: 'BET-151',
-            type: 'surfaces_tension_in',
-        });
         writeSpy.mockRestore();
     });
-    it('uses custom relation type when --type provided', async () => {
-        // Prefix "INS:" is extracted → skips classification, routes directly to insights
+    it('omits canonicalKey entirely when --entry-type is absent (byte-identical default path)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-2', entryId: 'INS-50' });
-            if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+                return Promise.resolve({ docId: 'doc-4', entryId: 'OBJ-1' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'INS: discovered X', link: 'DEC-264', type: 'informed_by' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
-            fromEntryId: 'INS-50',
-            toEntryId: 'DEC-264',
-            type: 'informed_by',
-        });
+        await runCapture({ text: 'a key result', collection: 'key-results' });
+        const call = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        expect(call?.[1]).not.toHaveProperty('canonicalKey');
         writeSpy.mockRestore();
     });
+    // TASK-894 (DEC-2113): --entry-type alone routes in the kernel (getTypeHintMap), so the CLI sends
+    // one request with the key and no collection: no listCollections, no resolveCollection.
+    it('--entry-type alone sends one chain.createEntry with canonicalKey and no collectionSlug', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry' ? Promise.resolve({ docId: 'doc-5', entryId: 'OBJ-2', collection: 'objectives' }) : Promise.resolve({})));
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        await runCapture({ text: 'another objective', entryType: 'objective' });
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+        const args = kernelCallWithSessionMock.mock.calls[0][1];
+        expect(args).toMatchObject({ canonicalKey: 'objective', name: 'another objective' });
+        expect(args).not.toHaveProperty('collectionSlug');
+        writeSpy.mockRestore();
+        stderrSpy.mockRestore();
+    });
 });
 describe('runCapture --json', () => {
     beforeEach(() => {
@@ -77,12 +166,10 @@ describe('runCapture --json', () => {
         mockSession = { sessionId: 'sess-test' };
     });
     it('outputs valid JSON with id field and no other stdout', async () => {
-        // Prefix "TEN:" is extracted → skips classification
+        // TASK-894: the kernel routes the "TEN:" prefix and names the slug on the reply.
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-711' });
+                return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-711', collection: 'tensions' });
             return Promise.resolve({});
         });
         let stdoutOutput = '';
@@ -109,269 +196,470 @@ describe('runCapture --json', () => {
         expect(output).toHaveProperty('confidence');
     });
 });
-describe('runCapture description field routing', () => {
+describe('runCapture coaching passthrough (WP-475 E1)', () => {
     beforeEach(() => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
-    it('passes description key to createEntry for assumptions (TEN-1258 — remap happens in Convex)', async () => {
-        // The CLI always sends `description` — the Convex write gate remaps it to `belief`
-        // for the assumptions collection (TEN-1258). Verify the CLI routes correctly and
-        // sends the text as description so the Convex remap can fire.
+    const coaching = {
+        source: 'heuristic',
+        verdict: {
+            entryId: 'DEC-77',
+            canonicalKey: 'decision',
+            tier: 'assertive',
+            context: 'capture',
+            passed: false,
+            criteria: [
+                { id: 'specificity', passed: false, weight: 2, hint: 'Be specific.', questionTemplate: 'What exactly?' },
+            ],
+            weakest: { criterion: 'specificity', hint: 'Be specific.', questionTemplate: 'What exactly?' },
+        },
+    };
+    it('--json output includes the raw coaching object from the write response', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-5', entryId: 'ASM-1' });
+                return Promise.resolve({ docId: 'doc-c1', entryId: 'DEC-77', coaching });
             return Promise.resolve({});
         });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'ASM: users won\'t pay before seeing value' });
-        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
-        expect(createCall?.[1]).toMatchObject({
-            collectionSlug: 'assumptions',
-            name: "users won't pay before seeing value",
-            data: { description: "users won't pay before seeing value" },
+        let stdoutOutput = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            stdoutOutput += String(chunk);
+            return true;
         });
+        await runCapture({ text: 'DEC: chose something', json: true });
         writeSpy.mockRestore();
+        const jsonLines = stdoutOutput.split('\n').filter((line) => {
+            try {
+                JSON.parse(line);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        expect(jsonLines).toHaveLength(1);
+        const output = JSON.parse(jsonLines[0]);
+        expect(output.coaching).toEqual(coaching);
     });
-});
-describe('runCapture classification guard', () => {
-    beforeEach(() => {
-        kernelCallWithSessionMock.mockReset();
-        mockSession = { sessionId: 'sess-test' };
+    it('--json output omits coaching when the write response has none (backward compat)', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-c2', entryId: 'DEC-78' });
+            return Promise.resolve({});
+        });
+        let stdoutOutput = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            stdoutOutput += String(chunk);
+            return true;
+        });
+        await runCapture({ text: 'DEC: chose another thing', json: true });
+        writeSpy.mockRestore();
+        const jsonLines = stdoutOutput.split('\n').filter((line) => {
+            try {
+                JSON.parse(line);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        expect(jsonLines).toHaveLength(1);
+        expect(JSON.parse(jsonLines[0])).not.toHaveProperty('coaching');
     });
-    it('throws CLIError when classification requires review', async () => {
-        kernelCallWithSessionMock.mockResolvedValueOnce(null);
-        await expect(runCapture({ text: 'Ambiguous capture' })).rejects.toThrow('Classification needs review before capture can continue.');
+    // TASK-897: the one verdict on the reply already saw the links (the kernel writes them before it judges), so a
+    // linked capture renders the create-response verdict as a plain one does; nothing is re-evaluated.
+    it('--link: renders the create-response verdict and calls no re-evaluation', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry'
+            ? Promise.resolve({ docId: 'doc-c3', entryId: 'DEC-79', coaching, links: [{ toEntryId: 'TEN-1', type: 'informs', outcome: 'written', line: 'linked informs TEN-1' }] })
+            : Promise.resolve({})));
+        let stdoutOutput = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { stdoutOutput += String(chunk); return true; });
+        await runCapture({ text: 'DEC: chose with a link', link: ['TEN-1'], linkType: ['informs'], json: true });
+        writeSpy.mockRestore();
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+        const output = JSON.parse(stdoutOutput.trim());
+        expect(output.coaching).toEqual(coaching);
+        expect(output.links).toEqual([{ toEntryId: 'TEN-1', type: 'informs', outcome: 'written', line: 'linked informs TEN-1' }]);
     });
 });
-describe('runCapture date inference', () => {
+// WP-690 S7 (TASK-120): the 'runCapture description field routing' describe block (TEN-1258's
+// ASM:-shortcode -> 'assumptions' collectionSlug routing test) is DELETED here — `assumption` is
+// one of the 15 genuinely-retired canonicalKeys (collectionRegistry.ts no longer carries an
+// 'assumptions'/ASM entry at all), so the scenario this test asserted can no longer occur: an
+// 'ASM:' capture now falls through to auto-classification (collectionSlug: undefined) instead of
+// the old explicit-shortcode routing. Found via the CI Quality Gate on this PR (new failure caused
+// by the S7 registry purge, fixed at root per the standing "fix new failures at root" contract —
+// not deferred, not papered over).
+describe('runCapture --field passthrough', () => {
     beforeEach(() => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
-    it('does not default date to today when no source date is present', async () => {
+    it('merges --field pairs into data', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
-            if (fn === 'chain.resolveCollection')
-                return Promise.resolve({ collection: 'decisions', confidence: 0.9, tier: 'high' });
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-3', entryId: 'DEC-10' });
+                return Promise.resolve({ docId: 'doc-6', entryId: 'STD-1' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'Decision without explicit source date' });
-        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
-        expect(createCall?.[1]).toMatchObject({
-            collectionSlug: 'decisions',
-            data: { description: 'Decision without explicit source date' },
+        await runCapture({
+            text: 'touched-code stewardship',
+            collection: 'standards',
+            field: ['rationale=signed specs define scope but agents need permission'],
         });
-        expect((createCall?.[1]).data).not.toHaveProperty('date');
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
+            description: 'touched-code stewardship', // TASK-894: the capture text; the kernel files it when the main field is empty
+            data: { rationale: 'signed specs define scope but agents need permission' },
+        }));
         writeSpy.mockRestore();
     });
-    it('uses inferred source date when the capture text includes one', async () => {
+    it('--field description=X overrides the derived description', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([]);
-            if (fn === 'chain.resolveCollection')
-                return Promise.resolve({ collection: 'decisions', confidence: 0.9, tier: 'high' });
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-4', entryId: 'DEC-11' });
+                return Promise.resolve({ docId: 'doc-7', entryId: 'TEN-1' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'Decision from April 1, 2026 steering meeting' });
-        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
-        expect((createCall?.[1]).data.date).toBe('2026-04-01');
+        await runCapture({
+            text: 'derived',
+            collection: 'tensions',
+            field: ['description=explicit'],
+        });
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
+            data: expect.objectContaining({ description: 'explicit' }),
+        }));
         writeSpy.mockRestore();
     });
 });
-// ---------------------------------------------------------------------------
-// WP-319 S3: Pre-write grounding tests
-// ---------------------------------------------------------------------------
-describe('runCapture WP-319 grounding', () => {
-    const emptyGrounding = { index: 0, related: [], duplicates: [], governance: [], v: 1 };
-    const groundingWithDuplicate = {
-        index: 0,
-        related: [],
-        duplicates: [{ entryId: 'TEN-5', name: 'Similar tension', collectionSlug: 'tensions', matchType: 'possible_duplicate', overlapRatio: 0.9 }],
-        governance: [],
-        v: 1,
-    };
+// TASK-584 (WP-802, TEN-4312): the CLI sends only the fields the caller sent. The default
+// description (the capture text) exists to be remapped into the collection's primary field;
+// TASK-894: data carries only what the caller sent; the kernel fills the main text field when it is empty.
+describe('runCapture sends only caller fields (TASK-584)', () => {
     beforeEach(() => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
-        delete process.env.PB_GROUNDING_MODE;
-    });
-    it('fires chain.suggestLinksForCapture in parallel and still calls createEntry', async () => {
-        // Prefix-based route skips classification; grounding fires for TEN prefix
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([emptyGrounding]);
+    });
+    const createData = () => kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry')?.[1]?.data;
+    it('omits description when -f sets the primary field and no -d is given', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-720' });
+                return Promise.resolve({ docId: 'd', entryId: 'INS-1', status: 'draft' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: grounding test tension' });
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.objectContaining({
-            entries: expect.arrayContaining([expect.objectContaining({ name: 'grounding test tension' })]),
-        }));
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        await runCapture({ text: 'an insight', collection: 'insights', field: ['body=the full body'] });
         writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        expect(createData()).toEqual({ body: 'the full body' });
     });
-    it('does NOT block capture when grounding call fails', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.reject(new Error('network error'));
+    it('keeps description when -d is given, even with -f body', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-2', entryId: 'TEN-721' });
+                return Promise.resolve({ docId: 'd', entryId: 'INS-2', status: 'draft' });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        // Must not throw — grounding failure is fail-open
-        await expect(runCapture({ text: 'TEN: grounding failure test' })).resolves.toBeUndefined();
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        await runCapture({ text: 'an insight', description: 'explicit', collection: 'insights', field: ['body=b'] });
         writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        expect(createData()).toEqual({ description: 'explicit', body: 'b' });
     });
-    it('--suggest-only does NOT call createEntry and outputs grounding data', async () => {
-        // In test env (non-TTY), isJsonMode() returns true → JSON path is taken.
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([groundingWithDuplicate]);
+    it('a bare capture sends its text as description only, for the kernel to file in the empty body', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'd', entryId: 'INS-3', status: 'draft' });
             return Promise.resolve({});
         });
-        let stdoutOutput = '';
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
-            stdoutOutput += String(chunk);
-            return true;
-        });
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: duplicate candidate', suggestOnly: true });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        // JSON output contains suggestOnly flag and grounding report
-        const jsonLines = stdoutOutput.split('\n').filter((l) => { try {
-            JSON.parse(l);
-            return true;
-        }
-        catch {
-            return false;
-        } });
-        expect(jsonLines).toHaveLength(1);
-        const parsed = JSON.parse(jsonLines[0]);
-        expect(parsed.suggestOnly).toBe(true);
-        expect(parsed.groundingReport).toBeDefined();
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runCapture({ text: 'an insight', collection: 'insights' });
         writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        expect(createData()).toEqual({});
+        expect(kernelCallWithSessionMock.mock.calls[0][1]).toMatchObject({ description: 'an insight' });
     });
-    it('--suggest-only with --json outputs machine-readable object without calling createEntry', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([emptyGrounding]);
+    it('a landed create with a dropped field resolves (exit 0) and names only that field as dropped', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
+            if (fn === 'chain.createEntry') {
+                return Promise.resolve({
+                    docId: 'd', entryId: 'INS-5', status: 'draft', warnings: ['Unknown fields dropped: nosuchfield. Expected: body (text, required).'],
+                    normalization: { remapped: {}, rejected: ['nosuchfield'], accepted: ['body'] },
+                });
+            }
             return Promise.resolve({});
         });
-        let stdoutOutput = '';
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
-            stdoutOutput += String(chunk);
-            return true;
-        });
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: dry run json', json: true, suggestOnly: true });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        const jsonLines = stdoutOutput.split('\n').filter((l) => { try {
-            JSON.parse(l);
-            return true;
-        }
-        catch {
-            return false;
-        } });
-        expect(jsonLines).toHaveLength(1);
-        const parsed = JSON.parse(jsonLines[0]);
-        expect(parsed.suggestOnly).toBe(true);
+        const out = [];
+        const errOut = [];
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
+        const errSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => { errOut.push(String(chunk)); return true; });
+        await expect(runCapture({ text: 'an insight', collection: 'insights', field: ['nosuchfield=x'], json: true })).resolves.toBeUndefined();
         writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        errSpy.mockRestore();
+        expect(JSON.parse(out.join(''))).toMatchObject({ id: 'INS-5', droppedFields: ['nosuchfield'] });
+        expect(errOut.join('')).not.toContain('Fields rejected');
+    });
+    it('the human receipt names the dropped field as a warning, with pb fields for the collection', () => {
+        const out = formatCaptureReceipt({
+            entryId: 'INS-5', name: 'an insight', collection: 'insights', statusLabel: 'Draft', classification: null,
+            warnings: ['Unknown fields dropped: nosuchfield. Expected: body (text, required).'],
+            normalization: { remapped: {}, rejected: ['nosuchfield'], accepted: [] },
+        });
+        expect(out).toContain('Warning: Unknown fields dropped: nosuchfield.');
+        expect(out).toContain('pb fields insights');
+        expect(out).not.toContain('Rejected fields');
     });
-    it('banner is suppressed when grounding has no matches (zero-noise floor)', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([emptyGrounding]);
+});
+describe('runCapture prints the kernel pool sentence (TASK-800)', () => {
+    const POOL = 'This workspace already has an unscoped strategy, Grow the core (STR-1). Saved as a draft. Scope this one to a product (belongs_to a product), or merge it into Grow the core by hand.';
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-3', entryId: 'TEN-722' });
+                return Promise.resolve({ docId: 'd', entryId: 'STR-2', status: 'draft', warnings: [POOL] });
             return Promise.resolve({});
         });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrLines = [];
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
-            stderrLines.push(String(chunk));
-            return true;
-        });
-        await runCapture({ text: 'TEN: no matches tension' });
-        // No "Grounding" banner in stderr when zero matches
-        const groundingInStderr = stderrLines.some((l) => l.includes('Grounding'));
-        expect(groundingInStderr).toBe(false);
+    });
+    it('--json carries the sentence verbatim in warnings', async () => {
+        const out = [];
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
+        await runCapture({ text: 'Grow through partner referrals', collection: 'strategy', json: true });
         writeSpy.mockRestore();
+        expect(JSON.parse(out.join(''))).toMatchObject({ id: 'STR-2', status: 'draft', warnings: [POOL] });
+    });
+    it('the human receipt prints the sentence verbatim', () => {
+        const out = formatCaptureReceipt({ entryId: 'STR-2', name: 'Grow through partner referrals', collection: 'strategy', statusLabel: 'Draft', classification: null, warnings: [POOL] });
+        expect(out).toContain(`Warning: ${POOL}`);
+    });
+    // TASK-1160: the why hold's sentence is the kernel's (kernel/coherency/whyCheck.ts whyHeldSentence; whyCheck.test.ts pins this text).
+    it('a held why prints the kernel sentence verbatim, coaching line included', () => {
+        const held = 'Held as a draft: the why does not say why. This repeats the decision; name the evidence that made provider B the choice. Rewrite the why and accept, or keep it as a draft.';
+        const out = formatCaptureReceipt({ entryId: 'DEC-7', name: 'Switch payments to provider B', collection: 'decisions', statusLabel: 'Draft', classification: null, warnings: [held] });
+        expect(out).toContain(`Warning: ${held}`);
+    });
+    it('TASK-1046 (DEC-2219): the receipt prints the name whole, never cut at read', () => {
+        const name = 'Every message a person or an agent reads is understood and acted on in three seconds; any moving entry says so';
+        const out = formatCaptureReceipt({ entryId: 'RULE-9', name, collection: 'rules', statusLabel: 'Draft', classification: null });
+        expect(out).toContain(`  Name: ${name}\n`);
+    });
+});
+// TASK-894 (DEC-2113): no client pre-check answers before the kernel; every refusal is the server's own 400.
+describe('runCapture leaves every refusal to the kernel', () => {
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+    });
+    it.each([
+        ['the WHY gate', 'Not saved: a standard needs a why, at least 12 characters.'],
+        ['an abstaining classifier', 'No collection fits this capture. Choose one: decisions, insights, tensions.'],
+        ['the exact-name guard', 'Duplicate entry: "x" already exists in tensions.'],
+    ])('%s: the one request is refused and the server sentence reaches the caller unchanged', async (_gate, reason) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry' ? Promise.reject(new CLIError(reason, { code: ErrorCode.VALIDATION_FAILED, category: 'validation' })) : Promise.resolve({})));
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        await expect(runCapture({ text: 'x', collection: 'standards', field: ['rationale=short'] })).rejects.toThrow(reason);
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
         stderrSpy.mockRestore();
     });
-    it('PB_GROUNDING_MODE=off skips grounding call entirely', async () => {
-        process.env.PB_GROUNDING_MODE = 'off';
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
+});
+describe('runCapture writes no date (TEN-4244, DEC-1787)', () => {
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+    });
+    it.each([
+        ['tasks', 'TASK-10', 'Task due April 1, 2026'],
+        ['decisions', 'DEC-10', 'Decision from April 1, 2026 steering meeting'],
+        ['tasks', 'TASK-11', 'Task without any date'],
+    ])('a %s capture carries no data.date, even when the text names a date', async (collection, entryId, text) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-4', entryId: 'TEN-723' });
+                return Promise.resolve({ docId: 'doc-3', entryId, collection });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: no grounding env off' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        delete process.env.PB_GROUNDING_MODE;
+        await runCapture({ text });
+        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        expect(createCall?.[1]).not.toHaveProperty('collectionSlug');
+        expect((createCall?.[1]).data).not.toHaveProperty('date');
         writeSpy.mockRestore();
-        stderrSpy.mockRestore();
     });
-    it('--json output stdout is clean (no grounding on stdout)', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.suggestLinksForCapture')
-                return Promise.resolve([groundingWithDuplicate]);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-5', entryId: 'TEN-724' });
-            return Promise.resolve({});
-        });
-        let stdoutOutput = '';
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
-            stdoutOutput += String(chunk);
-            return true;
+});
+// TASK-894 (DEC-2113): the kernel judges inside chain.createEntry; the CLI renders its verdict.
+describe('runCapture renders the kernel verdict', () => {
+    const ask = { kind: 'ask', matches: [{ entryId: 'TEN-5', name: 'Similar tension', collectionSlug: 'tensions', score: 0.6 }] };
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+        setOutputMode('auto'); // runner.ts keeps output mode at module level; an earlier json test must not leak it
+    });
+    async function capture(reply, options = {}) {
+        kernelCallWithSessionMock.mockImplementation((fn) => Promise.resolve(fn === 'chain.createEntry' ? { docId: 'doc-1', collection: 'tensions', ...reply } : {}));
+        let out = '';
+        let err = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out += String(chunk); return true; });
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => { err += String(chunk); return true; });
+        try {
+            await runCapture({ text: 'TEN: a capture', ...options });
+        }
+        finally {
+            writeSpy.mockRestore();
+            stderrSpy.mockRestore();
+        }
+        return { out, err };
+    }
+    it('one request: no chain.capture, listCollections, resolveCollection, getCollectionFields or recordGroundingOutcome', async () => {
+        await capture({ entryId: 'TEN-720', verdict: { kind: 'create' }, judged: true });
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+        expect(kernelCallWithSessionMock.mock.calls[0][1]).toMatchObject({ name: 'TEN: a capture', description: 'TEN: a capture' });
+    });
+    it('a create verdict prints no Possible match line (TASK-608, DEC-1915)', async () => {
+        const { err } = await capture({ entryId: 'TEN-722', verdict: { kind: 'create' }, judged: true });
+        expect(err).not.toContain('Possible match');
+    });
+    // TASK-619 (TEN-4420): a close match is named and never written to.
+    it('an ask names the match on stderr and never updates it', async () => {
+        const { err } = await capture({ entryId: 'TEN-729', verdict: ask, judged: true });
+        expect(err).toContain('Possible match: TEN-5 "Similar tension". Nothing was written to it');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.updateEntry', expect.anything());
+    });
+    it('a judge that missed its budget says the check is still running', async () => {
+        const { err } = await capture({ entryId: 'TEN-730', judged: false });
+        expect(err).toContain('The duplicate check is still running; pb get TEN-730');
+    });
+    it('--json is one clean line carrying possibleMatches, verdict and judged', async () => {
+        const { out } = await capture({ entryId: 'TEN-725', verdict: ask, judged: true }, { json: true });
+        const lines = out.split('\n').filter((l) => l.trim());
+        expect(lines).toHaveLength(1);
+        expect(JSON.parse(lines[0])).toMatchObject({
+            id: 'TEN-725', collection: 'tensions', verdict: ask, judged: true,
+            possibleMatches: [{ entryId: 'TEN-5', name: 'Similar tension', collection: 'tensions', score: 0.6 }],
         });
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'TEN: json clean stdout', json: true });
-        // Stdout must be exactly one valid JSON line (jq .id must work)
-        const jsonLines = stdoutOutput.split('\n').filter((l) => { try {
-            JSON.parse(l);
-            return true;
+    });
+    it('--json on a create verdict carries no possibleMatches field', async () => {
+        const { out } = await capture({ entryId: 'TEN-726', verdict: { kind: 'create' }, judged: true }, { json: true });
+        expect(JSON.parse(out.trim())).not.toHaveProperty('possibleMatches');
+    });
+});
+// TASK-898 (DEC-2113): a re-sent capture the kernel replayed. TASK-897: the kernel answers the retry's links from the rows
+// (written by the first send, or refused then); the CLI prints them as on a first send and sends nothing more.
+describe('runCapture on a replayed reply (TASK-898)', () => {
+    const REPLAY_LINKS = [
+        { toEntryId: 'DEC-266', type: 'informed_by', outcome: 'written', line: 'linked informed_by DEC-266' },
+        { toEntryId: 'WP-29', type: 'part_of', outcome: 'refused', reason: 'Not written when INS-60 first landed; this reply is a replay. Relate it again to read the reason.', line: 'link refused: Not written when INS-60 first landed; this reply is a replay. Relate it again to read the reason.' },
+    ];
+    const REPLAY = { entryId: 'INS-60', docId: 'doc-60', status: 'draft', collection: 'decisions', replayed: true, links: REPLAY_LINKS };
+    async function run(json) {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry' ? Promise.resolve(REPLAY) : Promise.resolve({})));
+        let out = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out += String(chunk); return true; });
+        const errSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        setOutputMode(json ? 'json' : 'pretty');
+        try {
+            await runCapture({ text: 'INS: discovered Z', link: ['DEC-266', 'WP-29'], linkType: ['informed_by', 'part_of'], json });
         }
-        catch {
-            return false;
-        } });
-        expect(jsonLines).toHaveLength(1);
-        const parsed = JSON.parse(jsonLines[0]);
-        expect(parsed.id).toBe('TEN-724');
-        // No grounding content in stdout
-        expect(stdoutOutput).not.toContain('Grounding');
-        expect(stdoutOutput).not.toContain('duplicate');
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        finally {
+            setOutputMode('auto');
+            writeSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+        return out;
+    }
+    it('the replay is one request too: exit 0, the kernel collection, the links as the kernel reports them', async () => {
+        const output = JSON.parse((await run(true)).trim().split('\n').pop());
+        expect(output).toMatchObject({ id: 'INS-60', collection: 'decisions', replayed: true, links: REPLAY_LINKS });
+        expect(kernelCallWithSessionMock.mock.calls.map(([fn]) => fn)).toEqual(['chain.createEntry']);
+    });
+    it('the receipt names the first send\'s collection, says nothing was written twice, and prints the link lines', async () => {
+        const out = await run(false);
+        expect(out).toContain('decisions');
+        expect(out).toContain('Already captured as INS-60');
+        expect(out).toContain('  linked informed_by DEC-266');
+        expect(out).toContain('  link refused: Not written when INS-60 first landed');
+    });
+    it('a replay of a draft still without a required field prints the same lines as the first reply, before the Next', async () => {
+        kernelCallWithSessionMock.mockReset();
+        mockSession = { sessionId: 'sess-test' };
+        const lines = ['Add a Done When item before accepting.', 'pb update WP-36 -f doneWhen="<item>"'];
+        const spineFloor = { relationType: 'validates', parentKind: 'key_result', exempt: false, linkWritten: false, line: 'Validates one of 2 accepted key results.', nextTo: '<one of them>' };
+        kernelCallWithSessionMock.mockImplementation((fn) => (fn === 'chain.createEntry'
+            ? Promise.resolve({ entryId: 'WP-36', docId: 'doc-36', status: 'draft', collection: 'work-packages', replayed: true, missingFieldLines: lines, spineFloor }) : Promise.resolve({})));
+        let out = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out += String(chunk); return true; });
+        const errSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        setOutputMode('pretty');
+        try {
+            await runCapture({ text: 'WP: ship the ledger', json: false });
+        }
+        finally {
+            setOutputMode('auto');
+            writeSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+        expect(out).toContain('Already captured as WP-36');
+        expect(out).toContain(`  ${lines[0]}\n  ${lines[1]}`);
+        expect(out).toContain('  Kept as a draft. Validates one of 2 accepted key results.');
+        expect(out.indexOf(lines[0])).toBeLessThan(out.indexOf('Next: pb relate WP-36 validates <one of them>'));
+    });
+});
+// TASK-889 (TEN-4610, RULE-664): the capture receipt names the new row in the kernel's word, the one the Rail shows.
+describe('formatCaptureReceipt state word (TASK-889)', () => {
+    it('prints the kernel label for a born-live question, never the stored trust word', () => {
+        const out = formatCaptureReceipt({ entryId: 'Q-1', name: 'Who decides?', collection: 'questions', statusLabel: 'Open', classification: null });
+        expect(out.split('\n')[0]).toBe('→ Q-1 captured as Open');
+        expect(out).not.toContain('current');
+    });
+    it('names no state when the backend sends no label', () => {
+        const out = formatCaptureReceipt({ entryId: 'Q-1', name: 'Who decides?', collection: 'questions', classification: null });
+        expect(out.split('\n')[0]).toBe('→ Q-1 captured');
+    });
+});
+// TASK-1419 (WP-876, DEC-2512): the name is the text's first sentence, the whole text is the body, --name wins.
+describe('runCapture names a capture from its text', () => {
+    beforeEach(() => {
+        kernelCallWithSessionMock.mockReset();
+        kernelCallWithSessionMock.mockResolvedValue({ docId: 'doc-1', entryId: 'DEC-900', collection: 'decisions' });
+        mockSession = { sessionId: 'sess-test' };
+    });
+    async function sent(options) {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const errSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        setOutputMode('pretty');
+        try {
+            await runCapture(options);
+        }
+        finally {
+            setOutputMode('auto');
+            writeSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+        return kernelCallWithSessionMock.mock.calls[0][1];
+    }
+    const LONG = 'DEC: Names stay short and the detail goes in the body. The long reasons, the history and every option that was weighed follow here, '
+        + 'well past the point where a name could carry them, so the whole text is the body and only the first sentence is the name.';
+    it('sends the first sentence as the name and the whole text as the body', async () => {
+        const call = await sent({ text: LONG });
+        expect(call.name).toBe('DEC: Names stay short and the detail goes in the body.');
+        expect(call.description).toBe(LONG);
+    });
+    it('cuts a long first sentence at the last word within the working cap, prefix kept', async () => {
+        const text = `TEN: ${'a word of the sentence '.repeat(12)}`.trim();
+        const call = await sent({ text });
+        expect(Array.from(call.name).length).toBeLessThanOrEqual(80);
+        expect(call.name.startsWith('TEN: a word of the sentence')).toBe(true);
+        expect(text.startsWith(call.name)).toBe(true);
+        expect(call.description).toBe(text);
+    });
+    it('lets a direction kind keep a longer first sentence when the collection is named', async () => {
+        const sentence = `PUR: ${'People are free to act with confidence '.repeat(4).trim()}.`;
+        const call = await sent({ text: `${sentence} More words follow.`, collection: 'purpose' });
+        expect(call.name).toBe(sentence);
+    });
+    it('--name wins over the text, and --description over the body', async () => {
+        const call = await sent({ text: LONG, name: 'A name I chose', description: 'My own body.' });
+        expect(call.name).toBe('A name I chose');
+        expect(call.description).toBe('My own body.');
+    });
+    it('keeps a short text as the name, as before', async () => {
+        const call = await sent({ text: 'TEN: missing validation' });
+        expect(call.name).toBe('TEN: missing validation');
     });
 });
 //# sourceMappingURL=capture.test.js.map