@kaelio/ktx 0.1.1 → 0.3.0

package/dist/index.test.js

@@ -31,9 +31,7 @@ describe('getKtxCliPackageInfo', () => {
     it('identifies the CLI package and its context dependency', () => {
         expect(getKtxCliPackageInfo()).toEqual({
             name: '@ktx/cli',
-            version: '0.1.0-rc.1',
-            packageVersion: '0.0.0-private',
-            runtimeVersion: '0.1.0-rc.1',
+            version: '0.0.0-private',
             contextPackageName: '@ktx/context',
         });
     });
@@ -51,8 +49,6 @@ describe('getKtxCliPackageInfo', () => {
         })).toEqual({
             name: '@kaelio/ktx',
             version: '0.1.0',
-            packageVersion: '0.1.0',
-            runtimeVersion: '0.1.0',
             contextPackageName: '@ktx/context',
         });
     });
@@ -90,7 +86,7 @@ describe('runKtxCli', () => {
     it('prints version information', async () => {
         const testIo = makeIo();
         await expect(runKtxCli(['--version'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).toBe('@ktx/cli 0.1.0-rc.1\n');
+        expect(testIo.stdout()).toBe('@ktx/cli 0.0.0-private\n');
         expect(testIo.stderr()).toBe('');
     });
     it('prints the public command surface in root help', async () => {
@@ -98,9 +94,10 @@ describe('runKtxCli', () => {
         await expect(runKtxCli(['--help'], testIo.io)).resolves.toBe(0);
         expect(testIo.stdout()).toContain('Usage: ktx [options] [command]');
         expect(testIo.stdout()).toContain('KTX data agent context layer CLI');
-        for (const command of ['setup', 'connection', 'ingest', 'wiki', 'sl', 'status', 'dev']) {
+        for (const command of ['setup', 'connection', 'ingest', 'wiki', 'sl', 'status', 'admin']) {
             expect(testIo.stdout()).toContain(`${command}`);
         }
+        expect(testIo.stdout()).not.toMatch(/^  dev\s/m);
         expect(testIo.stdout()).not.toMatch(/^  scan\s/m);
         for (const removed of ['demo', 'init', 'connect', 'ask', 'knowledge', 'agent', 'completion', 'serve']) {
             expect(testIo.stdout()).not.toMatch(new RegExp(`^\\s+${removed}(?:\\s|\\[|$)`, 'm'));
@@ -115,7 +112,7 @@ describe('runKtxCli', () => {
     it('routes supported public wiki commands', async () => {
         const knowledge = vi.fn(async () => 0);
         const listIo = makeIo();
-        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'list', '--json'], listIo.io, { knowledge }))
+        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', '--json'], listIo.io, { knowledge }))
             .resolves.toBe(0);
         expect(knowledge).toHaveBeenCalledWith({
             command: 'list',
@@ -124,7 +121,7 @@ describe('runKtxCli', () => {
             json: true,
         }, listIo.io);
         const searchIo = makeIo();
-        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'search', 'revenue', '--limit', '5'], searchIo.io, { knowledge })).resolves.toBe(0);
+        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'revenue', '--limit', '5'], searchIo.io, { knowledge })).resolves.toBe(0);
         expect(knowledge).toHaveBeenLastCalledWith({
             command: 'search',
             projectDir: tempDir,
@@ -134,7 +131,7 @@ describe('runKtxCli', () => {
             limit: 5,
         }, searchIo.io);
         const debugSearchIo = makeIo();
-        await expect(runKtxCli(['--project-dir', tempDir, '--debug', 'wiki', 'search', 'revenue'], debugSearchIo.io, { knowledge })).resolves.toBe(0);
+        await expect(runKtxCli(['--project-dir', tempDir, '--debug', 'wiki', 'revenue'], debugSearchIo.io, { knowledge })).resolves.toBe(0);
         expect(knowledge).toHaveBeenLastCalledWith({
             command: 'search',
             projectDir: tempDir,
@@ -143,35 +140,32 @@ describe('runKtxCli', () => {
             json: false,
             debug: true,
         }, debugSearchIo.io);
+        const multiWordIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'revenue', 'policy'], multiWordIo.io, { knowledge })).resolves.toBe(0);
+        expect(knowledge).toHaveBeenLastCalledWith({
+            command: 'search',
+            projectDir: tempDir,
+            query: 'revenue policy',
+            userId: 'local',
+            json: false,
+        }, multiWordIo.io);
     });
-    it('rejects removed public wiki read and write commands', async () => {
+    it('rejects unknown write-style flags on the flattened wiki and sl commands', async () => {
         const knowledge = vi.fn(async () => 0);
-        for (const argv of [
-            ['--project-dir', tempDir, 'wiki', 'read', 'revenue', '--json'],
-            ['--project-dir', tempDir, 'wiki', 'write', 'revenue', '--summary', 'Revenue', '--content', 'Revenue.'],
-        ]) {
-            const io = makeIo();
-            await expect(runKtxCli(argv, io.io, { knowledge })).resolves.toBe(1);
-            expect(io.stderr()).toMatch(/unknown command|error:/);
-        }
-        expect(knowledge).not.toHaveBeenCalled();
-    });
-    it('rejects removed public sl read/write commands', async () => {
         const sl = vi.fn(async () => 0);
-        for (const argv of [
-            ['--project-dir', tempDir, 'sl', 'read', 'orders', '--connection-id', 'warehouse'],
-            ['--project-dir', tempDir, 'sl', 'write', 'orders', '--connection-id', 'warehouse', '--yaml', 'name: orders'],
-        ]) {
-            const io = makeIo();
-            await expect(runKtxCli(argv, io.io, { sl })).resolves.toBe(1);
-            expect(io.stderr()).toMatch(/unknown command|error:/);
-        }
+        const wikiIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'revenue', '--summary', 'Revenue', '--content', 'Revenue.'], wikiIo.io, { knowledge })).resolves.toBe(1);
+        expect(wikiIo.stderr()).toMatch(/unknown option|error:/);
+        expect(knowledge).not.toHaveBeenCalled();
+        const slIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'orders', '--yaml', 'name: orders'], slIo.io, { sl })).resolves.toBe(1);
+        expect(slIo.stderr()).toMatch(/unknown option|error:/);
         expect(sl).not.toHaveBeenCalled();
     });
-    it('routes sl search and rejects the old sl list --query flag', async () => {
+    it('routes sl search via the flattened query positional and rejects unknown flags', async () => {
         const sl = vi.fn(async () => 0);
         const searchIo = makeIo();
-        await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'search', 'revenue', '--connection-id', 'warehouse', '--limit', '5', '--json'], searchIo.io, { sl })).resolves.toBe(0);
+        await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'revenue', '--connection-id', 'warehouse', '--limit', '5', '--json'], searchIo.io, { sl })).resolves.toBe(0);
         expect(sl).toHaveBeenCalledWith({
             command: 'search',
             projectDir: tempDir,
@@ -181,11 +175,20 @@ describe('runKtxCli', () => {
             json: true,
             output: undefined,
         }, searchIo.io);
-        const listIo = makeIo();
-        await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'list', '--query', 'revenue'], listIo.io, { sl })).resolves.toBe(1);
-        expect(listIo.stderr()).toContain("unknown option '--query'");
+        const bareIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'sl', '--connection-id', 'warehouse', '--json'], bareIo.io, { sl })).resolves.toBe(0);
+        expect(sl).toHaveBeenLastCalledWith({
+            command: 'list',
+            projectDir: tempDir,
+            connectionId: 'warehouse',
+            json: true,
+            output: undefined,
+        }, bareIo.io);
+        const unknownIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'sl', '--query', 'revenue'], unknownIo.io, { sl })).resolves.toBe(1);
+        expect(unknownIo.stderr()).toContain("unknown option '--query'");
     });
