@productbrain/cli 0.1.0-beta.4863 → 0.1.0-beta.4879

package/dist/__tests__/capture.test.js

@@ -6,6 +6,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runCapture } from '../commands/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),
@@ -23,34 +24,264 @@ describe('runCapture --link', () => {
         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
-        kernelCallWithSessionMock.mockImplementation((fn) => {
+    // WP-688 S4 (TASK-105, element 11): --link with no --link-type no longer defaults to
+    // surfaces_tension_in — it refuses instead. The capture itself still succeeds (createEntry
+    // ran for real); only the relation write is skipped, replaced by a PREVIEW probe used to
+    // 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.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-1', entryId: 'TEN-710' });
-            if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'TEN-710')
+                    return Promise.resolve({ entryId: 'TEN-710', name: 'x', status: 'draft', canonicalKey: 'tension' });
+                return Promise.resolve(null);
+            }
+            // bdABL: the type row is resolved by scanning the semantic-types collection and
+            // matching on data.canonical_key — NOT by guessing entryId === `TYPE-<key>`. This
+            // row deliberately uses a non-conventional entryId (`ST-1`) to prove that.
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'ST-1', name: 'tension', status: 'active', data: { canonical_key: 'tension', valid_relation_types: ['related_to', 'depends_on', 'surfaces_tension_in'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
             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 expect(runCapture({ text: 'TEN: missing validation', link: 'BET-151' })).rejects.toThrow(CLIError);
+        // The entry was created for real — only the LINK is refused.
         expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
             collectionSlug: 'tensions',
             name: 'missing validation',
         }));
-        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
-            fromEntryId: 'TEN-710',
-            toEntryId: 'BET-151',
-            type: 'surfaces_tension_in',
+        // Legal verbs are READ by scanning the semantic-types collection (chain.listEntries)
+        // and matching data.canonical_key — the same resolution loadTypeMap itself uses,
+        // never a probe, never a guessed entryId.
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.getEntry', { entryId: 'TEN-710' });
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.listEntries', { collectionSlug: 'semantic-types' });
+        // Never a createEntryRelation call at all — a real write, preview, or probe.
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntryRelation', expect.anything());
+        writeSpy.mockRestore();
+    });
+    it('--link without --link-type: refusal message lists the source entry\'s declared relation types', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn, args) => {
+            if (fn === 'chain.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-1b', entryId: 'TEN-711' });
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'TEN-711')
+                    return Promise.resolve({ entryId: 'TEN-711', name: 'x', status: 'draft', canonicalKey: 'tension' });
+                // bcRUMR: the target must actually resolve for this test to exercise the
+                // pb-relate-guidance branch rather than the target-missing branch.
+                if (entryId === 'BET-151')
+                    return Promise.resolve({ entryId: 'BET-151', name: 'y', status: 'active', canonicalKey: 'work_package' });
+                return Promise.resolve(null);
+            }
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'TYPE-tension', name: 'tension', status: 'active', data: { canonical_key: 'tension', valid_relation_types: ['related_to', 'depends_on', 'surfaces_tension_in'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
+            return Promise.resolve({});
         });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: missing validation', link: 'BET-151' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught).toBeInstanceOf(CLIError);
+        expect(caught?.code).toBe(ErrorCode.VALIDATION_FAILED);
+        expect(caught?.message).toContain('related_to, depends_on, surfaces_tension_in');
+        expect(caught?.guidance).toContain('TEN-711');
+        expect(caught?.guidance).toContain('pb relate TEN-711');
+    });
+    // WP-688 S4 review round 5 (bcRUML): a whitespace-only --link must not silently no-op —
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-ws', entryId: 'TEN-720' });
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: whitespace link', link: '   ' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught).toBeInstanceOf(CLIError);
+        expect(caught?.message).toContain('--link requires a non-empty entry ID');
+        // Never a relate/probe call — the target never resolved to anything real.
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntryRelation', expect.anything());
+    });
+    // WP-688 S4 review round 5 (bcRpJQ): --link "" is falsy at the outer `if (options.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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-empty', entryId: 'TEN-722' });
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: empty link', link: '' });
+        }
+        catch (e) {
+            caught = e;
+        }
         writeSpy.mockRestore();
+        expect(caught).toBeInstanceOf(CLIError);
+        expect(caught?.message).toContain('--link requires a non-empty entry ID');
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntryRelation', expect.anything());
     });
