@kaelio/ktx 0.1.0-rc.1 → 0.1.0-rc.4

package/dist/cli-program.js

@@ -116,6 +116,9 @@ function shouldSuppressProjectDirLine(path, options) {
     if (commandPathKey === 'ktx setup') {
         return true;
     }
+    if (commandPathKey === 'ktx mcp stdio') {
+        return true;
+    }
     if (commandPathKey === 'ktx status' &&
         typeof options.projectDir !== 'string' &&
         process.env.KTX_PROJECT_DIR === undefined &&

package/dist/cli-runtime.d.ts

@@ -35,6 +35,7 @@ export interface KtxCliDeps {
         stopDaemon?: typeof import('./managed-mcp-daemon.js').stopKtxMcpDaemon;
         readStatus?: typeof import('./managed-mcp-daemon.js').readKtxMcpDaemonStatus;
         runServer?: typeof import('./mcp-http-server.js').runKtxMcpHttpServer;
+        runStdioServer?: typeof import('./mcp-stdio-server.js').runKtxMcpStdioServer;
     };
 }
 export declare function getKtxCliPackageInfo(): KtxCliPackageInfo;

package/dist/commands/mcp-commands.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { collectOption, parsePositiveIntegerOption, resolveCommandProjectDir, } from '../cli-program.js';
 import { mcpDaemonLayout, readKtxMcpDaemonStatus, startKtxMcpDaemon, stopKtxMcpDaemon, } from '../managed-mcp-daemon.js';
 import { buildMcpSecurityConfig, runKtxMcpHttpServer } from '../mcp-http-server.js';
+import { runKtxMcpStdioServer } from '../mcp-stdio-server.js';
 function tokenFromOption(value) {
     return value ?? process.env.KTX_MCP_TOKEN;
 }
@@ -12,6 +13,16 @@ function binPath() {
 }
 export function registerMcpCommands(program, context) {
     const mcp = program.command('mcp').description('Run the KTX MCP HTTP server');
+    mcp
+        .command('stdio')
+        .description('Run the KTX MCP server over stdio')
+        .action(async (_options, command) => {
+        await (context.deps.mcp?.runStdioServer ?? runKtxMcpStdioServer)({
+            projectDir: resolveCommandProjectDir(command),
+            cliVersion: context.packageInfo.version,
+            io: context.io,
+        });
+    });
     mcp
         .command('start')
         .description('Start the KTX MCP HTTP server')
@@ -55,7 +66,9 @@ export function registerMcpCommands(program, context) {
             allowedOrigins: options.allowedOrigin,
             binPath: binPath(),
         });
-        context.io.stdout.write(`KTX MCP daemon started: ${result.url}\n`);
+        context.io.stdout.write(result.status === 'started'
+            ? `KTX MCP daemon started: ${result.url}\n`
+            : `KTX MCP daemon already running: ${result.url}\n`);
     });
     mcp
         .command('stop')

package/dist/commands/mcp-commands.test.js

@@ -31,6 +31,7 @@ describe('registerMcpCommands', () => {
             'serve-internal',
             'start',
             'status',
+            'stdio',
             'stop',
         ]);
         expect(mcp?.commands.find((command) => command.name() === 'serve-internal')
@@ -44,4 +45,38 @@ describe('registerMcpCommands', () => {
         await expect(program.parseAsync(['mcp', 'start', '--host', '0.0.0.0'], { from: 'user' })).rejects.toThrow('Binding KTX MCP to 0.0.0.0 requires --token or KTX_MCP_TOKEN');
         expect(startDaemon).not.toHaveBeenCalled();
     });
+    it('prints "already running" when startDaemon reports already-running', async () => {
+        const program = new Command().exitOverride().option('--project-dir <path>');
+        const startDaemon = vi.fn().mockResolvedValue({
+            status: 'already-running',
+            url: 'http://127.0.0.1:7878/mcp',
+            state: {
+                schemaVersion: 1,
+                pid: 4242,
+                host: '127.0.0.1',
+                port: 7878,
+                tokenAuth: false,
+                projectDir: '/tmp/ktx-already',
+                startedAt: '2026-05-14T00:00:00.000Z',
+                logPath: '/tmp/ktx-already/.ktx/logs/mcp.log',
+            },
+        });
+        const context = makeContext({ deps: { mcp: { startDaemon } } });
+        registerMcpCommands(program, context);
+        await program.parseAsync(['--project-dir', '/tmp/ktx-already', 'mcp', 'start'], { from: 'user' });
+        expect(startDaemon).toHaveBeenCalledTimes(1);
+        expect(context.io.stdout.write).toHaveBeenCalledWith('KTX MCP daemon already running: http://127.0.0.1:7878/mcp\n');
+    });
+    it('runs the stdio server with the resolved project directory', async () => {
+        const program = new Command().exitOverride().option('--project-dir <path>');
+        const runStdioServer = vi.fn().mockResolvedValue(undefined);
+        const context = makeContext({ deps: { mcp: { runStdioServer } } });
+        registerMcpCommands(program, context);
+        await expect(program.parseAsync(['--project-dir', '/tmp/ktx6', 'mcp', 'stdio'], { from: 'user' })).resolves.toBe(program);
+        expect(runStdioServer).toHaveBeenCalledWith({
+            projectDir: '/tmp/ktx6',
+            cliVersion: '0.0.0-test',
+            io: context.io,
+        });
+    });
 });

