@productbrain/cli 0.1.0-beta.10904 → 0.1.0-beta.10914

package/dist/__tests__/capture.test.js

@@ -1,9 +1,9 @@
 /**
  * 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, --strict, PB_GROUNDING_MODE.
+ * TASK-894 (DEC-2113): one chain.createEntry per capture; the kernel's verdict rides the reply.
  */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+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';
@@ -31,8 +31,6 @@ describe('runCapture --link', () => {
     // list the source entry's legal verbs in the refusal message.
     it('--link without --link-type refuses (no default), preserving the created entry', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-710' });
             if (fn === 'chain.getEntry') {
@@ -51,10 +49,9 @@ describe('runCapture --link', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await expect(runCapture({ text: 'TEN: missing validation', link: 'BET-151' })).rejects.toThrow(CLIError);
-        // The entry was created for real — only the LINK is refused.
+        // The entry was created for real — only the LINK is refused. TASK-894: the text goes as typed; the kernel routes the prefix.
         expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'tensions',
-            name: 'missing validation',
+            name: 'TEN: missing validation',
         }));
         // Legal verbs are READ by scanning the semantic-types collection (chain.listEntries)
         // and matching data.canonical_key — the same resolution loadTypeMap itself uses,
@@ -67,8 +64,6 @@ describe('runCapture --link', () => {
     });
     it('--link without --link-type: refusal message lists the source entry\'s declared relation types', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1b', entryId: 'TEN-711' });
             if (fn === 'chain.getEntry') {
@@ -105,8 +100,6 @@ describe('runCapture --link', () => {
     // the entry still gets created, but the link itself must be explicitly refused.
     it('--link "   " (whitespace-only) refuses instead of silently dropping the link', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-ws', entryId: 'TEN-720' });
             return Promise.resolve({});
@@ -129,8 +122,6 @@ describe('runCapture --link', () => {
     // must check `!== undefined` instead, or this whole block (and the bcRUML refusal) never runs.
     it('--link "" (empty string) refuses instead of silently dropping the link', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-empty', entryId: 'TEN-722' });
             return Promise.resolve({});
@@ -152,8 +143,6 @@ describe('runCapture --link', () => {
     // guidance must say so rather than recommending `pb relate <verb> <missing-id>`.
     it('--link <missing-id> without --link-type reports the target was not found, not a verb-recovery command', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-miss', entryId: 'TEN-721' });
             if (fn === 'chain.getEntry') {
@@ -186,8 +175,6 @@ describe('runCapture --link', () => {
     // `pb relate` would name a guaranteed-to-fail re-run.
     it('excludes replaces and do_not_confuse_with from the refusal\'s legal-verb list (both are door-blocked)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1c', entryId: 'DEC-1' });
             if (fn === 'chain.getEntry') {
@@ -218,8 +205,6 @@ describe('runCapture --link', () => {
     // so it must never be listed as a `pb relate`-usable recovery verb.
     it('excludes a declared verb outside the kernel allowlist from the refusal\'s legal-verb list', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1d', entryId: 'GOAL-1' });
             if (fn === 'chain.getEntry') {
@@ -250,8 +235,6 @@ describe('runCapture --link', () => {
     // supply (guards.ts:349-363) — never recommend them as recovery verbs for such a target.
     it('excludes domain-tag verbs from the refusal\'s legal-verb list when the target is a domain', async () => {
         kernelCallWithSessionMock.mockImplementation((fn, args) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1e', entryId: 'INS-1' });
             if (fn === 'chain.getEntry') {
@@ -281,10 +264,7 @@ describe('runCapture --link', () => {
         expect(caught?.message).not.toContain('authority_domain');
     });
     it('uses the supplied relation type when --link-type provided (no probe, real write)', async () => {
-        // Prefix "INS:" is extracted → skips classification, routes directly to insights
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-2', entryId: 'INS-50' });
             if (fn === 'chain.createEntryRelation')
@@ -293,7 +273,6 @@ describe('runCapture --link', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'INS: discovered X', link: 'DEC-264', linkType: 'informed_by' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
         // A REAL (non-preview) write — the exact verb supplied, echoed verbatim, no probe call.
         expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'INS-50',
@@ -310,8 +289,6 @@ describe('runCapture --link', () => {
     // --link-without---link-type branch above).
     it('a relate-door refusal during --link is deferred, naming the persisted entry — never an unhandled rejection', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-wp', entryId: 'WP-6' });
             if (fn === 'chain.createEntryRelation') {
@@ -337,8 +314,6 @@ describe('runCapture --link', () => {
     // real error's identity.
     it('a non-validation relate-door failure during --link preserves its own code/category, not a relabeled VALIDATION_FAILED', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-wp7', entryId: 'WP-7' });
             if (fn === 'chain.createEntryRelation') {
@@ -366,8 +341,6 @@ describe('runCapture --link', () => {
     // the "was refused, re-run" template, which would prompt a blind duplicate-risking retry.
     it('a NETWORK_TIMEOUT relate-door failure during --link says outcome-unknown, never "was refused"', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-wp9', entryId: 'WP-9' });
             if (fn === 'chain.createEntryRelation') {
@@ -396,8 +369,6 @@ describe('runCapture --link', () => {
     // scheduled.
     it('the quality re-eval still runs after a relate-door refusal — the entry is not left permanently deferred', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-wp8', entryId: 'WP-8' });
             if (fn === 'chain.createEntryRelation') {
@@ -423,8 +394,6 @@ describe('runCapture --link', () => {
     // fallback (formatters/capture.ts:105).
     it('the human-readable receipt prints the real relation type, never the dead surfaces_tension_in fallback', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-2b', entryId: 'INS-51' });
             if (fn === 'chain.createEntryRelation')
@@ -453,8 +422,6 @@ describe('runCapture --link', () => {
     // WITHOUT a relationId — only a real, persisted write may claim `linkedTo`/`relationType`.
     it('an auto-link-gate diversion (no relationId) is never reported as a persisted link', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-3', entryId: 'WPKG-1' });
             if (fn === 'chain.createEntryRelation') {
@@ -493,8 +460,6 @@ describe('runCapture --link', () => {
     // deferred-then-never-run schedule would leave the entry permanently stuck.
     it('--link without --link-type does NOT defer the LLM schedule (nothing will ever un-defer it)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-4', entryId: 'TEN-20' });
             if (fn === 'chain.createEntryRelation')
@@ -513,8 +478,6 @@ describe('runCapture --link', () => {
     // refusal is the only error.
     it('prints the dropped-field warning AND throws the link-type refusal when they co-occur', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry') {
                 return Promise.resolve({
                     docId: 'doc-5', entryId: 'TEN-21',
@@ -547,8 +510,6 @@ describe('runCapture --link', () => {
     // error code must still see the timeout, not a generic validation failure.
     it('the link-refused error beside a dropped field keeps the link failure\'s own code (NETWORK_TIMEOUT), not VALIDATION_FAILED', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry') {
                 return Promise.resolve({
                     docId: 'doc-10', entryId: 'TEN-22',
@@ -585,8 +546,6 @@ describe('runCapture --entry-type', () => {
     });
     it('forwards --entry-type as canonicalKey on the chain.createEntry payload', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-3', entryId: 'OBJ-1' });
             return Promise.resolve({});
@@ -601,8 +560,6 @@ describe('runCapture --entry-type', () => {
     });
     it('omits canonicalKey entirely when --entry-type is absent (byte-identical default path)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-4', entryId: 'OBJ-1' });
             return Promise.resolve({});
@@ -613,110 +570,19 @@ describe('runCapture --entry-type', () => {
         expect(call?.[1]).not.toHaveProperty('canonicalKey');
         writeSpy.mockRestore();
     });
-    // Review round 2 (bcI42): --entry-type's help text promises it "bypasses classification",
-    // but without an ALSO-explicit --collection, the resolution chain fell through to
-    // chain.resolveCollection anyway — objective/key_result text could classify into the wrong
-    // collection (e.g. strategy) and then fail the placement guard. --entry-type alone must route
-    // straight to the shared Objectives drawer with no classification call at all.
-    it('--entry-type objective alone (no --collection) skips classification and routes to the Objectives drawer (bcI42)', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-5', entryId: 'OBJ-2' });
-            return Promise.resolve({});
-        });
+    // 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).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        // PR #713 post-merge review (PRRT_kwDORS4ils6cQP_I, P1): 'key-results' is the RETIRED slug —
-        // the fix derives the drawer's current slug from the live registry (OBJ idPrefix), which is
-        // 'objectives' post-WP-686.
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'objectives',
-            canonicalKey: 'objective',
-        }));
-        writeSpy.mockRestore();
-    });
-    // WP-707 S1 round 2 (DEC-1622, Codex PRRT_kwDORS4ils6dUxaz): key_result now files into its
-    // OWN 1:1 drawer (key-results, idPrefix KR) — it no longer shares the Objectives drawer.
-    it('--entry-type key_result alone (no --collection) routes to the Key Results drawer (DEC-1622)', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-6', entryId: 'KR-2' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'another key result', entryType: 'key_result' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'key-results',
-            canonicalKey: 'key_result',
-        }));
-        writeSpy.mockRestore();
-    });
-    // Review round 3 (bclZ9): --entry-type Objective (mixed case) or " objective " (whitespace)
-    // must route to the drawer too -- the server normalizes explicit keys with
-    // toLowerCase().trim() downstream, so client-side routing must match or it falls through to
-    // classification (often landing in 'strategy') and the placement guard then rejects it.
-    it('--entry-type with mixed case/whitespace still routes to the Objectives drawer, no classification call (bclZ9)', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-7', entryId: 'OBJ-3' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'a padded objective', entryType: ' Objective ' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'objectives',
-        }));
-        writeSpy.mockRestore();
-    });
-    // WP-707 S1 round 3 (operator ruling #13): the fast path is now a GENERAL derivation off the
-    // registry's defaultCanonicalKey (getCanonicalKeyToCollection), not two hardcoded
-    // objective/key_result branches — this proves a THIRD kind that was never one of those two
-    // branches (strategy) still skips classification and routes to its own drawer.
-    it('--entry-type strategy alone (no --collection) skips classification and routes to the Strategy drawer — proves the derivation is general, not a hardcoded pair', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-8', entryId: 'STR-1' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'our approach to winning', entryType: 'strategy' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'strategy',
-            canonicalKey: 'strategy',
-        }));
-        writeSpy.mockRestore();
-    });
-    // WP-707 S1 round 3.1 (Codex post-round-3 P2): vision/purpose are brand-new drawers this same
-    // PR adds — the offline SEED fallback (collectionRegistry.ts) must carry them too, or the
-    // --entry-type derivation silently can't resolve them during a chain.listCollections outage.
-    it('--entry-type vision alone (no --collection) skips classification and routes to the Vision drawer, even offline', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-9', entryId: 'VIS-1' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'a world where knowledge compounds', entryType: 'vision' });
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            collectionSlug: 'vision',
-            canonicalKey: 'vision',
-        }));
+        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', () => {
@@ -725,12 +591,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.capture')
-                return Promise.resolve(null);
             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 = '';
@@ -779,8 +643,6 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
     };
     it('--json output includes the raw coaching object from the write response', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c1', entryId: 'DEC-77', coaching });
             return Promise.resolve({});
@@ -807,8 +669,6 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
     });
     it('--json output omits coaching when the write response has none (backward compat)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c2', entryId: 'DEC-78' });
             return Promise.resolve({});
@@ -848,8 +708,6 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
     };
     it('--link: re-evaluates after the relation lands and renders the post-relation verdict', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c3', entryId: 'DEC-79', coaching });
             if (fn === 'chain.createEntryRelation')
@@ -892,8 +750,6 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
     });
     it('--link: keeps the create-response verdict when the re-eval fails (fail-open, BR-144)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c4', entryId: 'DEC-80', coaching });
             if (fn === 'chain.createEntryRelation')
@@ -923,8 +779,6 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
     });
     it('no --link: does NOT call the re-evaluation and does NOT defer the LLM schedule (plain capture unchanged)', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c5', entryId: 'DEC-81', coaching });
             return Promise.resolve({});
@@ -952,8 +806,6 @@ describe('runCapture --field passthrough', () => {
     });
     it('merges --field pairs into data', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-6', entryId: 'STD-1' });
             return Promise.resolve({});
@@ -965,17 +817,13 @@ describe('runCapture --field passthrough', () => {
             field: ['rationale=signed specs define scope but agents need permission'],
         });
         expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
-            data: expect.objectContaining({
-                description: 'touched-code stewardship',
-                rationale: 'signed specs define scope but agents need permission',
-            }),
+            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('--field description=X overrides the derived description', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-7', entryId: 'TEN-1' });
             return Promise.resolve({});
@@ -994,20 +842,15 @@ describe('runCapture --field passthrough', () => {
 });
 // 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;
-// when -f already set that field and no -d was passed, it is left out.
+// 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' };
     });
-    const bodyContract = { governed: false, whyField: null, minChars: 0, descriptionFieldKey: 'body' };
     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.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.resolve(bodyContract);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'd', entryId: 'INS-1', status: 'draft' });
             return Promise.resolve({});
@@ -1019,10 +862,6 @@ describe('runCapture sends only caller fields (TASK-584)', () => {
     });
     it('keeps description when -d is given, even with -f body', async () => {
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.resolve(bodyContract);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'd', entryId: 'INS-2', status: 'draft' });
             return Promise.resolve({});
@@ -1032,12 +871,8 @@ describe('runCapture sends only caller fields (TASK-584)', () => {
         writeSpy.mockRestore();
         expect(createData()).toEqual({ description: 'explicit', body: 'b' });
     });
-    it('keeps description on a bare capture so the server can remap it into body', async () => {
+    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.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.resolve(bodyContract);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'd', entryId: 'INS-3', status: 'draft' });
             return Promise.resolve({});
@@ -1045,29 +880,11 @@ describe('runCapture sends only caller fields (TASK-584)', () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'an insight', collection: 'insights' });
         writeSpy.mockRestore();
-        expect(createData()).toEqual({ description: 'an insight' });
-    });
-    it('sends description as before when the contract fetch fails', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.reject(new Error('network'));
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'd', entryId: 'INS-4', status: 'draft' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'an insight', collection: 'insights', field: ['body=b'] });
-        writeSpy.mockRestore();
-        expect(createData()).toEqual({ description: 'an insight', body: 'b' });
+        expect(createData()).toEqual({});
+        expect(kernelCallWithSessionMock.mock.calls[0][1]).toMatchObject({ description: 'an insight' });
     });
     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.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.resolve(bodyContract);
             if (fn === 'chain.createEntry') {
                 return Promise.resolve({
                     docId: 'd', entryId: 'INS-5', status: 'draft', warnings: ['Unknown fields dropped: nosuchfield. Expected: body (text, required).'],
@@ -1103,10 +920,6 @@ describe('runCapture prints the kernel pool sentence (TASK-800)', () => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.resolve({ governed: false, whyField: null, minChars: 0, descriptionFieldKey: 'description' });
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'd', entryId: 'STR-2', status: 'draft', warnings: [POOL] });
             return Promise.resolve({});
@@ -1124,174 +937,22 @@ describe('runCapture prints the kernel pool sentence (TASK-800)', () => {
         expect(out).toContain(`Warning: ${POOL}`);
     });
 });
-describe('runCapture WHY pre-flight', () => {
+// 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('blocks with guidance when governed and whyField is missing', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({ governed: true, whyField: 'rationale', minChars: 12, fields: [] });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-8', entryId: 'STD-2' });
-            return Promise.resolve({});
-        });
-        await expect(runCapture({ text: 'x', collection: 'standards' })).rejects.toThrow(/rationale/);
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
-    });
-    it('blocks with guidance for a why-required, non-governed collection (WP-770 W2a, DEC-1787 ruling A)', async () => {
-        // purpose/vision/strategy/objective are why-required but NOT `governed` (steering-shared
-        // subject) — the gate must fire on `whyField` alone, since getCollectionFields now widens
-        // `whyField` for these four independently of `governed`.
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({ governed: false, whyField: 'why', minChars: 12, fields: [] });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-10', entryId: 'STRAT-2' });
-            return Promise.resolve({});
-        });
-        await expect(runCapture({ text: 'x', collection: 'strategy' })).rejects.toThrow(/why/);
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
-    });
-    it('does not block when whyField is description', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({ governed: true, whyField: 'description', minChars: 12, fields: [] });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-9', entryId: 'ARCH-1' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'an architecture note body', collection: 'architecture' });
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        writeSpy.mockRestore();
-    });
-    it('does not block when description remaps to the whyField (descriptionFieldKey === whyField)', async () => {
-        // TEN-1258 regression: `decisions` sets descriptionFieldKey='rationale' and the server
-        // remaps data.description → rationale before the WHY gate. A bare `pb capture "DEC: …"`
-        // (description set, no --field rationale) must NOT be false-blocked client-side.
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({
-                    governed: true,
-                    whyField: 'rationale',
-                    minChars: 12,
-                    descriptionFieldKey: 'rationale',
-                    fields: [],
-                });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-12', entryId: 'DEC-5' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({ text: 'chose X because it is simpler', collection: 'decisions' });
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        writeSpy.mockRestore();
-    });
-    it('still blocks a governed collection whose descriptionFieldKey does NOT map to the whyField', async () => {
-        // proof_governed has whyField='rationale' but no descriptionFieldKey remap, so a bare
-        // capture (no --field rationale) is correctly blocked — the description will not satisfy it.
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({
-                    governed: true,
-                    whyField: 'rationale',
-                    minChars: 12,
-                    descriptionFieldKey: null,
-                    fields: [],
-                });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-13', entryId: 'PGV-9' });
-            return Promise.resolve({});
-        });
-        await expect(runCapture({ text: 'x', collection: 'proof_governed' })).rejects.toThrow(/rationale/);
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
-    });
-    it('fails open and proceeds when the contract fetch fails', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields')
-                return Promise.reject(new Error('network'));
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-10', entryId: 'STD-3' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({
-            text: 'x',
-            collection: 'standards',
-            field: ['rationale=enough characters here ok'],
-        });
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        writeSpy.mockRestore();
-    });
-    it('fails open when the contract fetch rejects with a CLIError (server 4xx/5xx surfaces as McpError, an instanceof CLIError)', async () => {
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.reject(new CLIError('Could not reach test.convex.site.', {
-                    code: ErrorCode.NETWORK_UNREACHABLE,
-                    category: 'network',
-                }));
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-11', entryId: 'STD-4' });
-            return Promise.resolve({});
-        });
-        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await runCapture({
-            text: 'x',
-            collection: 'standards',
-            field: ['rationale=enough characters here ok'],
-        });
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        writeSpy.mockRestore();
-    });
-    it('surfaces the server WHY-gate reason on rejection', async () => {
-        const serverReason = 'Governance entries (standard) require an explicit WHY before they can be created. Set "rationale" to at least 12 characters.';
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.getCollectionFields') {
-                return Promise.resolve({ governed: true, whyField: 'rationale', minChars: 12, fields: [] });
-            }
-            if (fn === 'chain.createEntry')
-                return Promise.reject(new Error(serverReason));
-            return Promise.resolve({});
-        });
-        await expect(runCapture({
-            text: 'x',
-            collection: 'standards',
-            field: ['rationale=short'],
-        })).rejects.toThrow(/at least 12 characters/);
-    });
-});
-describe('runCapture classification guard', () => {
-    beforeEach(() => {
-        kernelCallWithSessionMock.mockReset();
-        mockSession = { sessionId: 'sess-test' };
-    });
-    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.');
+    it.each([
+        ['the WHY gate', 'Governance entries (standard) require an explicit WHY before they can be created. Set "rationale" to 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();
     });
 });
 describe('runCapture writes no date (TEN-4244, DEC-1787)', () => {
@@ -1305,273 +966,76 @@ describe('runCapture writes no date (TEN-4244, DEC-1787)', () => {
         ['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.capture')
-                return Promise.resolve(null);
-            if (fn === 'chain.resolveCollection')
-                return Promise.resolve({ collection, confidence: 0.9, tier: 'high' });
             if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-3', entryId });
+                return Promise.resolve({ docId: 'doc-3', entryId, collection });
             return Promise.resolve({});
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text });
         const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
-        expect(createCall?.[1]).toMatchObject({ collectionSlug: collection });
+        expect(createCall?.[1]).not.toHaveProperty('collectionSlug');
         expect((createCall?.[1]).data).not.toHaveProperty('date');
         writeSpy.mockRestore();
     });
 });
-// ---------------------------------------------------------------------------
-// WP-319 S3 / WP-755 C1a: Pre-write grounding tests (the one capture door)
-// ---------------------------------------------------------------------------
-describe('runCapture WP-319/WP-755 grounding', () => {
-    const emptyVerdict = { kind: 'create', candidates: [], scanTruncated: false };
-    const askVerdict = {
-        kind: 'ask',
-        candidates: [{ entryId: 'TEN-5', name: 'Similar tension', collectionSlug: 'tensions', score: 0.6 }],
-        scanTruncated: false,
-    };
+// 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' };
-        delete process.env.PB_GROUNDING_MODE;
-        // Pre-existing gap this fix round's new --strict tests surfaced: runner.ts's outputMode is
-        // module-level `let` state, set permanently by any earlier test in this file that passed
-        // `json: true` (setOutputMode is never test-scoped). Reset it here so a later test's
-        // `!json` branches (the --strict prompt gate) are never silently skipped by an earlier
-        // test's leaked JSON mode.
-        setOutputMode('auto');
-    });
-    it('fires chain.capture in parallel and still calls createEntry', async () => {
-        // Prefix-based route skips classification; grounding fires for TEN prefix
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(emptyVerdict);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-720' });
-            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.capture', expect.objectContaining({
-            name: 'grounding test tension',
-        }));
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
-    });
-    it('does NOT block capture when grounding call fails', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.reject(new Error('network error'));
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-2', entryId: 'TEN-721' });
-            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());
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
-    });
-    it('a create verdict prints no Related line and no how-it-connects list (TASK-608, DEC-1915)', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(emptyVerdict);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-3', entryId: 'TEN-722' });
-            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 "Related"/"Possible match" banner in stderr, and no first-capture "how it connects" list.
-        const groundingInStderr = stderrLines.some((l) => l.includes('Related') || l.includes('Possible match'));
-        expect(groundingInStderr).toBe(false);
-        const stdoutText = writeSpy.mock.calls.map(([chunk]) => String(chunk)).join('');
-        expect(stdoutText).not.toContain('how it connects');
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
-    });
-    it('PB_GROUNDING_MODE=off skips the door entirely', async () => {
-        process.env.PB_GROUNDING_MODE = 'off';
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-4', entryId: 'TEN-723' });
-            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.capture', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
-        delete process.env.PB_GROUNDING_MODE;
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+        setOutputMode('auto'); // runner.ts keeps output mode at module level; an earlier json test must not leak it
     });
-    it('--json output stdout is clean (no grounding on stdout)', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(askVerdict);
-            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;
-        });
-        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;
+    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 });
         }
