@kaelio/ktx 0.5.0 → 0.7.0

package/dist/database-tree-picker.js

@@ -1,3 +1,4 @@
+import { parseDottedTableEntry } from './context/scan/enabled-tables.js';
 import { profileMark } from './startup-profile.js';
 import { buildInitialState, buildPickerTree, } from './tree-picker-state.js';
 import { renderTreePickerTui, } from './tree-picker-tui.js';
@@ -7,7 +8,9 @@ function defaultRenderer(chrome, initialState, io) {
     return renderTreePickerTui({ chrome, initialState }, io, { scriptedModeHint: DATABASE_SCRIPTED_MODE_HINT });
 }
 function qualifiedTableId(entry) {
-    return `${entry.schema}.${entry.name}`;
+    return entry.catalog !== null
+        ? `${entry.catalog}.${entry.schema}.${entry.name}`
+        : `${entry.schema}.${entry.name}`;
 }
 function tableTitle(entry) {
     return entry.kind === 'view' ? `${entry.name} (view)` : entry.name;
@@ -91,7 +94,8 @@ function schemasFromEnabledTables(enabledTables) {
     const seen = new Set();
     const result = [];
     for (const qualified of enabledTables) {
-        const schema = qualified.split('.')[0] ?? '';
+        const ref = parseDottedTableEntry(qualified);
+        const schema = ref?.db ?? '';
         if (schema.length === 0 || seen.has(schema))
             continue;
         seen.add(schema);
@@ -132,11 +136,14 @@ async function runStageTwoTreePicker(input) {
     const initialSelection = args.existing.enabledTables.length > 0
         ? initialSelectionForExisting(args.existing.enabledTables, byId)
         : initialSelectionFromDefaults(selectedSchemas, schemaIds);
-    const initialState = buildInitialState({
-        tree,
-        existingSelectedIds: initialSelection,
-        skipEmptyAction: 'save-empty',
-    });
+    const initialState = {
+        ...buildInitialState({
+            tree,
+            existingSelectedIds: initialSelection,
+            skipEmptyAction: 'save-empty',
+        }),
+        expanded: new Set(schemaIds),
+    };
     const schemaWordPlural = schemaCount === 1 ? args.schemaNoun : args.schemaNounPlural;
     const subtitleLines = [
         `Connection: ${args.connectionId}`,

package/dist/error-message.d.ts

@@ -0,0 +1 @@
+export declare function describeError(error: unknown): string;

package/dist/error-message.js

@@ -0,0 +1,29 @@
+export function describeError(error) {
+    if (!(error instanceof Error)) {
+        const text = String(error);
+        return text.length > 0 ? text : 'unknown error';
+    }
+    const parts = [];
+    if (error.message.length > 0) {
+        parts.push(error.message);
+    }
+    const seen = new Set([error]);
+    let cause = error.cause;
+    while (cause && !seen.has(cause)) {
+        seen.add(cause);
+        if (cause instanceof Error) {
+            if (cause.message.length > 0) {
+                parts.push(cause.message);
+            }
+            cause = cause.cause;
+        }
+        else {
+            const text = String(cause);
+            if (text.length > 0) {
+                parts.push(text);
+            }
+            break;
+        }
+    }
+    return parts.length > 0 ? parts.join(': ') : 'unknown error';
+}

package/dist/ingest-depth.js

@@ -1,7 +1,6 @@
 const KTX_DATABASE_DRIVER_IDS = new Set([
     'sqlite',
     'postgres',
-    'postgresql',
     'mysql',
     'clickhouse',
     'sqlserver',

package/dist/ingest.js

@@ -129,7 +129,7 @@ function writeMetabaseFanoutStatus(result, io) {
             slCount: acc.slCount + childCounts.slCount,
         };
     }, { wikiCount: 0, slCount: 0 });
-    io.stdout.write(`Metabase fan-out: ${result.status}\n`);
+    io.stdout.write(`Metabase fanout: ${result.status}\n`);
     io.stdout.write(`Source: ${result.metabaseConnectionId}\n`);
     io.stdout.write(`Children: ${result.children.length}\n`);
     if (result.totals) {
@@ -520,7 +520,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
             const queryExecutor = localIngestOptions.queryExecutor ??
                 (deps.createQueryExecutor ?? createKtxCliIngestQueryExecutor)(ingestProject);
             if (args.adapter === 'metabase' && args.sourceDir) {
-                throw new Error('source-dir uploads are not supported for the Metabase fan-out adapter');
+                throw new Error('source-dir uploads are not supported for the Metabase fanout adapter');
             }
             if (args.adapter === 'metabase') {
                 const executeMetabaseFanout = deps.runLocalMetabaseIngest ?? runLocalMetabaseIngest;

package/dist/llm/embedding-health.js

@@ -1,3 +1,4 @@
+import { describeError } from '../error-message.js';
 import { createKtxEmbeddingProvider } from './embedding-provider.js';
 function redactHealthCheckMessage(message, config) {
     const secrets = [config.openai?.apiKey].filter((value) => typeof value === 'string' && value.length > 0);
@@ -30,7 +31,6 @@ export async function runKtxEmbeddingHealthCheck(config, options = {}) {
         return { ok: true };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { ok: false, message: redactHealthCheckMessage(message, config) };
+        return { ok: false, message: redactHealthCheckMessage(describeError(error), config) };
     }
 }

package/dist/local-scan-connectors.js

@@ -1,4 +1,5 @@
-const SUPPORTED_DRIVERS = 'sqlite, postgres, mysql, clickhouse, sqlserver, bigquery, snowflake';
+import { getDriverRegistration, listSupportedDrivers, } from './context/connections/drivers.js';
+const SUPPORTED_DRIVERS = listSupportedDrivers().join(', ');
 export async function createKtxCliScanConnector(project, connectionId) {
     const connection = project.config.connections[connectionId];
     if (!connection) {
@@ -8,63 +9,19 @@ export async function createKtxCliScanConnector(project, connectionId) {
     if (!driver) {
         throw new Error(`Connection "${connectionId}" has no \`driver\` field in ktx.yaml. Supported drivers: ${SUPPORTED_DRIVERS}.`);
     }
-    if (driver === 'sqlite' || driver === 'sqlite3') {
-        const { KtxSqliteScanConnector, isKtxSqliteConnectionConfig } = await import('./connectors/sqlite/connector.js');
-        ;
-        if (!isKtxSqliteConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxSqliteScanConnector({ connectionId, connection, projectDir: project.projectDir });
+    const registration = getDriverRegistration(driver);
+    if (!registration) {
+        throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone KTX scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
     }
-    if (driver === 'postgres' || driver === 'postgresql') {
-        const { KtxPostgresScanConnector, isKtxPostgresConnectionConfig } = await import('./connectors/postgres/connector.js');
-        ;
-        if (!isKtxPostgresConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxPostgresScanConnector({ connectionId, connection });
+    const connectorModule = await registration.load();
+    if (!connectorModule.isConnectionConfig(connection)) {
+        throw invalidConnectionConfigError(connectionId, driver);
     }
-    if (driver === 'mysql') {
-        const { KtxMysqlScanConnector, isKtxMysqlConnectionConfig } = await import('./connectors/mysql/connector.js');
-        ;
-        if (!isKtxMysqlConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxMysqlScanConnector({ connectionId, connection });
-    }
-    if (driver === 'clickhouse') {
-        const { KtxClickHouseScanConnector, isKtxClickHouseConnectionConfig } = await import('./connectors/clickhouse/connector.js');
-        ;
-        if (!isKtxClickHouseConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxClickHouseScanConnector({ connectionId, connection });
-    }
-    if (driver === 'sqlserver') {
-        const { KtxSqlServerScanConnector, isKtxSqlServerConnectionConfig } = await import('./connectors/sqlserver/connector.js');
-        ;
-        if (!isKtxSqlServerConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxSqlServerScanConnector({ connectionId, connection });
-    }
-    if (driver === 'bigquery') {
-        const { KtxBigQueryScanConnector, isKtxBigQueryConnectionConfig } = await import('./connectors/bigquery/connector.js');
-        ;
-        if (!isKtxBigQueryConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxBigQueryScanConnector({ connectionId, connection });
-    }
-    if (driver === 'snowflake') {
-        const { KtxSnowflakeScanConnector, isKtxSnowflakeConnectionConfig } = await import('./connectors/snowflake/connector.js');
-        ;
-        if (!isKtxSnowflakeConnectionConfig(connection)) {
-            throw invalidConnectionConfigError(connectionId, driver);
-        }
-        return new KtxSnowflakeScanConnector({ connectionId, connection, projectDir: project.projectDir });
-    }
-    throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone KTX scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
+    return connectorModule.createScanConnector({
+        connectionId,
+        connection,
+        projectDir: project.projectDir,
+    });
 }
 function invalidConnectionConfigError(connectionId, driver) {
     return new Error(`Connection "${connectionId}" uses driver "${driver}" but its configuration in ktx.yaml does not match the expected shape for that driver. Check the required fields for ${driver} (e.g. url/host/database).`);

package/dist/managed-local-embeddings.js

@@ -1,3 +1,4 @@
+import { writePrefixedLines } from './clack.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { readManagedPythonDaemonStatus, startManagedPythonDaemon, } from './managed-python-daemon.js';
 export function managedLocalEmbeddingHealthConfig(input) {
@@ -27,7 +28,7 @@ export async function ensureManagedLocalEmbeddingsDaemon(options) {
         force: false,
     });
     const verb = daemon.status === 'started' ? 'Started' : 'Using';
-    options.io.stderr.write(`${verb} KTX daemon: ${daemon.baseUrl}\n`);
+    writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
     return {
         baseUrl: daemon.baseUrl,
         stdoutLog: daemon.state.stdoutLog,

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

@@ -1,4 +1,9 @@
 import { type KtxRuntimeFeature, type ManagedPythonDaemonLayout, type ManagedPythonDaemonLayoutOptions, type ManagedPythonRuntimeInstallOptions, type ManagedPythonRuntimeInstallResult } from './managed-python-runtime.js';
+export declare class ManagedPythonDaemonStartError extends Error {
+    readonly detail: string;
+    readonly stderrLog: string;
+    constructor(detail: string, stderrLog: string);
+}
 export interface ManagedPythonDaemonState {
     schemaVersion: 1;
     pid: number;

package/dist/managed-python-daemon.js

@@ -4,8 +4,19 @@ import { createServer } from 'node:net';
 import { setTimeout as delay } from 'node:timers/promises';
 import { promisify } from 'node:util';
 import { z } from 'zod';
+import { describeError } from './error-message.js';
 import { installManagedPythonRuntime, managedPythonDaemonLayout, runtimeFeatureSchema, } from './managed-python-runtime.js';
 import { sanitizeChildProxyEnv } from './proxy-env.js';
+export class ManagedPythonDaemonStartError extends Error {
+    detail;
+    stderrLog;
+    constructor(detail, stderrLog) {
+        super(`KTX daemon failed to start: ${detail}. stderr: ${stderrLog}`);
+        this.name = 'ManagedPythonDaemonStartError';
+        this.detail = detail;
+        this.stderrLog = stderrLog;
+    }
+}
 const execFileAsync = promisify(execFile);
 const daemonStateSchema = z.object({
     schemaVersion: z.literal(1),
@@ -92,7 +103,7 @@ async function healthOk(input) {
         return { ok: true };
     }
     catch (error) {
-        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        return { ok: false, detail: describeError(error) };
     }
 }
 export async function readManagedPythonDaemonStatus(options) {
@@ -173,7 +184,7 @@ async function waitForHealth(input) {
         return;
     }
     lastDetail = finalHealth.detail;
-    throw new Error(`KTX daemon failed to start: ${lastDetail}. stderr: ${input.state.stderrLog}`);
+    throw new ManagedPythonDaemonStartError(lastDetail, input.state.stderrLog);
 }
 async function removeState(layout) {
     await rm(layout.daemonStatePath, { force: true });
@@ -504,13 +515,22 @@ export async function startManagedPythonDaemon(options) {
             stdoutLog: layout.daemonStdoutPath,
             stderrLog: layout.daemonStderrPath,
         };
-        await waitForHealth({
-            state,
-            cliVersion: options.cliVersion,
-            fetch: fetchImpl,
-            timeoutMs: options.startupTimeoutMs ?? 10_000,
-            pollIntervalMs: options.pollIntervalMs ?? 100,
-        });
+        try {
+            await waitForHealth({
+                state,
+                cliVersion: options.cliVersion,
+                fetch: fetchImpl,
+                timeoutMs: options.startupTimeoutMs ?? 30_000,
+                pollIntervalMs: options.pollIntervalMs ?? 100,
+            });
+        }
+        catch (error) {
+            if (processAlive(state.pid)) {
+                killProcess(state.pid);
+            }
+            await removeState(layout);
+            throw error;
+        }
         await writeState(layout.daemonStatePath, state);
         return { status: 'started', layout, state, baseUrl: baseUrl(state) };
     }

package/dist/managed-python-http.js

@@ -3,6 +3,7 @@ import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
 import { createDaemonLookerTableIdentifierParser } from './context/ingest/adapters/looker/daemon-table-identifier-parser.js';
 import { createHttpSqlAnalysisPort } from './context/sql-analysis/http-sql-analysis-port.js';
+import { writePrefixedLines } from './clack.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { startManagedPythonDaemon } from './managed-python-daemon.js';
 function normalizedBaseUrl(baseUrl) {
@@ -71,7 +72,7 @@ export function createManagedPythonDaemonBaseUrlResolver(options) {
             force: false,
         });
         const verb = daemon.status === 'started' ? 'Started' : 'Using existing';
-        options.io.stderr.write(`${verb} KTX daemon: ${daemon.baseUrl}\n`);
+        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
         cachedBaseUrl = daemon.baseUrl;
         return cachedBaseUrl;
     };

package/dist/public-ingest.js

@@ -12,7 +12,6 @@ const sourceAdapterByDriver = new Map([
     ['metabase', 'metabase'],
     ['local_metabase', 'metabase'],
     ['looker', 'looker'],
-    ['local_looker', 'looker'],
     ['notion', 'notion'],
     ['metricflow', 'metricflow'],
     ['dbt', 'dbt'],
@@ -20,7 +19,6 @@ const sourceAdapterByDriver = new Map([
 ]);
 const queryHistoryDialectByDriver = new Map([
     ['postgres', 'postgres'],
-    ['postgresql', 'postgres'],
     ['bigquery', 'bigquery'],
     ['snowflake', 'snowflake'],
 ]);
@@ -125,9 +123,6 @@ function queryHistoryPullConfig(input) {
         ...(input.windowDays !== undefined ? { windowDays: input.windowDays } : {}),
     };
 }
-function depthFromLegacyScanMode(mode) {
-    return mode === 'enriched' || mode === 'relationships' ? 'deep' : undefined;
-}
 function sourceDirForConnection(connection) {
     const value = connection.source_dir;
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
@@ -140,7 +135,7 @@ function resolveDatabaseTargetOptions(input) {
     const windowOverrideRequested = input.args.queryHistoryWindowDays !== undefined;
     const requestedQh = explicitQueryHistory === 'enabled' ||
         (explicitQueryHistory !== 'disabled' && (windowOverrideRequested || storedEnabled));
-    let depth = input.args.depth ?? depthFromLegacyScanMode(input.args.scanMode) ?? databaseContextDepth(input.connection) ?? 'fast';
+    let depth = input.args.depth ?? databaseContextDepth(input.connection) ?? 'fast';
     const queryHistory = {
         enabled: false,
         ...(input.args.queryHistoryWindowDays !== undefined

package/dist/runtime-requirements.js

@@ -49,7 +49,7 @@ export function resolveProjectRuntimeRequirements(config, options = {}) {
     }
     for (const [connectionId, connection] of Object.entries(config.connections)) {
         const driver = normalizeDriver(connection.driver);
-        if ((driver === 'looker' || driver === 'local_looker') && !hasDaemonOverride(env)) {
+        if (driver === 'looker' && !hasDaemonOverride(env)) {
             requirements.push({
                 feature: 'core',
                 reason: 'looker-source',
@@ -86,7 +86,7 @@ export function resolvePublicIngestRuntimeRequirements(plan, options = {}) {
                 detail: `${target.connectionId} query-history ingest uses SQL analysis.`,
             });
         }
-        if ((driver === 'looker' || driver === 'local_looker' || adapter === 'looker') && !hasDaemonOverride(env)) {
+        if ((driver === 'looker' || adapter === 'looker') && !hasDaemonOverride(env)) {
             requirements.push({
                 feature: 'core',
                 reason: 'looker-source',

package/dist/setup-agents.d.ts

@@ -49,7 +49,7 @@ export interface KtxAgentInstallManifest {
     entries: Array<{
         kind: 'file';
         path: string;
-        role?: 'skill' | 'rule' | 'analytics-skill' | 'claude-desktop-skill-bundle' | 'launcher';
+        role?: 'skill' | 'rule' | 'analytics-skill' | 'claude-desktop-skill-bundle';
     } | {
         kind: 'json-key';
         path: string;

package/dist/setup-agents.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
@@ -8,6 +8,7 @@ import { loadKtxProject } from './context/project/project.js';
 import { markKtxSetupStateStepComplete } from './context/project/setup-config.js';
 import { serializeKtxProjectConfig } from './context/project/config.js';
 import { strToU8, zipSync } from 'fflate';
+import { errorMessage, writePrefixedLines } from './clack.js';
 import { createKtxSetupPromptAdapter, createKtxSetupUiAdapter, } from './setup-prompts.js';
 import { readKtxMcpDaemonStatus } from './managed-mcp-daemon.js';
 const MCP_DAEMON_REQUIRED_NOTICE = 'mcp-daemon-required';
@@ -213,9 +214,10 @@ function collectClaudeDesktopForwardedEnv(source) {
 }
 function claudeDesktopMcpEntry(input) {
     const captured = collectClaudeDesktopForwardedEnv(input.env ?? process.env);
+    const launcher = ktxCliLauncher();
     return {
-        command: input.launcherPath,
-        args: ['--project-dir', input.projectDir, 'mcp', 'stdio'],
+        command: launcher.command,
+        args: [...launcher.args, '--project-dir', input.projectDir, 'mcp', 'stdio'],
         ...(Object.keys(captured).length > 0 ? { env: captured } : {}),
     };
 }
@@ -225,8 +227,7 @@ async function installMcpClientConfig(input) {
     const notices = [];
     if (input.target === 'claude-desktop') {
         const config = claudeDesktopConfigPath();
-        const launcherPath = claudeDesktopLauncherPath(input.projectDir);
-        await writeJsonKey(config.path, config.jsonPath, claudeDesktopMcpEntry({ launcherPath, projectDir: input.projectDir }));
+        await writeJsonKey(config.path, config.jsonPath, claudeDesktopMcpEntry({ projectDir: input.projectDir }));
         entries.push({ kind: 'json-key', path: config.path, jsonPath: config.jsonPath });
         return { entries, snippets, notices };
     }
@@ -282,9 +283,6 @@ function claudeDesktopAnalyticsSkillBundlePath(projectDir) {
 function claudeDesktopAdminSkillBundlePath(projectDir) {
     return join(resolve(projectDir), '.ktx/agents/claude/ktx.zip');
 }
-function claudeDesktopLauncherPath(projectDir) {
-    return join(resolve(projectDir), '.ktx/agents/claude/ktx-plugin-runner.sh');
-}
 /** @internal */
 export function plannedKtxAgentFiles(input) {
     const withAdminCli = input.mode === 'mcp-cli';
@@ -318,7 +316,6 @@ export function plannedKtxAgentFiles(input) {
         }
         if (input.target === 'claude-desktop') {
             return [
-                { kind: 'file', path: claudeDesktopLauncherPath(input.projectDir), role: 'launcher' },
                 {
                     kind: 'file',
                     path: claudeDesktopAnalyticsSkillBundlePath(input.projectDir),
@@ -452,58 +449,6 @@ function cliInstructionContent(input) {
         '',
     ].join('\n');
 }
-function claudeDesktopLauncherContent(input) {
-    const binPath = input.launcher.args[0];
-    if (!binPath) {
-        throw new Error('Expected KTX CLI launcher to include a bin path.');
-    }
-    const candidates = [
-        input.launcher.command,
-        '/opt/homebrew/bin/node',
-        '/usr/local/bin/node',
-        '/usr/bin/node',
-    ];
-    return [
-        '#!/bin/sh',
-        'set -eu',
-        '',
-        `KTX_CLI_BIN=${shellScriptQuote(binPath)}`,
-        '',
-        'run_with_node() {',
-        '  node_bin=$1',
-        '  shift',
-        '  exec "$node_bin" "$KTX_CLI_BIN" "$@"',
-        '}',
-        '',
-        'if [ -n "${KTX_NODE:-}" ] && [ -x "${KTX_NODE:-}" ]; then',
-        '  run_with_node "$KTX_NODE" "$@"',
-        'fi',
-        '',
-        'if [ -x "$HOME/.volta/bin/node" ]; then',
-        '  run_with_node "$HOME/.volta/bin/node" "$@"',
-        'fi',
-        '',
-        ...candidates.map((candidate) => [
-            `if [ -x ${shellScriptQuote(candidate)} ]; then`,
-            `  run_with_node ${shellScriptQuote(candidate)} "$@"`,
-            'fi',
-        ].join('\n')),
-        '',
-        'for candidate in "$HOME"/.nvm/versions/node/*/bin/node; do',
-        '  if [ -x "$candidate" ]; then',
-        '    run_with_node "$candidate" "$@"',
-        '  fi',
-        'done',
-        '',
-        'if command -v node >/dev/null 2>&1; then',
-        '  run_with_node "$(command -v node)" "$@"',
-        'fi',
-        '',
-        'echo "KTX Claude Desktop launcher could not find Node.js. Set KTX_NODE to a Node executable and rerun ktx setup --agents." >&2',
-        'exit 127',
-        '',
-    ].join('\n');
-}
 async function writeClaudeDesktopSkillBundle(input) {
     const content = input.skillName === 'ktx-analytics'
         ? await readAnalyticsSkillContent()
@@ -523,11 +468,6 @@ function claudeDesktopSkillNameForBundle(path) {
     }
     throw new Error(`Unsupported Claude Desktop skill bundle path: ${path}`);
 }
-async function writeClaudeDesktopLauncher(input) {
-    await mkdir(dirname(input.path), { recursive: true });
-    await writeFile(input.path, claudeDesktopLauncherContent({ launcher: input.launcher }), 'utf-8');
-    await chmod(input.path, 0o755);
-}
 function ruleInstructionContent(input) {
     return [
         `Use the \`ktx\` CLI to query local semantic context and wiki knowledge for this project ` +
@@ -732,9 +672,6 @@ export function formatInstallSummaryLines(installs, entries, projectDir) {
         else if (hasAnalytics || hasAdmin) {
             lines.push(`${guidanceInstallLine(install.target)}.`);
         }
-        if (hasEntryRole(targetEntries, 'launcher')) {
-            lines.push('Starts KTX over stdio from Claude Desktop.');
-        }
         return {
             title: `${targetDisplayName(install.target)} · ${scopeDisplayName(install.scope)}`,
             lines,
@@ -893,10 +830,6 @@ async function installTarget(input) {
     for (const entry of entries) {
         if (entry.kind !== 'file')
             continue;
-        if (entry.role === 'launcher') {
-            await writeClaudeDesktopLauncher({ path: entry.path, launcher });
-            continue;
-        }
         if (entry.role === 'claude-desktop-skill-bundle') {
             await writeClaudeDesktopSkillBundle({
                 projectDir: input.projectDir,
@@ -948,10 +881,19 @@ export async function runKtxSetupAgentsStep(args, io, deps = {}) {
                     label: 'Ask data questions + manage KTX with CLI commands',
                     hint: 'Adds an admin CLI skill so agents can run ktx status, sl, wiki, and setup commands.',
                 },
+                {
+                    value: 'skip',
+                    label: 'Skip agent setup for now',
+                    hint: 'Leaves agent integration incomplete. You can run ktx setup --agents later.',
+                },
             ],
         }));
     if (mode === 'back')
         return { status: 'skipped', projectDir: args.projectDir };
+    if (mode === 'skip') {
+        io.stdout.write('│  Agent integration skipped.\n');
+        return { status: 'skipped', projectDir: args.projectDir };
+    }
     const targets = args.target !== undefined
         ? [args.target]
         : args.inputMode === 'disabled'
@@ -1039,7 +981,7 @@ export async function runKtxSetupAgentsStep(args, io, deps = {}) {
         return { status: 'ready', projectDir: args.projectDir, installs, nextActions };
     }
     catch (error) {
-        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        writePrefixedLines((chunk) => io.stderr.write(chunk), errorMessage(error));
         return { status: 'failed', projectDir: args.projectDir };
     }
 }

package/dist/setup-context.js

@@ -4,6 +4,7 @@ import { join, resolve } from 'node:path';
 import { loadKtxProject } from './context/project/project.js';
 import { markKtxSetupStateStepComplete, readKtxSetupState } from './context/project/setup-config.js';
 import { serializeKtxProjectConfig } from './context/project/config.js';
+import { errorMessage, writePrefixedLines } from './clack.js';
 import { buildPublicIngestPlan } from './public-ingest.js';
 import { databaseContextDepth, } from './ingest-depth.js';
 import { ensureSetupDatabaseContextDepths } from './setup-database-context-depth.js';
@@ -554,7 +555,7 @@ export async function runKtxSetupContextStep(args, io, deps = {}) {
         return await runBuild(args, io, deps, project, targets);
     }
     catch (error) {
-        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        writePrefixedLines((chunk) => io.stderr.write(chunk), errorMessage(error));
         return { status: 'failed', projectDir: args.projectDir };
     }
 }

package/dist/setup-databases.d.ts

@@ -1,4 +1,4 @@
-import type { HistoricSqlDialect } from './context/ingest/adapters/historic-sql/types.js';
+import { type HistoricSqlReadinessProbe } from './context/ingest/historic-sql-probes.js';
 import type { KtxTableListEntry } from './context/scan/types.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type DatabaseScopePickResult, type PickDatabaseScopeArgs } from './database-tree-picker.js';
@@ -24,6 +24,7 @@ export type KtxSetupDatabasesResult = {
     status: 'ready';
     projectDir: string;
     connectionIds: string[];
+    skipSources?: boolean;
 } | {
     status: 'skipped';
     projectDir: string;
@@ -67,16 +68,6 @@ export interface KtxSetupDatabasesPromptAdapter {
     }): Promise<string | undefined>;
     cancel(message: string): void;
 }
-interface KtxSetupHistoricSqlProbeInput {
-    projectDir: string;
-    connectionId: string;
-    dialect: HistoricSqlDialect;
-}
-interface KtxSetupHistoricSqlProbeResult {
-    ok: boolean;
-    lines: string[];
-}
-type KtxSetupHistoricSqlProbe = (input: KtxSetupHistoricSqlProbeInput) => Promise<KtxSetupHistoricSqlProbeResult>;
 export interface KtxSetupDatabasesDeps {
     prompts?: KtxSetupDatabasesPromptAdapter;
     testConnection?: (projectDir: string, connectionId: string, io: KtxCliIo) => Promise<number>;
@@ -85,7 +76,6 @@ export interface KtxSetupDatabasesDeps {
     listSchemas?: (projectDir: string, connectionId: string) => Promise<string[]>;
     listTables?: (projectDir: string, connectionId: string, schemas?: string[]) => Promise<KtxTableListEntry[]>;
     pickDatabaseScope?: (args: PickDatabaseScopeArgs, io: KtxCliIo) => Promise<DatabaseScopePickResult>;
-    historicSqlProbe?: KtxSetupHistoricSqlProbe;
+    historicSqlReadinessProbe?: HistoricSqlReadinessProbe;
 }
 export declare function runKtxSetupDatabasesStep(args: KtxSetupDatabasesArgs, io: KtxCliIo, deps?: KtxSetupDatabasesDeps): Promise<KtxSetupDatabasesResult>;
-export {};