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

package/dist/__tests__/promote.test.js

@@ -1,12 +1,12 @@
 /**
- * pb promote — verify convexCallWithSession sequence and args.
+ * pb promote — verify kernelCallWithSession sequence and args.
  * Covers: happy path (direct commit), governance proposal, no session, empty entryId.
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runPromote } from '../commands/promote.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' })),
@@ -29,7 +29,7 @@ describe('runPromote', () => {
         mockSession = { sessionId: 'sess-test' };
     });
     it('calls chain.commitEntry with correct args (happy path)', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Test entry', collectionSlug: 'tensions', data: { description: 'Valid description' } })
             .mockResolvedValueOnce([])
             .mockResolvedValueOnce({
@@ -41,14 +41,14 @@ describe('runPromote', () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runPromote({ entryId: 'TEN-951' });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
             entryId: 'TEN-951',
             author: 'agent:sess-test',
             sessionId: 'sess-test',
         });
     });
     it('passes commitMessage when --message is provided', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Test entry', collectionSlug: 'tensions', data: { description: 'Valid description' } })
             .mockResolvedValueOnce([])
             .mockResolvedValueOnce({
@@ -60,7 +60,7 @@ describe('runPromote', () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runPromote({ entryId: 'TEN-951', message: 'Validated and ready' });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.commitEntry', {
             entryId: 'TEN-951',
             author: 'agent:sess-test',
             sessionId: 'sess-test',
@@ -68,7 +68,7 @@ describe('runPromote', () => {
         });
     });
     it('displays version result for direct commit', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Wave 2 smoke test', collectionSlug: 'tensions', data: { description: 'Valid description' } })
             .mockResolvedValueOnce([])
             .mockResolvedValueOnce({
@@ -88,7 +88,7 @@ describe('runPromote', () => {
         expect(output).toContain('v1');
     });
     it('displays proposal result for governance mode', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Some governed decision', collectionSlug: 'decisions', data: { rationale: 'Valid description' } })
             .mockResolvedValueOnce([])
             .mockResolvedValueOnce({
@@ -107,7 +107,7 @@ describe('runPromote', () => {
         expect(output).toContain('governance mode');
     });
     it('displays quality warnings when present', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Test Bet', collectionSlug: 'bets', data: { description: 'Valid description' } })
             .mockResolvedValueOnce([])
             .mockResolvedValueOnce({
@@ -132,18 +132,18 @@ describe('runPromote', () => {
     it('throws CLIError with no active session', async () => {
         mockSession = null;
         await expect(runPromote({ entryId: 'TEN-951' })).rejects.toThrow('No active session');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     it('throws CLIError with empty entryId', async () => {
         await expect(runPromote({ entryId: '  ' })).rejects.toThrow('Entry ID is required');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     it('handles server errors thrown during commit', async () => {
-        convexCallWithSessionMock.mockRejectedValue(new Error('Entry not found.'));
+        kernelCallWithSessionMock.mockRejectedValue(new Error('Entry not found.'));
         await expect(runPromote({ entryId: 'TEN-999' })).rejects.toThrow('Entry not found.');
     });
     it('blocks promote when semantic contradiction preflight finds a contradiction', async () => {
-        convexCallWithSessionMock
+        kernelCallWithSessionMock
             .mockResolvedValueOnce({ name: 'Conflicting entry', collectionSlug: 'decisions', data: { rationale: 'Valid description' } })
             .mockResolvedValueOnce([
             {
@@ -155,7 +155,7 @@ describe('runPromote', () => {
             },
         ]);
         await expect(runPromote({ entryId: 'DEC-100' })).rejects.toThrow('Commit blocked by contradiction with DEC-42: Directly contradicts the approved baseline.');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalledWith('chain.commitEntry', expect.anything());
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalledWith('chain.commitEntry', expect.anything());
     });
 });
 //# sourceMappingURL=promote.test.js.map

package/dist/__tests__/proposals.test.js

@@ -13,9 +13,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runProposals } from '../commands/proposals.js';
 import { runAccept } from '../commands/accept.js';
 import { runReject } from '../commands/reject.js';
-const convexCallMock = vi.fn();
+const kernelCallMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
-    convexCall: (...args) => convexCallMock(...args),
+    kernelCall: (...args) => kernelCallMock(...args),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfigOrGuide: vi.fn(() => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -48,16 +48,16 @@ describe('runProposals', () => {
         vi.clearAllMocks();
     });
     it('formats empty proposal list', async () => {
-        convexCallMock.mockResolvedValue([]);
+        kernelCallMock.mockResolvedValue([]);
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runProposals();
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
         writeSpy.mockRestore();
         expect(output).toContain('No open consent proposals');
-        expect(convexCallMock).toHaveBeenCalledWith('governance.listProposals', {});
+        expect(kernelCallMock).toHaveBeenCalledWith('governance.listProposals', {});
     });
     it('formats non-empty proposal list with expiry', async () => {
-        convexCallMock.mockResolvedValue([sampleProposal]);
+        kernelCallMock.mockResolvedValue([sampleProposal]);
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runProposals();
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
@@ -74,7 +74,7 @@ describe('runAccept', () => {
         vi.clearAllMocks();
     });
     it('calls governance.respondToProposal with approve verdict', async () => {
-        convexCallMock.mockResolvedValue({
+        kernelCallMock.mockResolvedValue({
             status: 'approved',
             proposalId: 'prop-abc123',
             message: 'Proposal approved. Governs relation created.',
@@ -83,7 +83,7 @@ describe('runAccept', () => {
         await runAccept({ proposalId: 'prop-abc123' });
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
         writeSpy.mockRestore();
-        expect(convexCallMock).toHaveBeenCalledWith('governance.respondToProposal', {
+        expect(kernelCallMock).toHaveBeenCalledWith('governance.respondToProposal', {
             proposalId: 'prop-abc123',
             verdict: 'approve',
         });
@@ -98,9 +98,9 @@ describe('runAccept', () => {
         };
         const freshProposal = { ...sampleProposal, _id: 'prop-fresh' };
         // First call: listProposals
-        convexCallMock.mockResolvedValueOnce([expiredProposal, freshProposal]);
+        kernelCallMock.mockResolvedValueOnce([expiredProposal, freshProposal]);
         // Second call: respondToProposal for fresh proposal
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             status: 'approved',
             proposalId: 'prop-fresh',
             message: 'Proposal approved. Governs relation created.',
@@ -110,9 +110,9 @@ describe('runAccept', () => {
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
         writeSpy.mockRestore();
         // Should have called listProposals, then respondToProposal for fresh only
-        expect(convexCallMock).toHaveBeenCalledTimes(2);
-        expect(convexCallMock).toHaveBeenNthCalledWith(1, 'governance.listProposals', {});
-        expect(convexCallMock).toHaveBeenNthCalledWith(2, 'governance.respondToProposal', {
+        expect(kernelCallMock).toHaveBeenCalledTimes(2);
+        expect(kernelCallMock).toHaveBeenNthCalledWith(1, 'governance.listProposals', {});
+        expect(kernelCallMock).toHaveBeenNthCalledWith(2, 'governance.respondToProposal', {
             proposalId: 'prop-fresh',
             verdict: 'approve',
         });
@@ -122,7 +122,7 @@ describe('runAccept', () => {
         expect(output).toContain('Expired');
     });
     it('--auto with no proposals reports nothing to process', async () => {
-        convexCallMock.mockResolvedValueOnce([]);
+        kernelCallMock.mockResolvedValueOnce([]);
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runAccept({ auto: true });
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
@@ -131,7 +131,7 @@ describe('runAccept', () => {
     });
     it('throws CLIError when no proposal-id and no --auto', async () => {
         await expect(runAccept({})).rejects.toThrow('Proposal ID is required');
-        expect(convexCallMock).not.toHaveBeenCalled();
+        expect(kernelCallMock).not.toHaveBeenCalled();
     });
 });
 describe('runReject', () => {
@@ -139,7 +139,7 @@ describe('runReject', () => {
         vi.clearAllMocks();
     });
     it('calls governance.respondToProposal with reject verdict and reason', async () => {
-        convexCallMock.mockResolvedValue({
+        kernelCallMock.mockResolvedValue({
             status: 'objected',
             proposalId: 'prop-abc123',
             message: 'Proposal rejected: Creates circular governance',
@@ -148,7 +148,7 @@ describe('runReject', () => {
         await runReject({ proposalId: 'prop-abc123', reason: 'Creates circular governance' });
         const output = writeSpy.mock.calls.map((c) => String(c[0])).join('');
         writeSpy.mockRestore();
-        expect(convexCallMock).toHaveBeenCalledWith('governance.respondToProposal', {
+        expect(kernelCallMock).toHaveBeenCalledWith('governance.respondToProposal', {
             proposalId: 'prop-abc123',
             verdict: 'reject',
             reason: 'Creates circular governance',
@@ -157,11 +157,11 @@ describe('runReject', () => {
     });
     it('throws CLIError when reason is empty', async () => {
         await expect(runReject({ proposalId: 'prop-abc123', reason: '' })).rejects.toThrow('reason is required');
-        expect(convexCallMock).not.toHaveBeenCalled();
+        expect(kernelCallMock).not.toHaveBeenCalled();
     });
     it('throws CLIError when proposal-id is empty', async () => {
         await expect(runReject({ proposalId: '', reason: 'Some reason' })).rejects.toThrow('Proposal ID is required');
-        expect(convexCallMock).not.toHaveBeenCalled();
+        expect(kernelCallMock).not.toHaveBeenCalled();
     });
 });
 //# sourceMappingURL=proposals.test.js.map

package/dist/__tests__/relate.test.js

@@ -1,12 +1,12 @@
 /**
- * pb relate / pb unrelate — verify convexCallWithSession sequence and args.
+ * pb relate / pb unrelate — verify kernelCallWithSession sequence and args.
  * TEN-341 test contract: happy paths, no session.
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runRelate, runUnrelate } from '../commands/relate.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,11 +19,11 @@ describe('runRelate', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockSession = { sessionId: 'sess-test' };
-        convexCallWithSessionMock.mockResolvedValue({});
+        kernelCallWithSessionMock.mockResolvedValue({});
     });
     it('calls chain.createEntryRelation with correct args', async () => {
         await runRelate({ fromId: 'BET-151', type: 'informed_by', toId: 'DEC-264' });
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'BET-151',
             toEntryId: 'DEC-264',
             type: 'informed_by',
@@ -31,7 +31,7 @@ describe('runRelate', () => {
     });
     it('passes ifMissing=true when --if-missing flag is set', async () => {
         await runRelate({ fromId: 'BET-151', type: 'part_of', toId: 'FEAT-77', ifMissing: true });
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'BET-151',
             toEntryId: 'FEAT-77',
             type: 'part_of',
@@ -40,14 +40,14 @@ describe('runRelate', () => {
     });
     it('does not pass ifMissing when flag is not set', async () => {
         await runRelate({ fromId: 'BET-151', type: 'part_of', toId: 'FEAT-77' });
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.createEntryRelation', {
             fromEntryId: 'BET-151',
             toEntryId: 'FEAT-77',
             type: 'part_of',
         });
     });
     it('handles alreadyExists=true response gracefully and reflects it in output', async () => {
-        convexCallWithSessionMock.mockResolvedValue({ alreadyExists: true });
+        kernelCallWithSessionMock.mockResolvedValue({ alreadyExists: true });
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runRelate({ fromId: 'BET-151', type: 'part_of', toId: 'FEAT-77', ifMissing: true });
         const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
@@ -56,7 +56,7 @@ describe('runRelate', () => {
         expect(output).toContain('alreadyExists');
     });
     it('surfaces proposal_created when backend returns a proposal instead of a relation', async () => {
-        convexCallWithSessionMock.mockResolvedValue({
+        kernelCallWithSessionMock.mockResolvedValue({
             status: 'proposal_created',
             proposalId: 'prop-123',
             fromEntryId: 'STD-2',
@@ -73,22 +73,22 @@ describe('runRelate', () => {
     it('throws CLIError with no active session', async () => {
         mockSession = null;
         await expect(runRelate({ fromId: 'A', type: 'x', toId: 'B' })).rejects.toThrow('No active session');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     it('throws CLIError with empty args', async () => {
         await expect(runRelate({ fromId: '', type: 'x', toId: 'B' })).rejects.toThrow('All arguments required');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
 });
 describe('runUnrelate', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockSession = { sessionId: 'sess-test' };
-        convexCallWithSessionMock.mockResolvedValue({});
+        kernelCallWithSessionMock.mockResolvedValue({});
     });
     it('calls chain.removeEntryRelation with correct args', async () => {
         await runUnrelate({ fromId: 'BET-151', type: 'part_of', toId: 'FEAT-77' });
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.removeEntryRelation', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.removeEntryRelation', {
             fromEntryId: 'BET-151',
             toEntryId: 'FEAT-77',
             type: 'part_of',
@@ -97,7 +97,7 @@ describe('runUnrelate', () => {
     it('throws CLIError with no active session', async () => {
         mockSession = null;
         await expect(runUnrelate({ fromId: 'A', type: 'x', toId: 'B' })).rejects.toThrow('No active session');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
 });
 //# sourceMappingURL=relate.test.js.map

package/dist/__tests__/session-touch.test.js

@@ -1,13 +1,13 @@
 /**
- * session-touch — verify convexCallWithSession auto-renews the session TTL.
+ * session-touch — verify kernelCallWithSession auto-renews the session TTL.
  * BET-181 Slice 1: Session Auto-Renew on Write.
  *
  * Done-when criteria tested:
- * 1. After a successful convexCallWithSession, agent.touchSession is called with the current session ID
- * 2. Touch happens in exactly ONE place (convexCallWithSession) — not per-command
+ * 1. After a successful kernelCallWithSession, agent.touchSession is called with the current session ID
+ * 2. Touch happens in exactly ONE place (kernelCallWithSession) — not per-command
  * 3. Touch is fire-and-forget (does not block the write response)
  * 4. When no session is active (session.json absent), no touch is attempted
- * 5. When convexCallWithSession fails (write error), touch is NOT called
+ * 5. When kernelCallWithSession fails (write error), touch is NOT called
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 // We need to control what readSession() returns per test.
@@ -19,7 +19,7 @@ vi.mock('../lib/config.js', () => ({
     getConfig: vi.fn(() => ({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
 }));
 // Import the module under test AFTER setting up mocks.
-import { convexCallWithSession } from '../lib/client.js';
+import { kernelCallWithSession } from '../lib/client.js';
 // Helper: build a fetch mock that returns different responses based on `fn`.
 function makeFetch({ writeOk = true, writeData = { ok: true }, } = {}) {
     return vi.fn(async (_input, init) => {
@@ -43,7 +43,7 @@ async function flushMicrotasks() {
     await Promise.resolve();
     await Promise.resolve();
 }
-describe('convexCallWithSession — session touch on write', () => {
+describe('kernelCallWithSession — session touch on write', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockSession = {
@@ -59,7 +59,7 @@ describe('convexCallWithSession — session touch on write', () => {
     });
     it('calls agent.touchSession with the current session ID after a successful write', async () => {
         global.fetch = makeFetch({ writeOk: true, writeData: { entryId: 'BET-181' } });
-        await convexCallWithSession('chain.updateEntry', { entryId: 'BET-181', name: 'New name' });
+        await kernelCallWithSession('chain.updateEntry', { entryId: 'BET-181', name: 'New name' });
         await flushMicrotasks();
         const calls = global.fetch.mock.calls;
         // Expect exactly 2 fetch calls: the write + the touch
@@ -75,7 +75,7 @@ describe('convexCallWithSession — session touch on write', () => {
     it('does NOT call agent.touchSession when no session is active', async () => {
         mockSession = null;
         global.fetch = makeFetch({ writeOk: true });
-        await convexCallWithSession('chain.updateEntry', { entryId: 'BET-100' });
+        await kernelCallWithSession('chain.updateEntry', { entryId: 'BET-100' });
         await flushMicrotasks();
         const calls = global.fetch.mock.calls;
         // Only the write call — no touch
@@ -85,7 +85,7 @@ describe('convexCallWithSession — session touch on write', () => {
     });
     it('does NOT call agent.touchSession when the write fails', async () => {
         global.fetch = makeFetch({ writeOk: false });
-        await expect(convexCallWithSession('chain.updateEntry', { entryId: 'BET-100' })).rejects.toThrow('Server error');
+        await expect(kernelCallWithSession('chain.updateEntry', { entryId: 'BET-100' })).rejects.toThrow('Server error');
         await flushMicrotasks();
         const calls = global.fetch.mock.calls;
         // Only the write call — no touch because write threw
@@ -106,7 +106,7 @@ describe('convexCallWithSession — session touch on write', () => {
             };
         });
         // Should resolve successfully despite touch throwing
-        const result = await convexCallWithSession('chain.updateEntry', { entryId: 'BET-181' });
+        const result = await kernelCallWithSession('chain.updateEntry', { entryId: 'BET-181' });
         await flushMicrotasks();
         expect(result).toEqual({ entryId: 'BET-181' });
     });
@@ -123,7 +123,7 @@ describe('convexCallWithSession — session touch on write', () => {
             order.push('write-complete');
             return { ok: true, json: async () => ({ data: { entryId: 'BET-181' } }) };
         });
-        await convexCallWithSession('chain.updateEntry', { entryId: 'BET-181' });
+        await kernelCallWithSession('chain.updateEntry', { entryId: 'BET-181' });
         // Write has resolved — touch has NOT yet completed (it's still pending)
         expect(order).toEqual(['write-complete']);
         // After waiting for the touch to finish

package/dist/__tests__/session.test.js

@@ -5,8 +5,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runSessionId } from '../commands/session.js';
 vi.mock('../lib/client.js', () => ({
-    convexCall: vi.fn(),
-    convexCallWithSession: vi.fn(),
+    kernelCall: vi.fn(),
+    kernelCallWithSession: vi.fn(),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfigOrGuide: vi.fn(() => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),

package/dist/__tests__/setup.test.js

@@ -14,11 +14,11 @@ vi.mock('../lib/telemetry.js', () => ({
     },
     initTelemetry: vi.fn(),
 }));
-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),
 }));
 let mockConfig = {
     apiKey: 'pb_sk_test_key_1234',
@@ -85,7 +85,7 @@ describe('runSetup', () => {
         mockSession = null;
     });
     it('skips login when valid config exists and runs onboarding', async () => {
-        convexCallMock.mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1', name: 'Test Workspace' }); // resolveWorkspace
+        kernelCallMock.mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1', name: 'Test Workspace' }); // resolveWorkspace
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await runSetup();
         // Should NOT call runLogin
@@ -118,7 +118,7 @@ describe('runSetup', () => {
         runLoginMock.mockImplementation(() => {
             mockConfig = { apiKey: 'pb_sk_new_key', siteUrl: 'https://test.convex.site' };
         });
-        convexCallMock.mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1', name: 'Test Workspace' }); // resolveWorkspace
+        kernelCallMock.mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1', name: 'Test Workspace' }); // resolveWorkspace
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await runSetup();
         expect(runLoginMock).toHaveBeenCalledOnce();
@@ -128,7 +128,7 @@ describe('runSetup', () => {
         logSpy.mockRestore();
     });
     it('handles workspace verification failure gracefully', async () => {
-        convexCallMock.mockRejectedValueOnce(new Error('Network error')); // resolveWorkspace fails
+        kernelCallMock.mockRejectedValueOnce(new Error('Network error')); // resolveWorkspace fails
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await runSetup();
         // Should warn about connection

package/dist/__tests__/update.test.js

@@ -1,15 +1,15 @@
 /**
- * pb update — verify convexCallWithSession sequence and args.
+ * pb update — verify kernelCallWithSession sequence and args.
  * TEN-341 test contract: happy path, no session, empty entryId.
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runUpdate } from '../commands/update.js';
 import { CLIError } from '../lib/errors.js';
-const convexCallWithSessionMock = vi.fn();
-const convexCallMock = vi.fn();
+const kernelCallWithSessionMock = vi.fn();
+const kernelCallMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
-    convexCallWithSession: (...args) => convexCallWithSessionMock(...args),
-    convexCall: (...args) => convexCallMock(...args),
+    kernelCallWithSession: (...args) => kernelCallWithSessionMock(...args),
+    kernelCall: (...args) => kernelCallMock(...args),
     // McpError exported so update.ts can import the type (not used at runtime in tests).
     McpError: class McpError extends Error {
         details;
@@ -50,7 +50,7 @@ describe('runUpdate', () => {
         vi.clearAllMocks();
         mockSession = { sessionId: 'sess-test' };
         // BET-192: updateEntry returns warnings + normalization breakdown (symmetric with createEntry)
-        convexCallWithSessionMock.mockResolvedValue({
+        kernelCallWithSessionMock.mockResolvedValue({
             id: 'j571abc123def456',
             warnings: [],
             normalization: { remapped: {}, rejected: [], accepted: [] },
@@ -58,7 +58,7 @@ describe('runUpdate', () => {
             validationWarnings: [],
         });
         // Post-update refresh: default to returning a minimal entry.
-        convexCallMock.mockResolvedValue({
+        kernelCallMock.mockResolvedValue({
             entryId: 'BET-151',
             name: 'Test Entry',
             status: 'active',
@@ -72,7 +72,7 @@ describe('runUpdate', () => {
             note: 'Updated description',
         });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'BET-151',
             changedBy: 'agent:sess-test',
             data: { description: 'new description' },
@@ -88,7 +88,7 @@ describe('runUpdate', () => {
             note: 'Resolved',
         });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'TEN-703',
             changedBy: 'agent:sess-test',
             name: 'New name',
@@ -103,7 +103,7 @@ describe('runUpdate', () => {
             workflowStatus: 'shipped',
         });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'BET-271',
             changedBy: 'agent:sess-test',
             workflowStatus: 'shipped',
@@ -116,7 +116,7 @@ describe('runUpdate', () => {
             field: ['rationale=a=b=c'],
         });
         writeSpy.mockRestore();
-        expect(convexCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
+        expect(kernelCallWithSessionMock).toHaveBeenCalledWith('chain.updateEntry', {
             entryId: 'DEC-264',
             changedBy: 'agent:sess-test',
             data: { rationale: 'a=b=c' },
@@ -126,21 +126,21 @@ describe('runUpdate', () => {
         mockSession = null;
         await expect(runUpdate({ entryId: 'BET-151', field: ['x=1'] })).rejects.toThrow(CLIError);
         await expect(runUpdate({ entryId: 'BET-151', field: ['x=1'] })).rejects.toThrow('No active session');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     it('throws CLIError with empty entryId', async () => {
         await expect(runUpdate({ entryId: '  ', field: ['x=1'] })).rejects.toThrow(CLIError);
         await expect(runUpdate({ entryId: '  ', field: ['x=1'] })).rejects.toThrow('Entry ID is required');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     it('throws CLIError when nothing to update', async () => {
         await expect(runUpdate({ entryId: 'BET-151' })).rejects.toThrow(CLIError);
         await expect(runUpdate({ entryId: 'BET-151' })).rejects.toThrow('Nothing to update');
-        expect(convexCallWithSessionMock).not.toHaveBeenCalled();
+        expect(kernelCallWithSessionMock).not.toHaveBeenCalled();
     });
     // ── Structured validation error tests ────────────────────────────────────
     it('throws CLIError with structured select field error message', async () => {
-        convexCallWithSessionMock.mockRejectedValue(makeMcpError("Entry data validation failed: Field \"appetite\" must be one of: small, medium, large. Got: 'Small Batch'. Fix the values and try again.", 'VALIDATION_FAILED', [{
+        kernelCallWithSessionMock.mockRejectedValue(makeMcpError("Entry data validation failed: Field \"appetite\" must be one of: small, medium, large. Got: 'Small Batch'. Fix the values and try again.", 'VALIDATION_FAILED', [{
                 fieldKey: 'appetite',
                 fieldLabel: 'appetite',
                 invalidValue: 'Small Batch',
@@ -154,14 +154,14 @@ describe('runUpdate', () => {
         expect(err.message).toContain("Got: 'Small Batch'");
     });
     it('throws CLIError with plain error message when no structured details', async () => {
-        convexCallWithSessionMock.mockRejectedValue(makeMcpError('Entry not found.', 'NOT_FOUND'));
+        kernelCallWithSessionMock.mockRejectedValue(makeMcpError('Entry not found.', 'NOT_FOUND'));
         const err = await runUpdate({ entryId: 'BET-999', field: ['x=1'] }).catch((e) => e);
         expect(err).toBeInstanceOf(CLIError);
         expect(err.message).toContain('Entry not found.');
     });
     // ── Slice 3: post-update refresh ─────────────────────────────────────────
     it('calls chain.getEntry after successful update and includes entry in output', async () => {
-        convexCallMock.mockResolvedValue({
+        kernelCallMock.mockResolvedValue({
             entryId: 'BET-151',
             name: 'My Bet',
             status: 'active',
@@ -170,13 +170,13 @@ describe('runUpdate', () => {
         await runUpdate({ entryId: 'BET-151', field: ['description=new'] });
         const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
         writeSpy.mockRestore();
-        expect(convexCallMock).toHaveBeenCalledWith('chain.getEntry', { entryId: 'BET-151' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getEntry', { entryId: 'BET-151' });
         // Pretty output: receipt then entry block
         expect(output).toContain('Updated BET-151');
         expect(output).toContain('My Bet');
     });
     it('still shows update receipt when post-update getEntry fails (graceful degradation)', async () => {
-        convexCallMock.mockRejectedValue(new Error('network error'));
+        kernelCallMock.mockRejectedValue(new Error('network error'));
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runUpdate({ entryId: 'BET-151', field: ['description=new'] });
         const output = writeSpy.mock.calls.map(c => String(c[0])).join('');
@@ -187,7 +187,7 @@ describe('runUpdate', () => {
     });
     // ── BET-192 / FEAT-575: Normalization warning tests ──────────────────────
     it('throws CLIError when fields are rejected (BET-192, BET-271)', async () => {
-        convexCallWithSessionMock.mockResolvedValue({
+        kernelCallWithSessionMock.mockResolvedValue({
             id: 'j571abc123def456',
             warnings: ['Unknown field "foo" dropped. Available fields: description, doneWhen'],
             normalization: { remapped: {}, rejected: ['foo'], accepted: ['description'] },
@@ -207,7 +207,7 @@ describe('runUpdate', () => {
         writeSpy.mockRestore();
     });
     it('displays no warnings when all fields are valid (BET-192)', async () => {
-        convexCallWithSessionMock.mockResolvedValue({
+        kernelCallWithSessionMock.mockResolvedValue({
             id: 'j571abc123def456',
             warnings: [],
             normalization: { remapped: {}, rejected: [], accepted: ['description'] },