-    it('uses custom relation type when --type provided', async () => {
+    // WP-688 S4 review round 5 (bcRUMR): the target entry doesn't exist — the recovery
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-miss', entryId: 'TEN-721' });
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'TEN-721')
+                    return Promise.resolve({ entryId: 'TEN-721', name: 'x', status: 'draft', canonicalKey: 'tension' });
+                return Promise.resolve(null); // GHOST-1 does not exist
+            }
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'TYPE-tension', name: 'tension', status: 'active', data: { canonical_key: 'tension', valid_relation_types: ['informs'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: bad target', link: 'GHOST-1' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught?.guidance).toContain('not found');
+        expect(caught?.guidance).toContain('GHOST-1');
+        expect(caught?.guidance).not.toContain('pb relate');
+    });
+    // WP-688 S4 review round 3 (bc4Pj): `replaces`/`do_not_confuse_with` are declared for
+    // scoring but hard-refused at the generic relate door with a DIFFERENT recovery command
+    // (setSupersededBy / addDoNotConfuseWith, guards.ts:308-321) — listing them as usable via
+    // `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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-1c', entryId: 'DEC-1' });
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'DEC-1')
+                    return Promise.resolve({ entryId: 'DEC-1', name: 'x', status: 'draft', canonicalKey: 'decision' });
+                return Promise.resolve(null);
+            }
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'TYPE-decision', name: 'decision', status: 'active', data: { canonical_key: 'decision', valid_relation_types: ['informs', 'governs', 'replaces', 'conflicts_with'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'DEC: no link-type', link: 'STD-1' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught?.message).toContain('informs, governs, conflicts_with');
+        expect(caught?.message).not.toContain('replaces');
+    });
+    // WP-688 S4 review round 5 (bdB5K): registry reconciliation deliberately preserves a
+    // workspace's customized valid_relation_types even when it contains a verb outside the
+    // kernel ALLOWED_RELATION_TYPES allowlist (registryReconcile.test.ts:131-147) — a supported
+    // persisted state, not malformed data. guardRelation still refuses it (guards.ts:302-307),
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-1d', entryId: 'GOAL-1' });
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'GOAL-1')
+                    return Promise.resolve({ entryId: 'GOAL-1', name: 'x', status: 'draft', canonicalKey: 'goal' });
+                return Promise.resolve(null);
+            }
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'TYPE-goal', name: 'goal', status: 'active', data: { canonical_key: 'goal', valid_relation_types: ['informs', 'depends_on', 'custom_hand_added'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'GOAL: no link-type', link: 'BET-1' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught?.message).toContain('informs, depends_on');
+        expect(caught?.message).not.toContain('custom_hand_added');
+    });
+    // WP-688 S4 review round 5 (cQFZ_): belongs_to/authority_domain toward a domain-tagged
+    // target require ratification metadata (stagingEntryId + source) that `pb relate` cannot
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-1e', entryId: 'INS-1' });
+            if (fn === 'chain.getEntry') {
+                const entryId = args?.entryId;
+                if (entryId === 'INS-1')
+                    return Promise.resolve({ entryId: 'INS-1', name: 'x', status: 'draft', canonicalKey: 'insight' });
+                if (entryId === 'DOM-1')
+                    return Promise.resolve({ entryId: 'DOM-1', name: 'product-design', status: 'active', canonicalKey: 'domain' });
+                return Promise.resolve(null);
+            }
+            if (fn === 'chain.listEntries') {
+                return Promise.resolve([{ entryId: 'TYPE-insight', name: 'insight', status: 'active', data: { canonical_key: 'insight', valid_relation_types: ['informs', 'belongs_to', 'authority_domain'], description: 'x', cardinality_rule: 'multiple' } }]);
+            }
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'INS: no link-type', link: 'DOM-1' });
+        }
+        catch (e) {
+            caught = e;
+        }
+        writeSpy.mockRestore();
+        expect(caught?.message).toContain('Legal relation types for this entry: informs.');
+        expect(caught?.message).not.toContain('belongs_to');
+        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.suggestLinksForCapture')
@@ -58,18 +289,140 @@ describe('runCapture --link', () => {
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-2', entryId: 'INS-50' });
             if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+                return Promise.resolve({ relationId: 'rel-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' });
+        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',
             toEntryId: 'DEC-264',
             type: 'informed_by',
         });