-    it('routes runtime management commands with the release runtime version', async () => {
+    it('routes runtime management commands with the CLI package version', async () => {
         const runtime = vi.fn(async () => 0);
         const installIo = makeIo();
         const startIo = makeIo();
@@ -193,42 +196,42 @@ describe('runKtxCli', () => {
         const stopAllIo = makeIo();
         const statusIo = makeIo();
         const pruneIo = makeIo();
-        await expect(runKtxCli(['dev', 'runtime', 'install', '--feature', 'local-embeddings', '--force', '--yes'], installIo.io, {
+        await expect(runKtxCli(['admin', 'runtime', 'install', '--feature', 'local-embeddings', '--force', '--yes'], installIo.io, {
             runtime,
         })).resolves.toBe(0);
-        await expect(runKtxCli(['dev', 'runtime', 'start', '--feature', 'local-embeddings', '--force'], startIo.io, { runtime })).resolves.toBe(0);
-        await expect(runKtxCli(['dev', 'runtime', 'stop'], stopIo.io, { runtime })).resolves.toBe(0);
-        await expect(runKtxCli(['dev', 'runtime', 'stop', '--all'], stopAllIo.io, { runtime })).resolves.toBe(0);
-        await expect(runKtxCli(['dev', 'runtime', 'status', '--json'], statusIo.io, { runtime })).resolves.toBe(0);
-        await expect(runKtxCli(['dev', 'runtime', 'prune', '--dry-run'], pruneIo.io, { runtime })).resolves.toBe(1);
+        await expect(runKtxCli(['admin', 'runtime', 'start', '--feature', 'local-embeddings', '--force'], startIo.io, { runtime })).resolves.toBe(0);
+        await expect(runKtxCli(['admin', 'runtime', 'stop'], stopIo.io, { runtime })).resolves.toBe(0);
+        await expect(runKtxCli(['admin', 'runtime', 'stop', '--all'], stopAllIo.io, { runtime })).resolves.toBe(0);
+        await expect(runKtxCli(['admin', 'runtime', 'status', '--json'], statusIo.io, { runtime })).resolves.toBe(0);
+        await expect(runKtxCli(['admin', 'runtime', 'prune', '--dry-run'], pruneIo.io, { runtime })).resolves.toBe(1);
         expect(runtime).toHaveBeenNthCalledWith(1, {
             command: 'install',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             feature: 'local-embeddings',
             force: true,
         }, installIo.io);
         expect(runtime).toHaveBeenNthCalledWith(2, {
             command: 'start',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             projectDir: expect.any(String),
             feature: 'local-embeddings',
             force: true,
         }, startIo.io);
         expect(runtime).toHaveBeenNthCalledWith(3, {
             command: 'stop',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             projectDir: expect.any(String),
             all: false,
         }, stopIo.io);
         expect(runtime).toHaveBeenNthCalledWith(4, {
             command: 'stop',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             projectDir: expect.any(String),
             all: true,
         }, stopAllIo.io);
         expect(runtime).toHaveBeenNthCalledWith(5, {
             command: 'status',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             json: true,
         }, statusIo.io);
         expect(runtime).toHaveBeenCalledTimes(5);
@@ -262,7 +265,7 @@ describe('runKtxCli', () => {
     });
     it('documents runtime stop all in command help', async () => {
         const testIo = makeIo();
-        await expect(runKtxCli(['dev', 'runtime', 'stop', '--help'], testIo.io)).resolves.toBe(0);
+        await expect(runKtxCli(['admin', 'runtime', 'stop', '--help'], testIo.io)).resolves.toBe(0);
         expect(testIo.stdout()).toContain('--all');
         expect(testIo.stdout()).toContain('Stop all KTX daemon processes recorded or discoverable');
         expect(testIo.stdout()).toContain('on this machine');
@@ -275,7 +278,7 @@ describe('runKtxCli', () => {
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'query',
             projectDir: tempDir,
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'prompt',
             query: expect.objectContaining({ measures: ['orders.order_count'], dimensions: [] }),
         }), promptIo.io);
@@ -284,13 +287,13 @@ describe('runKtxCli', () => {
             sl,
         })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'auto',
         }), autoIo.io);
         const noInputIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'query', '--measure', 'orders.order_count', '--no-input'], noInputIo.io, { sl })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'never',
         }), noInputIo.io);
     });
