@productbrain/cli 0.1.0-beta.71 → 0.1.0-beta.72

package/dist/__tests__/audit.test.js

@@ -3,7 +3,7 @@
  * BET-182 Slice 2: CLI command + auto-fix.
  *
  * Verifies:
- * 1. JSON mode: correct structure on pipe (mock convexCall with fixture)
+ * 1. JSON mode: correct structure on pipe (mock kernelCall with fixture)
  * 2. TTY mode: PASS gates collapsed, FAIL gates expanded
  * 3. Exit codes: 0/1/2/3 for each verdict
  * 4. --gate flag: only specified gate runs
@@ -15,11 +15,11 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runAudit } from '../commands/audit.js';
 import { setOutputMode } from '../lib/runner.js';
-const convexCallMock = vi.fn();
-const convexCallWithSessionMock = vi.fn();
+const kernelCallMock = vi.fn();
+const kernelCallWithSessionMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
-    convexCall: (...args) => convexCallMock(...args),
-    convexCallWithSession: (...args) => convexCallWithSessionMock(...args),
+    kernelCall: (...args) => kernelCallMock(...args),
+    kernelCallWithSession: (...args) => kernelCallWithSessionMock(...args),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfigOrGuide: vi.fn((_fn) => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -122,7 +122,7 @@ afterEach(() => {
 // ─── Tests ──────────────────────────────────────────────────────────────────
 describe('runAudit — JSON mode (non-TTY)', () => {
     it('outputs correct JSON structure on pipe', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-182'] })).rejects.toThrow('process.exit');
         const parsed = JSON.parse(stdoutOutput);
@@ -135,10 +135,10 @@ describe('runAudit — JSON mode (non-TTY)', () => {
         expect(exit.code).toBe(0);
     }));
     it('calls chain.auditBet with correct entryId', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-182'] })).rejects.toThrow('process.exit');
-        expect(convexCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
     }));
     it('strips Convex internals from JSON output', withTty(false, async () => {
         const fixtureWithInternals = {
@@ -146,7 +146,7 @@ describe('runAudit — JSON mode (non-TTY)', () => {
             _id: 'sys-internal-id',
             _creationTime: 123456,
         };
-        convexCallMock.mockResolvedValue(fixtureWithInternals);
+        kernelCallMock.mockResolvedValue(fixtureWithInternals);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-182'] })).rejects.toThrow('process.exit');
         const parsed = JSON.parse(stdoutOutput);
@@ -156,7 +156,7 @@ describe('runAudit — JSON mode (non-TTY)', () => {
 });
 describe('runAudit — TTY mode', () => {
     it('collapses PASS gates (shows count), expands FAIL gates', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'] })).rejects.toThrow('process.exit');
         // FAIL gates should be expanded with detail
@@ -169,7 +169,7 @@ describe('runAudit — TTY mode', () => {
         expect(stdoutOutput).toContain('strategic-anchor');
     }));
     it('shows WARN gates expanded with hints', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(WARN_FIXTURE);
+        kernelCallMock.mockResolvedValue(WARN_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-201'] })).rejects.toThrow('process.exit');
         expect(stdoutOutput).toContain('WARN:');
@@ -178,7 +178,7 @@ describe('runAudit — TTY mode', () => {
         expect(stdoutOutput).toContain('Consider removing auto-link noise');
     }));
     it('--verbose expands all gates including PASS', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-182'], verbose: true })).rejects.toThrow('process.exit');
         // PASS gates should show detail, not just count
@@ -191,25 +191,25 @@ describe('runAudit — TTY mode', () => {
 });
 describe('runAudit — exit codes', () => {
     it('exit 0 for pass verdict', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-182'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(0);
     }));
     it('exit 1 for fail verdict', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-200'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(1);
     }));
     it('exit 2 for warn verdict', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(WARN_FIXTURE);
+        kernelCallMock.mockResolvedValue(WARN_FIXTURE);
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-201'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(2);
     }));
     it('exit 3 for error (entry not found)', withTty(false, async () => {
-        convexCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
+        kernelCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-999'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(3);
@@ -217,7 +217,7 @@ describe('runAudit — exit codes', () => {
 });
 describe('runAudit — --gate flag', () => {
     it('filters JSON output to only specified gate(s)', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], gate: ['field-completeness'] })).rejects.toThrow('process.exit');
         const parsed = JSON.parse(stdoutOutput);
@@ -226,7 +226,7 @@ describe('runAudit — --gate flag', () => {
         expect(parsed.gates[0].gate).toBe('field-completeness');
     }));
     it('filters TTY output to only specified gate(s)', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], gate: ['field-completeness'] })).rejects.toThrow('process.exit');
         // Should show the filtered gate
@@ -235,7 +235,7 @@ describe('runAudit — --gate flag', () => {
         expect(stdoutOutput).not.toContain('intentional-relations');
     }));
     it('supports multiple --gate values', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], gate: ['intentional-relations', 'field-completeness'] })).rejects.toThrow('process.exit');
         const parsed = JSON.parse(stdoutOutput);
@@ -247,51 +247,51 @@ describe('runAudit — --gate flag', () => {
 });
 describe('runAudit — --phase flag', () => {
     it('passes phase through to MCP call', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-182'], phase: 'handoff' })).rejects.toThrow('process.exit');
-        expect(convexCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182', phase: 'handoff' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182', phase: 'handoff' });
     }));
     it('omits phase from MCP call when not specified', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(PASS_FIXTURE);
+        kernelCallMock.mockResolvedValue(PASS_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-182'] })).rejects.toThrow('process.exit');
-        expect(convexCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
     }));
 });
 describe('runAudit — --fix', () => {
     it('calls updateEntry for exact fixes and reruns audit once', withTty(false, async () => {
         // First call: failing audit
         // Second call (after fix): passing audit
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce(FAIL_FIXTURE)
             .mockResolvedValueOnce({ ...PASS_FIXTURE, entryId: 'BET-200', entryName: 'Broken Bet' });
-        convexCallWithSessionMock.mockResolvedValue({ id: 'result-id', warnings: [] });
+        kernelCallWithSessionMock.mockResolvedValue({ id: 'result-id', warnings: [] });
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], fix: true })).rejects.toThrow('process.exit');
         // Should have called updateEntry for each exact fix
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'BET-200',
             data: { problem: 'needs definition' },
             changeNote: 'Auto-fix via pb audit: set problem',
         });
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'BET-200',
             data: { appetite: '6 weeks' },
             changeNote: 'Auto-fix via pb audit: set appetite',
         });