package/dist/commands/setup-commands.js

@@ -91,6 +91,7 @@ function shouldShowSetupEntryMenu(options, command) {
         'llmBackend',
         'anthropicApiKeyEnv',
         'anthropicApiKeyFile',
+        'llmModel',
         'anthropicModel',
         'vertexProject',
         'vertexLocation',
@@ -136,6 +137,7 @@ export function registerSetupCommands(program, context) {
         .option('--agents', 'Install agent integration only', false)
         .addOption(new Option('--target <target>', 'Agent target').choices([
         'claude-code',
+        'claude-desktop',
         'codex',
         'cursor',
         'opencode',
@@ -149,6 +151,7 @@ export function registerSetupCommands(program, context) {
         .addOption(new Option('--llm-backend <backend>', 'LLM backend').argParser(llmBackend).hideHelp())
         .addOption(new Option('--anthropic-api-key-env <name>', 'Environment variable containing the Anthropic API key').hideHelp())
         .addOption(new Option('--anthropic-api-key-file <path>', 'File containing the Anthropic API key').hideHelp())
+        .addOption(new Option('--llm-model <model>', 'LLM model ID or backend model alias').hideHelp())
         .addOption(new Option('--anthropic-model <model>', 'Anthropic model ID to validate and save').hideHelp())
         .addOption(new Option('--vertex-project <project>', 'Google Vertex AI project ID, env:NAME, or file:/path').hideHelp())
         .addOption(new Option('--vertex-location <location>', 'Google Vertex AI location, env:NAME, or file:/path').hideHelp())
@@ -235,6 +238,11 @@ export function registerSetupCommands(program, context) {
             context.setExitCode(1);
             return;
         }
+        if (options.llmModel && options.anthropicModel) {
+            context.io.stderr.write('Choose only one LLM model flag: --llm-model or --anthropic-model.\n');
+            context.setExitCode(1);
+            return;
+        }
         if (options.llmBackend &&
             options.llmBackend !== 'anthropic' &&
             (options.anthropicApiKeyEnv || options.anthropicApiKeyFile)) {
@@ -293,6 +301,7 @@ export function registerSetupCommands(program, context) {
             ...(options.llmBackend ? { llmBackend: options.llmBackend } : {}),
             ...(options.anthropicApiKeyEnv ? { anthropicApiKeyEnv: options.anthropicApiKeyEnv } : {}),
             ...(options.anthropicApiKeyFile ? { anthropicApiKeyFile: options.anthropicApiKeyFile } : {}),
+            ...(options.llmModel ? { llmModel: options.llmModel } : {}),
             ...(options.anthropicModel ? { anthropicModel: options.anthropicModel } : {}),
             ...(options.vertexProject ? { vertexProject: options.vertexProject } : {}),
             ...(options.vertexLocation ? { vertexLocation: options.vertexLocation } : {}),

package/dist/context-build-view.js

@@ -801,6 +801,7 @@ export async function runContextBuild(project, args, io, deps = {}) {
             const progressDeps = {
                 scanProgress: createContextBuildProgressPort(updateSchemaPhase),
                 ingestProgress: updateIngestPhase,
+                runtimeIo: io,
                 onPhaseStart,
                 onPhaseEnd,
             };

package/dist/context-build-view.test.js

@@ -764,6 +764,24 @@ describe('runContextBuild', () => {
             ingestProgress: expect.any(Function),
         }));
     });
+    it('threads the original runtime IO into captured target execution', async () => {
+        const io = makeIo({ isTTY: true });
+        const project = projectWithConnections({
+            warehouse: { driver: 'postgres', context: { queryHistory: { enabled: true } } },
+        });
+        const executeTarget = vi.fn(async (target) => successResult(target.connectionId, target.driver, target.operation));
+        await runContextBuild(project, {
+            projectDir: '/tmp/project',
+            inputMode: 'auto',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+        }, io.io, { executeTarget, now: () => 1000 });
+        expect(executeTarget).toHaveBeenCalledWith(expect.objectContaining({ connectionId: 'warehouse' }), expect.objectContaining({ runtimeInstallPolicy: 'auto' }), expect.objectContaining({
+            stdout: expect.objectContaining({ isTTY: false }),
+        }), expect.objectContaining({
+            runtimeIo: io.io,
+        }));
+    });
     it('calls onSourceProgress when sources start and finish', async () => {
         const io = makeIo();
         const project = projectWithConnections({

package/dist/index.test.js

@@ -785,6 +785,29 @@ describe('runKtxCli', () => {
             skipLlm: false,
         }), setupIo.io);
     });
+    it('dispatches the provider-neutral LLM model setup flag to the setup runner', async () => {
+        const setup = vi.fn(async () => 0);
+        const setupIo = makeIo();
+        await expect(runKtxCli([
+            '--project-dir',
+            tempDir,
+            'setup',
+            '--no-input',
+            '--llm-backend',
+            'claude-code',
+            '--llm-model',
+            'opus',
+        ], setupIo.io, { setup })).resolves.toBe(0);
+        expect(setup).toHaveBeenCalledWith(expect.objectContaining({
+            command: 'run',
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            cliVersion: '0.0.0-private',
+            llmBackend: 'claude-code',
+            llmModel: 'opus',
+            skipLlm: false,
+        }), setupIo.io);
+    });
     it('rejects conflicting Anthropic credential setup flags', async () => {
         const setup = vi.fn(async () => 0);
         const setupIo = makeIo();

package/dist/ingest.d.ts

@@ -59,6 +59,7 @@ export interface KtxIngestDeps {
     env?: NodeJS.ProcessEnv;
     localIngestOptions?: Pick<RunLocalIngestOptions, 'agentRunner' | 'llmRuntime' | 'memoryModel' | 'semanticLayerCompute' | 'queryExecutor' | 'logger' | 'pullConfigOptions'>;
     progress?: (update: KtxIngestProgressUpdate) => void;
+    runtimeIo?: KtxIngestIo;
 }
 export declare function runKtxIngest(args: KtxIngestArgs, io?: KtxIngestIo, deps?: KtxIngestDeps): Promise<number>;
 export {};

package/dist/ingest.js

@@ -412,7 +412,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                 (deps.runLocalIngest || deps.runLocalMetabaseIngest ? () => [] : createKtxCliLocalIngestAdapters);
             const executeLocalIngest = deps.runLocalIngest ?? runLocalIngest;
             const localIngestOptions = deps.localIngestOptions ?? {};
-            const managedDaemon = managedDaemonOptionsForIngestRun(args, io);
+            const managedDaemon = managedDaemonOptionsForIngestRun(args, deps.runtimeIo ?? io);
             const operationalLogger = createCliOperationalLogger(io, args.outputMode);
             const adapterOptions = {
                 ...(localIngestOptions.pullConfigOptions ?? {}),

package/dist/ingest.test.js

@@ -852,6 +852,7 @@ describe('runKtxIngest', () => {
         const createAdapters = vi.fn(() => createdAdapters);
         const runLocal = vi.fn(async (input) => completedLocalBundleRun(input, input.jobId ?? 'local-job-1'));
         const io = makeIo();
+        const runtimeIo = makeIo({ isTTY: true });
         await expect(runKtxIngest({
             command: 'run',
             projectDir,
@@ -864,12 +865,13 @@ describe('runKtxIngest', () => {
             createAdapters,
             runLocalIngest: runLocal,
             jobIdFactory: () => 'local-job-1',
+            runtimeIo: runtimeIo.io,
         })).resolves.toBe(0);
         const expectedManagedDaemon = {
             cliVersion: '0.2.0',
             projectDir,
             installPolicy: 'auto',
-            io: io.io,
+            io: runtimeIo.io,
         };
         expect(createAdapters).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), expect.objectContaining({
             managedDaemon: expectedManagedDaemon,

package/dist/managed-mcp-daemon.d.ts

@@ -48,7 +48,7 @@ export declare function startKtxMcpDaemon(options: {
     spawnDaemon?: typeof defaultSpawnDaemon;
     now?: () => Date;
 }): Promise<{
-    status: 'started';
+    status: 'started' | 'already-running';
     state: KtxMcpDaemonState;
     url: string;
 }>;

package/dist/managed-mcp-daemon.js

@@ -81,7 +81,18 @@ export async function startKtxMcpDaemon(options) {
     const existing = await readState(options.projectDir).catch(() => undefined);
     const processAlive = options.processAlive ?? defaultProcessAlive;
     if (existing && processAlive(existing.pid)) {
-        throw new Error(`KTX MCP daemon is already recorded at http://${existing.host}:${existing.port}/mcp`);
+        const sameConfig = existing.host === options.host &&
+            existing.port === options.port &&
+            existing.tokenAuth === Boolean(options.token);
+        if (sameConfig) {
+            return {
+                status: 'already-running',
+                state: existing,
+                url: `http://${existing.host}:${existing.port}/mcp`,
+            };
+        }
+        throw new Error(`KTX MCP daemon is already running at http://${existing.host}:${existing.port}/mcp ` +
+            'with a different configuration. Run `ktx mcp stop` first, then start again.');
     }
     const portAvailable = options.portAvailable ?? defaultPortAvailable;
     if (!(await portAvailable(options.host, options.port))) {

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

@@ -72,6 +72,64 @@ describe('managed MCP daemon lifecycle', () => {
         }));
         expect(JSON.stringify(JSON.parse(await readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')))).not.toContain('secret-token');
     });
+    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`);
+        const spawnDaemon = vi.fn(() => child(9999));
+        const result = await startKtxMcpDaemon({
+            projectDir,
+            cliVersion: '0.0.0-test',
+            host: '127.0.0.1',
+            port: 7878,
+            allowedHosts: [],
+            allowedOrigins: [],
+            binPath: '/repo/packages/cli/dist/bin.js',
+            spawnDaemon,
+            processAlive: vi.fn(() => true),
+            portAvailable: vi.fn(async () => true),
+        });
+        expect(result.status).toBe('already-running');
+        expect(result.url).toBe('http://127.0.0.1:7878/mcp');
+        expect(result.state.pid).toBe(4242);
+        expect(spawnDaemon).not.toHaveBeenCalled();
+    });
+    it('throws when the recorded daemon uses a different host or port', async () => {
+        await mkdir(join(projectDir, '.ktx'), { recursive: true });
+        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
+        const spawnDaemon = vi.fn(() => child(9999));
+        await expect(startKtxMcpDaemon({
+            projectDir,
+            cliVersion: '0.0.0-test',
+            host: '127.0.0.1',
+            port: 9000,
+            allowedHosts: [],
+            allowedOrigins: [],
+            binPath: '/repo/packages/cli/dist/bin.js',
+            spawnDaemon,
+            processAlive: vi.fn(() => true),
+            portAvailable: vi.fn(async () => true),
+        })).rejects.toThrow(/different configuration[\s\S]*ktx mcp stop/);
+        expect(spawnDaemon).not.toHaveBeenCalled();
+    });
+    it('throws when token-auth presence differs from the recorded daemon', async () => {
+        await mkdir(join(projectDir, '.ktx'), { recursive: true });
+        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir, { tokenAuth: false }), null, 2)}\n`);
+        const spawnDaemon = vi.fn(() => child(9999));
+        await expect(startKtxMcpDaemon({
+            projectDir,
+            cliVersion: '0.0.0-test',
+            host: '127.0.0.1',
+            port: 7878,
+            token: 'secret-token',
+            allowedHosts: [],
+            allowedOrigins: [],
+            binPath: '/repo/packages/cli/dist/bin.js',
+            spawnDaemon,
+            processAlive: vi.fn(() => true),
+            portAvailable: vi.fn(async () => true),
+        })).rejects.toThrow(/different configuration/);
+        expect(spawnDaemon).not.toHaveBeenCalled();
+    });
     it('reports running when the process is alive and health passes', async () => {
         await mkdir(join(projectDir, '.ktx'), { recursive: true });
         await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);

package/dist/mcp-http-server.js

@@ -1,14 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
-import { createDefaultKtxMcpServer, createLocalProjectMcpContextPorts } from '@ktx/context/mcp';
-import { createLocalProjectMemoryCapture } from '@ktx/context/memory';
 import { loadKtxProject } from '@ktx/context/project';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
-import { createKtxCliScanConnector } from './local-scan-connectors.js';
-import { createManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
-import { createManagedDaemonSqlAnalysisPort } from './managed-python-http.js';
+import { createKtxMcpServerFactory } from './mcp-server-factory.js';
 const DEFAULT_ALLOWED_HOSTS = ['localhost', '127.0.0.1', '::1'];
 function isLoopbackHost(host) {
     const normalized = normalizeHostHeader(host);
@@ -79,12 +74,6 @@ export function isMcpRequestAuthorized(request, config) {
     }
     return { ok: true };
 }
-function noopIo() {
-    return {
-        stdout: { write() { } },
-        stderr: { write() { } },
-    };
-}
 function writeJson(res, status, body) {
     const payload = `${JSON.stringify(body)}\n`;
     res.writeHead(status, {
@@ -109,47 +98,6 @@ async function readJsonBody(req) {
     const raw = Buffer.concat(chunks).toString('utf8');
     return raw.trim().length === 0 ? undefined : JSON.parse(raw);
 }
-async function defaultMcpServerFactory(input) {
-    const io = input.io ?? noopIo();
-    const queryExecutor = createKtxCliIngestQueryExecutor(input.project);
-    const semanticLayerCompute = await createManagedPythonSemanticLayerComputePort({
-        cliVersion: input.cliVersion,
-        installPolicy: 'auto',
-        io,
-    });
-    const sqlAnalysis = createManagedDaemonSqlAnalysisPort({
-        cliVersion: input.cliVersion,
-        projectDir: input.projectDir,
-        installPolicy: 'auto',
-        io,
-    });
-    const contextTools = createLocalProjectMcpContextPorts(input.project, {
-        semanticLayerCompute,
-        queryExecutor,
-        sqlAnalysis,
-        localScan: {
-            createConnector: async (connectionId) => createKtxCliScanConnector(input.project, connectionId),
-        },
-        localIngest: {
-            semanticLayerCompute,
-            queryExecutor,
-        },
-    });
-    let memoryCapture;
-    try {
-        memoryCapture = createLocalProjectMemoryCapture(input.project, { semanticLayerCompute, queryExecutor });
-    }
-    catch (error) {
-        input.io?.stderr.write(`KTX MCP memory_capture disabled: ${error instanceof Error ? error.message : String(error)}\n`);
-    }
-    return () => createDefaultKtxMcpServer({
-        name: 'ktx',
-        version: input.cliVersion,
-        userContext: { userId: 'local' },
-        contextTools,
-        memoryCapture,
-    });
-}
 function listenerPort(server, fallback) {
     const address = server.address();
     return typeof address === 'object' && address ? address.port : fallback;
@@ -171,7 +119,7 @@ export async function runKtxMcpHttpServer(options) {
         ? await (options.loadProject ?? loadKtxProject)({ projectDir: options.projectDir })
         : undefined;
     const createMcpServer = options.createMcpServer ??
-        (await defaultMcpServerFactory({
+        (await createKtxMcpServerFactory({
             project: project,
             projectDir: options.projectDir,
             cliVersion: options.cliVersion ?? '0.0.0-private',

package/dist/mcp-server-factory.d.ts

@@ -0,0 +1,9 @@
+import type { KtxLocalProject } from '@ktx/context/project';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { KtxCliIo } from './cli-runtime.js';
+export declare function createKtxMcpServerFactory(input: {
+    project: KtxLocalProject;
+    projectDir: string;
+    cliVersion: string;
+    io?: KtxCliIo;
+}): Promise<() => McpServer>;

package/dist/mcp-server-factory.js

@@ -0,0 +1,51 @@
+import { createDefaultKtxMcpServer, createLocalProjectMcpContextPorts } from '@ktx/context/mcp';
+import { createLocalProjectMemoryIngest } from '@ktx/context/memory';
+import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
+import { createKtxCliScanConnector } from './local-scan-connectors.js';
+import { createManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
+import { createManagedDaemonSqlAnalysisPort } from './managed-python-http.js';
+function noopMcpIo() {
+    return {
+        stdout: { write() { } },
+        stderr: { write() { } },
+    };
+}
+export async function createKtxMcpServerFactory(input) {
+    const io = input.io ?? noopMcpIo();
+    const queryExecutor = createKtxCliIngestQueryExecutor(input.project);
+    const semanticLayerCompute = await createManagedPythonSemanticLayerComputePort({
+        cliVersion: input.cliVersion,
+        installPolicy: 'auto',
+        io,
+    });
+    const sqlAnalysis = createManagedDaemonSqlAnalysisPort({
+        cliVersion: input.cliVersion,
+        projectDir: input.projectDir,
+        installPolicy: 'auto',
+        io,
+    });
+    const contextTools = createLocalProjectMcpContextPorts(input.project, {
+        semanticLayerCompute,
+        queryExecutor,
+        sqlAnalysis,
+        localScan: {
+            createConnector: async (connectionId) => createKtxCliScanConnector(input.project, connectionId),
+        },
+    });
+    let memoryIngest;
+    try {
+        memoryIngest = createLocalProjectMemoryIngest(input.project, { semanticLayerCompute, queryExecutor });
+    }
+    catch (error) {
+        input.io?.stderr.write(`KTX MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    return () => createDefaultKtxMcpServer({
+        name: 'ktx',
+        version: input.cliVersion,
+        userContext: { userId: 'local' },
+        contextTools: {
+            ...contextTools,
+            ...(memoryIngest ? { memoryIngest } : {}),
+        },
+    });
+}

package/dist/mcp-stdio-server.d.ts

@@ -0,0 +1,14 @@
+import type { Readable, Writable } from 'node:stream';
+import { loadKtxProject } from '@ktx/context/project';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { KtxCliIo } from './cli-runtime.js';
+export interface RunKtxMcpStdioServerOptions {
+    projectDir: string;
+    cliVersion?: string;
+    io?: KtxCliIo;
+    createMcpServer?: () => McpServer;
+    loadProject?: typeof loadKtxProject;
+    stdin?: Readable;
+    stdout?: Writable;
+}
+export declare function runKtxMcpStdioServer(options: RunKtxMcpStdioServerOptions): Promise<void>;

package/dist/mcp-stdio-server.js

@@ -0,0 +1,48 @@
+import process from 'node:process';
+import { loadKtxProject } from '@ktx/context/project';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createKtxMcpServerFactory } from './mcp-server-factory.js';
+export async function runKtxMcpStdioServer(options) {
+    const project = options.createMcpServer === undefined
+        ? await (options.loadProject ?? loadKtxProject)({ projectDir: options.projectDir })
+        : undefined;
+    const protocolIo = {
+        stdout: { write() { } },
+        stderr: options.io?.stderr ?? { write() { } },
+    };
+    const createMcpServer = options.createMcpServer ??
+        (await createKtxMcpServerFactory({
+            project: project,
+            projectDir: options.projectDir,
+            cliVersion: options.cliVersion ?? '0.0.0-private',
+            io: protocolIo,
+        }));
+    const stdin = options.stdin ?? process.stdin;
+    const transport = new StdioServerTransport(stdin, options.stdout);
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            stdin.off('end', closeTransport);
+            stdin.off('close', closeTransport);
+            callback();
+        };
+        const closeTransport = () => {
+            transport.close().catch((error) => {
+                settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+            });
+        };
+        transport.onclose = () => settle(resolve);
+        transport.onerror = (error) => {
+            options.io?.stderr.write(`KTX MCP stdio transport error: ${error.message}\n`);
+            settle(() => reject(error));
+        };
+        stdin.once('end', closeTransport);
+        stdin.once('close', closeTransport);
+        createMcpServer().connect(transport).catch((error) => {
+            settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+        });
+    });
+}

package/dist/memory-flow-tui.test.js

@@ -17,7 +17,7 @@ function replayInput() {
                 { unitKey: 'customers', target: 'sl', action: 'updated', key: 'orbit_demo.customers', summary: 'customer metrics', rawFiles: ['customers'], status: 'success' },
             ],
             provenance: [{ rawPath: 'orders', artifactKind: 'wiki', artifactKey: 'wiki/orders.md', actionType: 'wiki_written' }],
-            transcripts: [{ unitKey: 'orders', path: '/tmp/t.jsonl', toolCallCount: 2, errorCount: 0, toolNames: ['read_raw_span', 'wiki_write'] }],
+            transcripts: [{ unitKey: 'orders', path: '/tmp/t.jsonl', toolCallCount: 2, errorCount: 0, toolNames: ['read_raw_span', 'memory_ingest'] }],
         },
         events: [
             { type: 'source_acquired', adapter: 'live-database', trigger: 'manual_resync', fileCount: 2 },

package/dist/public-ingest.d.ts

@@ -75,6 +75,7 @@ export interface KtxPublicIngestDeps {
     }>;
     scanProgress?: KtxProgressPort;
     ingestProgress?: (update: KtxIngestProgressUpdate) => void;
+    runtimeIo?: KtxCliIo;
     onPhaseStart?: (phaseKey: KtxPublicIngestPhaseKey) => void;
     onPhaseEnd?: (phaseKey: KtxPublicIngestPhaseKey, status: 'done' | 'failed' | 'skipped', summary?: string) => void;
 }

package/dist/public-ingest.js

@@ -434,10 +434,12 @@ export async function executePublicIngestTarget(target, args, io, deps) {
         const runScan = deps.runScan ?? runKtxScan;
         const capturedScanIo = deps.scanProgress ? null : createCapturedPublicIngestIo();
         const scanIo = capturedScanIo ?? io;
+        const scanDeps = {
+            ...(deps.scanProgress ? { progress: deps.scanProgress } : {}),
+            ...(deps.runtimeIo ? { runtimeIo: deps.runtimeIo } : {}),
+        };
         deps.onPhaseStart?.('database-schema');
-        const scanExitCode = deps.scanProgress
-            ? await runScan(scanArgs, scanIo, { progress: deps.scanProgress })
-            : await runScan(scanArgs, scanIo);
+        const scanExitCode = Object.keys(scanDeps).length > 0 ? await runScan(scanArgs, scanIo, scanDeps) : await runScan(scanArgs, scanIo);
         if (scanExitCode !== 0) {
             deps.onPhaseEnd?.('database-schema', 'failed');
             if (target.queryHistory?.enabled === true) {
@@ -466,9 +468,13 @@ export async function executePublicIngestTarget(target, args, io, deps) {
             };
             const capturedIngestIo = deps.ingestProgress ? null : createCapturedPublicIngestIo();
             const ingestIo = capturedIngestIo ?? io;
+            const ingestDeps = {
+                ...(deps.ingestProgress ? { progress: deps.ingestProgress } : {}),
+                ...(deps.runtimeIo ? { runtimeIo: deps.runtimeIo } : {}),
+            };
             deps.onPhaseStart?.('query-history');
-            const qhExitCode = deps.ingestProgress
-                ? await runIngest(ingestArgs, ingestIo, { progress: deps.ingestProgress })
+            const qhExitCode = Object.keys(ingestDeps).length > 0
+                ? await runIngest(ingestArgs, ingestIo, ingestDeps)
                 : await runIngest(ingestArgs, ingestIo);
             if (qhExitCode !== 0) {
                 deps.onPhaseEnd?.('query-history', 'failed');
@@ -494,9 +500,13 @@ export async function executePublicIngestTarget(target, args, io, deps) {
     const runIngest = deps.runIngest ?? runKtxIngest;
     const capturedIngestIo = deps.ingestProgress ? null : createCapturedPublicIngestIo();
     const ingestIo = capturedIngestIo ?? io;
+    const ingestDeps = {
+        ...(deps.ingestProgress ? { progress: deps.ingestProgress } : {}),
+        ...(deps.runtimeIo ? { runtimeIo: deps.runtimeIo } : {}),
+    };
     deps.onPhaseStart?.('source-ingest');
-    const exitCode = deps.ingestProgress
-        ? await runIngest(ingestArgs, ingestIo, { progress: deps.ingestProgress })
+    const exitCode = Object.keys(ingestDeps).length > 0
+        ? await runIngest(ingestArgs, ingestIo, ingestDeps)
         : await runIngest(ingestArgs, ingestIo);
     deps.onPhaseEnd?.('source-ingest', exitCode === 0 ? 'done' : 'failed');
     return markTargetResult(target, args, exitCode === 0 ? 'done' : 'failed', 'source-ingest', capturedIngestIo ? firstCapturedFailureLine(capturedIngestIo.capturedOutput()) : undefined);