@@ -367,7 +370,7 @@ describe('runKtxCli', () => {
         await initKtxProject({ projectDir });
         const commands = [
             ['--project-dir', projectDir, 'status', '--json'],
-            ['--project-dir', projectDir, 'sl', 'list', '--json'],
+            ['--project-dir', projectDir, 'sl', '--json'],
         ];
         for (const argv of commands) {
             const testIo = makeIo();
@@ -400,7 +403,7 @@ describe('runKtxCli', () => {
                 skipAgents: false,
                 inputMode: 'auto',
                 yes: false,
-                cliVersion: '0.1.0-rc.1',
+                cliVersion: '0.0.0-private',
                 skipLlm: false,
                 skipEmbeddings: false,
                 databaseSchemas: [],
@@ -483,8 +486,8 @@ describe('runKtxCli', () => {
     it('rejects removed shell completion commands', async () => {
         const completionIo = makeIo();
         const hiddenIo = makeIo();
-        await expect(runKtxCli(['dev', 'completion', 'zsh'], completionIo.io)).resolves.toBe(1);
-        await expect(runKtxCli(['dev', '__complete', '--shell', 'zsh', '--position', '2', '--', 'ktx', 'co'], hiddenIo.io)).resolves.toBe(1);
+        await expect(runKtxCli(['admin', 'completion', 'zsh'], completionIo.io)).resolves.toBe(1);
+        await expect(runKtxCli(['admin', '__complete', '--shell', 'zsh', '--position', '2', '--', 'ktx', 'co'], hiddenIo.io)).resolves.toBe(1);
         expect(completionIo.stderr()).toMatch(/unknown command|error:/);
         expect(hiddenIo.stderr()).toMatch(/unknown command|error:/);
     });
@@ -509,7 +512,7 @@ describe('runKtxCli', () => {
             inputMode: 'disabled',
             depth: 'fast',
             queryHistory: 'default',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'never',
         }, testIo.io);
         expect(testIo.stderr()).toBe(`Project: ${tempDir}\n`);
@@ -528,7 +531,7 @@ describe('runKtxCli', () => {
             inputMode: 'auto',
             depth: 'deep',
             queryHistory: 'default',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'prompt',
         }, testIo.io);
         expect(testIo.stderr()).toBe('');
@@ -577,7 +580,7 @@ describe('runKtxCli', () => {
             json: false,
             inputMode: 'disabled',
             queryHistory: 'default',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'never',
         }, testIo.io);
     });
@@ -636,7 +639,8 @@ describe('runKtxCli', () => {
         expect(testIo.stdout()).toContain('--query-history');
         expect(testIo.stdout()).toContain('--no-query-history');
         expect(testIo.stdout()).toContain('--query-history-window-days <days>');
-        expect(testIo.stdout()).toContain('text');
+        expect(testIo.stdout()).toContain('--text');
+        expect(testIo.stdout()).toContain('--file');
         expect(testIo.stdout()).not.toMatch(/^  status\s/m);
         expect(testIo.stdout()).not.toMatch(/^  replay\s/m);
         expect(testIo.stdout()).not.toMatch(/^  run\s/m);
@@ -652,7 +656,6 @@ describe('runKtxCli', () => {
             '--project-dir',
             tempDir,
             'ingest',
-            'text',
             '--text',
             'Revenue means gross receipts.',
             '--text',
@@ -675,37 +678,46 @@ describe('runKtxCli', () => {
         }, testIo.io);
         expect(testIo.stderr()).toBe('');
     });
-    it('documents text ingest inputs without a manifest option', async () => {
+    it('rejects a positional connection id when --text is supplied', async () => {
         const textIngest = vi.fn(async () => 0);
+        const publicIngest = vi.fn(async () => 0);
         const testIo = makeIo();
-        await expect(runKtxCli(['ingest', 'text', '--help'], testIo.io, { textIngest })).resolves.toBe(0);
-        expect(testIo.stdout()).toContain('Usage: ktx ingest text [options] [files...]');
-        expect(testIo.stdout()).toContain('--text <content>');
-        expect(testIo.stdout()).toContain('--connection-id <connectionId>');
-        expect(testIo.stdout()).toContain('--user-id <id>');
-        expect(testIo.stdout()).toContain('--fail-fast');
-        expect(testIo.stdout()).not.toContain('--manifest');
+        await expect(runKtxCli(['--project-dir', tempDir, 'ingest', 'warehouse', '--text', 'hello'], testIo.io, { textIngest, publicIngest })).resolves.toBe(1);
         expect(textIngest).not.toHaveBeenCalled();
+        expect(publicIngest).not.toHaveBeenCalled();
+        expect(testIo.stderr()).toMatch(/--text\/--file does not accept a positional connection id/);
+    });
+    it('treats bare ingest as ingest --all', async () => {
+        const publicIngest = vi.fn().mockResolvedValue(0);
+        const testIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, 'ingest', '--no-input'], testIo.io, { publicIngest })).resolves.toBe(0);
+        expect(publicIngest).toHaveBeenCalledWith(expect.objectContaining({
+            command: 'run',
+            projectDir: tempDir,
+            all: true,
+        }), testIo.io);
+        const args = publicIngest.mock.calls[0]?.[0];
+        expect(args.targetConnectionId).toBeUndefined();
     });
-    it('rejects old adapter-backed ingest flags at the top level and under dev', async () => {
+    it('rejects old adapter-backed ingest flags at the top level and under admin', async () => {
         const rootRunIo = makeIo();
         const devRunIo = makeIo();
         const publicIngest = vi.fn(async () => 0);
         await expect(runKtxCli(['ingest', 'run', '--connection-id', 'warehouse', '--adapter', 'metabase'], rootRunIo.io, {
             publicIngest,
         })).resolves.toBe(1);
-        await expect(runKtxCli(['dev', 'ingest', 'run', '--connection-id', 'warehouse', '--adapter', 'metabase'], devRunIo.io, {
+        await expect(runKtxCli(['admin', 'ingest', 'run', '--connection-id', 'warehouse', '--adapter', 'metabase'], devRunIo.io, {
             publicIngest,
         })).resolves.toBe(1);
         expect(publicIngest).not.toHaveBeenCalled();
         expect(rootRunIo.stderr()).toMatch(/unknown option '--connection-id'|error:/);
         expect(devRunIo.stderr()).toMatch(/unknown command|error:/);
     });
-    it('rejects removed dev doctor and removed ingest parser cases', async () => {
+    it('rejects removed admin doctor and removed ingest parser cases', async () => {
         const doctor = vi.fn(async () => 0);
         const doctorIo = makeIo();
         const ingestRunIo = makeIo();
-        await expect(runKtxCli(['dev', 'doctor', 'setup', '--json', '--no-input'], doctorIo.io, { doctor })).resolves.toBe(1);
+        await expect(runKtxCli(['admin', 'doctor', 'setup', '--json', '--no-input'], doctorIo.io, { doctor })).resolves.toBe(1);
         await expect(runKtxCli([
             'ingest',
             'run',
@@ -786,7 +798,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
             llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
@@ -813,7 +825,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             llmBackend: 'vertex',
             vertexProject: 'local-gcp-project',
             vertexLocation: 'us-east5',
@@ -838,7 +850,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             llmBackend: 'claude-code',
             llmModel: 'opus',
             skipLlm: false,
@@ -913,7 +925,7 @@ describe('runKtxCli', () => {
             projectDir: '/tmp/project',
             inputMode: 'disabled',
             yes: true,
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             skipLlm: true,
             skipEmbeddings: true,
             databaseDrivers: ['postgres'],
@@ -1131,7 +1143,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'auto',
         }, autoIo.io);
         expect(sl).toHaveBeenNthCalledWith(2, {
@@ -1141,7 +1153,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.1.0-rc.1',
+            cliVersion: '0.0.0-private',
             runtimeInstallPolicy: 'never',
         }, neverIo.io);
         expect(conflictIo.stderr()).toContain('Choose only one runtime install mode: --yes or --no-input');
@@ -1237,10 +1249,10 @@ describe('runKtxCli', () => {
         ], serveIo.io)).resolves.toBe(1);
         expect(serveIo.stderr()).toMatch(/unknown command|error:/);
     });
-    it('prints dev help for bare dev commands', async () => {
+    it('prints admin help for bare admin commands', async () => {
         const testIo = makeIo();
-        await expect(runKtxCli(['dev'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).toContain('Usage: ktx dev [options] [command]');
+        await expect(runKtxCli(['admin'], testIo.io)).resolves.toBe(0);
+        expect(testIo.stdout()).toContain('Usage: ktx admin [options] [command]');
         expect(testIo.stdout()).toContain('Low-level project initialization');
         expect(testIo.stdout()).toContain('init');
         expect(testIo.stdout()).toContain('runtime');
@@ -1251,20 +1263,20 @@ describe('runKtxCli', () => {
         expect(testIo.stdout()).not.toContain('knowledge');
         expect(testIo.stderr()).toBe('');
     });
-    it('rejects removed dev command groups without invoking execution', async () => {
+    it('rejects removed admin command groups without invoking execution', async () => {
         for (const command of ['scan', 'ingest', 'mapping']) {
             const testIo = makeIo();
             const publicIngest = vi.fn().mockResolvedValue(0);
             const sl = vi.fn().mockResolvedValue(0);
-            await expect(runKtxCli(['dev', command], testIo.io, { publicIngest, sl })).resolves.toBe(1);
+            await expect(runKtxCli(['admin', command], testIo.io, { publicIngest, sl })).resolves.toBe(1);
             expect(testIo.stderr()).toMatch(/unknown command|error:/);
             expect(publicIngest).not.toHaveBeenCalled();
             expect(sl).not.toHaveBeenCalled();
         }
     });
-    it('rejects removed reserved dev subcommands', async () => {
+    it('rejects removed reserved admin subcommands', async () => {
         const testIo = makeIo();
-        await expect(runKtxCli(['dev', 'artifacts'], testIo.io)).resolves.toBe(1);
+        await expect(runKtxCli(['admin', 'artifacts'], testIo.io)).resolves.toBe(1);
         expect(testIo.stderr()).toMatch(/unknown command|error:/);
     });
     it('rejects mutually exclusive public ingest output modes before invoking runners', async () => {

package/dist/ingest.js

@@ -1,5 +1,5 @@
 import { buildMemoryFlowViewModel, createMemoryFlowLiveBuffer, formatMemoryFlowFinalSummary, getLatestLocalIngestStatus, getLocalIngestStatus, ingestReportToMemoryFlowReplay, renderMemoryFlowReplay, runLocalIngest, runLocalMetabaseIngest, savedMemoryCountsForReport, sanitizeMemoryFlowError, } from '@ktx/context/ingest';
-import { loadKtxProject } from '@ktx/context/project';
+import { loadKtxCliProject } from './cli-project.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { readIngestReportSnapshotFile } from './ingest-report-file.js';
 import { createCliOperationalLogger } from './io/logger.js';
@@ -470,7 +470,14 @@ async function writeReportRecord(report, outputMode, io, options = {}) {
 }
 export async function runKtxIngest(args, io = process, deps = {}) {
     try {
-        const project = await loadKtxProject({ projectDir: args.projectDir });
+        const cliVersion = args.command === 'run' ? args.cliVersion : undefined;
+        const runtimeInstallPolicy = args.command === 'run' ? args.runtimeInstallPolicy : undefined;
+        const project = await loadKtxCliProject({
+            projectDir: args.projectDir,
+            cliVersion: cliVersion ?? '0.0.0-private',
+            installPolicy: runtimeInstallPolicy ?? 'never',
+            io,
+        });
         const env = deps.env ?? process.env;
         if (args.command === 'run') {
             const ingestProject = args.allowImplicitAdapter && !project.config.ingest.adapters.includes(args.adapter)

package/dist/ingest.test.js

@@ -807,9 +807,16 @@ describe('runKtxIngest', () => {
                     sourceKey: 'historic-sql',
                     body: {
                         workUnits: [],
-                        postProcessor: {
+                        finalization: {
                             sourceKey: 'historic-sql',
                             status: 'success',
+                            commitSha: 'finalization-sha',
+                            touchedPaths: ['semantic-layer/warehouse/_schema/public.yaml', 'wiki/global/historic-sql-orders.md'],
+                            declaredTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+                            derivedTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+                            declaredChangedWikiPageKeys: ['historic-sql-orders'],
+                            derivedChangedWikiPageKeys: ['historic-sql-orders'],
+                            mismatches: [],
                             result: {
                                 tableUsageMerged: 56,
                                 staleTablesMarked: 1,
@@ -819,7 +826,24 @@ describe('runKtxIngest', () => {
                             },
                             errors: [],
                             warnings: [],
-                            touchedSources: [],
+                            actions: [
+                                ...Array.from({ length: 57 }, (_, index) => ({
+                                    target: 'sl',
+                                    type: 'updated',
+                                    key: `orders-${index}`,
+                                    detail: 'Merged usage',
+                                    targetConnectionId: 'warehouse',
+                                    rawPaths: ['tables/public/orders.json'],
+                                })),
+                                ...Array.from({ length: 35 }, (_, index) => ({
+                                    target: 'wiki',
+                                    type: 'updated',
+                                    key: `historic-sql-orders-${index}`,
+                                    detail: 'Projected pattern',
+                                    rawPaths: ['patterns/orders.json'],
+                                })),
+                            ],
+                            provenanceExclusions: [],
                         },
                     },
                 }),
@@ -1048,7 +1072,7 @@ describe('runKtxIngest', () => {
             }),
         }));
     });
-    it('passes managed daemon options to adapters and pull-config options when no explicit daemon URL is set', async () => {
+    it('passes KTX daemon options to adapters and pull-config options when no explicit daemon URL is set', async () => {
         const projectDir = join(tempDir, 'managed-daemon-ingest-project');
         await initKtxProject({ projectDir });
         await writeWarehouseConfig(projectDir);

package/dist/io/print-list.test.js

@@ -60,13 +60,13 @@ describe('printList — plain mode', () => {
             mode: 'plain',
             command: 'sl search',
             emptyMessage: 'No sources matched "foo"',
-            emptyHint: 'Run `ktx sl list` to see available sources.',
+            emptyHint: 'Run `ktx sl` to see available sources.',
             unit: 'source',
             io: r.io,
         });
         expect(r.out()).toBe('');
         expect(r.err()).toBe('No sources matched "foo"\n' +
-            'Run `ktx sl list` to see available sources.\n');
+            'Run `ktx sl` to see available sources.\n');
     });
 });
 describe('printList — json mode', () => {
@@ -162,13 +162,13 @@ describe('printList — pretty mode', () => {
             mode: 'pretty',
             command: 'sl search',
             emptyMessage: 'No sources matched "foo"',
-            emptyHint: 'Run `ktx sl list` to see available sources.',
+            emptyHint: 'Run `ktx sl` to see available sources.',
             unit: 'source',
             io: r.io,
         });
         const out = stripAnsi(r.out());
         expect(out).toContain('No sources matched "foo"');
-        expect(out).toContain('Run `ktx sl list` to see available sources.');
+        expect(out).toContain('Run `ktx sl` to see available sources.');
     });
     it('singularizes the footer when there is one row', () => {
         const r = recorder();

package/dist/knowledge.js

@@ -74,7 +74,7 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
             }
             const mode = resolveOutputMode({ explicit: args.output, json: args.json, io });
             let emptyMessage = `No local wiki pages matched "${args.query}"`;
-            let emptyHint = 'Run `ktx wiki list` to inspect available pages.';
+            let emptyHint = 'Run `ktx wiki` to inspect available pages.';
             if (results.length === 0 && mode !== 'json') {
                 const pages = await listLocalKnowledgePages(project, { userId: args.userId });
                 if (pages.length === 0) {

package/dist/managed-local-embeddings.d.ts

@@ -1,4 +1,3 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV } from '@ktx/context';
 import type { KtxProjectEmbeddingConfig } from '@ktx/context/project';
 import type { KtxEmbeddingConfig } from '@ktx/llm';
 import type { KtxCliIo } from './cli-runtime.js';
@@ -8,7 +7,6 @@ export interface ManagedLocalEmbeddingsDaemon {
     baseUrl: string;
     stdoutLog: string;
     stderrLog: string;
-    env: Record<typeof MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, string>;
 }
 export interface ManagedLocalEmbeddingsOptions {
     cliVersion: string;

package/dist/managed-local-embeddings.js

@@ -1,4 +1,4 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, } from '@ktx/context';
+import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { startManagedPythonDaemon } from './managed-python-daemon.js';
 export function managedLocalEmbeddingProjectConfig(input) {
@@ -39,13 +39,10 @@ export async function ensureManagedLocalEmbeddingsDaemon(options) {
         force: false,
     });
     const verb = daemon.status === 'started' ? 'Started' : 'Using';
-    options.io.stderr.write(`${verb} KTX local embeddings daemon: ${daemon.baseUrl}\n`);
+    options.io.stderr.write(`${verb} KTX daemon: ${daemon.baseUrl}\n`);
     return {
         baseUrl: daemon.baseUrl,
         stdoutLog: daemon.state.stdoutLog,
         stderrLog: daemon.state.stderrLog,
-        env: {
-            [MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV]: daemon.baseUrl,
-        },
     };
 }