@kaelio/ktx 0.1.1 → 0.2.0

package/dist/commands/connection-selection.js

@@ -0,0 +1,9 @@
+export function resolveConnectionSelection(input) {
+    if (input.all && input.connectionId !== undefined) {
+        throw new Error('--all cannot be combined with a connection id argument');
+    }
+    if (input.connectionId !== undefined) {
+        return { kind: 'single', connectionId: input.connectionId };
+    }
+    return { kind: 'all' };
+}

package/dist/commands/ingest-commands.js

@@ -2,32 +2,59 @@ import { Option } from '@commander-js/extra-typings';
 import { collectOption, parsePositiveIntegerOption, resolveCommandProjectDir, } from '../cli-program.js';
 import { runtimeInstallPolicyFromFlags } from '../managed-python-command.js';
 import { profileMark } from '../startup-profile.js';
+import { resolveConnectionSelection } from './connection-selection.js';
 profileMark('module:commands/ingest-commands');
 export function registerIngestCommands(program, context, commandOptions) {
     const ingest = program
         .command('ingest')
-        .description('Build or inspect KTX context')
+        .description('Build or inspect KTX context, or capture text into memory')
         .usage('[options] [connectionId]')
-        .argument('[connectionId]', 'Configured connection id to ingest')
+        .argument('[connectionId]', 'Configured connection id to ingest (omit to ingest all)')
         .option('--all', 'Ingest all configured connections', false)
         .addOption(new Option('--fast', 'Use deterministic database schema ingest').conflicts('deep'))
         .addOption(new Option('--deep', 'Use AI-enriched database ingest').conflicts('fast'))
         .addOption(new Option('--query-history', 'Include database query-history usage patterns').conflicts('noQueryHistory'))
         .addOption(new Option('--no-query-history', 'Skip database query-history usage patterns'))
         .option('--query-history-window-days <days>', 'Query-history lookback window for this run', parsePositiveIntegerOption)
+        .option('--text <content>', 'Capture inline text into KTX memory; repeatable', collectOption, [])
+        .option('--file <path>', 'Capture a text file into KTX memory; use - for stdin; repeatable', collectOption, [])
+        .option('--connection-id <connectionId>', 'KTX connection id to tag captured text/file notes')
+        .option('--user-id <id>', 'Memory user id for text/file capture attribution', 'local-cli')
+        .option('--fail-fast', 'Stop after the first failed text/file item', false)
         .addOption(new Option('--plain', 'Print plain text output').conflicts(['json']))
         .addOption(new Option('--json', 'Print JSON output').conflicts(['plain']))
         .option('--yes', 'Install required managed runtime features without prompting')
         .option('--no-input', 'Disable interactive terminal input')
         .showHelpAfterError();
     ingest.action(async (connectionId, options, command) => {
+        const projectDir = resolveCommandProjectDir(command);
+        const hasTextCapture = options.text.length > 0 || options.file.length > 0;
+        if (hasTextCapture) {
+            if (connectionId !== undefined) {
+                command.error('error: --text/--file does not accept a positional connection id; use --connection-id <id> to tag captured notes');
+            }
+            if (options.all === true) {
+                command.error('error: --all cannot be combined with --text or --file');
+            }
+            context.setExitCode(await commandOptions.runTextIngest({
+                projectDir,
+                texts: options.text,
+                files: options.file,
+                ...(options.connectionId ? { connectionId: options.connectionId } : {}),
+                userId: options.userId,
+                json: options.json === true,
+                failFast: options.failFast === true,
+            }, context.io, context.deps));
+            return;
+        }
+        const selection = resolveConnectionSelection({ connectionId, all: options.all === true });
         const { runKtxPublicIngest } = await import('../public-ingest.js');
         const queryHistory = options.queryHistory === true ? 'enabled' : options.queryHistory === false ? 'disabled' : 'default';
         const args = {
             command: 'run',
-            projectDir: resolveCommandProjectDir(command),
-            ...(connectionId ? { targetConnectionId: connectionId } : {}),
-            all: options.all === true,
+            projectDir,
+            ...(selection.kind === 'single' ? { targetConnectionId: selection.connectionId } : {}),
+            all: selection.kind === 'all',
             json: options.json === true,
             inputMode: options.input === false ? 'disabled' : 'auto',
             ...(options.fast === true ? { depth: 'fast' } : {}),
@@ -42,25 +69,4 @@ export function registerIngestCommands(program, context, commandOptions) {
     ingest.hook('preAction', (_thisCommand, actionCommand) => {
         context.writeDebug?.('ingest', actionCommand);
     });
-    ingest
-        .command('text')
-        .description('Ingest free-form text artifacts into KTX memory')
-        .argument('[files...]', 'Files to ingest; use - to read one item from stdin')
-        .option('--text <content>', 'Text content to ingest; repeat for a batch', collectOption, [])
-        .option('--connection-id <connectionId>', 'Optional KTX connection id for semantic-layer capture')
-        .option('--user-id <id>', 'Memory user id for capture attribution', 'local-cli')
-        .option('--json', 'Print JSON output')
-        .option('--fail-fast', 'Stop after the first failed text item', false)
-        .action(async (files, options, command) => {
-        const parentOptions = command.parent?.opts();
-        context.setExitCode(await commandOptions.runTextIngest({
-            projectDir: resolveCommandProjectDir(command),
-            texts: options.text,
-            files,
-            ...(options.connectionId ? { connectionId: options.connectionId } : {}),
-            userId: options.userId,
-            json: options.json === true || parentOptions?.json === true,
-            failFast: options.failFast === true,
-        }, context.io, context.deps));
-    });
 }

package/dist/commands/knowledge-commands.js

@@ -11,47 +11,36 @@ function isDebugEnabled(command) {
     return options.debug === true;
 }
 export function registerWikiCommands(program, context) {
-    const wiki = program
+    program
         .command('wiki')
         .description('List or search local wiki pages')
-        .showHelpAfterError()
-        .addHelpText('after', '\nProject directory defaults to KTX_PROJECT_DIR when set, otherwise the current working directory.\n');
-    wiki
-        .command('list')
-        .description('List local wiki pages')
-        .option('--user-id <id>', 'Local user id', 'local')
-        .addOption(new Option('--output <mode>', 'Output mode: pretty (default in TTY), plain (TSV), or json').choices([
-        'pretty',
-        'plain',
-        'json',
-    ]))
-        .option('--json', 'Shortcut for --output=json (overrides --output)', false)
-        .action(async (options, command) => {
-        await runKnowledgeArgs(context, {
-            command: 'list',
-            projectDir: resolveCommandProjectDir(command),
-            userId: options.userId,
-            output: options.output,
-            json: options.json,
-        });
-    });
-    wiki
-        .command('search')
-        .description('Search local wiki pages')
-        .argument('<query>', 'Search query')
+        .usage('[options] [query...]')
+        .argument('[query...]', 'Search query; omit to list all pages')
         .option('--user-id <id>', 'Local user id', 'local')
-        .option('--limit <number>', 'Maximum search results', parsePositiveIntegerOption)
+        .option('--limit <number>', 'Maximum search results (search mode only)', parsePositiveIntegerOption)
         .addOption(new Option('--output <mode>', 'Output mode: pretty (default in TTY), plain (TSV), or json').choices([
         'pretty',
         'plain',
         'json',
     ]))
         .option('--json', 'Shortcut for --output=json (overrides --output)', false)
+        .showHelpAfterError()
+        .addHelpText('after', '\nProject directory defaults to KTX_PROJECT_DIR when set, otherwise the current working directory.\n')
         .action(async (query, options, command) => {
+        if (query.length === 0) {
+            await runKnowledgeArgs(context, {
+                command: 'list',
+                projectDir: resolveCommandProjectDir(command),
+                userId: options.userId,
+                output: options.output,
+                json: options.json,
+            });
+            return;
+        }
         await runKnowledgeArgs(context, {
             command: 'search',
             projectDir: resolveCommandProjectDir(command),
-            query,
+            query: query.join(' '),
             userId: options.userId,
             output: options.output,
             json: options.json,

package/dist/commands/mcp-commands.js

@@ -21,8 +21,23 @@ function formatMcpStartResultMessage(input) {
         '',
     ].join('\n');
 }
+async function printMcpStatus(context, projectDir) {
+    const status = await (context.deps.mcp?.readStatus ?? readKtxMcpDaemonStatus)({ projectDir });
+    context.io.stdout.write(`${status.detail}\n`);
+    if (status.kind === 'running') {
+        context.io.stdout.write(`URL: ${status.url}\n`);
+        context.io.stdout.write(`PID: ${status.state.pid}\n`);
+        context.io.stdout.write(`Token auth: ${status.state.tokenAuth ? 'enabled' : 'disabled'}\n`);
+        context.io.stdout.write(`Project: ${status.state.projectDir}\n`);
+    }
+}
 export function registerMcpCommands(program, context) {
-    const mcp = program.command('mcp').description('Run the KTX MCP HTTP server');
+    const mcp = program
+        .command('mcp')
+        .description('Manage the KTX MCP HTTP server (bare command: show status)')
+        .action(async (_options, command) => {
+        await printMcpStatus(context, resolveCommandProjectDir(command));
+    });
     mcp
         .command('stdio')
         .description('Run the KTX MCP server over stdio')
@@ -91,16 +106,7 @@ export function registerMcpCommands(program, context) {
         .command('status')
         .description('Show KTX MCP daemon status')
         .action(async (_options, command) => {
-        const status = await (context.deps.mcp?.readStatus ?? readKtxMcpDaemonStatus)({
-            projectDir: resolveCommandProjectDir(command),
-        });
-        context.io.stdout.write(`${status.detail}\n`);
-        if (status.kind === 'running') {
-            context.io.stdout.write(`URL: ${status.url}\n`);
-            context.io.stdout.write(`PID: ${status.state.pid}\n`);
-            context.io.stdout.write(`Token auth: ${status.state.tokenAuth ? 'enabled' : 'disabled'}\n`);
-            context.io.stdout.write(`Project: ${status.state.projectDir}\n`);
-        }
+        await printMcpStatus(context, resolveCommandProjectDir(command));
     });
     mcp
         .command('logs')

package/dist/commands/sl-commands.js

@@ -28,63 +28,57 @@ export function registerSlCommands(program, context, commandName = 'sl') {
     const sl = program
         .command(commandName)
         .description('List, search, validate, or query local semantic-layer sources')
-        .showHelpAfterError()
-        .addHelpText('after', '\nProject directory defaults to KTX_PROJECT_DIR when set, otherwise the current working directory.\n');
-    sl.command('list')
-        .description('List semantic-layer sources')
-        .option('--connection-id <id>', 'KTX connection id')
-        .addOption(new Option('--output <mode>', 'Output mode: pretty (default in TTY), plain (TSV), or json').choices([
-        'pretty',
-        'plain',
-        'json',
-    ]))
-        .option('--json', 'Shortcut for --output=json (overrides --output)', false)
-        .action(async (options, command) => {
-        await runSlArgs(context, {
-            command: 'list',
-            projectDir: resolveCommandProjectDir(command),
-            connectionId: options.connectionId,
-            output: options.output,
-            json: options.json,
-        });
-    });
-    sl.command('search')
-        .description('Search semantic-layer sources')
-        .argument('<query>', 'Search query')
+        .usage('[options] [query...]')
+        .argument('[query...]', 'Search query; omit to list all sources')
         .option('--connection-id <id>', 'KTX connection id')
-        .option('--limit <number>', 'Maximum search results', parsePositiveIntegerOption)
+        .option('--limit <number>', 'Maximum search results (search mode only)', parsePositiveIntegerOption)
         .addOption(new Option('--output <mode>', 'Output mode: pretty (default in TTY), plain (TSV), or json').choices([
         'pretty',
         'plain',
         'json',
     ]))
         .option('--json', 'Shortcut for --output=json (overrides --output)', false)
+        .showHelpAfterError()
+        .addHelpText('after', '\nProject directory defaults to KTX_PROJECT_DIR when set, otherwise the current working directory.\n')
         .action(async (query, options, command) => {
+        if (query.length === 0) {
+            await runSlArgs(context, {
+                command: 'list',
+                projectDir: resolveCommandProjectDir(command),
+                connectionId: options.connectionId,
+                output: options.output,
+                json: options.json,
+            });
+            return;
+        }
         await runSlArgs(context, {
             command: 'search',
             projectDir: resolveCommandProjectDir(command),
             connectionId: options.connectionId,
-            query,
+            query: query.join(' '),
             ...(options.limit !== undefined ? { limit: options.limit } : {}),
             output: options.output,
             json: options.json,
         });
     });
     sl.command('validate')
-        .description('Validate a semantic-layer source')
+        .description('Validate a semantic-layer source (set --connection-id on `ktx sl`)')
         .argument('<sourceName>', 'Semantic-layer source name')
-        .requiredOption('--connection-id <id>', 'KTX connection id')
-        .action(async (sourceName, options, command) => {
+        .action(async (sourceName, _options, command) => {
+        const parentOpts = command.parent?.opts();
+        const connectionId = parentOpts?.connectionId;
+        if (connectionId === undefined) {
+            command.error("error: required option '--connection-id <id>' not specified");
+        }
         await runSlArgs(context, {
             command: 'validate',
             projectDir: resolveCommandProjectDir(command),
-            connectionId: options.connectionId,
+            connectionId: connectionId,
             sourceName,
         });
     });
     sl.command('query')
-        .description('Compile or execute a semantic-layer query')
-        .option('--connection-id <id>', 'KTX connection id')
+        .description('Compile or execute a semantic-layer query (set --connection-id on `ktx sl`)')
         .option('--query-file <path>', 'JSON semantic-layer query file')
         .option('--measure <measure>', 'Measure to query; repeatable', collectOption, [])
         .option('--dimension <dimension>', 'Dimension to include; repeatable', collectOption, [])
@@ -102,10 +96,11 @@ export function registerSlCommands(program, context, commandName = 'sl') {
         if (options.measure.length === 0 && !options.queryFile) {
             throw new Error('sl query requires at least one --measure');
         }
+        const parentOpts = command.parent?.opts();
         const args = slQueryCommandSchema.parse({
             command: 'query',
             projectDir: resolveCommandProjectDir(command),
-            connectionId: options.connectionId,
+            connectionId: parentOpts?.connectionId,
             ...(options.queryFile
                 ? { queryFile: options.queryFile }
                 : {

package/dist/doctor.test.js

@@ -55,8 +55,8 @@ describe('formatDoctorReport', () => {
         expect(output).not.toContain('v22.16.0');
         expect(output).toContain('Everything ready.');
         expect(output).toContain('ktx status --json');
-        expect(output).toContain('ktx sl list');
-        expect(output).toContain('ktx wiki list');
+        expect(output).toContain('ktx sl');
+        expect(output).toContain('ktx wiki');
         expect(output).not.toContain('ktx scan');
         expect(output).not.toContain('ktx sl ask');
     });
@@ -412,8 +412,8 @@ describe('runKtxDoctor', () => {
         expect(out).toContain('info: pg_stat_statements.max is 1000');
         expect(out).not.toContain('Update the Postgres parameter group or config');
         expect(out).toContain('ktx status --json');
-        expect(out).toContain('ktx sl list');
-        expect(out).toContain('ktx wiki list');
+        expect(out).toContain('ktx sl');
+        expect(out).toContain('ktx wiki');
         expect(out).not.toContain('ktx scan');
         expect(out).not.toContain('ktx sl ask');
         delete process.env.ANTHROPIC_API_KEY;

package/dist/example-smoke.test.js

@@ -51,10 +51,10 @@ describe('standalone local warehouse example', () => {
     });
     it('runs local CLI commands against the copied example project', async () => {
         const projectDir = await copyExampleProject(tempDir);
-        const knowledgeList = await runBuiltCli(['wiki', 'search', 'revenue', '--json', '--project-dir', projectDir]);
+        const knowledgeList = await runBuiltCli(['wiki', 'revenue', '--json', '--project-dir', projectDir]);
         expect(knowledgeList).toMatchObject({ code: 0, stderr: '' });
         expect(parseJsonOutput(knowledgeList.stdout).data.items).toContainEqual(expect.objectContaining({ key: 'revenue', summary: 'Paid order value after refunds' }));
-        const slList = await runBuiltCli(['sl', 'list', '--json', '--project-dir', projectDir, '--connection-id', 'warehouse']);
+        const slList = await runBuiltCli(['sl', '--json', '--project-dir', projectDir, '--connection-id', 'warehouse']);
         expect(slList).toMatchObject({ code: 0, stderr: '' });
         expect(parseJsonOutput(slList.stdout).data.items).toContainEqual(expect.objectContaining({ connectionId: 'warehouse', name: 'orders', columnCount: 3 }));
         const slSearch = await runBuiltCli([
@@ -78,6 +78,6 @@ describe('standalone local warehouse example', () => {
             'fake',
         ]);
         expect(ingest).toMatchObject({ code: 1, stdout: '' });
-        expect(ingest.stderr).toContain("unknown option '--connection-id'");
+        expect(ingest.stderr).toContain("unknown option '--adapter'");
     }, 30_000);
 });

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');
@@ -367,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();
@@ -483,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:/);
     });
@@ -636,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);
@@ -652,7 +660,6 @@ describe('runKtxCli', () => {
             '--project-dir',
             tempDir,
             'ingest',
-            'text',
             '--text',
             'Revenue means gross receipts.',
             '--text',
@@ -675,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('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',
@@ -1237,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');
@@ -1251,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 () => {