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

package/dist/__tests__/constellation.test.js

@@ -3,16 +3,16 @@
  * BET-181 Slice 3: compound view (entry + grouped relations).
  *
  * Verifies:
- * 1. Mock convexCall returns known constellation structure; command outputs entry + grouped relations
+ * 1. Mock kernelCall returns known constellation structure; command outputs entry + grouped relations
  * 2. Edge: entry with no relations returns entry-only, empty relations object
  * 3. Relation types in output derive from the server response, not hardcoded
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runConstellation } from '../commands/constellation.js';
 import { setOutputMode } from '../lib/runner.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((_fn) => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -95,12 +95,12 @@ afterEach(() => {
 });
 describe('runConstellation — JSON mode (non-TTY)', () => {
     it('calls chain.getConstellation with the correct entryId', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
+        kernelCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
         await runConstellation({ entryId: 'BET-181' });
-        expect(convexCallMock).toHaveBeenCalledWith('chain.getConstellation', { entryId: 'BET-181' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getConstellation', { entryId: 'BET-181' });
     }));
     it('outputs entry and grouped relations as JSON in non-TTY mode', withTty(false, async () => {
-        convexCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
+        kernelCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
         await runConstellation({ entryId: 'BET-181' });
         const parsed = JSON.parse(stdoutOutput);
         expect(parsed.entry.entryId).toBe('BET-181');
@@ -114,7 +114,7 @@ describe('runConstellation — JSON mode (non-TTY)', () => {
             ...CONSTELLATION_FIXTURE,
             entry: { ...CONSTELLATION_FIXTURE.entry, _id: 'sys-id', _creationTime: 999999 },
         };
-        convexCallMock.mockResolvedValue(fixtureWithInternals);
+        kernelCallMock.mockResolvedValue(fixtureWithInternals);
         await runConstellation({ entryId: 'BET-181' });
         const parsed = JSON.parse(stdoutOutput);
         expect(parsed.entry).not.toHaveProperty('_id');
@@ -123,13 +123,13 @@ describe('runConstellation — JSON mode (non-TTY)', () => {
 });
 describe('runConstellation — pretty mode (TTY)', () => {
     it('outputs human-readable grouped view in TTY mode', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
+        kernelCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
         await runConstellation({ entryId: 'BET-181' });
         expect(stdoutOutput).toContain('BET-181');
         expect(stdoutOutput).toContain('CLI Agent-Native Foundation');
     }));
     it('shows relation types grouped in TTY output', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
+        kernelCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
         await runConstellation({ entryId: 'BET-181' });
         expect(stdoutOutput).toContain('part_of');
         expect(stdoutOutput).toContain('informed_by');
@@ -137,7 +137,7 @@ describe('runConstellation — pretty mode (TTY)', () => {
         expect(stdoutOutput).toContain('FEAT-100');
     }));
     it('shows direction arrows in TTY output', withTty(true, async () => {
-        convexCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
+        kernelCallMock.mockResolvedValue(CONSTELLATION_FIXTURE);
         await runConstellation({ entryId: 'BET-181' });
         // outgoing → for part_of, incoming ← for informed_by
         expect(stdoutOutput).toContain('→');
@@ -160,7 +160,7 @@ describe('runConstellation — edge case: entry with no relations', () => {
                 relationTypes: [],
             },
         };
-        convexCallMock.mockResolvedValue(noRelationsFixture);
+        kernelCallMock.mockResolvedValue(noRelationsFixture);
         await runConstellation({ entryId: 'BET-999' });
         const parsed = JSON.parse(stdoutOutput);
         expect(parsed.entry.entryId).toBe('BET-999');
@@ -183,7 +183,7 @@ describe('runConstellation — edge case: entry with no relations', () => {
                 relationTypes: [],
             },
         };
-        convexCallMock.mockResolvedValue(noRelationsFixture);
+        kernelCallMock.mockResolvedValue(noRelationsFixture);
         await runConstellation({ entryId: 'BET-999' });
         expect(stdoutOutput).toContain('No relations');
     }));
@@ -233,7 +233,7 @@ describe('runConstellation — relation types derive from server response', () =
                 relationTypes: ['related_to', 'governs', 'blocks'],
             },
         };
-        convexCallMock.mockResolvedValue(customRelationFixture);
+        kernelCallMock.mockResolvedValue(customRelationFixture);
         await runConstellation({ entryId: 'DEC-999' });
         const parsed = JSON.parse(stdoutOutput);
         // Verify the CLI passes through whatever the server returns
@@ -247,7 +247,7 @@ describe('runConstellation — relation types derive from server response', () =
 });
 describe('runConstellation — error handling', () => {
     it('throws CLIError when entry is not found', withTty(false, async () => {
-        convexCallMock.mockRejectedValue(new Error('Entry "NOTEXIST-9999" not found.'));
+        kernelCallMock.mockRejectedValue(new Error('Entry "NOTEXIST-9999" not found.'));
         await expect(runConstellation({ entryId: 'NOTEXIST-9999' })).rejects.toThrow('NOTEXIST-9999');
     }));
 });

package/dist/__tests__/context-strategy.test.js

@@ -9,9 +9,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runContext } from '../commands/context.js';
 import { setOutputMode } from '../lib/runner.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' })),
