@kaelio/ktx 0.1.0 → 0.2.0

package/node_modules/@ktx/context/dist/project/config.d.ts

@@ -69,7 +69,6 @@ declare const llmSchema: z.ZodObject<{
 }, z.core.$strict>;
 declare const embeddingSchema: z.ZodObject<{
     backend: z.ZodDefault<z.ZodEnum<{
-        deterministic: "deterministic";
         none: "none";
         openai: "openai";
         "sentence-transformers": "sentence-transformers";
@@ -102,7 +101,6 @@ declare const scanEnrichmentSchema: z.ZodObject<{
     }>>;
     embeddings: z.ZodOptional<z.ZodObject<{
         backend: z.ZodDefault<z.ZodEnum<{
-            deterministic: "deterministic";
             none: "none";
             openai: "openai";
             "sentence-transformers": "sentence-transformers";
@@ -141,7 +139,6 @@ declare const scanSchema: z.ZodObject<{
         }>>;
         embeddings: z.ZodOptional<z.ZodObject<{
             backend: z.ZodDefault<z.ZodEnum<{
-                deterministic: "deterministic";
                 none: "none";
                 openai: "openai";
                 "sentence-transformers": "sentence-transformers";
@@ -462,7 +459,6 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
         adapters: z.ZodDefault<z.ZodArray<z.ZodString>>;
         embeddings: z.ZodPrefault<z.ZodObject<{
             backend: z.ZodDefault<z.ZodEnum<{
-                deterministic: "deterministic";
                 none: "none";
                 openai: "openai";
                 "sentence-transformers": "sentence-transformers";
@@ -507,7 +503,6 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
             }>>;
             embeddings: z.ZodOptional<z.ZodObject<{
                 backend: z.ZodDefault<z.ZodEnum<{
-                    deterministic: "deterministic";
                     none: "none";
                     openai: "openai";
                     "sentence-transformers": "sentence-transformers";

package/node_modules/@ktx/context/dist/project/config.js

@@ -3,7 +3,7 @@ import YAML from 'yaml';
 import * as z from 'zod';
 import { connectionConfigSchema } from './driver-schemas.js';
 const KTX_LLM_BACKENDS = ['none', 'anthropic', 'vertex', 'gateway', 'claude-code'];
-const KTX_EMBEDDING_BACKENDS = ['none', 'deterministic', 'openai', 'sentence-transformers'];
+const KTX_EMBEDDING_BACKENDS = ['none', 'openai', 'sentence-transformers'];
 const KTX_PROMPT_CACHE_TTLS = ['5m', '1h'];
 const KTX_ENRICHMENT_MODES = ['none', 'deterministic', 'llm'];
 const KTX_WORK_UNIT_FAILURE_MODES = ['abort', 'continue'];
@@ -69,9 +69,9 @@ const embeddingSchema = z
     .strictObject({
     backend: z
         .enum(KTX_EMBEDDING_BACKENDS)
-        .default('deterministic')
-        .describe('Embedding backend. "deterministic" is a built-in hash-based vector for offline use; "openai" and "sentence-transformers" call out to those providers; "none" disables embeddings.'),
-    model: z.string().min(1).optional().describe('Provider-specific embedding model identifier (e.g. "text-embedding-3-small"). Ignored by the "deterministic" backend.'),
+        .default('none')
+        .describe('Embedding backend. "openai" and "sentence-transformers" call out to those providers; "none" disables embeddings.'),
+    model: z.string().min(1).optional().describe('Provider-specific embedding model identifier (e.g. "text-embedding-3-small").'),
     dimensions: z.int().positive().default(8).describe('Embedding vector dimensionality. Must match the chosen model when using a real provider.'),
     openai: apiCredentialsSchema.optional().describe('OpenAI credentials, used when backend is "openai".'),
     sentenceTransformers: sentenceTransformersSchema.optional().describe('Sentence-transformers server config, used when backend is "sentence-transformers".'),
@@ -95,7 +95,7 @@ const ingestSchema = z
         .default([])
         .describe('Ingest adapter identifiers to run (e.g. "metabase", "looker", "historic-sql"). Empty array means no adapters are run.'),
     embeddings: embeddingSchema
-        .prefault({ backend: 'deterministic', model: 'deterministic' })
+        .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.'),
 })

package/node_modules/@ktx/context/dist/project/config.test.js

@@ -32,8 +32,7 @@ connections:
             ingest: {
                 adapters: [],
                 embeddings: {
-                    backend: 'deterministic',
-                    model: 'deterministic',
+                    backend: 'none',
                     dimensions: 8,
                 },
                 workUnits: {
@@ -75,11 +74,10 @@ connections:
         const parsed = parseKtxProjectConfig(serialized);
         expect(serialized).not.toContain('project:');
         expect(serialized).not.toContain('live-database');
-        expect(serialized).toContain('  embeddings:\n    backend: deterministic\n    model: deterministic\n    dimensions: 8');
+        expect(serialized).toContain('  embeddings:\n    backend: none\n    dimensions: 8');
         expect(parsed.ingest.adapters).toEqual([]);
         expect(parsed.ingest.embeddings).toEqual({
-            backend: 'deterministic',
-            model: 'deterministic',
+            backend: 'none',
             dimensions: 8,
         });
     });
@@ -350,8 +348,7 @@ scan:
         const config = parseKtxProjectConfig('{}\n');
         expect(config).toEqual(buildDefaultKtxProjectConfig());
         expect(config.ingest.embeddings).toEqual({
-            backend: 'deterministic',
-            model: 'deterministic',
+            backend: 'none',
             dimensions: 8,
         });
     });

package/node_modules/@ktx/context/dist/scan/enrichment-state.test.js

@@ -48,13 +48,13 @@ describe('scan enrichment state', () => {
             snapshot,
             mode: 'enriched',
             detectRelationships: true,
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 8, llmModel: 'a' },
+            providerIdentity: { provider: 'local-heuristic', llmModel: 'a' },
         });
         const second = computeKtxScanEnrichmentInputHash({
             snapshot: { ...snapshot, metadata: {} },
             mode: 'enriched',
             detectRelationships: true,
-            providerIdentity: { llmModel: 'a', embeddingDimensions: 8, provider: 'deterministic' },
+            providerIdentity: { llmModel: 'a', provider: 'local-heuristic' },
         });
         const firstTable = snapshot.tables[0];
         if (!firstTable) {
@@ -64,7 +64,7 @@ describe('scan enrichment state', () => {
             snapshot: { ...snapshot, tables: [{ ...firstTable, name: 'orders_v2' }] },
             mode: 'enriched',
             detectRelationships: true,
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 8, llmModel: 'a' },
+            providerIdentity: { provider: 'local-heuristic', llmModel: 'a' },
         });
         expect(first).toMatch(/^[a-f0-9]{64}$/);
         expect(second).toBe(first);
@@ -75,7 +75,7 @@ describe('scan enrichment state', () => {
             snapshot,
             mode: 'enriched',
             detectRelationships: true,
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 8 },
+            providerIdentity: { provider: 'local-heuristic' },
         });
         await store.saveCompletedStage({
             runId: 'scan-run-1',

package/node_modules/@ktx/context/dist/scan/index.d.ts

@@ -13,7 +13,7 @@ export { createKtxEntityDetailsService } from './entity-details.js';
 export type { DisplayTargetResolution, RawSchemaHit, TableDetail, WarehouseCatalogServiceDeps, } from './warehouse-catalog.js';
 export { WarehouseCatalogService } from './warehouse-catalog.js';
 export type { KtxColumnSampleUpdate, KtxDescriptionSource, KtxDescriptionUpdate, KtxEmbeddingUpdate, KtxEnrichedColumn, KtxEnrichedRelationship, KtxEnrichedSchema, KtxEnrichedTable, KtxRelationshipEndpoint, KtxRelationshipSource, KtxRelationshipType, KtxRelationshipUpdate, KtxScanMetadataStore, KtxSkippedRelationship, KtxStructuralSyncPlan, } from './enrichment-types.js';
-export type { DeterministicLocalScanEnrichmentProviderOptions, KtxLocalScanEnrichmentInput, KtxLocalScanEnrichmentProviders, KtxLocalScanEnrichmentResult, } from './local-enrichment.js';
+export type { KtxLocalScanEnrichmentInput, KtxLocalScanEnrichmentProviders, KtxLocalScanEnrichmentResult, } from './local-enrichment.js';
 export { createDeterministicLocalScanEnrichmentProviders, runLocalScanEnrichment, snapshotToKtxEnrichedSchema, } from './local-enrichment.js';
 export type { WriteLocalScanEnrichmentArtifactsInput, WriteLocalScanEnrichmentArtifactsResult, WriteLocalScanManifestShardsInput, WriteLocalScanManifestShardsResult, } from './local-enrichment-artifacts.js';
 export { writeLocalScanEnrichmentArtifacts, writeLocalScanManifestShards, } from './local-enrichment-artifacts.js';

package/node_modules/@ktx/context/dist/scan/local-enrichment.d.ts

@@ -6,13 +6,9 @@ import type { KtxCompositeRelationshipCandidate } from './relationship-composite
 import type { KtxResolvedRelationshipDiscoveryCandidate } from './relationship-graph-resolver.js';
 import type { KtxRelationshipProfileArtifact } from './relationship-profiling.js';
 import type { KtxEmbeddingPort, KtxScanConnector, KtxScanContext, KtxScanEnrichmentStateSummary, KtxScanEnrichmentSummary, KtxScanMode, KtxScanRelationshipSummary, KtxScanWarning, KtxSchemaSnapshot, KtxTableRef } from './types.js';
-export interface DeterministicLocalScanEnrichmentProviderOptions {
-    embeddingDimensions?: number;
-    maxBatchSize?: number;
-}
 export interface KtxLocalScanEnrichmentProviders {
     llmRuntime: KtxLlmRuntimePort;
-    embedding: KtxEmbeddingPort;
+    embedding?: KtxEmbeddingPort | null;
 }
 export interface KtxLocalScanEnrichmentInput {
     connectionId: string;
@@ -44,6 +40,6 @@ export interface KtxLocalScanEnrichmentResult {
     resolvedRelationships: KtxResolvedRelationshipDiscoveryCandidate[] | null;
     compositeRelationships: KtxCompositeRelationshipCandidate[] | null;
 }
-export declare function createDeterministicLocalScanEnrichmentProviders(options?: DeterministicLocalScanEnrichmentProviderOptions): KtxLocalScanEnrichmentProviders;
+export declare function createDeterministicLocalScanEnrichmentProviders(): KtxLocalScanEnrichmentProviders;
 export declare function snapshotToKtxEnrichedSchema(snapshot: KtxSchemaSnapshot, embeddingsByColumnId?: ReadonlyMap<string, number[]>): KtxEnrichedSchema;
 export declare function runLocalScanEnrichment(input: KtxLocalScanEnrichmentInput): Promise<KtxLocalScanEnrichmentResult>;

package/node_modules/@ktx/context/dist/scan/local-enrichment.js

@@ -76,28 +76,9 @@ function providerlessEnrichedWarning(relationshipDetection) {
         },
     };
 }
-function hashEmbedding(text, dimensions) {
-    const values = Array.from({ length: dimensions }, (_, index) => {
-        let hash = index + 17;
-        for (const char of text) {
-            hash = (hash * 31 + char.charCodeAt(0) + index) % 1009;
-        }
-        return Number(((hash % 200) / 100 - 1).toFixed(4));
-    });
-    return values;
-}
-export function createDeterministicLocalScanEnrichmentProviders(options = {}) {
-    const dimensions = options.embeddingDimensions ?? 8;
-    const maxBatchSize = options.maxBatchSize ?? 64;
+export function createDeterministicLocalScanEnrichmentProviders() {
     return {
         llmRuntime: deterministicLlmRuntime(),
-        embedding: {
-            dimensions,
-            maxBatchSize,
-            async embedBatch(texts) {
-                return texts.map((text) => hashEmbedding(text, dimensions));
-            },
-        },
     };
 }
 function deterministicLlmRuntime() {
@@ -262,7 +243,7 @@ async function buildEmbeddings(input) {
         }
     }
     const embeddings = [];
-    const maxBatchSize = embeddingBatchSize(input.providers.embedding.maxBatchSize);
+    const maxBatchSize = embeddingBatchSize(input.embedding.maxBatchSize);
     const embeddingTexts = texts.map((item) => item.text);
     const batchCount = Math.ceil(embeddingTexts.length / maxBatchSize);
     if (batchCount === 0) {
@@ -274,7 +255,7 @@ async function buildEmbeddings(input) {
             transient: true,
         });
         const batch = embeddingTexts.slice(offset, offset + maxBatchSize);
-        const batchEmbeddings = await input.providers.embedding.embedBatch(batch);
+        const batchEmbeddings = await input.embedding.embedBatch(batch);
         if (batchEmbeddings.length !== batch.length) {
             throw new Error(`expected ${batch.length} embeddings, received ${batchEmbeddings.length}`);
         }
@@ -395,34 +376,37 @@ export async function runLocalScanEnrichment(input) {
                 warnings,
             }),
         });
-        const embeddingProgress = progress?.startPhase(0.2);
-        embeddingUpdates = await runEnrichmentStage({
-            stateStore: input.stateStore,
-            runId: input.context.runId,
-            connectionId: input.connectionId,
-            syncId,
-            mode: input.mode,
-            stage: 'embeddings',
-            inputHash,
-            now,
-            resumedStages: state.resumedStages,
-            completedStages: state.completedStages,
-            failedStages: state.failedStages,
-            compute: async () => {
-                const embeddings = await buildEmbeddings({
-                    snapshot,
-                    providers,
-                    descriptions,
-                    progress: embeddingProgress,
-                });
-                return embeddings.updates;
-            },
-        });
-        schema = snapshotToKtxEnrichedSchema(snapshot, embeddingsByColumnId(embeddingUpdates));
         summary.dataDictionary = input.connector.sampleColumn ? 'completed' : 'skipped';
         summary.tableDescriptions = 'completed';
         summary.columnDescriptions = 'completed';
-        summary.embeddings = 'completed';
+        const embeddingProgress = progress?.startPhase(0.2);
+        const embedding = providers.embedding;
+        if (embedding) {
+            embeddingUpdates = await runEnrichmentStage({
+                stateStore: input.stateStore,
+                runId: input.context.runId,
+                connectionId: input.connectionId,
+                syncId,
+                mode: input.mode,
+                stage: 'embeddings',
+                inputHash,
+                now,
+                resumedStages: state.resumedStages,
+                completedStages: state.completedStages,
+                failedStages: state.failedStages,
+                compute: async () => {
+                    const embeddings = await buildEmbeddings({
+                        snapshot,
+                        embedding,
+                        descriptions,
+                        progress: embeddingProgress,
+                    });
+                    return embeddings.updates;
+                },
+            });
+            schema = snapshotToKtxEnrichedSchema(snapshot, embeddingsByColumnId(embeddingUpdates));
+            summary.embeddings = 'completed';
+        }
     }
     let relationshipUpdate = null;
     let relationshipProfile = null;

package/node_modules/@ktx/context/dist/scan/local-enrichment.test.js

@@ -4,6 +4,15 @@ import { buildDefaultKtxProjectConfig } from '../project/config.js';
 import { createDeterministicLocalScanEnrichmentProviders, runLocalScanEnrichment, snapshotToKtxEnrichedSchema, } from './local-enrichment.js';
 import { createLocalScanEnrichmentProvidersFromConfig } from './local-scan.js';
 import { createKtxConnectorCapabilities, } from './types.js';
+function fakeScanEmbedding(options) {
+    return {
+        dimensions: options.dimensions,
+        maxBatchSize: options.maxBatchSize ?? 64,
+        async embedBatch(texts) {
+            return texts.map((_, textIndex) => Array.from({ length: options.dimensions }, (__, dimensionIndex) => textIndex + dimensionIndex));
+        },
+    };
+}
 const snapshot = {
     connectionId: 'warehouse',
     driver: 'postgres',
@@ -317,7 +326,7 @@ describe('local scan enrichment', () => {
         }
     });
     it('honors scan relationship config when LLM proposals are disabled', async () => {
-        const providers = createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 3 });
+        const providers = createDeterministicLocalScanEnrichmentProviders();
         const generateObject = vi.fn();
         const result = await runLocalScanEnrichment({
             connectionId: 'warehouse',
@@ -381,7 +390,7 @@ describe('local scan enrichment', () => {
             detectRelationships: false,
             connector: failingConnector,
             context: { runId: 'scan-run-warnings', logger },
-            providers: createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 6 }),
+            providers: createDeterministicLocalScanEnrichmentProviders(),
         });
         const codes = result.warnings.map((warning) => warning.code);
         expect(codes).toContain('sampling_failed');
@@ -394,24 +403,23 @@ describe('local scan enrichment', () => {
         // Sampling was retried 3× for each of the 2 tables = 6 calls
         expect(failingConnector.sampleTable).toHaveBeenCalledTimes(6);
     });
-    it('runs configured deterministic enrichment with descriptions and embeddings', async () => {
+    it('runs configured deterministic enrichment with descriptions and no embeddings', async () => {
         const result = await runLocalScanEnrichment({
             connectionId: 'warehouse',
             mode: 'enriched',
             detectRelationships: true,
             connector: connector(),
             context: { runId: 'scan-run-2' },
-            providers: createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 6 }),
+            providers: createDeterministicLocalScanEnrichmentProviders(),
         });
         expect(result.summary).toMatchObject({
             dataDictionary: 'completed',
             tableDescriptions: 'completed',
             columnDescriptions: 'completed',
-            embeddings: 'completed',
+            embeddings: 'skipped',
             deterministicRelationships: 'completed',
         });
-        expect(result.embeddingUpdates).toHaveLength(3);
-        expect(result.embeddingUpdates[0]?.embedding).toHaveLength(6);
+        expect(result.embeddingUpdates).toEqual([]);
         expect(result.snapshot).toEqual(snapshot);
         expect(result.relationships).toEqual({ accepted: 0, review: 1, rejected: 0, skipped: 0 });
     });
@@ -470,7 +478,7 @@ describe('local scan enrichment', () => {
             mode: 'enriched',
             connector: scanConnector,
             context: { runId: 'scan-run-concurrent-descriptions' },
-            providers: createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 3 }),
+            providers: createDeterministicLocalScanEnrichmentProviders(),
             relationshipSettings: settings,
         });
         expect(maxActiveColumnSamples).toBe(6);
@@ -491,7 +499,10 @@ describe('local scan enrichment', () => {
             detectRelationships: true,
             connector: connector(),
             context: { runId: 'scan-run-progress', progress },
-            providers: createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 6 }),
+            providers: {
+                ...createDeterministicLocalScanEnrichmentProviders(),
+                embedding: fakeScanEmbedding({ dimensions: 6 }),
+            },
         });
         expect(events).toEqual(expect.arrayContaining([
             expect.objectContaining({ message: 'Generating descriptions 1/2 tables', transient: true }),
@@ -555,7 +566,7 @@ describe('local scan enrichment', () => {
             ...connector(),
             introspect: vi.fn(async () => manyColumnSnapshot),
         };
-        const deterministicProviders = createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 3 });
+        const deterministicProviders = createDeterministicLocalScanEnrichmentProviders();
         const embedBatch = vi.fn(async (texts) => {
             if (texts.length > 2) {
                 throw new Error(`Embedding batch size ${texts.length} exceeds maximum 2`);
@@ -583,7 +594,10 @@ describe('local scan enrichment', () => {
     it('reuses completed description and embedding stages for the same run id and snapshot hash', async () => {
         const stateStore = memoryEnrichmentStateStore();
         const scanConnector = connector();
-        const providers = createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 6 });
+        const providers = {
+            ...createDeterministicLocalScanEnrichmentProviders(),
+            embedding: fakeScanEmbedding({ dimensions: 6 }),
+        };
         const first = await runLocalScanEnrichment({
             connectionId: 'warehouse',
             mode: 'enriched',
@@ -593,7 +607,7 @@ describe('local scan enrichment', () => {
             providers,
             stateStore,
             syncId: 'sync-resume-1',
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 6 },
+            providerIdentity: { provider: 'fake', embeddingDimensions: 6 },
         });
         const generateText = vi.spyOn(providers.llmRuntime, 'generateText');
         const embedBatch = vi.spyOn(providers.embedding, 'embedBatch');
@@ -606,7 +620,7 @@ describe('local scan enrichment', () => {
             providers,
             stateStore,
             syncId: 'sync-resume-1',
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 6 },
+            providerIdentity: { provider: 'fake', embeddingDimensions: 6 },
         });
         expect(first.state.completedStages).toEqual(['descriptions', 'embeddings', 'relationships']);
         expect(first.state.resumedStages).toEqual([]);
@@ -620,7 +634,10 @@ describe('local scan enrichment', () => {
     });
     it('does not reuse completed stages when the snapshot changes', async () => {
         const stateStore = memoryEnrichmentStateStore();
-        const providers = createDeterministicLocalScanEnrichmentProviders({ embeddingDimensions: 6 });
+        const providers = {
+            ...createDeterministicLocalScanEnrichmentProviders(),
+            embedding: fakeScanEmbedding({ dimensions: 6 }),
+        };
         const scanConnector = connector();
         await runLocalScanEnrichment({
             connectionId: 'warehouse',
@@ -631,7 +648,7 @@ describe('local scan enrichment', () => {
             providers,
             stateStore,
             syncId: 'sync-resume-hash',
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 6 },
+            providerIdentity: { provider: 'fake', embeddingDimensions: 6 },
         });
         const firstTable = snapshot.tables[0];
         if (!firstTable) {
@@ -654,7 +671,7 @@ describe('local scan enrichment', () => {
             providers,
             stateStore,
             syncId: 'sync-resume-hash',
-            providerIdentity: { provider: 'deterministic', embeddingDimensions: 6 },
+            providerIdentity: { provider: 'fake', embeddingDimensions: 6 },
         });
         expect(result.state.resumedStages).toEqual([]);
         expect(result.state.completedStages).toEqual(['descriptions', 'embeddings', 'relationships']);
@@ -749,8 +766,8 @@ describe('local scan enrichment', () => {
             createKtxEmbeddingProvider: createKtxEmbeddingProvider,
             env: { OPENAI_API_KEY: 'openai-key' }, // pragma: allowlist secret
         });
-        expect(providers?.embedding.dimensions).toBe(1536);
-        expect(providers?.embedding.maxBatchSize).toBe(8);
+        expect(providers?.embedding?.dimensions).toBe(1536);
+        expect(providers?.embedding?.maxBatchSize).toBe(8);
         expect(createKtxLlmProvider).toHaveBeenCalledWith(expect.objectContaining({ backend: 'gateway', modelSlots: { default: 'provider/language-model' } }));
         expect(createKtxEmbeddingProvider).toHaveBeenCalledWith(expect.objectContaining({ backend: 'openai', model: 'provider/embedding-model' }));
     });

package/node_modules/@ktx/context/dist/scan/local-scan.test.js

@@ -916,7 +916,7 @@ describe('local scan', () => {
         expect(persistedReport).toContain('postgres://reader:<redacted>@example.test/db');
         expect(persistedReport).not.toContain('postgres://reader:secret@example.test/db'); // pragma: allowlist secret
     });
-    it('runs enriched scans when deterministic standalone enrichment is configured', async () => {
+    it('runs enriched scans when deterministic standalone enrichment is configured without embeddings', async () => {
         await writeFile(join(project.projectDir, 'ktx.yaml'), [
             'connections:',
             '  warehouse:',
@@ -995,10 +995,9 @@ describe('local scan', () => {
         expect(result.report.mode).toBe('enriched');
         expect(result.report.enrichment.tableDescriptions).toBe('completed');
         expect(result.report.enrichment.columnDescriptions).toBe('completed');
-        expect(result.report.enrichment.embeddings).toBe('completed');
+        expect(result.report.enrichment.embeddings).toBe('skipped');
         expect(result.report.artifactPaths.enrichmentArtifacts).toEqual([
             'raw-sources/warehouse/live-database/2026-04-29-091500-scan-enriched-1/enrichment/descriptions.json',
-            'raw-sources/warehouse/live-database/2026-04-29-091500-scan-enriched-1/enrichment/embeddings.json',
             'raw-sources/warehouse/live-database/2026-04-29-091500-scan-enriched-1/enrichment/relationships.json',
             'raw-sources/warehouse/live-database/2026-04-29-091500-scan-enriched-1/enrichment/relationship-profile.json',
             'raw-sources/warehouse/live-database/2026-04-29-091500-scan-enriched-1/enrichment/relationship-diagnostics.json',

package/node_modules/@ktx/context/dist/sl/ports.d.ts

@@ -50,9 +50,9 @@ export interface SlSourcesIndexPort {
         searchText: string;
         hasEmbedding: boolean;
     }>>;
-    deleteStale(connectionId: string, keepNames: string[]): Promise<void>;
-    deleteByConnection(connectionId: string): Promise<void>;
-    deleteByConnectionAndName(connectionId: string, sourceName: string): Promise<void>;
+    deleteStale(connectionId: string, keepNames: string[]): Promise<number>;
+    deleteByConnection(connectionId: string): Promise<number>;
+    deleteByConnectionAndName(connectionId: string, sourceName: string): Promise<number>;
     search(connectionId: string, queryEmbedding: number[] | null, queryText: string, limit: number, minRrfScore?: number): Promise<Array<{
         sourceName: string;
         rrfScore: number;

package/node_modules/@ktx/context/dist/sl/sl-search.service.d.ts

@@ -1,4 +1,5 @@
 import type { KtxEmbeddingPort, KtxLogger } from '../core/index.js';
+import type { ReindexWorkResult } from '../index-sync/types.js';
 import type { SlSourcesIndexPort } from './ports.js';
 import type { SemanticLayerSource } from './types.js';
 export declare function buildSemanticLayerSourceSearchText(source: SemanticLayerSource, priority?: string[]): string;
@@ -6,8 +7,8 @@ export declare class SlSearchService {
     private readonly embeddingService;
     private readonly slSourcesRepository;
     private readonly logger;
-    constructor(embeddingService: KtxEmbeddingPort, slSourcesRepository: SlSourcesIndexPort, logger?: KtxLogger);
-    indexSources(connectionId: string, sources: SemanticLayerSource[]): Promise<void>;
+    constructor(embeddingService: KtxEmbeddingPort | null, slSourcesRepository: SlSourcesIndexPort, logger?: KtxLogger);
+    indexSources(connectionId: string, sources: SemanticLayerSource[]): Promise<ReindexWorkResult>;
     search(connectionId: string, query: string, limit?: number, minRrfScore?: number): Promise<Array<{
         sourceName: string;
         score: number;

package/node_modules/@ktx/context/dist/sl/sl-search.service.js

@@ -84,64 +84,66 @@ export class SlSearchService {
         this.logger = logger;
     }
     async indexSources(connectionId, sources) {
+        const existing = await this.slSourcesRepository.getExistingSearchTexts(connectionId);
         if (sources.length === 0) {
-            await this.slSourcesRepository.deleteByConnection(connectionId);
-            return;
+            const deleted = await this.slSourcesRepository.deleteByConnection(connectionId);
+            return { scanned: 0, updated: 0, deleted, embeddingsRecomputed: 0, embeddingsFailed: 0 };
         }
-        // Detect which sources actually changed by comparing search_text
-        const existing = await this.slSourcesRepository.getExistingSearchTexts(connectionId);
         const searchTexts = sources.map((s) => this.buildSearchText(s));
+        const embeddingService = this.embeddingService;
         const changedIndices = [];
-        for (let i = 0; i < sources.length; i++) {
-            const prev = existing.get(sources[i].name);
-            if (!prev || prev.searchText !== searchTexts[i] || !prev.hasEmbedding) {
+        for (let i = 0; i < sources.length; i += 1) {
+            const previous = existing.get(sources[i].name);
+            if (!previous ||
+                previous.searchText !== searchTexts[i] ||
+                (embeddingService !== null && !previous.hasEmbedding)) {
                 changedIndices.push(i);
             }
         }
-        if (changedIndices.length === 0) {
-            // Still clean up stale sources even if nothing changed
-            const keepNames = sources.map((s) => s.name);
-            await this.slSourcesRepository.deleteStale(connectionId, keepNames);
-            this.logger.log(`SL sources for connection ${connectionId}: all ${sources.length} up to date, 0 reindexed`);
-            return;
-        }
-        // Compute embeddings only for changed sources
-        const changedTexts = changedIndices.map((i) => searchTexts[i]);
-        let changedEmbeddings;
-        try {
-            const batchSize = this.embeddingService.maxBatchSize;
-            const allEmbeddings = [];
-            for (let i = 0; i < changedTexts.length; i += batchSize) {
-                const batch = changedTexts.slice(i, i + batchSize);
-                const batchEmbeddings = await this.embeddingService.computeEmbeddingsBulk(batch);
-                allEmbeddings.push(...batchEmbeddings);
+        let changedEmbeddings = changedIndices.map(() => null);
+        let embeddingsRecomputed = 0;
+        let embeddingsFailed = 0;
+        if (embeddingService && changedIndices.length > 0) {
+            try {
+                const changedTexts = changedIndices.map((index) => searchTexts[index]);
+                const allEmbeddings = [];
+                for (let i = 0; i < changedTexts.length; i += embeddingService.maxBatchSize) {
+                    const batch = changedTexts.slice(i, i + embeddingService.maxBatchSize);
+                    allEmbeddings.push(...(await embeddingService.computeEmbeddingsBulk(batch)));
+                }
+                changedEmbeddings = allEmbeddings;
+                embeddingsRecomputed = allEmbeddings.length;
+            }
+            catch (error) {
+                this.logger.warn(`Failed to compute SL source embeddings: ${error instanceof Error ? error.message : String(error)}`);
+                embeddingsFailed = changedIndices.length;
             }
-            changedEmbeddings = allEmbeddings;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to compute SL source embeddings: ${error instanceof Error ? error.message : String(error)}`);
-            changedEmbeddings = changedIndices.map(() => null);
         }
-        const rows = changedIndices.map((srcIdx, i) => {
-            return {
-                sourceName: sources[srcIdx].name,
-                searchText: searchTexts[srcIdx],
-                embedding: changedEmbeddings[i],
-            };
-        });
+        const rows = changedIndices.map((sourceIndex, embeddingIndex) => ({
+            sourceName: sources[sourceIndex].name,
+            searchText: searchTexts[sourceIndex],
+            embedding: changedEmbeddings[embeddingIndex] ?? null,
+        }));
         await this.slSourcesRepository.upsertSources(connectionId, rows);
-        // Remove sources that no longer exist in YAML
-        const keepNames = sources.map((s) => s.name);
-        await this.slSourcesRepository.deleteStale(connectionId, keepNames);
-        this.logger.log(`SL sources for connection ${connectionId}: ${changedIndices.length}/${sources.length} reindexed, ${sources.length - changedIndices.length} unchanged`);
+        const keepNames = sources.map((source) => source.name);
+        const deleted = await this.slSourcesRepository.deleteStale(connectionId, keepNames);
+        return {
+            scanned: sources.length,
+            updated: changedIndices.length,
+            deleted,
+            embeddingsRecomputed,
+            embeddingsFailed,
+        };
     }
     async search(connectionId, query, limit = 15, minRrfScore = 0) {
         let queryEmbedding = null;
-        try {
-            queryEmbedding = await this.embeddingService.computeEmbedding(query);
-        }
-        catch (error) {
-            this.logger.warn(`Failed to compute query embedding, falling back to FTS + trigram: ${error instanceof Error ? error.message : String(error)}`);
+        if (this.embeddingService) {
+            try {
+                queryEmbedding = await this.embeddingService.computeEmbedding(query);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to compute query embedding, falling back to FTS + trigram: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         const results = await this.slSourcesRepository.search(connectionId, queryEmbedding, query, limit, minRrfScore);
         return results.map((result) => ({