@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/dist/setup-embeddings.test.js

@@ -145,9 +145,25 @@ describe('setup embeddings step', () => {
         expect(config.scan.enrichment.embeddings).toMatchObject(config.ingest.embeddings);
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
         expect((await readKtxSetupState(tempDir)).completed_steps).toContain('embeddings');
-        expect(spinnerEvents).toContainEqual('start:Testing local sentence-transformers embeddings (all-MiniLM-L6-v2, 384 dimensions). First run may take up to 60 seconds.');
+        expect(spinnerEvents).toContainEqual('start:Testing local embeddings (all-MiniLM-L6-v2)');
         expect(io.stdout()).toContain('Embeddings ready: yes');
     });
+    it('uses a short non-animated local embeddings health-check status by default', async () => {
+        const io = makeIo();
+        const healthCheck = vi.fn(async () => ({ ok: true }));
+        const prompts = makePromptAdapter({ selectValues: ['sentence-transformers'] });
+        const result = await runKtxSetupEmbeddingsStep({
+            projectDir: tempDir,
+            inputMode: 'auto',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+            skipEmbeddings: false,
+        }, io.io, { prompts, env: {}, healthCheck, ensureLocalEmbeddings: vi.fn(async () => managedDaemon()) });
+        expect(result.status).toBe('ready');
+        expect(io.stderr()).toContain('Testing local embeddings (all-MiniLM-L6-v2)');
+        expect(io.stderr()).not.toContain('First run may take up to 60 seconds');
+        expect(io.stderr().match(/Testing local embeddings/g)).toHaveLength(1);
+    });
     it('shows live progress while local sentence-transformers embeddings are being tested', async () => {
         const io = makeIo();
         const prompts = makePromptAdapter({ selectValues: ['sentence-transformers'] });
@@ -170,7 +186,7 @@ describe('setup embeddings step', () => {
             skipEmbeddings: false,
         }, io.io, { prompts, env: {}, healthCheck, ensureLocalEmbeddings: vi.fn(async () => managedDaemon()), spinner });
         await vi.waitFor(() => {
-            expect(spinnerEvents).toContainEqual('start:Testing local sentence-transformers embeddings (all-MiniLM-L6-v2, 384 dimensions). First run may take up to 60 seconds.');
+            expect(spinnerEvents).toContainEqual('start:Testing local embeddings (all-MiniLM-L6-v2)');
         });
         expect(resolveHealthCheck).toBeDefined();
         resolveHealthCheck?.({ ok: true });

package/dist/setup-models.js

@@ -335,9 +335,9 @@ async function chooseBackend(args, io, deps) {
     const choice = await prompts.select({
         message: 'Which LLM provider should KTX use?',
         options: [
-            { value: 'anthropic', label: 'Anthropic API' },
+            { value: 'claude-code', label: 'Claude subscription (Pro/Max)' },
+            { value: 'anthropic', label: 'Anthropic API key' },
             { value: 'vertex', label: 'Google Vertex AI for Anthropic Claude' },
-            { value: 'claude-code', label: 'Local Claude Code session' },
             { value: 'back', label: 'Back' },
         ],
     });

package/dist/setup-models.test.js

@@ -120,16 +120,18 @@ describe('setup Anthropic model step', () => {
             ],
         }));
     });