@@ -46,7 +46,7 @@ beforeEach(() => {
         stderrOutput += String(chunk);
         return true;
     });
-    convexCallMock.mockReset();
+    kernelCallMock.mockReset();
     setOutputMode('pretty');
 });
 afterEach(() => {
@@ -56,21 +56,21 @@ afterEach(() => {
 });
 describe('runContext — entry-based gather (BET-205 S2 regression)', () => {
     it('calls chain.gatherContext with entryId and maxHops only', async () => {
-        convexCallMock.mockResolvedValue(GATHER_FIXTURE);
+        kernelCallMock.mockResolvedValue(GATHER_FIXTURE);
         await runContext({ entryId: 'BET-205' });
-        expect(convexCallMock).toHaveBeenCalledWith('chain.gatherContext', {
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.gatherContext', {
             entryId: 'BET-205',
             maxHops: 2,
         });
     });
     it('does not pass strategy to chain.gatherContext', async () => {
-        convexCallMock.mockResolvedValue(GATHER_FIXTURE);
+        kernelCallMock.mockResolvedValue(GATHER_FIXTURE);
         await runContext({ entryId: 'BET-205' });
-        const callArgs = convexCallMock.mock.calls[0][1];
+        const callArgs = kernelCallMock.mock.calls[0][1];
         expect(callArgs).not.toHaveProperty('strategy');
     });
     it('renders context output correctly', async () => {
-        convexCallMock.mockResolvedValue(GATHER_FIXTURE);
+        kernelCallMock.mockResolvedValue(GATHER_FIXTURE);
         await runContext({ entryId: 'BET-205' });
         expect(stdoutOutput).toContain('BET-205');
         expect(stdoutOutput).toContain('Vector Seed Spike');

package/dist/__tests__/fields.test.js

@@ -3,7 +3,7 @@
  * BET-181 Slice 2: Verifies field discovery via chain.getCollectionFields.
  *
  * Test contract:
- * 1. Mock convexCall returns known field array → command outputs all field properties
+ * 1. Mock kernelCall returns known field array → command outputs all field properties
  * 2. Edge: collection with no fields → returns empty array, not error
  * 3. Error: invalid collection slug → actionable error message
  */
@@ -11,9 +11,9 @@ import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 import { runFields } from '../commands/fields.js';
 import { setOutputMode } from '../lib/runner.js';
 import { CLIError } from '../lib/errors.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' })),
@@ -35,7 +35,7 @@ beforeEach(() => {
         return true;
     });
     exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('process.exit'); });
-    convexCallMock.mockReset();
+    kernelCallMock.mockReset();
     // Force TTY mode so we get human-readable output in tests
     setOutputMode('pretty');
 });