-        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('Possible match');
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
-    });
-    // TASK-619: an automated --json caller must learn the close match (id, name, collection, score)
-    // to update it deliberately — still one JSON line on stdout.
-    it('--json on an ask verdict carries possibleMatches in the single JSON line', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(askVerdict);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-6', entryId: 'TEN-725' });
-            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: json ask shape', json: true });
-        const lines = stdoutOutput.split('\n').filter((l) => l.trim());
-        expect(lines).toHaveLength(1);
-        const parsed = JSON.parse(lines[0]);
-        expect(parsed.id).toBe('TEN-725');
-        expect(parsed.possibleMatches).toEqual([{ entryId: 'TEN-5', name: 'Similar tension', collection: 'tensions', score: 0.6 }]);
+        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());
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
     });
-    // TASK-899: the kernel's own verdict and whether its judge answered in budget ride the --json line.
-    it('--json carries the kernel verdict and judged when chain.createEntry returns them', async () => {
-        const verdict = { kind: 'ask', matches: [{ entryId: 'TEN-5', name: 'Similar tension', collectionSlug: 'tensions', score: 0.9 }] };
-        kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-8', entryId: 'TEN-727', verdict, judged: true, collection: 'tensions' });
-            return Promise.resolve(fn === 'chain.capture' ? emptyVerdict : {});
-        });
-        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: json kernel verdict', json: true });
-        const parsed = JSON.parse(stdoutOutput.split('\n').filter((l) => l.trim())[0]);
-        expect(parsed).toMatchObject({ id: 'TEN-727', verdict, judged: true });
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
-    });
-    it('--json on a create verdict carries no possibleMatches field', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(emptyVerdict);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-7', entryId: 'TEN-726' });
-            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: json create shape', json: true });
-        const parsed = JSON.parse(stdoutOutput.split('\n').filter((l) => l.trim())[0]);
-        expect(parsed).not.toHaveProperty('possibleMatches');
-        writeSpy.mockRestore();
-        stderrSpy.mockRestore();
+    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');
     });
