@kaelio/ktx 0.7.0 → 0.9.0

package/dist/public-ingest.d.ts

@@ -2,14 +2,13 @@ import { type KtxLocalProject } from './context/project/project.js';
 import type { KtxProgressPort } from './context/scan/types.js';
 import type { KtxCliIo } from './index.js';
 import type { KtxIngestArgs, KtxIngestDeps, KtxIngestProgressUpdate } from './ingest.js';
-import { type KtxDatabaseContextDepth } from './ingest-depth.js';
 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';
-type KtxPublicIngestDepth = KtxDatabaseContextDepth;
 type KtxPublicIngestQueryHistoryFlag = 'default' | 'enabled' | 'disabled';
 type HistoricSqlDialect = 'postgres' | 'bigquery' | 'snowflake';
 export type KtxPublicIngestArgs = {
@@ -19,7 +18,6 @@ export type KtxPublicIngestArgs = {
     all: boolean;
     json: boolean;
     inputMode: KtxPublicIngestInputMode;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {
@@ -37,7 +35,6 @@ export interface KtxPublicIngestPlanTarget {
     sourceDir?: string;
     debugCommand: string;
     steps: KtxPublicIngestStepName[];
-    databaseDepth?: KtxPublicIngestDepth;
     detectRelationships?: boolean;
     preflightFailure?: string;
     queryHistory?: {
@@ -46,7 +43,6 @@ export interface KtxPublicIngestPlanTarget {
         windowDays?: number;
         pullConfig?: Record<string, unknown>;
         unsupported?: boolean;
-        skippedStoredByFast?: boolean;
     };
 }
 export interface KtxPublicIngestPlan {
@@ -94,7 +90,6 @@ interface KtxPublicContextBuildArgs {
     inputMode: 'auto' | 'disabled';
     targetConnectionId?: string;
     all?: boolean;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {
@@ -104,19 +99,36 @@ 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;
     all: boolean;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {
         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 { databaseContextDepth, deepReadinessGaps, isDatabaseDriver, normalizeConnectionDriver, } from './ingest-depth.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'],
@@ -25,7 +38,6 @@ const queryHistoryDialectByDriver = new Map([
 function createWarningAccumulator() {
     return {
         warnings: [],
-        ignoredDepthForSources: [],
         ignoredQueryHistoryForSources: [],
         unsupportedQueryHistoryForDatabases: [],
     };
@@ -71,12 +83,6 @@ function finalizeWarnings(accumulator, args) {
         ...accumulator.warnings,
         ...unsupportedQueryHistoryWarnings(accumulator.unsupportedQueryHistoryForDatabases, args.all),
     ];
-    const depthOption = args.depth ? `--${args.depth}` : null;
-    if (depthOption) {
-        const warning = sourceIgnoredWarning(depthOption, accumulator.ignoredDepthForSources, args.all);
-        if (warning)
-            warnings.push(warning);
-    }
     if (args.queryHistory === 'enabled' || args.queryHistoryWindowDays !== undefined) {
         const warning = sourceIgnoredWarning('--query-history', accumulator.ignoredQueryHistoryForSources, args.all);
         if (warning)
@@ -106,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 } : {}),
     };
 }
@@ -135,7 +141,6 @@ function resolveDatabaseTargetOptions(input) {
     const windowOverrideRequested = input.args.queryHistoryWindowDays !== undefined;
     const requestedQh = explicitQueryHistory === 'enabled' ||
         (explicitQueryHistory !== 'disabled' && (windowOverrideRequested || storedEnabled));
-    let depth = input.args.depth ?? databaseContextDepth(input.connection) ?? 'fast';
     const queryHistory = {
         enabled: false,
         ...(input.args.queryHistoryWindowDays !== undefined
@@ -151,18 +156,12 @@ function resolveDatabaseTargetOptions(input) {
             reason: explicitQueryHistory === 'enabled' || input.args.queryHistoryWindowDays !== undefined ? 'explicit' : 'stored',
         });
         return {
-            databaseDepth: depth,
             queryHistory: { ...queryHistory, unsupported: true },
             steps: ['database-schema'],
         };
     }
     if (requestedQh && dialect) {
-        if (depth === 'fast') {
-            input.warnings.warnings.push(`--query-history requires deep ingest; running ${input.connectionId} with --deep.`);
-        }
-        depth = 'deep';
         return {
-            databaseDepth: depth,
             queryHistory: {
                 ...queryHistory,
                 enabled: true,
@@ -171,34 +170,66 @@ function resolveDatabaseTargetOptions(input) {
                     stored: storedQh,
                     dialect,
                     windowDays: queryHistory.windowDays,
-                    enabledTables: enabledTablesForConnection(input.connection),
                 }),
             },
             steps: ['database-schema', 'query-history'],
         };
     }
-    if (input.args.depth === 'fast' && explicitQueryHistory !== 'enabled' && storedEnabled) {
-        input.warnings.warnings.push(`${input.connectionId} has query history enabled in ktx.yaml, but --fast skips query-history processing.`);
-        return {
-            databaseDepth: 'fast',
-            queryHistory: { ...queryHistory, skippedStoredByFast: true },
-            steps: ['database-schema'],
-        };
-    }
     return {
-        databaseDepth: depth,
         queryHistory,
         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) {
+        gaps.push('model configuration');
+    }
+    if (config.scan.enrichment.mode !== 'llm') {
+        gaps.push('scan enrichment mode');
+    }
+    const embeddings = config.scan.enrichment.embeddings;
+    if (!embeddings || embeddings.backend === 'none' || !embeddings.model || embeddings.dimensions <= 0) {
+        gaps.push('scan embeddings');
+    }
+    return gaps;
+}
 function targetForConnection(connectionId, connection, projectConfig, args, warnings) {
     const driver = normalizeConnectionDriver(connection);
     const adapter = sourceAdapterByDriver.get(driver);
     const sourceDir = sourceDirForConnection(connection);
     if (adapter) {
-        if (args.depth) {
-            warnings.ignoredDepthForSources.push(connectionId);
-        }
         if (args.queryHistory === 'enabled' || args.queryHistoryWindowDays !== undefined) {
             warnings.ignoredQueryHistoryForSources.push(connectionId);
         }
@@ -214,16 +245,16 @@ function targetForConnection(connectionId, connection, projectConfig, args, warn
     }
     if (isDatabaseDriver(driver)) {
         const options = resolveDatabaseTargetOptions({ connectionId, driver, connection, args, warnings });
-        const gaps = options.databaseDepth === 'deep' ? deepReadinessGaps(projectConfig) : [];
+        const gaps = enrichmentReadinessGaps(projectConfig);
         return {
             connectionId,
             driver,
             operation: 'database-ingest',
             debugCommand: `ktx ingest ${connectionId} --debug`,
-            detectRelationships: options.databaseDepth === 'deep' && projectConfig.scan.relationships.enabled,
+            detectRelationships: projectConfig.scan.relationships.enabled,
             ...(gaps.length > 0
                 ? {
-                    preflightFailure: `${connectionId} requires deep ingest readiness: ${gaps.join(', ')}. Run ktx setup or rerun with --fast.`,
+                    preflightFailure: `${connectionId} cannot be ingested: enrichment is not configured (${gaps.join(', ')}). Run ktx setup to configure a model and embeddings.`,
                 }
                 : {}),
             ...options,
@@ -281,12 +312,11 @@ function defaultSteps(target) {
 }
 function retryCommandForTarget(target, args) {
     const projectPart = ` --project-dir ${args.projectDir}`;
-    const depthPart = target.databaseDepth ? ` --${target.databaseDepth}` : '';
     const queryHistoryPart = target.queryHistory?.enabled === true ? ' --query-history' : '';
     const windowPart = target.queryHistory?.enabled === true && target.queryHistory.windowDays !== undefined
         ? ` --query-history-window-days ${target.queryHistory.windowDays}`
         : '';
-    return `ktx ingest ${target.connectionId}${projectPart}${depthPart}${queryHistoryPart}${windowPart}`;
+    return `ktx ingest ${target.connectionId}${projectPart}${queryHistoryPart}${windowPart}`;
 }
 function trimTrailingPeriod(value) {
     return value.endsWith('.') ? value.slice(0, -1) : value;
@@ -361,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,
@@ -374,6 +407,7 @@ async function emitIngestCompleted(input) {
             rowsBucket: rowsBucket(),
             durationMs: Math.max(0, performance.now() - input.startedAt),
             outcome: failed ? 'error' : 'ok',
+            ...(failureDetail ? { errorDetail: failureDetail } : {}),
         },
     });
 }
@@ -440,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\.?$/;
@@ -470,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);
@@ -488,7 +597,7 @@ export async function executePublicIngestTarget(target, args, io, deps) {
                 ? {
                     ...step,
                     status: 'failed',
-                    detail: target.preflightFailure,
+                    detail: `${target.connectionId} failed: ${target.preflightFailure}`,
                 }
                 : step),
         };
@@ -499,14 +608,18 @@ export async function executePublicIngestTarget(target, args, io, deps) {
             command: 'run',
             projectDir: args.projectDir,
             connectionId: target.connectionId,
-            mode: target.databaseDepth === 'deep' ? 'enriched' : 'structural',
+            mode: 'enriched',
             detectRelationships: target.detectRelationships === true,
             dryRun: false,
             ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
             ...(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 } : {}),
@@ -525,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,
@@ -535,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 } : {}),
@@ -577,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 } : {}),
@@ -622,7 +745,6 @@ export async function runKtxPublicIngest(args, io, deps = {}) {
             all: args.all,
             entrypoint: 'ingest',
             inputMode: args.inputMode,
-            ...(args.depth ? { depth: args.depth } : {}),
             ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
             ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
             ...(args.scanMode ? { scanMode: args.scanMode } : {}),
@@ -642,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;