@kaelio/ktx 0.7.0 → 0.8.0

package/dist/context/mcp/server.js

@@ -9,6 +9,7 @@ export function createKtxMcpServer(deps) {
             userContext: deps.userContext,
             projectDir: deps.projectDir,
             io: deps.io,
+            getClientInfo: deps.getClientInfo,
         });
     }
     return deps.server;
@@ -24,6 +25,9 @@ export function createDefaultKtxMcpServer(deps) {
         contextTools: deps.contextTools,
         projectDir: deps.projectDir,
         io: deps.io,
+        // The SDK populates the client identity after the initialize handshake, so
+        // read it lazily at emit time rather than at registration (undefined here).
+        getClientInfo: () => server.server.getClientVersion(),
     });
     return server;
 }

package/dist/context/mcp/types.d.ts

@@ -46,6 +46,15 @@ export interface MemoryIngestPort {
 export interface KtxMcpUserContext {
     userId: string;
 }
+/**
+ * Identity of the connected MCP client tool (e.g. Claude Desktop, Cursor),
+ * read from the initialize handshake. Untrusted, client-controlled strings —
+ * use only as telemetry properties, never to build paths or log lines.
+ */
+export interface KtxMcpClientInfo {
+    name: string;
+    version: string;
+}
 export interface KtxMcpServerLike {
     registerTool(name: string, config: {
         title?: string;
@@ -101,7 +110,10 @@ interface KtxSemanticLayerReadResponse {
     sourceName: string;
     yaml: string;
 }
-interface KtxSemanticLayerQueryResponse {
+/** @internal */
+export interface KtxSemanticLayerQueryResponse {
+    connectionId?: string;
+    dialect?: string;
     sql: string;
     headers: string[];
     rows: unknown[][];
@@ -165,5 +177,7 @@ export interface KtxMcpServerDeps {
     contextTools?: KtxMcpContextPorts;
     projectDir?: string;
     io?: KtxCliIo;
+    /** Reads the connected client's identity once the initialize handshake completes. */
+    getClientInfo?: () => KtxMcpClientInfo | undefined;
 }
 export {};

package/dist/context/project/config.d.ts

@@ -395,6 +395,7 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
                 continue: "continue";
             }>>;
         }, z.core.$strict>>;
+        profile: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"json">]>>;
     }, z.core.$strict>>;
     agent: z.ZodPrefault<z.ZodObject<{
         run_research: z.ZodPrefault<z.ZodObject<{

package/dist/context/project/config.js

@@ -96,6 +96,10 @@ const ingestSchema = z
         .prefault({ backend: 'none' })
         .describe('Embedding configuration used when ingest adapters need to embed documents.'),
     workUnits: workUnitsSchema.prefault({}).describe('Concurrency and failure handling for ingest work units.'),
+    profile: z
+        .union([z.boolean(), z.literal('json')])
+        .default(false)
+        .describe('Print a timing breakdown to stderr at the end of each ingest run. `true` prints a human table; `"json"` prints the raw structured profile for coding agents; `false` disables it. Equivalent to the KTX_PROFILE_INGEST environment variable (`1`/`true`/`json`).'),
 })
     .describe('Ingest pipeline configuration: adapters, embeddings, and work-unit policy.');
 const scanEnrichmentSchema = z

package/dist/context/project/driver-schemas.js

@@ -21,7 +21,7 @@ function warehouseConnectionSchema(driver) {
         enabled_tables: z
             .array(z.string().min(1))
             .optional()
-            .describe('Optional allowlist of fully-qualified table names ("schema.table") to ingest. When set, live-database ingest discards any table whose schema-qualified name is not in this list. Useful for smoke-testing deep ingest on a single table.'),
+            .describe('Optional allowlist of fully-qualified table names ("schema.table") to ingest. When set, live-database ingest discards any table whose schema-qualified name is not in this list. Useful for smoke-testing ingest on a single table.'),
     })
         .describe(`${driver} warehouse connection. Additional driver-tunable fields (e.g. context.queryHistory) are accepted and passed through.`);
 }