-    const originalStdinIsTTY = process.stdin.isTTY;
-    function mockInteractiveStdin(answer) {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
-        vi.spyOn(process.stdin, 'once').mockImplementation((_event, cb) => {
-            cb(Buffer.from(answer));
-            return process.stdin;
-        });
-    }
-    afterEach(() => {
-        // vitest's own hook, not a manual end-of-test call — runs even when an assertion above threw,
-        // so one failing case in this block can never leak its stdin mock into the next test.
-        Object.defineProperty(process.stdin, 'isTTY', { value: originalStdinIsTTY, configurable: true });
-        vi.restoreAllMocks();
+    it('a capped judge scan says more matches may exist', async () => {
+        const { err } = await capture({ entryId: 'TEN-731', verdict: { kind: 'create', scanTruncated: true }, judged: true });
+        expect(err).toContain('read a capped sample; more matching entries may exist');
     });
-    it('--strict prompts on an "ask" verdict too (unchanged from before this fix round)', async () => {
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(askVerdict);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-12', entryId: 'TEN-728' });
-            return Promise.resolve({});
-        });
-        mockInteractiveStdin('y');
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrLines = [];
-        vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
-            stderrLines.push(String(chunk));
-            return true;
+    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 }],
         });
-        await runCapture({ text: 'TEN: ask strict prompt', strict: true });
-        expect(stderrLines.some((l) => l.includes('Proceed with capture?'))).toBe(true);
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
     });
