@kaelio/ktx 0.1.0-rc.6 → 0.1.1

package/dist/managed-python-runtime.js

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
+import { strFromU8, unzipSync } from 'fflate';
 import { z } from 'zod';
 const execFileAsync = promisify(execFile);
 export const runtimeFeatureSchema = z.enum(['core', 'local-embeddings']);
@@ -100,6 +101,35 @@ async function readJsonFile(path) {
 function isErrnoException(error, code) {
     return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
 }
+function parseRequiresPythonFromWheel(input) {
+    let files;
+    try {
+        files = unzipSync(new Uint8Array(input.contents));
+    }
+    catch (error) {
+        throw new Error(`Unable to read bundled Python runtime wheel metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const metadataEntry = Object.entries(files).find(([path]) => path.endsWith('.dist-info/METADATA'));
+    if (!metadataEntry) {
+        throw new Error(`Bundled Python runtime wheel metadata is missing: ${input.wheelPath}`);
+    }
+    const metadata = strFromU8(metadataEntry[1]);
+    const requiresPython = metadata
+        .split(/\r?\n/)
+        .map((line) => line.match(/^Requires-Python:\s*(.+)\s*$/i)?.[1]?.trim())
+        .find((value) => typeof value === 'string' && value.length > 0);
+    if (!requiresPython) {
+        throw new Error('Bundled Python runtime wheel metadata is missing Requires-Python');
+    }
+    const minimumMatch = requiresPython.match(/(?:^|[,\s])>=\s*([0-9]+)\.([0-9]+)(?:\.[0-9]+)?\b/);
+    if (!minimumMatch) {
+        throw new Error(`Unsupported bundled Python runtime Requires-Python: ${requiresPython}`);
+    }
+    return {
+        specifier: requiresPython,
+        minimumVersion: `${minimumMatch[1]}.${minimumMatch[2]}`,
+    };
+}
 export async function verifyRuntimeAsset(input) {
     const manifestPath = join(input.assetDir, 'manifest.json');
     let manifestData;
@@ -124,7 +154,7 @@ export async function verifyRuntimeAsset(input) {
     if (sha256 !== manifest.wheel.sha256 || wheel.byteLength !== manifest.wheel.bytes) {
         throw new Error(`Bundled Python runtime wheel checksum mismatch: ${wheelPath}`);
     }
-    return { manifest, wheelPath };
+    return { manifest, wheelPath, requiresPython: parseRequiresPythonFromWheel({ wheelPath, contents: wheel }) };
 }
 function normalizeFeatures(features) {
     const requested = new Set(['core', ...features]);
@@ -155,6 +185,13 @@ function errorOutput(error) {
         stderr: typeof value.stderr === 'string' ? value.stderr : '',
     };
 }
+function installFailureMessage(input) {
+    const output = [input.stderr.trim(), input.stdout.trim()].filter((part) => part.length > 0).join('\n');
+    if (!output) {
+        return `Python runtime install failed. Install log: ${input.logPath}`;
+    }
+    return `Python runtime install failed.\n${output}\nInstall log: ${input.logPath}`;
+}
 async function runLogged(input) {
     await appendFile(input.logPath, `$ ${input.command} ${input.args.join(' ')}\n`);
     try {
@@ -175,7 +212,7 @@ async function runLogged(input) {
         if (output.stderr) {
             await appendFile(input.logPath, output.stderr.endsWith('\n') ? output.stderr : `${output.stderr}\n`);
         }
-        throw new Error(`Python runtime install failed. Install log: ${input.logPath}`);
+        throw new Error(installFailureMessage({ logPath: input.logPath, stdout: output.stdout, stderr: output.stderr }));
     }
 }
 function managedRuntimeUvEnv(baseEnv) {
@@ -214,7 +251,14 @@ export async function installManagedPythonRuntime(options) {
         exec,
         logPath: layout.installLogPath,
         command: 'uv',
-        args: ['venv', layout.venvDir],
+        args: ['python', 'install', asset.requiresPython.minimumVersion],
+        env: uvEnv,
+    });
+    await runLogged({
+        exec,
+        logPath: layout.installLogPath,
+        command: 'uv',
+        args: ['venv', '--python', asset.requiresPython.minimumVersion, layout.venvDir],
         env: uvEnv,
     });
     const wheelSpec = features.includes('local-embeddings') ? `${asset.wheelPath}[local-embeddings]` : asset.wheelPath;

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

@@ -2,12 +2,28 @@ import { createHash } from 'node:crypto';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { strToU8, zipSync } from 'fflate';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MISSING_UV_RUNTIME_INSTALL_MESSAGE, doctorManagedPythonRuntime, installManagedPythonRuntime, managedPythonDaemonLayout, managedPythonRuntimeLayout, readManagedPythonRuntimeStatus, verifyRuntimeAsset, } from './managed-python-runtime.js';
-async function writeAsset(root, contents = 'wheel-bytes') {
+function runtimeWheelContents(input = {}) {
+    const label = input.label ?? 'runtime-wheel';
+    const requiresPython = input.requiresPython === null ? [] : [`Requires-Python: ${input.requiresPython ?? '>=3.13'}`];
+    return Buffer.from(zipSync({
+        'kaelio_ktx-0.1.0.dist-info/METADATA': strToU8([
+            'Metadata-Version: 2.4',
+            'Name: kaelio-ktx',
+            'Version: 0.1.0',
+            ...requiresPython,
+            `Summary: ${label}`,
+            '',
+        ].join('\n')),
+    }));
+}
+async function writeAsset(root, options = {}) {
     const assetDir = join(root, 'assets', 'python');
     await mkdir(assetDir, { recursive: true });
     const wheelPath = join(assetDir, 'kaelio_ktx-0.1.0-py3-none-any.whl');
+    const contents = options.contents ?? runtimeWheelContents(options);
     await writeFile(wheelPath, contents);
     await writeFile(join(assetDir, 'manifest.json'), `${JSON.stringify({
         schemaVersion: 1,
@@ -17,7 +33,7 @@ async function writeAsset(root, contents = 'wheel-bytes') {
         wheel: {
             file: 'kaelio_ktx-0.1.0-py3-none-any.whl',
             sha256: createHash('sha256').update(contents).digest('hex'),
-            bytes: Buffer.byteLength(contents),
+            bytes: contents.byteLength,
         },
     }, null, 2)}\n`);
     return { assetDir, wheelPath };
@@ -112,19 +128,20 @@ describe('verifyRuntimeAsset', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('reads the manifest and verifies the wheel checksum', async () => {
-        const { assetDir, wheelPath } = await writeAsset(tempDir, 'valid-wheel');
+        const { assetDir, wheelPath } = await writeAsset(tempDir, { label: 'valid-wheel' });
         const asset = await verifyRuntimeAsset({ assetDir });
         expect(asset.manifest.distributionName).toBe('kaelio-ktx');
         expect(asset.manifest.normalizedName).toBe('kaelio_ktx');
         expect(asset.wheelPath).toBe(wheelPath);
+        expect(asset.requiresPython).toEqual({ specifier: '>=3.13', minimumVersion: '3.13' });
     });
     it('rejects a wheel whose checksum does not match the manifest', async () => {
-        const { assetDir, wheelPath } = await writeAsset(tempDir, 'original');
+        const { assetDir, wheelPath } = await writeAsset(tempDir, { label: 'original' });
         await writeFile(wheelPath, 'tampered');
         await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Bundled Python runtime wheel checksum mismatch/);
     });
     it('rejects an unsafe wheel filename in the manifest', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'valid-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'valid-wheel' });
         await writeFile(join(assetDir, 'manifest.json'), `${JSON.stringify({
             schemaVersion: 1,
             distributionName: 'kaelio-ktx',
@@ -142,6 +159,14 @@ describe('verifyRuntimeAsset', () => {
         const assetDir = join(tempDir, 'packages', 'cli', 'assets', 'python');
         await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Missing bundled Python runtime manifest.*pnpm run artifacts:build/s);
     });
+    it('rejects a bundled wheel without Requires-Python metadata', async () => {
+        const { assetDir } = await writeAsset(tempDir, { requiresPython: null });
+        await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Bundled Python runtime wheel metadata is missing Requires-Python/);
+    });
+    it('rejects a bundled wheel without a supported minimum Python version', async () => {
+        const { assetDir } = await writeAsset(tempDir, { requiresPython: '<4' });
+        await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Unsupported bundled Python runtime Requires-Python: <4/);
+    });
 });
 describe('installManagedPythonRuntime', () => {
     let tempDir;
@@ -152,7 +177,7 @@ describe('installManagedPythonRuntime', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('creates a venv, installs the core wheel, and writes a manifest', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -168,7 +193,8 @@ describe('installManagedPythonRuntime', () => {
         expect(result.status).toBe('installed');
         expect(commands).toEqual([
             { command: 'uv', args: ['--version'] },
-            { command: 'uv', args: ['venv', result.layout.venvDir] },
+            { command: 'uv', args: ['python', 'install', '3.13'] },
+            { command: 'uv', args: ['venv', '--python', '3.13', result.layout.venvDir] },
             {
                 command: 'uv',
                 args: ['pip', 'install', '--python', result.layout.pythonPath, result.asset.wheelPath],
@@ -181,7 +207,7 @@ describe('installManagedPythonRuntime', () => {
         expect(manifest.python.daemonExecutable).toBe(result.layout.daemonPath);
     });
     it('disables repo uv config for managed runtime uv commands', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args, options) => {
             commands.push({ command, args, env: options?.env });
@@ -197,12 +223,13 @@ describe('installManagedPythonRuntime', () => {
         });
         expect(commands.map((call) => [call.command, call.args[0], call.env?.UV_NO_CONFIG, call.env?.PATH])).toEqual([
             ['uv', '--version', '1', '/opt/homebrew/bin'],
+            ['uv', 'python', '1', '/opt/homebrew/bin'],
             ['uv', 'venv', '1', '/opt/homebrew/bin'],
             ['uv', 'pip', '1', '/opt/homebrew/bin'],
         ]);
     });
     it('installs the local-embeddings extra when requested', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'embedding-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'embedding-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -223,7 +250,7 @@ describe('installManagedPythonRuntime', () => {
         expect(manifest.features).toEqual(['core', 'local-embeddings']);
     });
     it('fails with the hard-prerequisite message when uv is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -239,7 +266,7 @@ describe('installManagedPythonRuntime', () => {
         expect(commands).toEqual([{ command: 'uv', args: ['--version'] }]);
     });
     it('reuses an existing compatible runtime when force is false', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -262,13 +289,16 @@ describe('installManagedPythonRuntime', () => {
             exec,
         });
         expect(second.status).toBe('ready');
-        expect(exec).toHaveBeenCalledTimes(3);
+        expect(exec).toHaveBeenCalledTimes(4);
     });
     it('keeps failed install logs in the versioned runtime directory', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => {
             if (command === 'uv' && args[0] === 'venv') {
-                throw Object.assign(new Error('uv venv failed'), { stdout: 'creating\n', stderr: 'bad python\n' });
+                throw Object.assign(new Error('uv venv failed'), {
+                    stdout: 'creating\n',
+                    stderr: '× No solution found\n╰─▶ current Python version (3.12.3) does not satisfy Python>=3.13\n',
+                });
             }
             return { stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '', stderr: '' };
         });
@@ -278,10 +308,10 @@ describe('installManagedPythonRuntime', () => {
             assetDir,
             features: ['core'],
             exec,
-        })).rejects.toThrow(/Python runtime install failed/);
+        })).rejects.toThrow(/current Python version \(3\.12\.3\) does not satisfy Python>=3\.13/);
         const log = await readFile(join(tempDir, 'runtime', '0.2.0', 'install.log'), 'utf8');
-        expect(log).toContain('$ uv venv');
-        expect(log).toContain('bad python');
+        expect(log).toContain('$ uv venv --python 3.13');
+        expect(log).toContain('current Python version (3.12.3) does not satisfy Python>=3.13');
     });
 });
 describe('readManagedPythonRuntimeStatus', () => {
@@ -302,7 +332,7 @@ describe('readManagedPythonRuntimeStatus', () => {
         expect(status.detail).toContain('No runtime manifest');
     });
     it('reports ready when manifest and executables exist', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -326,7 +356,7 @@ describe('readManagedPythonRuntimeStatus', () => {
         expect(status.manifest?.features).toEqual(['core']);
     });
     it('reports broken when an executable is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -356,7 +386,7 @@ describe('doctorManagedPythonRuntime', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('checks uv, bundled assets, and installed runtime status', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -375,7 +405,7 @@ describe('doctorManagedPythonRuntime', () => {
         expect(checks[2]?.fix).toBe('Run: ktx dev runtime install --yes');
     });
     it('reports uv as a hard prerequisite when uv is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async () => {
             throw new Error('spawn uv ENOENT');
         });

package/dist/next-steps.js

@@ -29,7 +29,7 @@ function commandLines(commands, indent) {
 }
 export function formatNextStepLines(indent = '  ') {
     return [
-        `${indent}KTX context is ready for agents. Open your coding agent in this directory and ask a data question.`,
+        `${indent}KTX context is ready for agents. Open your coding agent from the KTX project directory and ask a data question.`,
         `${indent}Verify with:`,
         ...commandLines(KTX_NEXT_STEP_DIRECT_COMMANDS, indent),
     ];

package/dist/next-steps.test.js

@@ -38,8 +38,10 @@ describe('KTX demo next steps', () => {
     it('explains what the next-step commands are for', () => {
         const rendered = formatNextStepLines().join('\n');
         expect(rendered).toContain('KTX context is ready for agents.');
+        expect(rendered).toContain('KTX project directory');
         expect(rendered).toContain('ask a data question');
         expect(rendered).toContain('Verify with:');
+        expect(rendered).not.toContain('this directory');
         expect(rendered).not.toContain('Preferred route');
         expect(rendered).not.toContain('Optional MCP:');
     });

package/dist/proxy-env.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeChildProxyEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/proxy-env.js

@@ -0,0 +1,23 @@
+const NO_PROXY_KEYS = ['NO_PROXY', 'no_proxy'];
+function isIpv6CidrNoProxyEntry(entry) {
+    return entry.includes('/') && entry.includes(':');
+}
+function cleanedNoProxyValue(env) {
+    const entries = NO_PROXY_KEYS.flatMap((key) => (env[key] ?? '').split(','))
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0 && !isIpv6CidrNoProxyEntry(entry));
+    if (!NO_PROXY_KEYS.some((key) => env[key] !== undefined)) {
+        return undefined;
+    }
+    return [...new Set(entries)].join(',');
+}
+export function sanitizeChildProxyEnv(env) {
+    const sanitized = { ...env };
+    const noProxy = cleanedNoProxyValue(env);
+    if (noProxy === undefined) {
+        return sanitized;
+    }
+    sanitized.NO_PROXY = noProxy;
+    sanitized.no_proxy = noProxy;
+    return sanitized;
+}

package/dist/proxy-env.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { sanitizeChildProxyEnv } from './proxy-env.js';
+describe('sanitizeChildProxyEnv', () => {
+    it('drops IPv6 CIDR no-proxy entries and normalizes both env keys', () => {
+        const env = sanitizeChildProxyEnv({
+            NO_PROXY: 'localhost,127.0.0.1,127.0.0.0/8,fd07:b51a:cc66:f0::/64,*.orb.local',
+            no_proxy: '::1,0.250.250.0/24,fd00::/8,*.orb.internal',
+        });
+        expect(env.NO_PROXY).toBe('localhost,127.0.0.1,127.0.0.0/8,*.orb.local,::1,0.250.250.0/24,*.orb.internal');
+        expect(env.no_proxy).toBe(env.NO_PROXY);
+    });
+    it('preserves the input object and leaves missing proxy env unset', () => {
+        const input = { PATH: '/usr/bin' };
+        expect(sanitizeChildProxyEnv(input)).toEqual({ PATH: '/usr/bin' });
+        expect(input).toEqual({ PATH: '/usr/bin' });
+    });
+});

package/dist/runtime-requirements.d.ts

@@ -1,7 +1,7 @@
 import type { KtxProjectConfig } from '@ktx/context/project';
 import type { KtxRuntimeFeature } from './managed-python-runtime.js';
 import type { KtxPublicIngestPlan } from './public-ingest.js';
-type KtxRuntimeRequirementReason = 'agent-mcp' | 'query-history' | 'looker-source' | 'database-introspection' | 'local-embeddings';
+type KtxRuntimeRequirementReason = 'query-history' | 'looker-source' | 'database-introspection' | 'local-embeddings';
 interface KtxRuntimeRequirement {
     feature: KtxRuntimeFeature;
     reason: KtxRuntimeRequirementReason;
@@ -12,7 +12,6 @@ export interface KtxRuntimeRequirements {
     requirements: KtxRuntimeRequirement[];
 }
 export interface KtxProjectRuntimeRequirementOptions {
-    agents?: boolean;
     databaseIntrospectionFallback?: boolean;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }

package/dist/runtime-requirements.js

@@ -41,13 +41,6 @@ function uniqueRequirements(requirements) {
 export function resolveProjectRuntimeRequirements(config, options = {}) {
     const env = options.env ?? process.env;
     const requirements = [];
-    if (options.agents === true) {
-        requirements.push({
-            feature: 'core',
-            reason: 'agent-mcp',
-            detail: 'Agent MCP setup uses semantic-layer query tools and SQL validation.',
-        });
-    }
     if (options.databaseIntrospectionFallback === true && !hasDaemonOverride(env)) {
         requirements.push({
             feature: 'core',

package/dist/runtime-requirements.test.js

@@ -3,9 +3,9 @@ import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
 import { describe, expect, it } from 'vitest';
 import { resolveProjectRuntimeRequirements, resolvePublicIngestRuntimeRequirements, } from './runtime-requirements.js';
 describe('runtime requirement detection', () => {
-    it('requires core for agent/MCP setup', () => {
+    it('does not require runtime for agent/MCP setup alone', () => {
         const config = buildDefaultKtxProjectConfig();
-        expect(resolveProjectRuntimeRequirements(config, { agents: true }).features).toEqual(['core']);
+        expect(resolveProjectRuntimeRequirements(config).features).toEqual([]);
     });
     it('requires core for Looker source ingest unless an external daemon is configured', () => {
         const config = {

package/dist/runtime.test.js

@@ -40,6 +40,7 @@ describe('runKtxRuntime', () => {
                 },
                 asset: {
                     wheelPath: '/assets/python/kaelio_ktx-0.1.0-py3-none-any.whl',
+                    requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
                     manifest: {
                         schemaVersion: 1,
                         distributionName: 'kaelio-ktx',

package/dist/setup-agents.d.ts

@@ -12,6 +12,7 @@ export interface KtxSetupAgentsArgs {
     scope: KtxAgentScope;
     mode: KtxAgentInstallMode;
     skipAgents: boolean;
+    showNextActions?: boolean;
 }
 export type KtxSetupAgentsResult = {
     status: 'ready';
@@ -21,6 +22,7 @@ export type KtxSetupAgentsResult = {
         scope: KtxAgentScope;
         mode: KtxAgentInstallMode;
     }>;
+    nextActions?: string;
 } | {
     status: 'skipped';
     projectDir: string;
@@ -46,7 +48,7 @@ export interface KtxAgentInstallManifest {
     entries: Array<{
         kind: 'file';
         path: string;
-        role?: 'skill' | 'rule' | 'analytics-skill' | 'claude-plugin' | 'launcher';
+        role?: 'skill' | 'rule' | 'analytics-skill' | 'claude-desktop-skill-bundle' | 'launcher';
     } | {
         kind: 'json-key';
         path: string;
@@ -54,6 +56,7 @@ export interface KtxAgentInstallManifest {
     }>;
 }
 type InstallEntry = KtxAgentInstallManifest['entries'][number];
+export declare function createAgentNextActionsLineFormatter(stdout: KtxCliIo['stdout']): (line: string) => string;
 export declare function collectClaudeDesktopForwardedEnv(source: NodeJS.ProcessEnv): Record<string, string>;
 export declare function agentInstallManifestPath(projectDir: string): string;
 export declare function plannedKtxAgentFiles(input: {
@@ -79,10 +82,15 @@ export interface KtxSetupAgentsPromptAdapter {
 export interface KtxSetupAgentsDeps {
     prompts?: KtxSetupAgentsPromptAdapter;
 }
-export declare function formatInstallSummary(installs: Array<{
+export declare function targetDisplayName(target: string): string;
+export interface InstallSummaryEntry {
+    title: string;
+    lines: string[];
+}
+export declare function formatInstallSummaryLines(installs: Array<{
     target: KtxAgentTarget;
     scope: KtxAgentScope;
     mode: KtxAgentInstallMode;
-}>, entries: InstallEntry[], projectDir: string): string;
+}>, entries: InstallEntry[], projectDir: string): InstallSummaryEntry[];
 export declare function runKtxSetupAgentsStep(args: KtxSetupAgentsArgs, io: KtxCliIo, deps?: KtxSetupAgentsDeps): Promise<KtxSetupAgentsResult>;
 export {};