@kaelio/ktx 0.1.0 → 0.2.0

package/dist/index.test.js

@@ -98,9 +98,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 +116,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 +125,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 +135,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 +144,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,9 +179,18 @@ 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 () => {
         const runtime = vi.fn(async () => 0);
@@ -193,14 +200,14 @@ 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',
@@ -262,7 +269,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');
@@ -318,8 +325,6 @@ describe('runKtxCli', () => {
         expect(stdout).not.toContain('setup demo');
         expect(stdout).not.toContain('setup context');
         for (const hiddenFlag of [
-            '--new',
-            '--existing',
             '--agent-scope',
             '--skip-agents',
             '--llm-backend',
@@ -328,7 +333,6 @@ describe('runKtxCli', () => {
             '--embedding-backend',
             '--database ',
             '--database-connection-id',
-            '--new-database-connection-id',
             '--enable-historic-sql',
             '--historic-sql-min-executions',
             '--enable-query-history',
@@ -370,7 +374,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();
@@ -486,8 +490,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:/);
     });
@@ -612,8 +616,12 @@ describe('runKtxCli', () => {
     it('rejects removed setup options', async () => {
         const setup = vi.fn(async () => 0);
         const cases = [
+            ['setup', '--new'],
+            ['setup', '--existing'],
             ['setup', '--project'],
             ['setup', '--agent-scope', 'global'],
+            ['setup', '--anthropic-model', 'claude-sonnet-4-6'],
+            ['setup', '--new-database-connection-id', 'warehouse'],
             ['setup', '--skip-initial-source-ingest'],
         ];
         for (const args of cases) {
@@ -635,7 +643,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);
@@ -651,7 +660,6 @@ describe('runKtxCli', () => {
             '--project-dir',
             tempDir,
             'ingest',
-            'text',
             '--text',
             'Revenue means gross receipts.',
             '--text',
@@ -674,37 +682,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('rejects old adapter-backed ingest flags at the top level and under dev', async () => {
+    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 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',
@@ -778,7 +795,7 @@ describe('runKtxCli', () => {
             '--no-input',
             '--anthropic-api-key-env',
             'ANTHROPIC_API_KEY',
-            '--anthropic-model',
+            '--llm-model',
             'claude-sonnet-4-6',
         ], setupIo.io, { setup })).resolves.toBe(0);
         expect(setup).toHaveBeenCalledWith(expect.objectContaining({
@@ -787,7 +804,7 @@ describe('runKtxCli', () => {
             inputMode: 'disabled',
             cliVersion: '0.1.0-rc.1',
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }), setupIo.io);
     });
@@ -805,7 +822,7 @@ describe('runKtxCli', () => {
             'local-gcp-project',
             '--vertex-location',
             'us-east5',
-            '--anthropic-model',
+            '--llm-model',
             'claude-sonnet-4-6',
         ], setupIo.io, { setup })).resolves.toBe(0);
         expect(setup).toHaveBeenCalledWith(expect.objectContaining({
@@ -816,7 +833,7 @@ describe('runKtxCli', () => {
             llmBackend: 'vertex',
             vertexProject: 'local-gcp-project',
             vertexLocation: 'us-east5',
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }), setupIo.io);
     });
@@ -895,7 +912,7 @@ describe('runKtxCli', () => {
             '--skip-embeddings',
             '--database',
             'postgres',
-            '--new-database-connection-id',
+            '--database-connection-id',
             'warehouse',
             '--database-url',
             'env:DATABASE_URL',
@@ -928,12 +945,27 @@ describe('runKtxCli', () => {
     it('dispatches setup database connection ids that match former ingest subcommand names', async () => {
         const testIo = makeIo();
         const setup = vi.fn(async () => 0);
-        await expect(runKtxCli(['setup', '--new-database-connection-id', 'status', '--no-input'], testIo.io, { setup })).resolves.toBe(0);
+        await expect(runKtxCli(['setup', '--database-connection-id', 'status', '--no-input'], testIo.io, { setup })).resolves.toBe(0);
         expect(setup).toHaveBeenCalledWith(expect.objectContaining({
             command: 'run',
-            databaseConnectionId: 'status',
+            databaseConnectionIds: ['status'],
         }), testIo.io);
     });
+    it('dispatches non-TTY agents setup with target without requiring --no-input or --yes', async () => {
+        const testIo = makeIo({ stdoutIsTty: false });
+        const setup = vi.fn(async () => 0);
+        await expect(runKtxCli(['--project-dir', tempDir, 'setup', '--agents', '--target', 'claude-code'], testIo.io, { setup })).resolves.toBe(0);
+        expect(setup).toHaveBeenCalledWith(expect.objectContaining({
+            command: 'run',
+            projectDir: tempDir,
+            agents: true,
+            target: 'claude-code',
+            agentScope: 'project',
+            inputMode: 'auto',
+            yes: false,
+        }), testIo.io);
+        expect(testIo.stderr()).toBe('');
+    });
     it('dispatches setup source flags', async () => {
         const setup = vi.fn(async () => 0);
         const testIo = makeIo();
@@ -1221,10 +1253,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');
@@ -1235,20 +1267,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-depth.js

@@ -46,7 +46,6 @@ export function deepReadinessGaps(config) {
     const embeddings = config.scan.enrichment.embeddings;
     if (!embeddings ||
         embeddings.backend === 'none' ||
-        embeddings.backend === 'deterministic' ||
         !embeddings.model ||
         embeddings.dimensions <= 0) {
         gaps.push('scan embeddings');

package/dist/ingest.test-utils.js

@@ -84,7 +84,7 @@ export async function writeMetabaseConfig(projectDir) {
         '  adapters:',
         '    - metabase',
         '  embeddings:',
-        '    backend: deterministic',
+        '    backend: none',
         '',
     ].join('\n'), 'utf-8');
 }
@@ -418,7 +418,7 @@ export async function runPublicMetabaseSyncModeCase(tempDir, input) {
         '  adapters:',
         '    - metabase',
         '  embeddings:',
-        '    backend: deterministic',
+        '    backend: none',
         '',
     ].join('\n'), 'utf-8');
     const project = await loadKtxProject({ projectDir });

package/dist/ingest.test.js

@@ -182,7 +182,7 @@ describe('runKtxIngest', () => {
         await expect(runKtxSetup({
             command: 'run',
             projectDir,
-            mode: 'new',
+            mode: 'auto',
             agents: false,
             agentScope: 'project',
             skipAgents: true,
@@ -227,7 +227,7 @@ describe('runKtxIngest', () => {
         expect(runIo.stderr()).toContain('ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, or claude-code, or an injected agentRunner.');
         expect(runIo.stderr()).toContain('Configure a local Claude Code session or API-backed LLM, then rerun ingest:');
         expect(runIo.stderr()).toContain(`ktx setup --project-dir ${projectDir} --llm-backend claude-code --no-input`);
-        expect(runIo.stderr()).toContain(`ktx setup --project-dir ${projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --anthropic-model claude-sonnet-4-6 --no-input`);
+        expect(runIo.stderr()).toContain(`ktx setup --project-dir ${projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --llm-model claude-sonnet-4-6 --no-input`);
     });
     it('routes metabase scheduled pulls to the fan-out runner and prints child summaries', async () => {
         const projectDir = join(tempDir, 'project');
@@ -620,7 +620,7 @@ describe('runKtxIngest', () => {
             '  adapters:',
             '    - metabase',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         const project = await loadKtxProject({ projectDir });
@@ -1449,7 +1449,7 @@ describe('runKtxIngest', () => {
             '  adapters:',
             '    - looker',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         const project = await loadKtxProject({ 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

@@ -6,6 +6,8 @@ import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime }
 import { type ManagedPythonDaemonStartResult } from './managed-python-daemon.js';
 export interface ManagedLocalEmbeddingsDaemon {
     baseUrl: string;
+    stdoutLog: string;
+    stderrLog: string;
     env: Record<typeof MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, string>;
 }
 export interface ManagedLocalEmbeddingsOptions {

package/dist/managed-local-embeddings.js

@@ -42,6 +42,8 @@ export async function ensureManagedLocalEmbeddingsDaemon(options) {
     options.io.stderr.write(`${verb} KTX local embeddings 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,
         },

package/dist/managed-local-embeddings.test.js

@@ -128,6 +128,8 @@ describe('ensureManagedLocalEmbeddingsDaemon', () => {
             startDaemon,
         })).resolves.toEqual({
             baseUrl: 'http://127.0.0.1:61234',
+            stdoutLog: '/work/proj/.ktx/runtime/daemon.stdout.log',
+            stderrLog: '/work/proj/.ktx/runtime/daemon.stderr.log',
             env: {
                 [MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV]: 'http://127.0.0.1:61234',
             },

package/dist/managed-mcp-daemon.js

@@ -4,6 +4,7 @@ import { createServer } from 'node:net';
 import { dirname, join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { z } from 'zod';
+import { sanitizeChildProxyEnv } from './proxy-env.js';
 const stateSchema = z.object({
     schemaVersion: z.literal(1),
     pid: z.number().int().positive(),
@@ -118,11 +119,11 @@ export async function startKtxMcpDaemon(options) {
         const child = (options.spawnDaemon ?? defaultSpawnDaemon)(process.execPath, args, {
             detached: true,
             stdio: ['ignore', log.fd, log.fd],
-            env: {
+            env: sanitizeChildProxyEnv({
                 ...process.env,
                 KTX_CLI_VERSION: options.cliVersion,
                 ...(options.token ? { KTX_MCP_TOKEN: options.token } : {}),
-            },
+            }),
         });
         if (!child.pid) {
             throw new Error('Failed to start KTX MCP daemon: child process pid was not available.');

package/dist/managed-mcp-daemon.test.js

@@ -28,6 +28,7 @@ describe('managed MCP daemon lifecycle', () => {
         await mkdir(projectDir, { recursive: true });
     });
     afterEach(async () => {
+        vi.unstubAllEnvs();
         await rm(tempDir, { recursive: true, force: true });
     });
     it('uses the spec state and log paths', () => {
@@ -72,6 +73,30 @@ describe('managed MCP daemon lifecycle', () => {
         }));
         expect(JSON.stringify(JSON.parse(await readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')))).not.toContain('secret-token');
     });
+    it('sanitizes IPv6 CIDR entries from child NO_PROXY env', async () => {
+        vi.stubEnv('NO_PROXY', 'localhost,fd07:b51a:cc66:f0::/64');
+        vi.stubEnv('no_proxy', '::1,fd00::/8,*.orb.local');
+        const spawnDaemon = vi.fn(() => child(5555));
+        await startKtxMcpDaemon({
+            projectDir,
+            cliVersion: '0.0.0-test',
+            host: '127.0.0.1',
+            port: 7879,
+            allowedHosts: [],
+            allowedOrigins: [],
+            binPath: '/repo/packages/cli/dist/bin.js',
+            spawnDaemon,
+            processAlive: vi.fn(() => false),
+            portAvailable: vi.fn(async () => true),
+            now: () => new Date('2026-05-14T00:00:00.000Z'),
+        });
+        const env = spawnDaemon.mock.calls[0]?.[2].env;
+        if (!env) {
+            throw new Error('Expected MCP daemon spawn env');
+        }
+        expect(env.NO_PROXY).toBe('localhost,::1,*.orb.local');
+        expect(env.no_proxy).toBe(env.NO_PROXY);
+    });
     it('returns already-running without spawning when the daemon is alive at the same host/port', async () => {
         await mkdir(join(projectDir, '.ktx'), { recursive: true });
         await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);

package/dist/managed-python-command.js

@@ -12,8 +12,8 @@ export function runtimeInstallPolicyFromFlags(options) {
 }
 export function managedRuntimeInstallCommand(feature) {
     return feature === 'local-embeddings'
-        ? 'ktx dev runtime install --feature local-embeddings --yes'
-        : 'ktx dev runtime install --yes';
+        ? 'ktx admin runtime install --feature local-embeddings --yes'
+        : 'ktx admin runtime install --yes';
 }
 function installPrompt(feature) {
     const label = feature === 'local-embeddings' ? 'local embeddings Python runtime' : 'core Python runtime';

package/dist/managed-python-command.test.js

@@ -81,6 +81,7 @@ function installResult(features = ['core']) {
         asset: {
             manifest: installedManifest.asset,
             wheelPath: '/assets/python/kaelio_ktx-0.2.0-py3-none-any.whl',
+            requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
         },
         manifest: installedManifest,
     };
@@ -97,8 +98,8 @@ function makeSpinnerEvents() {
 }
 describe('managedRuntimeInstallCommand', () => {
     it('prints the exact command for each managed runtime feature', () => {
-        expect(managedRuntimeInstallCommand('core')).toBe('ktx dev runtime install --yes');
-        expect(managedRuntimeInstallCommand('local-embeddings')).toBe('ktx dev runtime install --feature local-embeddings --yes');
+        expect(managedRuntimeInstallCommand('core')).toBe('ktx admin runtime install --yes');
+        expect(managedRuntimeInstallCommand('local-embeddings')).toBe('ktx admin runtime install --feature local-embeddings --yes');
     });
 });
 describe('runtimeInstallPolicyFromFlags', () => {
@@ -176,7 +177,7 @@ describe('createManagedPythonSemanticLayerComputePort', () => {
             io: io.io,
             readStatus: vi.fn(async () => missingStatus()),
             installRuntime,
-        })).rejects.toThrow('KTX Python runtime is required for this command. Run: ktx dev runtime install --yes');
+        })).rejects.toThrow('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
         expect(installRuntime).not.toHaveBeenCalled();
     });
     it('installs the core runtime without prompting when policy is auto', async () => {