-    // TASK-619 (TEN-4420): a close match never overwrites the matched entry. The CLI names the
-    // match and writes only its own new draft; chain.updateEntry is never called from capture.
-    it('a close same-collection match names the match and never updates it', async () => {
-        const closeMatch = {
-            kind: 'ask',
-            candidates: [{ entryId: 'TEN-9', name: 'Existing near-duplicate tension', collectionSlug: 'tensions', score: 0.95 }],
-            scanTruncated: false,
-        };
-        kernelCallWithSessionMock
-            .mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(closeMatch);
-            if (fn === 'chain.createEntry')
-                return Promise.resolve({ docId: 'doc-13', entryId: 'TEN-729' });
-            return Promise.resolve({});
-        });
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrLines = [];
-        vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
-            stderrLines.push(String(chunk));
-            return true;
-        });
-        await runCapture({ text: 'TEN: existing near-duplicate tension' });
-        expect(stderrLines.some((l) => l.includes('Possible match') && l.includes('TEN-9'))).toBe(true);
-        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.updateEntry', expect.anything());
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+    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. The first send may have timed out before its link,
@@ -1583,8 +1047,6 @@ describe('runCapture on a replayed reply (TASK-898)', () => {
         kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
         kernelCallWithSessionMock.mockImplementation((fn) => {
-            if (fn === 'chain.capture')
-                return Promise.resolve(null);
             if (fn === 'chain.createEntry')
                 return Promise.resolve(REPLAY);
             if (fn === 'chain.createEntryRelation')