@kaelio/ktx 0.8.0 → 0.9.0

package/dist/io/buffered-command-io.js

@@ -0,0 +1,28 @@
+/**
+ * Captures stdout/stderr from a command (e.g. `runKtxConnection`) into buffers
+ * instead of the terminal. Callers decide whether to flush the captured text to
+ * the user or discard it.
+ */
+export function createBufferedCommandIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        stdout: {
+            isTTY: false,
+            write(chunk) {
+                stdout += chunk;
+            },
+        },
+        stderr: {
+            write(chunk) {
+                stderr += chunk;
+            },
+        },
+        stdoutText() {
+            return stdout;
+        },
+        stderrText() {
+            return stderr;
+        },
+    };
+}

package/dist/llm/types.d.ts

@@ -1,7 +1,7 @@
 import type { LanguageModel, TelemetrySettings, ToolCallRepairFunction, ToolSet } from 'ai';
 export declare const KTX_MODEL_ROLES: readonly ["default", "triage", "candidateExtraction", "curator", "reconcile", "repair"];
 export type KtxModelRole = (typeof KTX_MODEL_ROLES)[number];
-type KtxLlmBackend = 'anthropic' | 'vertex' | 'gateway' | 'claude-code';
+type KtxLlmBackend = 'anthropic' | 'vertex' | 'gateway' | 'claude-code' | 'codex';
 export type KtxPromptCacheTtl = '5m' | '1h';
 type KtxJsonValue = null | string | number | boolean | KtxJsonValue[] | {
     [key: string]: KtxJsonValue | undefined;

package/dist/local-adapters.d.ts

@@ -1,14 +1,22 @@
 import { type DefaultLocalIngestAdaptersOptions } from './context/ingest/local-adapters.js';
+import type { HistoricSqlDialect, HistoricSqlReader } from './context/ingest/adapters/historic-sql/types.js';
 import type { SourceAdapter } from './context/ingest/types.js';
 import type { KtxLocalProject } from './context/project/project.js';
 import type { SqlAnalysisPort } from './context/sql-analysis/ports.js';
-import { type ManagedPythonCoreDaemonOptions } from './managed-python-http.js';
+import { type ManagedPythonDaemonHttpOptions } from './managed-python-http.js';
 import type { KtxOperationalLogger } from './io/logger.js';
 export interface KtxCliLocalIngestAdaptersOptions extends DefaultLocalIngestAdaptersOptions {
     historicSqlConnectionId?: string;
     sqlAnalysis?: SqlAnalysisPort;
     sqlAnalysisUrl?: string;
-    managedDaemon?: ManagedPythonCoreDaemonOptions;
+    managedDaemon?: ManagedPythonDaemonHttpOptions;
     logger?: KtxOperationalLogger;
 }
+export interface KtxCliHistoricSqlRuntime {
+    dialect: HistoricSqlDialect;
+    sqlAnalysis: SqlAnalysisPort;
+    reader: HistoricSqlReader;
+    queryClient: unknown;
+}
+export declare function createKtxCliHistoricSqlRuntime(project: KtxLocalProject, connectionId: string, options?: KtxCliLocalIngestAdaptersOptions): KtxCliHistoricSqlRuntime | undefined;
 export declare function createKtxCliLocalIngestAdapters(project: KtxLocalProject, options?: KtxCliLocalIngestAdaptersOptions): SourceAdapter[];

package/dist/local-adapters.js

@@ -12,7 +12,7 @@ import { isKtxSqliteConnectionConfig } from './connectors/sqlite/connector.js';
 import { createSqlServerLiveDatabaseIntrospection } from './connectors/sqlserver/live-database-introspection.js';
 import { isKtxSqlServerConnectionConfig } from './connectors/sqlserver/connector.js';
 import { BigQueryHistoricSqlQueryHistoryReader } from './context/ingest/adapters/historic-sql/bigquery-query-history-reader.js';
-import { queryHistoryDialectForConnection } from './context/ingest/adapters/historic-sql/connection-dialect.js';
+import { historicSqlDialectForConnectionDriver } from './context/ingest/adapters/historic-sql/connection-dialect.js';
 import { createDaemonLiveDatabaseIntrospection } from './context/ingest/adapters/live-database/daemon-introspection.js';
 import { createDefaultLocalIngestAdapters } from './context/ingest/local-adapters.js';
 import { LiveDatabaseSourceAdapter } from './context/ingest/adapters/live-database/live-database.adapter.js';
@@ -224,7 +224,12 @@ function historicSqlOptionsForLocalRun(project, options) {
         return undefined;
     }
     const connection = project.config.connections[connectionId];
-    const dialect = queryHistoryDialectForConnection(connection);
+    // historicSqlConnectionId is only set when query history was explicitly
+    // requested for this run (e.g. `--query-history`), so resolve the dialect from
+    // driver capability rather than the persisted context.queryHistory.enabled
+    // flag — otherwise the adapter is missing and findAdapter('historic-sql')
+    // throws even though the run asked for it.
+    const dialect = historicSqlDialectForConnectionDriver(connection);
     if (!dialect) {
         return undefined;
     }
@@ -234,6 +239,7 @@ function historicSqlOptionsForLocalRun(project, options) {
     if (dialect === 'postgres') {
         return {
             ...base,
+            dialect,
             reader: new PostgresPgssReader(),
             queryClient: createEphemeralPostgresHistoricSqlClient(project, connectionId),
         };
@@ -245,6 +251,7 @@ function historicSqlOptionsForLocalRun(project, options) {
         }
         return {
             ...base,
+            dialect,
             reader: new BigQueryHistoricSqlQueryHistoryReader({
                 projectId: bigQueryProjectId(connection, process.env),
                 region: bigQueryRegion(connection),
@@ -254,6 +261,7 @@ function historicSqlOptionsForLocalRun(project, options) {
     }
     return {
         ...base,
+        dialect,
         reader: new SnowflakeHistoricSqlQueryHistoryReader(),
         queryClient: {
             async executeQuery(query) {
@@ -264,8 +272,16 @@ function historicSqlOptionsForLocalRun(project, options) {
         },
     };
 }
+export function createKtxCliHistoricSqlRuntime(project, connectionId, options = {}) {
+    return historicSqlOptionsForLocalRun(project, {
+        ...options,
+        historicSqlConnectionId: connectionId,
+    });
+}
 export function createKtxCliLocalIngestAdapters(project, options = {}) {
-    const historicSql = historicSqlOptionsForLocalRun(project, options);
+    const historicSql = options.historicSqlConnectionId
+        ? createKtxCliHistoricSqlRuntime(project, options.historicSqlConnectionId, options)
+        : undefined;
     const base = createDefaultLocalIngestAdapters(project, {
         ...options,
         databaseIntrospection: ktxCliDaemonDatabaseIntrospectionOptions(options),

package/dist/next-steps.js

@@ -53,8 +53,7 @@ export function formatSetupNextStepLines(state, indent = '  ') {
     }
     if (!state.contextReady) {
         return [
-            `${indent}Build KTX context next.`,
-            `${indent}Run ingest to build database schema context before context-source ingest.`,
+            `${indent}Setup is complete. The only step left is to build context for your agents.`,
             ...commandLines(KTX_CONTEXT_BUILD_COMMANDS, indent),
         ];
     }

package/dist/progress-port-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { KtxProgressPort } from './context/scan/types.js';
+import type { KtxIngestProgressUpdate } from './ingest.js';
+export interface AggregateProgressState {
+    progress: number;
+}
+export declare function createAggregateProgressPort(onProgress: (update: KtxIngestProgressUpdate) => void, state?: AggregateProgressState, start?: number, weight?: number): KtxProgressPort;

package/dist/progress-port-adapter.js

@@ -0,0 +1,18 @@
+export function createAggregateProgressPort(onProgress, state = { progress: 0 }, start = 0, weight = 1) {
+    return {
+        async update(value, message, options) {
+            const absoluteValue = start + Math.max(0, Math.min(1, value)) * weight;
+            state.progress = Math.max(state.progress, Math.min(1, absoluteValue));
+            if (!message)
+                return;
+            onProgress({
+                percent: Math.max(0, Math.min(100, Math.round(state.progress * 100))),
+                message,
+                ...(options?.transient !== undefined ? { transient: options.transient } : {}),
+            });
+        },
+        startPhase(phaseWeight) {
+            return createAggregateProgressPort(onProgress, state, state.progress, weight * phaseWeight);
+        },
+    };
+}

package/dist/public-ingest.d.ts

@@ -5,6 +5,7 @@ import type { KtxIngestArgs, KtxIngestDeps, KtxIngestProgressUpdate } from './in
 import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime } from './managed-python-command.js';
 import type { KtxRuntimeFeature } from './managed-python-runtime.js';
 import type { KtxScanArgs, KtxScanDeps } from './scan.js';
+import type { KtxTableRef } from './context/scan/types.js';
 type KtxPublicIngestStepName = 'database-schema' | 'query-history' | 'source-ingest' | 'memory-update';
 type KtxPublicIngestStepStatus = 'done' | 'skipped' | 'failed' | 'not-run';
 type KtxPublicIngestInputMode = 'auto' | 'disabled';
@@ -98,6 +99,17 @@ interface KtxPublicContextBuildArgs {
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;
 }
+export declare function publicProgressMessage(message: string, target: KtxPublicIngestPlanTarget): string;
+/** @internal */
+export declare function queryHistoryPullConfig(input: {
+    stored: Record<string, unknown>;
+    dialect: HistoricSqlDialect;
+    windowDays?: number;
+    enabledTables?: KtxTableRef[];
+    enabledSchemas?: string[];
+    modeledTableCatalog?: KtxTableRef[];
+    scopeFloorWarnings?: string[];
+}): Record<string, unknown>;
 export declare function buildPublicIngestPlan(project: KtxPublicIngestProject, args: {
     projectDir: string;
     targetConnectionId?: string;
@@ -108,8 +120,15 @@ export declare function buildPublicIngestPlan(project: KtxPublicIngestProject, a
         command: 'run';
     }>['mode'];
 }): KtxPublicIngestPlan;
+/**
+ * Run one ingest target through its scan/ingest steps. The single per-target
+ * chokepoint reached by every entrypoint — standalone `ktx ingest` (plain/json
+ * and foreground) and `ktx setup` (via `runContextBuild`). The exported
+ * `executePublicIngestTarget` wraps this and emits the `ingest_completed`
+ * telemetry event exactly once, so every path is counted.
+ */
 export declare function executePublicIngestTarget(target: KtxPublicIngestPlanTarget, args: Extract<KtxPublicIngestArgs, {
     command: 'run';
-}>, io: KtxCliIo, deps: KtxPublicIngestDeps): Promise<KtxPublicIngestTargetResult>;
+}>, io: KtxCliIo, deps: KtxPublicIngestDeps, project: KtxPublicIngestProject): Promise<KtxPublicIngestTargetResult>;
 export declare function runKtxPublicIngest(args: KtxPublicIngestArgs, io: KtxCliIo, deps?: KtxPublicIngestDeps): Promise<number>;
 export {};

package/dist/public-ingest.js

@@ -1,12 +1,15 @@
 import { getKtxCliPackageInfo } from './cli-runtime.js';
 import { loadKtxProject } from './context/project/project.js';
 import { isDatabaseDriver, normalizeConnectionDriver } from './connection-drivers.js';
+import { resolveQueryHistoryScopeFloor } from './context/ingest/adapters/historic-sql/scope-floor.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
-import { publicIngestOutputLine } from './public-ingest-copy.js';
+import { publicDatabaseIngestMessage, publicIngestOutputLine, publicQueryHistoryMessage, } from './public-ingest-copy.js';
+import { createAggregateProgressPort } from './progress-port-adapter.js';
 import { resolvePublicIngestRuntimeRequirements } from './runtime-requirements.js';
 import { profileMark } from './startup-profile.js';
 import { isDemoConnection } from './telemetry/demo-detect.js';
 import { emitProjectStackSnapshot, emitTelemetryEvent } from './telemetry/index.js';
+import { formatErrorDetail } from './telemetry/scrubber.js';
 profileMark('module:public-ingest');
 const sourceAdapterByDriver = new Map([
     ['metabase', 'metabase'],
@@ -17,6 +20,16 @@ const sourceAdapterByDriver = new Map([
     ['dbt', 'dbt'],
     ['lookml', 'lookml'],
 ]);
+export function publicProgressMessage(message, target) {
+    let current = message;
+    if (target.operation === 'database-ingest') {
+        current = publicDatabaseIngestMessage(current);
+    }
+    if (target.steps.includes('query-history')) {
+        current = publicQueryHistoryMessage(current, target.connectionId);
+    }
+    return current;
+}
 const queryHistoryDialectByDriver = new Map([
     ['postgres', 'postgres'],
     ['bigquery', 'bigquery'],
@@ -99,20 +112,20 @@ function storedQueryHistory(connection) {
 function positiveInteger(value) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : undefined;
 }
-function enabledTablesForConnection(connection) {
-    const raw = connection.enabled_tables;
-    if (!Array.isArray(raw)) {
-        return undefined;
-    }
-    const tables = raw.filter((value) => typeof value === 'string' && value.trim().length > 0);
-    return tables.length > 0 ? tables : undefined;
-}
-function queryHistoryPullConfig(input) {
-    const { enabled: _enabled, dialect: _dialect, ...storedConfig } = input.stored;
+/** @internal */
+export function queryHistoryPullConfig(input) {
+    const { enabled: _enabled, dialect: _dialect, enabledTables: _enabledTables, enabledSchemas: _enabledSchemas, scopeFloorWarnings: _scopeFloorWarnings, ...storedConfig } = input.stored;
     return {
         ...storedConfig,
         dialect: input.dialect,
-        ...(input.enabledTables ? { enabledTables: input.enabledTables } : {}),
+        ...(input.enabledTables && input.enabledTables.length > 0 ? { enabledTables: input.enabledTables } : {}),
+        ...(input.enabledSchemas && input.enabledSchemas.length > 0 ? { enabledSchemas: input.enabledSchemas } : {}),
+        ...(input.modeledTableCatalog && input.modeledTableCatalog.length > 0
+            ? { modeledTableCatalog: input.modeledTableCatalog }
+            : {}),
+        ...(input.scopeFloorWarnings && input.scopeFloorWarnings.length > 0
+            ? { scopeFloorWarnings: input.scopeFloorWarnings }
+            : {}),
         ...(input.windowDays !== undefined ? { windowDays: input.windowDays } : {}),
     };
 }
@@ -157,7 +170,6 @@ function resolveDatabaseTargetOptions(input) {
                     stored: storedQh,
                     dialect,
                     windowDays: queryHistory.windowDays,
-                    enabledTables: enabledTablesForConnection(input.connection),
                 }),
             },
             steps: ['database-schema', 'query-history'],
@@ -168,6 +180,37 @@ function resolveDatabaseTargetOptions(input) {
         steps: ['database-schema'],
     };
 }
+async function resolvedQueryHistoryPullConfigForTarget(target, project) {
+    if (target.operation !== 'database-ingest' || target.queryHistory?.enabled !== true || !target.queryHistory.dialect) {
+        return null;
+    }
+    const connection = project.config.connections[target.connectionId];
+    if (!connection) {
+        return (target.queryHistory.pullConfig ??
+            queryHistoryPullConfig({
+                stored: {},
+                dialect: target.queryHistory.dialect,
+                windowDays: target.queryHistory.windowDays,
+            }));
+    }
+    const stored = storedQueryHistory(connection);
+    const scopeFloor = await resolveQueryHistoryScopeFloor({
+        projectDir: project.projectDir,
+        connectionId: target.connectionId,
+        driver: target.driver,
+        connection: connection,
+        storedQueryHistory: stored,
+    });
+    return queryHistoryPullConfig({
+        stored,
+        dialect: target.queryHistory.dialect,
+        windowDays: target.queryHistory.windowDays,
+        enabledTables: scopeFloor.enabledTables,
+        enabledSchemas: scopeFloor.enabledSchemas,
+        modeledTableCatalog: scopeFloor.modeledTableCatalog,
+        scopeFloorWarnings: scopeFloor.warnings,
+    });
+}
 function enrichmentReadinessGaps(config) {
     const gaps = [];
     if (config.llm.provider.backend === 'none' || !config.llm.models.default) {
@@ -348,6 +391,9 @@ function rowsBucket() {
 }
 async function emitIngestCompleted(input) {
     const failed = resultFailed(input.result);
+    const failureDetail = failed
+        ? formatErrorDetail(input.result.steps.find((step) => step.status === 'failed')?.detail)
+        : undefined;
     await emitTelemetryEvent({
         name: 'ingest_completed',
         projectDir: input.args.projectDir,
@@ -361,6 +407,7 @@ async function emitIngestCompleted(input) {
             rowsBucket: rowsBucket(),
             durationMs: Math.max(0, performance.now() - input.startedAt),
             outcome: failed ? 'error' : 'ok',
+            ...(failureDetail ? { errorDetail: failureDetail } : {}),
         },
     });
 }
@@ -427,6 +474,65 @@ function createCapturedPublicIngestIo() {
         },
     };
 }
+function isCapturedPublicIngestIo(io) {
+    return typeof io.capturedOutput === 'function';
+}
+const PLAIN_PUBLIC_INGEST_PHASE_LABELS = {
+    'database-schema': 'database schema',
+    'query-history': 'query history',
+    'source-ingest': 'source ingest',
+};
+function firstSummaryLine(summary) {
+    if (!summary)
+        return undefined;
+    return summary.split(/\r?\n/).find((line) => line.trim().length > 0)?.trim();
+}
+function plainPhaseHeader(options, phaseKey) {
+    const prefix = options.total > 1 ? `[${options.index + 1}/${options.total}] ` : '';
+    return `${prefix}${options.target.connectionId} · ${PLAIN_PUBLIC_INGEST_PHASE_LABELS[phaseKey]}`;
+}
+function plainPhaseEndLine(status, summary) {
+    const firstLine = firstSummaryLine(summary);
+    return firstLine ? `  ${status} · ${firstLine}` : `  ${status}`;
+}
+function createPlainPublicIngestProgress(io, options) {
+    let currentPhase = null;
+    const startedPhases = new Set();
+    const lastPercentByPhase = new Map();
+    const startPhase = (phaseKey) => {
+        currentPhase = phaseKey;
+        startedPhases.add(phaseKey);
+        lastPercentByPhase.set(phaseKey, -1);
+        io.stderr.write(`${plainPhaseHeader(options, phaseKey)}\n`);
+    };
+    const ensurePhaseStarted = (phaseKey) => {
+        if (!startedPhases.has(phaseKey)) {
+            startPhase(phaseKey);
+            return;
+        }
+        currentPhase = phaseKey;
+    };
+    const emitProgress = (update) => {
+        if (currentPhase === null)
+            return;
+        const rounded = Math.max(0, Math.min(100, Math.round(update.percent)));
+        const lastPercent = lastPercentByPhase.get(currentPhase) ?? -1;
+        if (rounded <= lastPercent)
+            return;
+        lastPercentByPhase.set(currentPhase, rounded);
+        io.stderr.write(`  [${rounded}%] ${publicProgressMessage(update.message, options.target)}\n`);
+    };
+    return {
+        onPhaseStart: startPhase,
+        onPhaseEnd(phaseKey, status, summary) {
+            ensurePhaseStarted(phaseKey);
+            io.stderr.write(`${plainPhaseEndLine(status, summary)}\n`);
+            currentPhase = null;
+        },
+        scanProgress: createAggregateProgressPort(emitProgress),
+        ingestProgress: emitProgress,
+    };
+}
 const INTERNAL_STATUS_LINE_RE = /^(Report|Run|Job|Status|Adapter|Connection|Sync|Diff|Tasks|Work units|Failed tasks|Saved memory|Provenance rows):\s*/;
 const ACTIONABLE_FAILURE_LINE_RE = /^(Missing bundled Python runtime manifest|KTX Python runtime is required|KTX daemon HTTP|Error:|Failed\b|Could not\b|Cannot\b)/;
 const RUNTIME_BACKED_RETRY_LINE_RE = /^Then retry the runtime-backed KTX command\.?$/;
@@ -457,7 +563,23 @@ function capturedFailureMessage(output) {
         .filter((line) => line.startsWith('In a source checkout, build the local runtime assets with:'));
     return [firstLine, ...followupLines].join('\n');
 }
-export async function executePublicIngestTarget(target, args, io, deps) {
+/**
+ * Run one ingest target through its scan/ingest steps. The single per-target
+ * chokepoint reached by every entrypoint — standalone `ktx ingest` (plain/json
+ * and foreground) and `ktx setup` (via `runContextBuild`). The exported
+ * `executePublicIngestTarget` wraps this and emits the `ingest_completed`
+ * telemetry event exactly once, so every path is counted.
+ */
+export async function executePublicIngestTarget(target, args, io, deps, project) {
+    const startedAt = performance.now();
+    const result = await runIngestTargetSteps(target, args, io, deps, project);
+    // `io` may be a capture buffer for the scan/ingest step output; the telemetry
+    // debug echo belongs on the real user-facing stream, which callers expose as
+    // `deps.runtimeIo` (falling back to `io` when the step io is already real).
+    await emitIngestCompleted({ args, project, target, result, startedAt, io: deps.runtimeIo ?? io });
+    return result;
+}
+async function runIngestTargetSteps(target, args, io, deps, project) {
     if (target.preflightFailure) {
         if (target.operation === 'database-ingest') {
             deps.onPhaseEnd?.('database-schema', 'failed', target.preflightFailure);
@@ -475,7 +597,7 @@ export async function executePublicIngestTarget(target, args, io, deps) {
                 ? {
                     ...step,
                     status: 'failed',
-                    detail: target.preflightFailure,
+                    detail: `${target.connectionId} failed: ${target.preflightFailure}`,
                 }
                 : step),
         };
@@ -493,7 +615,11 @@ export async function executePublicIngestTarget(target, args, io, deps) {
             ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),
         };
         const runScan = deps.runScan ?? runKtxScan;
-        const capturedScanIo = deps.scanProgress ? null : createCapturedPublicIngestIo();
+        const capturedScanIo = deps.scanProgress
+            ? isCapturedPublicIngestIo(io)
+                ? io
+                : null
+            : createCapturedPublicIngestIo();
         const scanIo = capturedScanIo ?? io;
         const scanDeps = {
             ...(deps.scanProgress ? { progress: deps.scanProgress } : {}),
@@ -512,6 +638,10 @@ export async function executePublicIngestTarget(target, args, io, deps) {
         if (target.queryHistory?.enabled === true) {
             const { runKtxIngest } = await import('./ingest.js');
             const runIngest = deps.runIngest ?? runKtxIngest;
+            const historicSqlPullConfigOverride = (await resolvedQueryHistoryPullConfigForTarget(target, project)) ?? {
+                dialect: target.queryHistory.dialect,
+                ...(target.queryHistory.windowDays !== undefined ? { windowDays: target.queryHistory.windowDays } : {}),
+            };
             const ingestArgs = {
                 command: 'run',
                 projectDir: args.projectDir,
@@ -522,12 +652,14 @@ export async function executePublicIngestTarget(target, args, io, deps) {
                 ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
                 ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),
                 allowImplicitAdapter: true,
-                historicSqlPullConfigOverride: target.queryHistory.pullConfig ?? {
-                    dialect: target.queryHistory.dialect,
-                    ...(target.queryHistory.windowDays !== undefined ? { windowDays: target.queryHistory.windowDays } : {}),
-                },
+                historicSqlPullConfigOverride,
             };
-            const capturedIngestIo = deps.ingestProgress ? null : createCapturedPublicIngestIo();
+            // Query history runs after the schema scan has already written its report
+            // into the shared target io, so it needs a phase-local capture. Reusing
+            // `io` here would let leftover scan text (e.g. "Mode: enriched") surface as
+            // the query-history failure detail. Only skip capture when progress is
+            // active and the caller manages its own buffer (io is not a capture).
+            const capturedIngestIo = deps.ingestProgress && !isCapturedPublicIngestIo(io) ? null : createCapturedPublicIngestIo();
             const ingestIo = capturedIngestIo ?? io;
             const ingestDeps = {
                 ...(deps.ingestProgress ? { progress: deps.ingestProgress } : {}),
@@ -564,7 +696,11 @@ export async function executePublicIngestTarget(target, args, io, deps) {
         allowImplicitAdapter: true,
     };
     const runIngest = deps.runIngest ?? runKtxIngest;
-    const capturedIngestIo = deps.ingestProgress ? null : createCapturedPublicIngestIo();
+    const capturedIngestIo = deps.ingestProgress
+        ? isCapturedPublicIngestIo(io)
+            ? io
+            : null
+        : createCapturedPublicIngestIo();
     const ingestIo = capturedIngestIo ?? io;
     const ingestDeps = {
         ...(deps.ingestProgress ? { progress: deps.ingestProgress } : {}),
@@ -628,11 +764,26 @@ export async function runKtxPublicIngest(args, io, deps = {}) {
             io.stderr.write(`Warning: ${warning}\n`);
         }
     }
-    for (const target of plan.targets) {
-        const startedAt = performance.now();
-        const result = await executePublicIngestTarget(target, args, io, deps);
-        results.push(result);
-        await emitIngestCompleted({ args, project, target, result, startedAt, io });
+    for (const [index, target] of plan.targets.entries()) {
+        if (args.json) {
+            results.push(await executePublicIngestTarget(target, args, io, deps, project));
+            continue;
+        }
+        const capture = createCapturedPublicIngestIo();
+        const progress = createPlainPublicIngestProgress(io, {
+            target,
+            index,
+            total: plan.targets.length,
+        });
+        const targetDeps = {
+            ...deps,
+            scanProgress: progress.scanProgress,
+            ingestProgress: progress.ingestProgress,
+            onPhaseStart: progress.onPhaseStart,
+            onPhaseEnd: progress.onPhaseEnd,
+            runtimeIo: deps.runtimeIo ?? io,
+        };
+        results.push(await executePublicIngestTarget(target, args, capture, targetDeps, project));
     }
     if (args.json) {
         io.stdout.write(`${JSON.stringify({ plan, results }, null, 2)}\n`);

package/dist/scan.js

@@ -6,7 +6,7 @@ import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
 import { profileMark } from './startup-profile.js';
 import { emitTelemetryEvent } from './telemetry/index.js';
-import { scrubErrorClass } from './telemetry/scrubber.js';
+import { formatErrorDetail, scrubErrorClass } from './telemetry/scrubber.js';
 profileMark('module:scan');
 function shouldUseStyledOutput(io) {
     return io.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== 'dumb' && !process.env.CI;
@@ -306,6 +306,7 @@ export async function runKtxScan(args, io = process, deps = {}) {
     }
     catch (error) {
         const errorClass = scrubErrorClass(error);
+        const errorDetail = formatErrorDetail(error);
         await emitTelemetryEvent({
             name: 'scan_completed',
             projectDir: args.projectDir,
@@ -319,6 +320,7 @@ export async function runKtxScan(args, io = process, deps = {}) {
                 durationMs: Math.max(0, performance.now() - startedAt),
                 outcome: 'error',
                 ...(errorClass ? { errorClass } : {}),
+                ...(errorDetail ? { errorDetail } : {}),
             },
         });
         io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);

package/dist/setup-context.d.ts

@@ -54,6 +54,7 @@ export type KtxSetupContextResult = {
 } | {
     status: 'failed';
     projectDir: string;
+    errorDetail?: string;
 };
 export interface KtxSetupContextStepArgs {
     projectDir: string;
@@ -77,6 +78,7 @@ export interface KtxSetupContextDeps {
     now?: () => Date;
     runContextBuild?: typeof runContextBuild;
     verifyContextReady?: (projectDir: string) => Promise<KtxSetupContextReadiness>;
+    testConnection?: (projectDir: string, connectionId: string, io: KtxCliIo) => Promise<number>;
 }
 /** @internal */
 export declare function contextBuildCommands(projectDir: string): KtxSetupContextCommands;