-        // Should have rerun the audit (2 convexCall invocations total)
-        expect(convexCallMock).toHaveBeenCalledTimes(2);
+        // Should have rerun the audit (2 kernelCall invocations total)
+        expect(kernelCallMock).toHaveBeenCalledTimes(2);
         // Exit code should reflect the rerun result (pass = 0)
         expect(exit.code).toBe(0);
     }));
     it('does not fix when no session is active', withTty(false, async () => {
         mockSession = null;
-        convexCallMock.mockResolvedValue(FAIL_FIXTURE);
+        kernelCallMock.mockResolvedValue(FAIL_FIXTURE);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], fix: true })).rejects.toThrow('process.exit');
         // Should NOT have called updateEntry
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
         // Should still show the result
         const parsed = JSON.parse(stdoutOutput);
         expect(parsed.verdict).toBe('fail');
@@ -304,36 +304,36 @@ describe('runAudit — --fix', () => {
                 { gate: 'strategic-anchor', status: 'pass', blocking: true, detail: 'OK' },
             ],
         };
-        convexCallMock.mockResolvedValue(manualFixFixture);
+        kernelCallMock.mockResolvedValue(manualFixFixture);
         catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], fix: true })).rejects.toThrow('process.exit');
         // No exact fixes → no updateEntry calls, no rerun
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
-        expect(convexCallMock).toHaveBeenCalledTimes(1);
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallMock).toHaveBeenCalledTimes(1);
     }));
     it('stops after one rerun even if issues remain', withTty(false, async () => {
         // Both calls return failing audit (fix didn't resolve everything)
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce(FAIL_FIXTURE)
             .mockResolvedValueOnce(FAIL_FIXTURE);
-        convexCallWithSessionMock.mockResolvedValue({ id: 'result-id', warnings: [] });
+        kernelCallWithSessionMock.mockResolvedValue({ id: 'result-id', warnings: [] });
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-200'], fix: true })).rejects.toThrow('process.exit');
         // Should have run audit exactly 2 times (initial + 1 rerun), not 3
-        expect(convexCallMock).toHaveBeenCalledTimes(2);
+        expect(kernelCallMock).toHaveBeenCalledTimes(2);
         expect(exit.code).toBe(1);
     }));
 });
 describe('runAudit — batch mode', () => {
     it('audits multiple bets sequentially', withTty(false, async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce(PASS_FIXTURE)
             .mockResolvedValueOnce(FAIL_FIXTURE);
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-182', 'BET-200'] })).rejects.toThrow('process.exit');
         // Both auditBet calls should have been made
-        expect(convexCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
-        expect(convexCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-200' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-182' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.auditBet', { entryId: 'BET-200' });
         // Exit code should be worst verdict (fail = 1)
         expect(exit.code).toBe(1);
         // Should have batch summary as last line of output
@@ -346,7 +346,7 @@ describe('runAudit — batch mode', () => {
         expect(batchSummary.failed).toBe(1);
     }));
     it('shows separator between entries in TTY mode', withTty(true, async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce(PASS_FIXTURE)
             .mockResolvedValueOnce(WARN_FIXTURE);
         catchExit();
@@ -358,7 +358,7 @@ describe('runAudit — batch mode', () => {
         expect(stdoutOutput).toContain('BET-201');
     }));
     it('continues after error on one entry', withTty(false, async () => {
-        convexCallMock
+        kernelCallMock
             .mockRejectedValueOnce(new Error('Entry "BET-999" not found.'))
             .mockResolvedValueOnce(PASS_FIXTURE);
         const exit = catchExit();
@@ -373,7 +373,7 @@ describe('runAudit — batch mode', () => {
 });
 describe('runAudit — error handling', () => {
     it('outputs JSON error on pipe when entry not found', withTty(false, async () => {
-        convexCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
+        kernelCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-999'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(3);
@@ -383,7 +383,7 @@ describe('runAudit — error handling', () => {
         expect(errParsed.entryId).toBe('BET-999');
     }));
     it('outputs human error in TTY when entry not found', withTty(true, async () => {
-        convexCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
+        kernelCallMock.mockRejectedValue(new Error('Entry "BET-999" not found.'));
         const exit = catchExit();
         await expect(runAudit({ entryIds: ['BET-999'] })).rejects.toThrow('process.exit');
         expect(exit.code).toBe(3);

package/dist/__tests__/capture.test.js

@@ -5,9 +5,9 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runCapture } from '../commands/capture.js';
-const convexCallWithSessionMock = vi.fn();
+const kernelCallWithSessionMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
-    convexCallWithSession: (...args) => convexCallWithSessionMock(...args),
+    kernelCallWithSession: (...args) => kernelCallWithSessionMock(...args),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfigOrGuide: vi.fn(() => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -19,12 +19,12 @@ vi.mock('../lib/session.js', () => ({
 }));
 describe('runCapture --link', () => {
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        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
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.createEntry')
@@ -36,13 +36,13 @@ describe('runCapture --link', () => {
         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(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
         // Verify prefix was stripped from entry name and routed to correct collection
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.objectContaining({
             collectionSlug: 'tensions',
             name: 'missing validation',
         }));
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'TEN-710',
             toEntryId: 'BET-151',
             type: 'surfaces_tension_in',
@@ -51,7 +51,7 @@ describe('runCapture --link', () => {
     });
     it('uses custom relation type when --type provided', async () => {
         // Prefix "INS:" is extracted → skips classification, routes directly to insights
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.createEntry')
@@ -62,8 +62,8 @@ describe('runCapture --link', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'INS: discovered X', link: 'DEC-264', type: 'informed_by' });
-        expect(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.resolveCollection', expect.anything());
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'INS-50',
             toEntryId: 'DEC-264',
             type: 'informed_by',
@@ -73,12 +73,12 @@ describe('runCapture --link', () => {
 });
 describe('runCapture --json', () => {
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
     it('outputs valid JSON with id field and no other stdout', async () => {
         // Prefix "TEN:" is extracted → skips classification
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.createEntry')
@@ -111,14 +111,14 @@ describe('runCapture --json', () => {
 });
 describe('runCapture description field routing', () => {
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        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.
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.createEntry')
@@ -127,7 +127,7 @@ describe('runCapture description field routing', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'ASM: users won\'t pay before seeing value' });
-        const createCall = convexCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
         expect(createCall?.[1]).toMatchObject({
             collectionSlug: 'assumptions',
             name: "users won't pay before seeing value",
@@ -138,21 +138,21 @@ describe('runCapture description field routing', () => {
 });
 describe('runCapture classification guard', () => {
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
     it('throws CLIError when classification requires review', async () => {
-        convexCallWithSessionMock.mockResolvedValueOnce(null);
+        kernelCallWithSessionMock.mockResolvedValueOnce(null);
         await expect(runCapture({ text: 'Ambiguous capture' })).rejects.toThrow('Classification needs review before capture can continue.');
     });
 });
 describe('runCapture date inference', () => {
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        kernelCallWithSessionMock.mockReset();
         mockSession = { sessionId: 'sess-test' };
     });
     it('does not default date to today when no source date is present', async () => {
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.resolveCollection')
@@ -163,7 +163,7 @@ describe('runCapture date inference', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'Decision without explicit source date' });
-        const createCall = convexCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
         expect(createCall?.[1]).toMatchObject({
             collectionSlug: 'decisions',
             data: { description: 'Decision without explicit source date' },
@@ -172,7 +172,7 @@ describe('runCapture date inference', () => {
         writeSpy.mockRestore();
     });
     it('uses inferred source date when the capture text includes one', async () => {
-        convexCallWithSessionMock.mockImplementation((fn) => {
+        kernelCallWithSessionMock.mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([]);
             if (fn === 'chain.resolveCollection')
@@ -183,7 +183,7 @@ describe('runCapture date inference', () => {
         });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runCapture({ text: 'Decision from April 1, 2026 steering meeting' });
-        const createCall = convexCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
+        const createCall = kernelCallWithSessionMock.mock.calls.find(([fn]) => fn === 'chain.createEntry');
         expect((createCall?.[1]).data.date).toBe('2026-04-01');
         writeSpy.mockRestore();
     });
@@ -201,13 +201,13 @@ describe('runCapture WP-319 grounding', () => {
         v: 1,
     };
     beforeEach(() => {
-        convexCallWithSessionMock.mockReset();
+        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
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([emptyGrounding]);
@@ -218,15 +218,15 @@ describe('runCapture WP-319 grounding', () => {
         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(convexCallWithSessionMock).toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.objectContaining({
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.objectContaining({
             entries: expect.arrayContaining([expect.objectContaining({ name: 'grounding test tension' })]),
         }));
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
         writeSpy.mockRestore();
         stderrSpy.mockRestore();
     });
     it('does NOT block capture when grounding call fails', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.reject(new Error('network error'));
@@ -238,13 +238,13 @@ describe('runCapture WP-319 grounding', () => {
         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(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
         writeSpy.mockRestore();
         stderrSpy.mockRestore();
     });
     it('--suggest-only does NOT call createEntry and outputs grounding data', async () => {
         // In test env (non-TTY), isJsonMode() returns true → JSON path is taken.
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([groundingWithDuplicate]);
@@ -257,7 +257,7 @@ describe('runCapture WP-319 grounding', () => {
         });
         const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
         await runCapture({ text: 'TEN: duplicate candidate', suggestOnly: true });
-        expect(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        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);
@@ -274,7 +274,7 @@ describe('runCapture WP-319 grounding', () => {
         stderrSpy.mockRestore();
     });
     it('--suggest-only with --json outputs machine-readable object without calling createEntry', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([emptyGrounding]);
@@ -287,7 +287,7 @@ describe('runCapture WP-319 grounding', () => {
         });
         const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
         await runCapture({ text: 'TEN: dry run json', json: true, suggestOnly: true });
-        expect(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
         const jsonLines = stdoutOutput.split('\n').filter((l) => { try {
             JSON.parse(l);
             return true;
@@ -302,7 +302,7 @@ describe('runCapture WP-319 grounding', () => {
         stderrSpy.mockRestore();
     });
     it('banner is suppressed when grounding has no matches (zero-noise floor)', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([emptyGrounding]);
@@ -325,7 +325,7 @@ describe('runCapture WP-319 grounding', () => {
     });
     it('PB_GROUNDING_MODE=off skips grounding call entirely', async () => {
         process.env.PB_GROUNDING_MODE = 'off';
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.createEntry')
                 return Promise.resolve({ docId: 'doc-4', entryId: 'TEN-723' });
@@ -334,14 +334,14 @@ describe('runCapture WP-319 grounding', () => {
         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(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.anything());
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.suggestLinksForCapture', expect.anything());
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntry', expect.anything());
         delete process.env.PB_GROUNDING_MODE;
         writeSpy.mockRestore();
         stderrSpy.mockRestore();
     });
     it('--json output stdout is clean (no grounding on stdout)', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockImplementation((fn) => {
             if (fn === 'chain.suggestLinksForCapture')
                 return Promise.resolve([groundingWithDuplicate]);