package/dist/context/search/discover.js

@@ -95,7 +95,7 @@ async function wikiCandidates(project, input, options, terms) {
         query: input.query,
         userId: options.userId,
         embeddingService: options.embeddingService ?? null,
-        limit: Math.max(input.limit ?? 15, 25),
+        limit: Math.max(input.limit ?? 10, 25),
     });
     const records = [];
     for (const result of searchResults) {
@@ -300,7 +300,8 @@ function hydrate(fused, refsByKey) {
         }
         return {
             ...ref,
-            score: maxScore > 0 ? Number((candidate.score / maxScore).toFixed(6)) : 0,
+            // 3 decimals is plenty for a relative-rank hint; 6 just spent bytes on noise.
+            score: maxScore > 0 ? Number((candidate.score / maxScore).toFixed(3)) : 0,
         };
     })
         .filter((result) => result !== null);
@@ -308,7 +309,7 @@ function hydrate(fused, refsByKey) {
 export function createKtxDiscoverDataService(project, options = {}) {
     return {
         async search(input) {
-            const limit = Math.max(1, Math.min(input.limit ?? 15, 50));
+            const limit = Math.max(1, Math.min(input.limit ?? 10, 50));
             const query = input.query.trim();
             if (!query) {
                 return [];

package/dist/context/sl/local-sl.d.ts

@@ -28,6 +28,7 @@ export interface LocalSlSearchInput {
     backend?: 'pglite-owner-prototype';
     pglite?: PgliteSlSearchPrototypeOwnerOptions;
 }
+/** @internal */
 export interface LocalSlSource extends LocalSlSourceSummary {
     yaml: string;
 }
@@ -38,6 +39,15 @@ export interface LocalSlValidationResult {
     valid: boolean;
     errors: string[];
 }
+export type ResolvedSlSource = {
+    kind: 'found';
+    source: LocalSlSource;
+} | {
+    kind: 'not-found';
+} | {
+    kind: 'ambiguous';
+    connectionIds: string[];
+};
 export declare function loadLocalSlSourceRecords(project: KtxLocalProject, input: {
     connectionId: string;
 }): Promise<LocalSlSourceRecord[]>;
@@ -52,10 +62,15 @@ export declare function writeLocalSlSource(project: KtxLocalProject, input: {
     sourceName: string;
     yaml: string;
 }): Promise<KtxFileWriteResult>;
+/** @internal */
 export declare function readLocalSlSource(project: KtxLocalProject, input: {
     connectionId: string;
     sourceName: string;
 }): Promise<LocalSlSource | null>;
+export declare function resolveLocalSlSource(project: KtxLocalProject, input: {
+    sourceName: string;
+    connectionId?: string;
+}): Promise<ResolvedSlSource>;
 export declare function listLocalSlSources(project: KtxLocalProject, input?: {
     connectionId?: string;
 }): Promise<LocalSlSourceSummary[]>;

package/dist/context/sl/local-sl.js

@@ -204,6 +204,7 @@ export async function writeLocalSlSource(project, input) {
     const path = slPath(input.connectionId, input.sourceName);
     return project.fileStore.writeFile(path, input.yaml.endsWith('\n') ? input.yaml : `${input.yaml}\n`, LOCAL_AUTHOR, LOCAL_AUTHOR_EMAIL, `Write semantic-layer source: ${input.connectionId}/${input.sourceName}`);
 }
+/** @internal */
 export async function readLocalSlSource(project, input) {
     const path = slPath(input.connectionId, input.sourceName);
     try {
@@ -221,6 +222,35 @@ export async function readLocalSlSource(project, input) {
         return record ? { ...record } : null;
     }
 }
+export async function resolveLocalSlSource(project, input) {
+    if (input.connectionId !== undefined) {
+        const source = await readLocalSlSource(project, {
+            connectionId: input.connectionId,
+            sourceName: input.sourceName,
+        });
+        return source ? { kind: 'found', source } : { kind: 'not-found' };
+    }
+    const summaries = await listLocalSlSources(project, {});
+    const matches = summaries.filter((summary) => summary.name === input.sourceName);
+    if (matches.length === 0) {
+        return { kind: 'not-found' };
+    }
+    if (matches.length > 1) {
+        return {
+            kind: 'ambiguous',
+            connectionIds: [...new Set(matches.map((match) => match.connectionId))].sort(),
+        };
+    }
+    const match = matches[0];
+    if (match === undefined) {
+        return { kind: 'not-found' };
+    }
+    const source = await readLocalSlSource(project, {
+        connectionId: match.connectionId,
+        sourceName: input.sourceName,
+    });
+    return source ? { kind: 'found', source } : { kind: 'not-found' };
+}
 export async function listLocalSlSources(project, input = {}) {
     if (input.connectionId) {
         return (await loadLocalSlSourceRecords(project, { connectionId: input.connectionId })).map(({ source: _source, yaml: _yaml, ...summary }) => summary);

package/dist/context/wiki/local-knowledge.d.ts

@@ -50,6 +50,16 @@ export declare function readLocalKnowledgePage(project: KtxLocalProject, input:
 export declare function listLocalKnowledgePages(project: KtxLocalProject, input?: {
     userId?: string;
 }): Promise<LocalKnowledgeSummary[]>;
+/**
+ * List wiki page keys without reading or parsing file contents.
+ *
+ * Keys are derived purely from file paths, so this stays cheap enough for
+ * shell tab-completion (unlike `listLocalKnowledgePages`, which reads every
+ * page to populate summaries).
+ */
+export declare function listLocalKnowledgePageKeys(project: KtxLocalProject, input?: {
+    userId?: string;
+}): Promise<string[]>;
 export declare function searchLocalKnowledgePages(project: KtxLocalProject, input: {
     query: string;
     userId?: string;

package/dist/context/wiki/local-knowledge.js

@@ -118,6 +118,28 @@ export async function listLocalKnowledgePages(project, input = {}) {
     }
     return pages.sort((left, right) => left.path.localeCompare(right.path));
 }
+/**
+ * List wiki page keys without reading or parsing file contents.
+ *
+ * Keys are derived purely from file paths, so this stays cheap enough for
+ * shell tab-completion (unlike `listLocalKnowledgePages`, which reads every
+ * page to populate summaries).
+ */
+export async function listLocalKnowledgePageKeys(project, input = {}) {
+    const userId = input.userId ?? 'local';
+    const keys = new Set();
+    for (const scope of ['GLOBAL', 'USER']) {
+        const root = scope === 'GLOBAL' ? 'wiki/global' : `wiki/user/${assertSafePathToken('user id', userId)}`;
+        const listed = await project.fileStore.listFiles(root);
+        for (const path of listed.files.filter((file) => file.endsWith('.md'))) {
+            const key = keyFromKnowledgePath(path, scope, userId);
+            if (key) {
+                keys.add(key);
+            }
+        }
+    }
+    return [...keys].sort();
+}
 function scorePage(page, terms) {
     const haystack = buildKnowledgeSearchText(page.key, page.summary, page.content, page.tags).toLowerCase();
     return terms.some((term) => haystack.includes(term)) ? 3 : 0;

package/dist/context-build-view.d.ts

@@ -39,9 +39,6 @@ export interface ContextBuildArgs {
     targetConnectionId?: string;
     all?: boolean;
     entrypoint?: 'setup' | 'ingest';
-    depth?: Extract<KtxPublicIngestArgs, {
-        command: 'run';
-    }>['depth'];
     queryHistory?: Extract<KtxPublicIngestArgs, {
         command: 'run';
     }>['queryHistory'];

package/dist/context-build-view.js

@@ -241,12 +241,11 @@ function renderMessageGroup(label, messages, styled) {
 function retryCommand(input) {
     const projectPart = input.projectDir ? ` --project-dir ${input.projectDir}` : '';
     if (input.entrypoint === 'ingest' && input.connectionId) {
-        const depthPart = input.depth ? ` --${input.depth}` : '';
         const queryHistoryPart = input.queryHistory ? ' --query-history' : '';
         const windowPart = input.queryHistory && input.queryHistoryWindowDays !== undefined
             ? ` --query-history-window-days ${input.queryHistoryWindowDays}`
             : '';
-        return `ktx ingest ${input.connectionId}${projectPart}${depthPart}${queryHistoryPart}${windowPart}`;
+        return `ktx ingest ${input.connectionId}${projectPart}${queryHistoryPart}${windowPart}`;
     }
     return input.projectDir ? `ktx setup --project-dir ${input.projectDir}` : 'ktx setup';
 }
@@ -563,7 +562,6 @@ function appendRetryIfNeeded(input) {
         projectDir: input.projectDir,
         entrypoint: input.entrypoint,
         connectionId: input.target.connectionId,
-        depth: input.target.databaseDepth,
         queryHistory: input.target.queryHistory?.enabled === true,
         queryHistoryWindowDays: input.target.queryHistory?.windowDays,
     })}`;
@@ -578,7 +576,6 @@ function failureTextForTarget(input) {
                 projectDir: input.projectDir,
                 entrypoint: input.entrypoint,
                 connectionId: input.target.connectionId,
-                depth: input.target.databaseDepth,
                 queryHistory: input.target.queryHistory?.enabled === true,
                 queryHistoryWindowDays: input.target.queryHistory?.windowDays,
             })}`,
@@ -593,7 +590,6 @@ function failureTextForTarget(input) {
                 projectDir: input.projectDir,
                 entrypoint: input.entrypoint,
                 connectionId: input.target.connectionId,
-                depth: input.target.databaseDepth,
                 queryHistory: input.target.queryHistory?.enabled === true,
                 queryHistoryWindowDays: input.target.queryHistory?.windowDays,
             })}`,
@@ -659,7 +655,6 @@ export async function runContextBuild(project, args, io, deps = {}) {
         projectDir: args.projectDir,
         ...(args.targetConnectionId ? { targetConnectionId: args.targetConnectionId } : {}),
         all: args.all ?? true,
-        ...(args.depth ? { depth: args.depth } : {}),
         ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
         ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
         ...(args.scanMode ? { scanMode: args.scanMode } : {}),
@@ -721,7 +716,6 @@ export async function runContextBuild(project, args, io, deps = {}) {
         all: args.all ?? true,
         json: false,
         inputMode: args.inputMode,
-        ...(args.depth ? { depth: args.depth } : {}),
         ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
         ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
         ...(args.scanMode ? { scanMode: args.scanMode } : {}),

package/dist/ingest.js

@@ -2,7 +2,7 @@ import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-mode
 import { createMemoryFlowLiveBuffer, sanitizeMemoryFlowError } from './context/ingest/memory-flow/live-buffer.js';
 import { formatMemoryFlowFinalSummary } from './context/ingest/memory-flow/summary.js';
 import { getLatestLocalIngestStatus, getLocalIngestStatus, runLocalIngest, runLocalMetabaseIngest } from './context/ingest/local-ingest.js';
-import { savedMemoryCountsForReport } from './context/ingest/reports.js';
+import { ingestReportOutcome, savedMemoryCountsForReport } from './context/ingest/reports.js';
 import { ingestReportToMemoryFlowReplay } from './context/ingest/memory-flow/events.js';
 import { renderMemoryFlowReplay } from './context/ingest/memory-flow/render.js';
 import { loadKtxProject } from './context/project/project.js';
@@ -17,9 +17,6 @@ import { renderMemoryFlowTui, startLiveMemoryFlowTui, } from './memory-flow-tui.
 import { resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';
 import { profileMark } from './startup-profile.js';
 profileMark('module:ingest');
-function reportStatus(report) {
-    return report.body.status === 'failed' || report.body.failedWorkUnits.length > 0 ? 'error' : 'done';
-}
 const REPORT_SOURCE_LABELS = new Map([
     ['live-database', 'Database schema'],
     ['historic-sql', 'Query history'],
@@ -106,7 +103,7 @@ function writeReportStatus(report, io) {
     if (report.body.tracePath) {
         io.stdout.write(`Trace: ${report.body.tracePath}\n`);
     }
-    io.stdout.write(`Status: ${reportStatus(report)}\n`);
+    io.stdout.write(`Status: ${ingestReportOutcome(report)}\n`);
     io.stdout.write(`Source: ${reportSourceLabel(report.sourceKey)}\n`);
     io.stdout.write(`Connection: ${report.connectionId}\n`);
     io.stdout.write(`Sync: ${report.body.syncId}\n`);
@@ -138,7 +135,7 @@ function writeMetabaseFanoutStatus(result, io) {
     }
     io.stdout.write(`Saved memory: ${counts.wikiCount} wiki, ${counts.slCount} SL\n`);
     for (const child of result.children) {
-        const status = reportStatus(child.report);
+        const status = ingestReportOutcome(child.report);
         io.stdout.write(`- target=${child.targetConnectionId} database=${child.metabaseDatabaseId} status=${status} job=${child.jobId} report=${child.report.id}\n`);
     }
 }
@@ -425,7 +422,7 @@ function initialRunMemoryFlowInput(args, runId) {
     };
 }
 function finalRunMemoryFlowInput(snapshot, report) {
-    const status = reportStatus(report);
+    const status = ingestReportOutcome(report) === 'error' ? 'error' : 'done';
     return {
         ...snapshot,
         runId: report.runId,
@@ -574,7 +571,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                 finally {
                     plainProgress?.flush();
                 }
-                return result.status === 'all_succeeded' ? 0 : 1;
+                return result.status === 'all_failed' ? 1 : 0;
             }
             const jobId = deps.jobIdFactory?.();
             let liveTui = null;
@@ -636,7 +633,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                     liveTui?.close();
                     liveTui = null;
                     io.stdout.write(formatMemoryFlowFinalSummary(latestMemoryFlowSnapshot));
-                    return reportStatus(result.report) === 'done' ? 0 : 1;
+                    return ingestReportOutcome(result.report) === 'error' ? 1 : 0;
                 }
                 plainProgress?.flush();
                 await writeReportRecord(result.report, runOutputMode, io, {
@@ -644,7 +641,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                     renderStoredMemoryFlow: deps.renderStoredMemoryFlow,
                     env,
                 });
-                return reportStatus(result.report) === 'done' ? 0 : 1;
+                return ingestReportOutcome(result.report) === 'error' ? 1 : 0;
             }
             finally {
                 plainProgress?.flush();

package/dist/knowledge.d.ts

@@ -18,6 +18,11 @@ export type KtxKnowledgeArgs = {
     limit?: number;
     debug?: boolean;
     cliVersion: string;
+} | {
+    command: 'read';
+    projectDir: string;
+    key: string;
+    userId: string;
 };
 type KtxKnowledgeIo = import('./cli-runtime.js').KtxCliIo;
 interface KtxKnowledgeDeps {

package/dist/knowledge.js

@@ -1,6 +1,6 @@
 import { KtxIngestEmbeddingPortAdapter } from './context/llm/embedding-port.js';
 import { loadKtxProject } from './context/project/project.js';
-import { listLocalKnowledgePages, searchLocalKnowledgePages as defaultSearchLocalKnowledgePages } from './context/wiki/local-knowledge.js';
+import { listLocalKnowledgePages, readLocalKnowledgePage, searchLocalKnowledgePages as defaultSearchLocalKnowledgePages, } from './context/wiki/local-knowledge.js';
 import { resolveProjectEmbeddingProvider, } from './embedding-resolution.js';
 import { resolveOutputMode } from './io/mode.js';
 import { createRankBadgeFormatter, printList } from './io/print-list.js';
@@ -72,6 +72,15 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
             });
             return 0;
         }
+        if (args.command === 'read') {
+            const page = await readLocalKnowledgePage(project, { key: args.key, userId: args.userId });
+            if (!page) {
+                throw new Error(`No wiki page found for key '${args.key}'`);
+            }
+            const raw = await project.fileStore.readFile(page.path);
+            io.stdout.write(raw.content);
+            return 0;
+        }
         if (args.command === 'search') {
             const embeddingService = await wikiSearchEmbeddingService(project, deps, { cliVersion: args.cliVersion }, io);
             const search = deps.searchLocalKnowledgePages ?? defaultSearchLocalKnowledgePages;

package/dist/public-ingest-copy.js

@@ -11,7 +11,7 @@ const DATABASE_INGEST_REPLACEMENTS = [
         'Database enrichment failed after schema context completed',
     ],
     [/\bstructural scan\b/gi, 'schema context'],
-    [/\benriched scan\b/gi, 'deep database ingest'],
+    [/\benriched scan\b/gi, 'database ingest'],
     [/\bscan results\b/gi, 'database context'],
 ];
 export function publicDatabaseIngestMessage(message) {

package/dist/public-ingest.d.ts

@@ -2,14 +2,12 @@ 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';
 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 +17,6 @@ export type KtxPublicIngestArgs = {
     all: boolean;
     json: boolean;
     inputMode: KtxPublicIngestInputMode;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {
@@ -37,7 +34,6 @@ export interface KtxPublicIngestPlanTarget {
     sourceDir?: string;
     debugCommand: string;
     steps: KtxPublicIngestStepName[];
-    databaseDepth?: KtxPublicIngestDepth;
     detectRelationships?: boolean;
     preflightFailure?: string;
     queryHistory?: {
@@ -46,7 +42,6 @@ export interface KtxPublicIngestPlanTarget {
         windowDays?: number;
         pullConfig?: Record<string, unknown>;
         unsupported?: boolean;
-        skippedStoredByFast?: boolean;
     };
 }
 export interface KtxPublicIngestPlan {
@@ -94,7 +89,6 @@ interface KtxPublicContextBuildArgs {
     inputMode: 'auto' | 'disabled';
     targetConnectionId?: string;
     all?: boolean;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {
@@ -108,7 +102,6 @@ export declare function buildPublicIngestPlan(project: KtxPublicIngestProject, a
     projectDir: string;
     targetConnectionId?: string;
     all: boolean;
-    depth?: KtxPublicIngestDepth;
     queryHistory?: KtxPublicIngestQueryHistoryFlag;
     queryHistoryWindowDays?: number;
     scanMode?: Extract<KtxScanArgs, {

package/dist/public-ingest.js

@@ -1,6 +1,6 @@
 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 { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { publicIngestOutputLine } from './public-ingest-copy.js';
 import { resolvePublicIngestRuntimeRequirements } from './runtime-requirements.js';
@@ -25,7 +25,6 @@ const queryHistoryDialectByDriver = new Map([
 function createWarningAccumulator() {
     return {
         warnings: [],
-        ignoredDepthForSources: [],
         ignoredQueryHistoryForSources: [],
         unsupportedQueryHistoryForDatabases: [],
     };
@@ -71,12 +70,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)
@@ -135,7 +128,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 +143,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,
@@ -177,28 +163,30 @@ function resolveDatabaseTargetOptions(input) {
             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'],
     };
 }
+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 +202,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 +269,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;
@@ -499,7 +486,7 @@ 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 } : {}),
@@ -622,7 +609,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 } : {}),