+        const previewCalls = kernelCallWithSessionMock.mock.calls.filter(([fn, args]) => fn === 'chain.createEntryRelation' && args?.preview);
+        expect(previewCalls).toHaveLength(0);
+        writeSpy.mockRestore();
+    });
+    // WP-688 S4 (element 11): the human receipt prints the REAL verb — no `?? 'surfaces_tension_in'`
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-2b', entryId: 'INS-51' });
+            if (fn === 'chain.createEntryRelation')
+                return Promise.resolve({ relationId: 'rel-1' });
+            return Promise.resolve({});
+        });
+        let stdoutOutput = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            stdoutOutput += String(chunk);
+            return true;
+        });
+        setOutputMode('pretty'); // force the human receipt path (test harness's stdout is non-TTY)
+        try {
+            await runCapture({ text: 'INS: discovered Y', link: 'DEC-265', linkType: 'validates' });
+        }
+        finally {
+            setOutputMode('auto');
+            writeSpy.mockRestore();
+        }
+        expect(stdoutOutput).toContain('Linked: → DEC-265 (validates)');
+        expect(stdoutOutput).not.toContain('surfaces_tension_in');
+    });
+    // WP-688 S4 review round 2 (bc04z): a diverted relation call (chain-debt / governs-consent
+    // proposal, or the DEC-1399 auto-link gate) returns WITHOUT a relationId — only a real,
+    // persisted write may claim `linkedTo`/`relationType`.
+    it('a governs-consent proposal diversion (no relationId) is never reported as a persisted link', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
+            if (fn === 'chain.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-3', entryId: 'WPKG-1' });
+            if (fn === 'chain.createEntryRelation') {
+                return Promise.resolve({ status: 'proposal_created', proposalId: 'PROP-1', existing: false });
+            }
+            return Promise.resolve({});
+        });
+        let stdoutOutput = '';
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            stdoutOutput += String(chunk);
+            return true;
+        });
+        await runCapture({ text: 'WPKG: governance test', link: 'STD-1', linkType: 'governs', json: true });
+        writeSpy.mockRestore();
+        const output = JSON.parse(stdoutOutput.split('\n').find((line) => {
+            try {
+                JSON.parse(line);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }));
+        expect(output.relationType).toBeUndefined();
+        // WP-688 S4 review fix (bc7cr): the re-eval call STILL fires — it's the only thing that
+        // un-defers the LLM schedule deferLLMSchedule set (a relate WAS attempted) — but its
+        // verdict is discarded: no relation landed, so relation-dependent criteria stay unscored.
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('quality.evaluateHeuristicAndSchedule', {
+            entryId: 'WPKG-1',
+            context: 'capture',
+        });
+        expect(output.coaching).toBeUndefined();
+    });
+    // WP-688 S4 review round 2 (bc045): --link without --link-type must not defer the LLM
+    // schedule — the refusal branch never runs the re-eval that would un-defer it, so a
+    // 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.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry')
+                return Promise.resolve({ docId: 'doc-4', entryId: 'TEN-20' });
+            if (fn === 'chain.createEntryRelation')
+                return Promise.resolve({ preview: true, advisories: [] });
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await expect(runCapture({ text: 'TEN: refused link, no defer', link: 'BET-1' })).rejects.toThrow(CLIError);
+        writeSpy.mockRestore();
+        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        expect(createCall?.[1]).not.toHaveProperty('deferLLMSchedule');
+    });
+    // WP-688 S4 review round 2 (bc049): both a fields-rejection and a --link-type refusal can
+    // be true on the SAME capture — the entry was created either way, so both recovery
+    // instructions must reach the operator, not just whichever check runs first.
+    it('surfaces BOTH the fields-rejected error and the link-type refusal when they co-occur', async () => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
+            if (fn === 'chain.suggestLinksForCapture')
+                return Promise.resolve([]);
+            if (fn === 'chain.createEntry') {
+                return Promise.resolve({
+                    docId: 'doc-5', entryId: 'TEN-21',
+                    normalization: { remapped: {}, rejected: ['badField'], accepted: [] },
+                });
+            }
+            if (fn === 'chain.createEntryRelation')
+                return Promise.resolve({ preview: true, advisories: [] });
+            return Promise.resolve({});
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        let caught;
+        try {
+            await runCapture({ text: 'TEN: both failures at once', link: 'BET-1' });
+        }
+        catch (e) {
+            caught = e;
+        }
         writeSpy.mockRestore();
+        expect(caught).toBeInstanceOf(CLIError);
+        expect(caught?.message).toContain('Fields rejected: badField');
+        expect(caught?.message).toContain('--link requires --link-type');
+        expect(caught?.guidance).toContain('pb fields');
+        expect(caught?.guidance).toContain('TEN-21');
     });
 });
 // WP-684 TASK-77 (E1.3): one-step typed create — --entry-type forwards to chain.createEntry's
@@ -303,7 +656,7 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c3', entryId: 'DEC-79', coaching });
             if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+                return Promise.resolve({ relationId: 'rel-1' });
             if (fn === 'quality.evaluateHeuristicAndSchedule')
                 return Promise.resolve(reEvalCoaching);
             return Promise.resolve({});
@@ -313,7 +666,7 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
             stdoutOutput += String(chunk);
             return true;
         });
-        await runCapture({ text: 'DEC: chose with a link', link: 'TEN-1', json: true });
+        await runCapture({ text: 'DEC: chose with a link', link: 'TEN-1', linkType: 'informs', json: true });
         writeSpy.mockRestore();
         // Deterministic --link fix: the CREATE call defers the LLM schedule (the
         // post-relation re-eval owns the single LLM run)…
@@ -347,7 +700,7 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-c4', entryId: 'DEC-80', coaching });
             if (fn === 'chain.createEntryRelation')
-                return Promise.resolve({});
+                return Promise.resolve({ relationId: 'rel-1' });
             if (fn === 'quality.evaluateHeuristicAndSchedule')
                 return Promise.reject(new Error('network'));
             return Promise.resolve({});
@@ -357,7 +710,7 @@ describe('runCapture coaching passthrough (WP-475 E1)', () => {
             stdoutOutput += String(chunk);
             return true;
         });
-        await runCapture({ text: 'DEC: chose with a broken re-eval', link: 'TEN-2', json: true });
+        await runCapture({ text: 'DEC: chose with a broken re-eval', link: 'TEN-2', linkType: 'informs', json: true });
         writeSpy.mockRestore();
         const jsonLines = stdoutOutput.split('\n').filter((line) => {
             try {