@@ -76,7 +76,7 @@ const SAMPLE_FIELDS = [
 ];
 describe('runFields — TTY output with known field array', () => {
     it('outputs collection name and slug header', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -85,7 +85,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('Collection: Work Packages (work-packages)');
     });
     it('outputs all field keys', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -96,7 +96,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('elements');
     });
     it('outputs field type for each field', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -107,7 +107,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('rich-text');
     });
     it('outputs options for select fields', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -116,7 +116,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('small, medium, large');
     });
     it('outputs helpText when present', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -126,7 +126,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('What problem are we solving?');
     });
     it('outputs displayHint when present', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -135,7 +135,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('badge');
     });
     it('outputs zone when present', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -145,7 +145,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('body');
     });
     it('outputs semanticRole when present', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -157,7 +157,7 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('role:    elements');
     });
     it('marks required fields', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -167,19 +167,19 @@ describe('runFields — TTY output with known field array', () => {
         expect(stdoutOutput).toContain('appetite *');
     });
     it('calls chain.getCollectionFields with the correct slug', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'decisions',
             name: 'Decisions',
             fields: [],
         });
         await runFields({ collectionSlug: 'decisions' });
-        expect(convexCallMock).toHaveBeenCalledWith('chain.getCollectionFields', { slug: 'decisions' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getCollectionFields', { slug: 'decisions' });
     });
 });
 describe('runFields — JSON mode', () => {
     it('outputs JSON with full field array when piped', async () => {
         setOutputMode('json');
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'work-packages',
             name: 'Work Packages',
             fields: SAMPLE_FIELDS,
@@ -202,7 +202,7 @@ describe('runFields — JSON mode', () => {
 });
 describe('runFields — edge: empty fields array', () => {
     it('returns "No fields defined" message, does not error', async () => {
-        convexCallMock.mockResolvedValueOnce({
+        kernelCallMock.mockResolvedValueOnce({
             slug: 'notes',
             name: 'Notes',
             fields: [],
@@ -215,21 +215,21 @@ describe('runFields — edge: empty fields array', () => {
 });
 describe('runFields — error: invalid collection slug', () => {
     it('throws CLIError with actionable message for invalid slug', async () => {
-        convexCallMock.mockResolvedValueOnce(null);
+        kernelCallMock.mockResolvedValueOnce(null);
         const err = await runFields({ collectionSlug: 'nonexistent-slug' }).catch((e) => e);
         expect(err).toBeInstanceOf(CLIError);
         expect(err.message).toContain('nonexistent-slug');
         expect(err.message).toContain('not found');
     });
     it('includes suggestion to use a valid slug in guidance', async () => {
-        convexCallMock.mockResolvedValueOnce(null);
+        kernelCallMock.mockResolvedValueOnce(null);
         const err = await runFields({ collectionSlug: 'bad-slug' }).catch((e) => e);
         expect(err).toBeInstanceOf(CLIError);
         expect(err.guidance).toContain('valid collection slug');
     });
     it('throws CLIError in JSON mode for invalid slug', async () => {
         setOutputMode('json');
-        convexCallMock.mockResolvedValueOnce(null);
+        kernelCallMock.mockResolvedValueOnce(null);
         const err = await runFields({ collectionSlug: 'bad-slug' }).catch((e) => e);
         expect(err).toBeInstanceOf(CLIError);
         expect(err.message).toContain('bad-slug');

package/dist/__tests__/ingest.test.js

@@ -1,5 +1,5 @@
 /**
- * CLI ingest command — verify convexCall sequence and args.
+ * CLI ingest command — verify kernelCall sequence and args.
  * BET-81 Slice 1: chain.ingestDocument called with correct args, batch size.
  * BET-221 S7 (FEAT-697): --dry-run, --resume, --concurrency flags.
  */
@@ -8,9 +8,9 @@ import { mkdtempSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { runIngest } from '../commands/ingest.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((retry) => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -20,7 +20,7 @@ describe('runIngest', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         tmpDir = mkdtempSync(join(tmpdir(), 'pb-ingest-'));
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' }) // resolveWorkspace
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' }) // startSession
             .mockResolvedValue({ entriesCreated: ['e1', 'e2'], skipped: 0 }); // ingestDocument, closeSession
@@ -32,15 +32,15 @@ describe('runIngest', () => {
         const f = join(tmpDir, 'doc.md');
         writeFileSync(f, '# Test\n\nContent here.');
         await runIngest({ pattern: f });
-        expect(convexCallMock).toHaveBeenNthCalledWith(1, 'resolveWorkspace', {});
-        expect(convexCallMock).toHaveBeenNthCalledWith(2, 'agent.startSession', {
+        expect(kernelCallMock).toHaveBeenNthCalledWith(1, 'resolveWorkspace', {});
+        expect(kernelCallMock).toHaveBeenNthCalledWith(2, 'agent.startSession', {
             workspaceId: 'ws-1',
             apiKeyId: 'key-1',
             clientKind: 'cli',
         });
     });
     it('calls chain.ingestDocument with content, sourceRef, ingestionRunId, sessionId', async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1', 'e2'], skipped: 0 });
@@ -48,7 +48,7 @@ describe('runIngest', () => {
         const content = '# Decision\n\nWe use TypeScript.';
         writeFileSync(f, content);
         await runIngest({ pattern: f });
-        const ingestCall = convexCallMock.mock.calls.find((c) => c[0] === 'chain.ingestDocument');
+        const ingestCall = kernelCallMock.mock.calls.find((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCall).toBeDefined();
         const [, args] = ingestCall;
         expect(args.content).toBe(content);
@@ -57,19 +57,19 @@ describe('runIngest', () => {
         expect(args.sessionId).toBe('sess-1');
     });
     it('calls agent.closeSession after ingest', async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1', 'e2'], skipped: 0 });
         const f = join(tmpDir, 'doc.md');
         writeFileSync(f, '# Test');
         await runIngest({ pattern: f });
-        const closeCall = convexCallMock.mock.calls.find((c) => c[0] === 'agent.closeSession');
+        const closeCall = kernelCallMock.mock.calls.find((c) => c[0] === 'agent.closeSession');
         expect(closeCall).toBeDefined();
         expect(closeCall).toEqual(['agent.closeSession', { sessionId: 'sess-1', status: 'closed' }]);
     });
     it('processes one file per chain.ingestDocument call (no batching of content)', async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1', 'e2'], skipped: 0 });
@@ -78,7 +78,7 @@ describe('runIngest', () => {
         writeFileSync(f1, '# A');
         writeFileSync(f2, '# B');
         await runIngest({ pattern: join(tmpDir, '*.md') });
-        const ingestCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
+        const ingestCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCalls).toHaveLength(2);
         const contents = ingestCalls.map((c) => c[1].content);
         expect(contents).toContain('# A');
@@ -86,27 +86,27 @@ describe('runIngest', () => {
     });
     // ─── BET-221 S7: --dry-run ────────────────────────────────────────────────
     it('--dry-run passes dryRun: true to chain.ingestDocument', async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 });
         const f = join(tmpDir, 'dry.md');
         writeFileSync(f, '# Dry Run Test');
         await runIngest({ pattern: f, dryRun: true });
-        const ingestCall = convexCallMock.mock.calls.find((c) => c[0] === 'chain.ingestDocument');
+        const ingestCall = kernelCallMock.mock.calls.find((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCall).toBeDefined();
         const [, args] = ingestCall;
         expect(args.dryRun).toBe(true);
     });
     it('--dry-run still calls agent.closeSession', async () => {
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 });
         const f = join(tmpDir, 'dry2.md');
         writeFileSync(f, '# Dry Run 2');
         await runIngest({ pattern: f, dryRun: true });
-        const closeCall = convexCallMock.mock.calls.find((c) => c[0] === 'agent.closeSession');
+        const closeCall = kernelCallMock.mock.calls.find((c) => c[0] === 'agent.closeSession');
         expect(closeCall).toBeDefined();
     });
     // ─── BET-221 S7: --resume ─────────────────────────────────────────────────
@@ -115,14 +115,14 @@ describe('runIngest', () => {
         const f2 = join(tmpDir, 'new.md');
         writeFileSync(f1, '# Already committed');
         writeFileSync(f2, '# New file');
-        convexCallMock.mockReset();
-        convexCallMock
+        kernelCallMock.mockReset();
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' }) // resolveWorkspace
             .mockResolvedValueOnce([f1]) // staging.getCommittedSourceRefs
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' }) // startSession
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 }); // ingestDocument, closeSession
         await runIngest({ pattern: join(tmpDir, '*.md'), resume: true });
-        const ingestCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
+        const ingestCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCalls).toHaveLength(1);
         const [, args] = ingestCalls[0];
         expect(args.sourceRef).toBe(f2);
@@ -130,13 +130,13 @@ describe('runIngest', () => {
     it('--resume exits early when all files already committed', async () => {
         const f = join(tmpDir, 'done.md');
         writeFileSync(f, '# Done');
-        convexCallMock.mockReset();
-        convexCallMock
+        kernelCallMock.mockReset();
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' }) // resolveWorkspace
             .mockResolvedValueOnce([f]); // staging.getCommittedSourceRefs
         await runIngest({ pattern: f, resume: true });
         // Should NOT call startSession or ingestDocument — all skipped
-        const sessionCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'agent.startSession');
+        const sessionCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'agent.startSession');
         expect(sessionCalls).toHaveLength(0);
     });
     // ─── BET-221 S7: --concurrency ────────────────────────────────────────────
@@ -147,12 +147,12 @@ describe('runIngest', () => {
         writeFileSync(f1, '# P1');
         writeFileSync(f2, '# P2');
         writeFileSync(f3, '# P3');
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 });
         await runIngest({ pattern: join(tmpDir, '*.md'), concurrency: 3 });
-        const ingestCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
+        const ingestCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCalls).toHaveLength(3);
     });
     it('default concurrency is 1 (sequential)', async () => {
@@ -160,25 +160,25 @@ describe('runIngest', () => {
         const f2 = join(tmpDir, 'seq2.md');
         writeFileSync(f1, '# Seq1');
         writeFileSync(f2, '# Seq2');
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 });
         await runIngest({ pattern: join(tmpDir, '*.md') });
         // Both files processed — sequential, no concurrency option
-        const ingestCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
+        const ingestCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCalls).toHaveLength(2);
     });
     it('--concurrency is clamped to max 5', async () => {
         const f = join(tmpDir, 'clamp.md');
         writeFileSync(f, '# Clamp');
-        convexCallMock
+        kernelCallMock
             .mockResolvedValueOnce({ _id: 'ws-1', keyId: 'key-1' })
             .mockResolvedValueOnce({ sessionId: 'sess-1', toolsScope: 'readwrite', workspaceName: 'Test' })
             .mockResolvedValue({ entriesCreated: ['e1'], skipped: 0 });
         // concurrency 10 should be clamped to 5 internally (no error)
         await runIngest({ pattern: f, concurrency: 10 });
-        const ingestCalls = convexCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
+        const ingestCalls = kernelCallMock.mock.calls.filter((c) => c[0] === 'chain.ingestDocument');
         expect(ingestCalls).toHaveLength(1);
     });
 });

package/dist/__tests__/orient.test.js

@@ -1,8 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { runOrient } from '../commands/orient.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' })),
@@ -85,24 +85,24 @@ const orientViewTaskOnly = {
 describe('runOrient', () => {
     beforeEach(() => {
         vi.clearAllMocks();
-        convexCallMock.mockResolvedValue(orientViewWithoutTask);
+        kernelCallMock.mockResolvedValue(orientViewWithoutTask);
     });
     it('calls chain.getOrientView without task by default', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runOrient();
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
-        expect(convexCallMock).toHaveBeenCalledWith('chain.getOrientView', {});
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {});
         expect(output).toContain('Task grounding required');
         expect(output).toContain('pb orient --task');
     });
     it('passes task through to chain.getOrientView and renders task context', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        convexCallMock.mockResolvedValueOnce(orientView);
+        kernelCallMock.mockResolvedValueOnce(orientView);
         await runOrient({ task: 'harden auth startup flow' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
-        expect(convexCallMock).toHaveBeenCalledWith('chain.getOrientView', {
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
             task: 'harden auth startup flow',
         });
         expect(output).toContain('## Task grounding');
@@ -113,7 +113,7 @@ describe('runOrient', () => {
     });
     it('renders task context even when governance buckets are empty', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        convexCallMock.mockResolvedValueOnce(orientViewTaskOnly);
+        kernelCallMock.mockResolvedValueOnce(orientViewTaskOnly);
         await runOrient({ task: 'trace supporting context only' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
@@ -131,7 +131,7 @@ describe('runOrient', () => {
     });
     it('brief mode with task context renders startup grounding line', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        convexCallMock.mockResolvedValueOnce(orientView);
+        kernelCallMock.mockResolvedValueOnce(orientView);
         await runOrient({ brief: true, task: 'harden auth startup flow' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();