-    it('offers Vertex AI as an Anthropic model provider option', async () => {
+    it('offers Anthropic provider paths in the preferred order', async () => {
         const prompts = makePromptAdapter({ providerChoice: 'back' });
         const result = await runKtxSetupAnthropicModelStep({ projectDir: tempDir, inputMode: 'auto', skipLlm: false }, makeIo().io, { prompts, env: {} });
         expect(result.status).toBe('back');
         expect(prompts.select).toHaveBeenCalledWith(expect.objectContaining({
             message: expect.stringContaining('Which LLM provider should KTX use?'),
-            options: expect.arrayContaining([
+            options: [
+                { value: 'claude-code', label: 'Claude subscription (Pro/Max)' },
+                { value: 'anthropic', label: 'Anthropic API key' },
                 { value: 'vertex', label: 'Google Vertex AI for Anthropic Claude' },
                 { value: 'back', label: 'Back' },
-            ]),
+            ],
         }));
     });
     it('configures Claude Code backend and validates local auth', async () => {

package/dist/setup-ready-menu.d.ts

@@ -1,6 +1,6 @@
 import { type KtxSetupPromptOption } from './setup-prompts.js';
 import type { KtxSetupStatus } from './setup.js';
-export type KtxSetupReadyAction = 'models' | 'embeddings' | 'databases' | 'sources' | 'context' | 'agents' | 'exit';
+export type KtxSetupReadyAction = 'models' | 'embeddings' | 'databases' | 'sources' | 'runtime' | 'context' | 'agents' | 'exit';
 export interface KtxSetupReadyMenuPromptAdapter {
     select(options: {
         message: string;

package/dist/setup-ready-menu.js

@@ -5,6 +5,7 @@ export function isKtxPreAgentSetupReady(status) {
         status.embeddings.ready &&
         status.databases.every((database) => database.ready) &&
         status.sources.every((source) => source.ready) &&
+        status.runtime.ready &&
         status.context.ready);
 }
 export function isKtxSetupReady(status) {
@@ -22,6 +23,7 @@ export async function runKtxSetupReadyChangeMenu(status, deps = {}) {
             { value: 'embeddings', label: 'Embeddings' },
             { value: 'databases', label: 'Databases' },
             { value: 'sources', label: 'Context sources' },
+            ...(status.runtime.required ? [{ value: 'runtime', label: 'Runtime' }] : []),
             { value: 'context', label: 'Rebuild KTX context' },
             { value: 'agents', label: 'Agent integration' },
             { value: 'exit', label: 'Exit' },

package/dist/setup-ready-menu.test.js

@@ -6,6 +6,7 @@ const readyStatus = {
     embeddings: { backend: 'openai', ready: true, model: 'text-embedding-3-small', dimensions: 1536 },
     databases: [{ connectionId: 'warehouse', ready: true }],
     sources: [],
+    runtime: { required: false, ready: true, features: [] },
     context: { ready: true, status: 'completed' },
     agents: [{ target: 'codex', scope: 'project', ready: true }],
 };
@@ -13,6 +14,7 @@ describe('setup ready menu', () => {
     it('recognizes a ready setup only when required sections are ready', () => {
         expect(isKtxSetupReady(readyStatus)).toBe(true);
         expect(isKtxSetupReady({ ...readyStatus, embeddings: { ready: false } })).toBe(false);
+        expect(isKtxSetupReady({ ...readyStatus, runtime: { required: true, ready: false, features: ['core'] } })).toBe(false);
         expect(isKtxSetupReady({ ...readyStatus, context: { ready: false, status: 'not_started' } })).toBe(false);
         expect(isKtxSetupReady({ ...readyStatus, agents: [] })).toBe(false);
     });
@@ -20,6 +22,7 @@ describe('setup ready menu', () => {
         expect(isKtxPreAgentSetupReady(readyStatus)).toBe(true);
         expect(isKtxPreAgentSetupReady({ ...readyStatus, agents: [] })).toBe(true);
         expect(isKtxPreAgentSetupReady({ ...readyStatus, embeddings: { ready: false } })).toBe(false);
+        expect(isKtxPreAgentSetupReady({ ...readyStatus, runtime: { required: true, ready: false, features: ['core'] } })).toBe(false);
         expect(isKtxPreAgentSetupReady({ ...readyStatus, context: { ready: false, status: 'not_started' } })).toBe(false);
     });
     it('maps ready-project menu choices to setup sections', async () => {

package/dist/setup-runtime.d.ts

@@ -0,0 +1,45 @@
+import { type KtxLocalProject } from '@ktx/context/project';
+import type { KtxCliIo } from './cli-runtime.js';
+import { type ManagedLocalEmbeddingsDaemon } from './managed-local-embeddings.js';
+import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime } from './managed-python-command.js';
+import type { KtxRuntimeFeature } from './managed-python-runtime.js';
+import { type KtxRuntimeRequirements } from './runtime-requirements.js';
+export interface KtxSetupRuntimeArgs {
+    projectDir: string;
+    inputMode: 'auto' | 'disabled';
+    cliVersion: string;
+    runtimeInstallPolicy: KtxManagedPythonInstallPolicy;
+    databaseIntrospectionFallback?: boolean;
+}
+export type KtxSetupRuntimeResult = {
+    status: 'ready';
+    projectDir: string;
+    requirements: KtxRuntimeRequirements;
+} | {
+    status: 'skipped';
+    projectDir: string;
+    requirements: KtxRuntimeRequirements;
+} | {
+    status: 'failed';
+    projectDir: string;
+    requirements: KtxRuntimeRequirements;
+};
+export interface KtxSetupRuntimeDeps {
+    env?: NodeJS.ProcessEnv;
+    loadProject?: (options: {
+        projectDir: string;
+    }) => Promise<Pick<KtxLocalProject, 'config'>>;
+    ensureRuntime?: (options: {
+        cliVersion: string;
+        installPolicy: KtxManagedPythonInstallPolicy;
+        io: KtxCliIo;
+        feature: KtxRuntimeFeature;
+    }) => Promise<ManagedPythonCommandRuntime>;
+    ensureLocalEmbeddings?: (options: {
+        cliVersion: string;
+        projectDir: string;
+        installPolicy: KtxManagedPythonInstallPolicy;
+        io: KtxCliIo;
+    }) => Promise<ManagedLocalEmbeddingsDaemon>;
+}
+export declare function runKtxSetupRuntimeStep(args: KtxSetupRuntimeArgs, io: KtxCliIo, deps?: KtxSetupRuntimeDeps): Promise<KtxSetupRuntimeResult>;

package/dist/setup-runtime.js

@@ -0,0 +1,47 @@
+import { loadKtxProject, markKtxSetupStateStepComplete, } from '@ktx/context/project';
+import { ensureManagedLocalEmbeddingsDaemon, } from './managed-local-embeddings.js';
+import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
+import { resolveProjectRuntimeRequirements, } from './runtime-requirements.js';
+function formatRuntimeFeature(feature) {
+    return feature === 'local-embeddings' ? 'local embeddings' : 'core';
+}
+export async function runKtxSetupRuntimeStep(args, io, deps = {}) {
+    const loadProjectForRuntime = deps.loadProject ?? loadKtxProject;
+    const project = await loadProjectForRuntime({ projectDir: args.projectDir });
+    const requirements = resolveProjectRuntimeRequirements(project.config, {
+        databaseIntrospectionFallback: args.databaseIntrospectionFallback,
+        env: deps.env ?? process.env,
+    });
+    if (requirements.features.length === 0) {
+        io.stdout.write('│  Runtime setup skipped.\n');
+        return { status: 'skipped', projectDir: args.projectDir, requirements };
+    }
+    const ensureRuntime = deps.ensureRuntime ?? ensureManagedPythonCommandRuntime;
+    const ensureLocalEmbeddings = deps.ensureLocalEmbeddings ?? ensureManagedLocalEmbeddingsDaemon;
+    try {
+        for (const feature of requirements.features) {
+            if (feature === 'local-embeddings') {
+                await ensureLocalEmbeddings({
+                    cliVersion: args.cliVersion,
+                    projectDir: args.projectDir,
+                    installPolicy: args.runtimeInstallPolicy,
+                    io,
+                });
+                continue;
+            }
+            await ensureRuntime({
+                cliVersion: args.cliVersion,
+                installPolicy: args.runtimeInstallPolicy,
+                io,
+                feature,
+            });
+        }
+    }
+    catch (error) {
+        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return { status: 'failed', projectDir: args.projectDir, requirements };
+    }
+    await markKtxSetupStateStepComplete(args.projectDir, 'runtime');
+    io.stdout.write(`│  Runtime ready: yes (${requirements.features.map(formatRuntimeFeature).join(', ')})\n`);
+    return { status: 'ready', projectDir: args.projectDir, requirements };
+}

package/dist/setup-runtime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup-runtime.test.js

@@ -0,0 +1,110 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
+import { buildDefaultKtxProjectConfig, readKtxSetupState } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runKtxSetupRuntimeStep } from './setup-runtime.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function projectConfig(config) {
+    return vi.fn(async () => ({ config }));
+}
+describe('runKtxSetupRuntimeStep', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-runtime-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('skips runtime setup when the project has no direct runtime requirements', async () => {
+        const io = makeIo();
+        const ensureRuntime = vi.fn();
+        await expect(runKtxSetupRuntimeStep({
+            projectDir: tempDir,
+            inputMode: 'auto',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'prompt',
+        }, io.io, {
+            loadProject: projectConfig(buildDefaultKtxProjectConfig()),
+            ensureRuntime,
+            env: {},
+        })).resolves.toMatchObject({ status: 'skipped' });
+        expect(ensureRuntime).not.toHaveBeenCalled();
+        expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
+        expect(io.stdout()).toContain('Runtime setup skipped.');
+    });
+    it('fails fast when required runtime features cannot be installed in no-input mode', async () => {
+        const io = makeIo();
+        const ensureRuntime = vi.fn(async () => {
+            throw new Error('KTX Python runtime is required for this command. Run: ktx dev runtime install --yes');
+        });
+        await expect(runKtxSetupRuntimeStep({
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'never',
+            databaseIntrospectionFallback: true,
+        }, io.io, {
+            loadProject: projectConfig(buildDefaultKtxProjectConfig()),
+            ensureRuntime,
+            env: {},
+        })).resolves.toMatchObject({ status: 'failed' });
+        expect(ensureRuntime).toHaveBeenCalledWith(expect.objectContaining({ installPolicy: 'never' }));
+        expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
+        expect(io.stderr()).toContain('ktx dev runtime install --yes');
+    });
+    it('starts the managed local embeddings daemon for configured sentence-transformers embeddings', async () => {
+        const io = makeIo();
+        const ensureLocalEmbeddings = vi.fn(async () => ({
+            baseUrl: 'http://127.0.0.1:61234',
+            env: { KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL: 'http://127.0.0.1:61234' },
+        }));
+        const config = {
+            ...buildDefaultKtxProjectConfig(),
+            ingest: {
+                ...buildDefaultKtxProjectConfig().ingest,
+                embeddings: {
+                    backend: 'sentence-transformers',
+                    model: 'all-MiniLM-L6-v2',
+                    dimensions: 384,
+                    sentenceTransformers: { base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL },
+                },
+            },
+        };
+        await expect(runKtxSetupRuntimeStep({
+            projectDir: tempDir,
+            inputMode: 'auto',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+        }, io.io, {
+            loadProject: projectConfig(config),
+            ensureLocalEmbeddings,
+            env: {},
+        })).resolves.toMatchObject({ status: 'ready' });
+        expect(ensureLocalEmbeddings).toHaveBeenCalledWith(expect.objectContaining({
+            projectDir: tempDir,
+            installPolicy: 'auto',
+        }));
+        expect(io.stdout()).toContain('Runtime ready: yes (local embeddings)');
+    });
+});

package/dist/setup-sources-notion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup-sources-notion.test.js

@@ -0,0 +1,107 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initKtxProject, parseKtxProjectConfig, serializeKtxProjectConfig, } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runKtxSetupSourcesStep, } from './setup-sources.js';
+const notionMocks = vi.hoisted(() => ({
+    tokens: [],
+    retrieveBotUser: vi.fn(async () => ({ name: 'Docs Bot' })),
+    retrievePage: vi.fn(async () => ({ id: 'page-1' })),
+}));
+vi.mock('@ktx/context/ingest', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        NotionClient: vi.fn().mockImplementation(function NotionClient(token) {
+            notionMocks.tokens.push(token);
+            return {
+                retrieveBotUser: notionMocks.retrieveBotUser,
+                retrievePage: notionMocks.retrievePage,
+            };
+        }),
+    };
+});
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                isTTY: true,
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function prompts(values) {
+    const multiselectValues = [...(values.multiselect ?? [])];
+    const selectValues = [...(values.select ?? [])];
+    return {
+        multiselect: vi.fn(async () => multiselectValues.shift() ?? []),
+        select: vi.fn(async () => selectValues.shift() ?? 'back'),
+        text: vi.fn(async () => ''),
+        password: vi.fn(async () => undefined),
+        cancel: vi.fn(),
+        log: vi.fn(),
+    };
+}
+describe('setup sources Notion validation', () => {
+    let tempDir;
+    let projectDir;
+    beforeEach(async () => {
+        notionMocks.tokens.length = 0;
+        notionMocks.retrieveBotUser.mockClear();
+        notionMocks.retrievePage.mockClear();
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-sources-notion-'));
+        projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    async function readConfig() {
+        return parseKtxProjectConfig(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8'));
+    }
+    async function writeConfigConnection(connectionId, connection) {
+        const config = await readConfig();
+        await writeFile(join(projectDir, 'ktx.yaml'), serializeKtxProjectConfig({
+            ...config,
+            connections: {
+                ...config.connections,
+                warehouse: { driver: 'postgres', url: 'env:DATABASE_URL' },
+                [connectionId]: connection,
+            },
+            setup: {
+                ...config.setup,
+                database_connection_ids: ['warehouse'],
+            },
+        }), 'utf-8');
+    }
+    it('validates an existing Notion source that uses an inline auth token', async () => {
+        await writeConfigConnection('notion', {
+            driver: 'notion',
+            auth_token: 'ntn_inline_token',
+            crawl_mode: 'all_accessible',
+        });
+        const io = makeIo();
+        await expect(runKtxSetupSourcesStep({ projectDir, inputMode: 'auto', runInitialSourceIngest: false, skipSources: false }, io.io, {
+            prompts: prompts({
+                multiselect: [['notion']],
+                select: ['existing:notion'],
+            }),
+        })).resolves.toEqual({ status: 'ready', projectDir, connectionIds: ['notion'] });
+        expect(notionMocks.tokens).toEqual(['ntn_inline_token']);
+        expect(notionMocks.retrieveBotUser).toHaveBeenCalledOnce();
+        expect(io.stderr()).toBe('');
+    });
+});

package/dist/setup-sources.js

@@ -2,7 +2,7 @@ import { mkdtemp, readdir, readFile, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { localConnectionTypeForConfig, resolveNotionAuthToken } from '@ktx/context/connections';
+import { localConnectionTypeForConfig, resolveNotionConnectionAuthToken, } from '@ktx/context/connections';
 import { resolveKtxConfigReference } from '@ktx/context/core';
 import { cloneOrPull, DEFAULT_METABASE_CLIENT_CONFIG, discoverMetabaseDatabases, loadDbtSchemaFiles, loadProjectInfo, MetabaseClient, NotionClient, parseLookmlStagedDir, parseMetricflowFiles, testRepoConnection, } from '@ktx/context/ingest';
 import { loadKtxProject, markKtxSetupStateStepComplete, serializeKtxProjectConfig, } from '@ktx/context/project';
@@ -467,7 +467,10 @@ async function defaultValidateLookml(connection) {
     return count > 0 ? { ok: true, detail: `lookmlFiles=${count}` } : { ok: false, message: 'No LookML files found' };
 }
 async function defaultValidateNotion(connection) {
-    const token = await resolveNotionAuthToken(String(connection.auth_token_ref));
+    const token = await resolveNotionConnectionAuthToken({
+        auth_token: stringField(connection.auth_token) ?? null,
+        auth_token_ref: stringField(connection.auth_token_ref) ?? null,
+    });
     const client = new NotionClient(token);
     await client.retrieveBotUser();
     const roots = Array.isArray(connection.root_page_ids)

package/dist/setup.d.ts

@@ -1,4 +1,5 @@
 import type { KtxCliIo } from './cli-runtime.js';
+import { readManagedPythonRuntimeStatus } from './managed-python-runtime.js';
 import { type KtxAgentScope, type KtxAgentTarget, type KtxSetupAgentsDeps, runKtxSetupAgentsStep } from './setup-agents.js';
 import { type KtxSetupDatabaseDriver, type KtxSetupDatabasesDeps, runKtxSetupDatabasesStep } from './setup-databases.js';
 import { type KtxSetupEmbeddingsDeps, runKtxSetupEmbeddingsStep } from './setup-embeddings.js';
@@ -6,6 +7,7 @@ import { type KtxSetupLlmBackend, type KtxSetupModelDeps, runKtxSetupAnthropicMo
 import { type KtxSetupProjectDeps } from './setup-project.js';
 import { type KtxSetupReadyMenuDeps } from './setup-ready-menu.js';
 import { type KtxSetupSourcesDeps, type KtxSetupSourceType, runKtxSetupSourcesStep } from './setup-sources.js';
+import { type KtxSetupRuntimeDeps, type KtxSetupRuntimeResult, runKtxSetupRuntimeStep } from './setup-runtime.js';
 import { type KtxSetupPromptOption, type KtxSetupUiAdapter } from './setup-prompts.js';
 import { type KtxSetupContextDeps, type KtxSetupContextResult, runKtxSetupContextStep, type KtxSetupContextStatusSummary } from './setup-context.js';
 export interface KtxSetupStatus {
@@ -34,6 +36,12 @@ export interface KtxSetupStatus {
         type: string;
         ready: boolean;
     }>;
+    runtime: {
+        required: boolean;
+        ready: boolean;
+        features: string[];
+        detail?: string;
+    };
     context: KtxSetupContextStatusSummary;
     agents: Array<{
         target: string;
@@ -108,6 +116,8 @@ export interface KtxSetupDeps {
     databasesDeps?: KtxSetupDatabasesDeps;
     sources?: (args: Parameters<typeof runKtxSetupSourcesStep>[0], io: KtxCliIo) => Promise<Awaited<ReturnType<typeof runKtxSetupSourcesStep>>>;
     sourcesDeps?: KtxSetupSourcesDeps;
+    runtime?: (args: Parameters<typeof runKtxSetupRuntimeStep>[0], io: KtxCliIo) => Promise<KtxSetupRuntimeResult>;
+    runtimeDeps?: KtxSetupRuntimeDeps;
     agents?: (args: Parameters<typeof runKtxSetupAgentsStep>[0], io: KtxCliIo) => Promise<Awaited<ReturnType<typeof runKtxSetupAgentsStep>>>;
     agentsDeps?: KtxSetupAgentsDeps;
     context?: (args: Parameters<typeof runKtxSetupContextStep>[0], io: KtxCliIo) => Promise<KtxSetupContextResult>;
@@ -126,6 +136,14 @@ export interface KtxSetupEntryMenuPromptAdapter {
 export interface KtxSetupEntryMenuDeps {
     prompts?: KtxSetupEntryMenuPromptAdapter;
 }
-export declare function readKtxSetupStatus(projectDir: string): Promise<KtxSetupStatus>;
+export interface ReadKtxSetupStatusOptions {
+    cliVersion?: string;
+    env?: NodeJS.ProcessEnv;
+    readRuntimeStatus?: typeof readManagedPythonRuntimeStatus;
+}
+export declare function readKtxSetupStatus(projectDir: string, options?: ReadKtxSetupStatusOptions): Promise<KtxSetupStatus>;
 export declare function formatKtxSetupStatus(status: KtxSetupStatus): string;
+export declare function formatKtxSetupCompletionSummary(status: KtxSetupStatus, options?: {
+    agentNextActions?: string;
+}): string;
 export declare function runKtxSetup(args: KtxSetupArgs, io: KtxCliIo, deps?: KtxSetupDeps): Promise<number>;