@kaelio/ktx 0.3.0 → 0.4.1

package/dist/managed-local-embeddings.test.js

@@ -1,6 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
-import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, tryUseManagedLocalEmbeddingsDaemon, } from './managed-local-embeddings.js';
 function makeIo() {
     let stdout = '';
     let stderr = '';
@@ -84,22 +83,6 @@ function daemonResult(status = 'reused') {
         },
     };
 }
-describe('managedLocalEmbeddingProjectConfig', () => {
-    it('uses a stable managed runtime marker instead of a random daemon port', () => {
-        expect(managedLocalEmbeddingProjectConfig({
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-        })).toEqual({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-            sentenceTransformers: {
-                base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
-                pathPrefix: '',
-            },
-        });
-    });
-});
 describe('managedLocalEmbeddingHealthConfig', () => {
     it('uses the active KTX daemon URL for the immediate health check', () => {
         expect(managedLocalEmbeddingHealthConfig({
@@ -158,3 +141,89 @@ describe('ensureManagedLocalEmbeddingsDaemon', () => {
         expect(io.stderr()).toContain('Using KTX daemon: http://127.0.0.1:61234');
     });
 });
+describe('tryUseManagedLocalEmbeddingsDaemon', () => {
+    it('returns the daemon when one is running and healthy', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'running',
+            detail: 'ok',
+            layout: {},
+            state: {
+                schemaVersion: 1,
+                pid: 123,
+                host: '127.0.0.1',
+                port: 4321,
+                version: '0.5.0',
+                features: ['local-embeddings'],
+                startedAt: '2026-05-21T00:00:00Z',
+                stdoutLog: '/tmp/stdout.log',
+                stderrLog: '/tmp/stderr.log',
+            },
+            baseUrl: 'http://127.0.0.1:4321',
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toEqual({
+            baseUrl: 'http://127.0.0.1:4321',
+            stdoutLog: '/tmp/stdout.log',
+            stderrLog: '/tmp/stderr.log',
+        });
+        expect(readStatus).toHaveBeenCalledWith({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+        });
+    });
+    it('returns null when no daemon state exists', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'stopped',
+            detail: 'no state',
+            layout: {},
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+    it('returns null when daemon is stale', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'stale',
+            detail: 'process gone',
+            layout: {},
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+    it('rejects daemons that do not advertise local-embeddings', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'running',
+            detail: 'ok',
+            layout: {},
+            state: {
+                schemaVersion: 1,
+                pid: 123,
+                host: '127.0.0.1',
+                port: 4321,
+                version: '0.5.0',
+                features: ['core'],
+                startedAt: '2026-05-21T00:00:00Z',
+                stdoutLog: '/tmp/stdout.log',
+                stderrLog: '/tmp/stderr.log',
+            },
+            baseUrl: 'http://127.0.0.1:4321',
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+});

package/dist/mcp-server-factory.js

@@ -1,5 +1,7 @@
+import { KtxIngestEmbeddingPortAdapter } from '@ktx/context';
 import { createDefaultKtxMcpServer, createLocalProjectMcpContextPorts } from '@ktx/context/mcp';
 import { createLocalProjectMemoryIngest } from '@ktx/context/memory';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
 import { createManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
@@ -24,10 +26,19 @@ export async function createKtxMcpServerFactory(input) {
         installPolicy: 'auto',
         io,
     });
+    const resolution = await resolveProjectEmbeddingProvider(input.project, {
+        mode: 'use-if-running',
+        cliVersion: input.cliVersion,
+        io,
+    });
+    const embeddingService = resolution.kind === 'configured' || resolution.kind === 'managed-running' || resolution.kind === 'managed-started'
+        ? new KtxIngestEmbeddingPortAdapter(resolution.provider)
+        : null;
     const contextTools = createLocalProjectMcpContextPorts(input.project, {
         semanticLayerCompute,
         queryExecutor,
         sqlAnalysis,
+        embeddingService,
         localScan: {
             createConnector: async (connectionId) => createKtxCliScanConnector(input.project, connectionId),
         },

package/dist/public-ingest.js

@@ -1,4 +1,4 @@
-import { loadKtxCliProject } from './cli-project.js';
+import { loadKtxProject } from '@ktx/context/project';
 import { databaseContextDepth, deepReadinessGaps, isDatabaseDriver, normalizeConnectionDriver, } from './ingest-depth.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { publicIngestOutputLine } from './public-ingest-copy.js';
@@ -536,13 +536,7 @@ export async function executePublicIngestTarget(target, args, io, deps) {
     return markTargetResult(target, args, exitCode === 0 ? 'done' : 'failed', 'source-ingest', capturedIngestIo ? capturedFailureMessage(capturedIngestIo.capturedOutput()) : undefined);
 }
 export async function runKtxPublicIngest(args, io, deps = {}) {
-    const loadProject = deps.loadProject ??
-        ((options) => loadKtxCliProject({
-            projectDir: options.projectDir,
-            cliVersion: args.cliVersion ?? '0.0.0-private',
-            installPolicy: args.runtimeInstallPolicy ?? 'never',
-            io,
-        }));
+    const loadProject = deps.loadProject ?? ((options) => loadKtxProject({ projectDir: options.projectDir }));
     const project = await loadProject({ projectDir: args.projectDir });
     if (shouldUseForegroundContextBuildView(args, io)) {
         const plan = buildPublicIngestPlan(project, args);

package/dist/runtime-requirements.js

@@ -1,4 +1,3 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 function normalizeDriver(driver) {
     return String(driver ?? '').trim().toLowerCase();
 }
@@ -22,7 +21,7 @@ function requiresManagedLocalEmbeddings(embeddings) {
         return false;
     }
     const baseUrl = embeddings.sentenceTransformers?.base_url;
-    return baseUrl === undefined || baseUrl === '' || baseUrl === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
+    return baseUrl === undefined || baseUrl === '';
 }
 function uniqueRequirements(requirements) {
     const seen = new Set();

package/dist/runtime-requirements.test.js

@@ -1,4 +1,3 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
 import { describe, expect, it } from 'vitest';
 import { resolveProjectRuntimeRequirements, resolvePublicIngestRuntimeRequirements, } from './runtime-requirements.js';
@@ -37,7 +36,7 @@ describe('runtime requirement detection', () => {
                     model: 'all-MiniLM-L6-v2',
                     dimensions: 384,
                     sentenceTransformers: {
-                        base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
+                        base_url: '',
                     },
                 },
             },

package/dist/scan.js

@@ -1,5 +1,6 @@
 import { runLocalScan, } from '@ktx/context/scan';
-import { loadKtxCliProject } from './cli-project.js';
+import { loadKtxProject } from '@ktx/context/project';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
 import { profileMark } from './startup-profile.js';
@@ -237,12 +238,14 @@ export function createCliScanProgress(io, state = { progress: 0, hasPendingTrans
 }
 export async function runKtxScan(args, io = process, deps = {}) {
     try {
-        const project = await loadKtxCliProject({
-            projectDir: args.projectDir,
-            cliVersion: args.cliVersion ?? '0.0.0-private',
+        const project = await loadKtxProject({ projectDir: args.projectDir });
+        const resolution = await resolveProjectEmbeddingProvider(project, {
+            mode: 'ensure',
             installPolicy: args.runtimeInstallPolicy ?? 'never',
+            cliVersion: args.cliVersion ?? '0.0.0-private',
             io,
         });
+        const embeddingProvider = resolution.kind === 'disabled' || resolution.kind === 'managed-unavailable' ? null : resolution.provider;
         const managedDaemon = managedDaemonOptionsForScanRun(args, deps.runtimeIo ?? io);
         const connector = args.mode !== 'structural' || args.detectRelationships
             ? await createKtxCliScanConnector(project, args.connectionId)
@@ -259,6 +262,7 @@ export async function runKtxScan(args, io = process, deps = {}) {
                 trigger: 'cli',
                 databaseIntrospectionUrl: args.databaseIntrospectionUrl,
                 connector,
+                embeddingProvider,
                 adapters: (deps.createLocalIngestAdapters ?? createKtxCliLocalIngestAdapters)(project, {
                     ...(args.databaseIntrospectionUrl ? { databaseIntrospectionUrl: args.databaseIntrospectionUrl } : {}),
                     ...(managedDaemon ? { managedDaemon } : {}),

package/dist/setup-embeddings.js

@@ -3,7 +3,7 @@ import { resolveKtxConfigReference } from '@ktx/context/core';
 import { loadKtxProject, markKtxSetupStateStepComplete, readKtxSetupState, serializeKtxProjectConfig, } from '@ktx/context/project';
 import { runKtxEmbeddingHealthCheck } from '@ktx/llm';
 import { createStaticCliSpinner } from './clack.js';
-import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, } from './managed-local-embeddings.js';
 import { withTextInputNavigation } from './prompt-navigation.js';
 import { envCredentialReference, writeProjectLocalSecretReference } from './setup-secrets.js';
 import { createKtxSetupPromptAdapter, } from './setup-prompts.js';
@@ -332,7 +332,11 @@ export async function runKtxSetupEmbeddingsStep(args, io, deps = {}) {
         if (health.ok) {
             progress.succeed(`Embedding test passed (${model}, ${dimensions} dimensions)`);
             await persistEmbeddingConfig(args.projectDir, selectedBackend === LOCAL_EMBEDDING_BACKEND
-                ? managedLocalEmbeddingProjectConfig({ model, dimensions })
+                ? {
+                    backend: 'sentence-transformers',
+                    model,
+                    dimensions,
+                }
                 : buildProjectEmbeddingConfig({
                     backend: selectedBackend,
                     model,

package/dist/setup-embeddings.test.js

@@ -44,9 +44,6 @@ function managedDaemon(baseUrl = 'http://127.0.0.1:61234', logs = {}) {
         baseUrl,
         stdoutLog: logs.stdoutLog ?? '/tmp/ktx-daemon.stdout.log',
         stderrLog: logs.stderrLog ?? '/tmp/ktx-daemon.stderr.log',
-        env: {
-            KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL: baseUrl,
-        },
     };
 }
 describe('setup embeddings step', () => {
@@ -142,8 +139,8 @@ describe('setup embeddings step', () => {
             backend: 'sentence-transformers',
             model: 'all-MiniLM-L6-v2',
             dimensions: 384,
-            sentenceTransformers: { base_url: 'managed:local-embeddings', pathPrefix: '' },
         });
+        expect(config.ingest.embeddings.sentenceTransformers).toBeUndefined();
         expect(config.scan.enrichment.embeddings).toMatchObject(config.ingest.embeddings);
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
         expect((await readKtxSetupState(tempDir)).completed_steps).toContain('embeddings');
@@ -216,8 +213,8 @@ describe('setup embeddings step', () => {
             backend: 'sentence-transformers',
             model: 'all-MiniLM-L6-v2',
             dimensions: 384,
-            sentenceTransformers: { base_url: 'managed:local-embeddings', pathPrefix: '' },
         });
+        expect(config.ingest.embeddings.sentenceTransformers).toBeUndefined();
         expect(config.scan.enrichment.embeddings).toMatchObject(config.ingest.embeddings);
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
         expect((await readKtxSetupState(tempDir)).completed_steps).toContain('embeddings');

package/dist/setup-runtime.test.js

@@ -1,7 +1,6 @@
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 import { buildDefaultKtxProjectConfig, readKtxSetupState } from '@ktx/context/project';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runKtxSetupRuntimeStep } from './setup-runtime.js';
@@ -79,7 +78,6 @@ describe('runKtxSetupRuntimeStep', () => {
             baseUrl: 'http://127.0.0.1:61234',
             stdoutLog: join(tempDir, '.ktx', 'runtime', 'daemon.stdout.log'),
             stderrLog: join(tempDir, '.ktx', 'runtime', 'daemon.stderr.log'),
-            env: { KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL: 'http://127.0.0.1:61234' },
         }));
         const config = {
             ...buildDefaultKtxProjectConfig(),
@@ -89,7 +87,7 @@ describe('runKtxSetupRuntimeStep', () => {
                     backend: 'sentence-transformers',
                     model: 'all-MiniLM-L6-v2',
                     dimensions: 384,
-                    sentenceTransformers: { base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL },
+                    sentenceTransformers: { base_url: '' },
                 },
             },
         };

package/dist/sl.d.ts

@@ -1,8 +1,8 @@
 import { type KtxSqlQueryExecutorPort } from '@ktx/context/connections';
-import { createLocalKtxEmbeddingProviderFromConfig, type KtxEmbeddingPort } from '@ktx/context';
 import type { KtxSemanticLayerComputePort } from '@ktx/context/daemon';
 import { loadKtxProject } from '@ktx/context/project';
-import { type SemanticLayerQueryInput } from '@ktx/context/sl';
+import { searchLocalSlSources as defaultSearchLocalSlSources, type SemanticLayerQueryInput } from '@ktx/context/sl';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { type KtxManagedPythonInstallPolicy } from './managed-python-command.js';
 type SlQueryFormat = 'json' | 'sql';
 export type KtxSlArgs = {
@@ -11,6 +11,7 @@ export type KtxSlArgs = {
     connectionId?: string;
     output?: string;
     json?: boolean;
+    cliVersion: string;
 } | {
     command: 'search';
     projectDir: string;
@@ -19,6 +20,7 @@ export type KtxSlArgs = {
     limit?: number;
     output?: string;
     json?: boolean;
+    cliVersion: string;
 } | {
     command: 'validate';
     projectDir: string;
@@ -46,8 +48,8 @@ interface KtxSlIo {
 }
 interface KtxSlDeps {
     loadProject?: typeof loadKtxProject;
-    embeddingService?: KtxEmbeddingPort | null;
-    createEmbeddingProvider?: typeof createLocalKtxEmbeddingProviderFromConfig;
+    resolveEmbeddingProvider?: typeof resolveProjectEmbeddingProvider;
+    searchLocalSlSources?: typeof defaultSearchLocalSlSources;
     createSemanticLayerCompute?: () => KtxSemanticLayerComputePort;
     createManagedSemanticLayerCompute?: (options: {
         cliVersion: string;

package/dist/sl.js

@@ -1,17 +1,19 @@
 import { readFile } from 'node:fs/promises';
 import { createDefaultLocalQueryExecutor } from '@ktx/context/connections';
-import { createLocalKtxEmbeddingProviderFromConfig, KtxIngestEmbeddingPortAdapter, } from '@ktx/context';
+import { KtxIngestEmbeddingPortAdapter } from '@ktx/context';
 import { loadKtxProject } from '@ktx/context/project';
-import { compileLocalSlQuery, listLocalSlSources, readLocalSlSource, searchLocalSlSources, validateLocalSlSource, } from '@ktx/context/sl';
+import { compileLocalSlQuery, listLocalSlSources, readLocalSlSource, searchLocalSlSources as defaultSearchLocalSlSources, validateLocalSlSource, } from '@ktx/context/sl';
+import { resolveProjectEmbeddingProvider, } from './embedding-resolution.js';
 import { createManagedPythonSemanticLayerComputePort, } from './managed-python-command.js';
 import { profileMark } from './startup-profile.js';
 profileMark('module:sl');
-function slSearchEmbeddingService(project, deps) {
-    if ('embeddingService' in deps) {
-        return deps.embeddingService ?? null;
+function resolutionToEmbeddingPort(resolution) {
+    if (resolution.kind === 'configured' ||
+        resolution.kind === 'managed-running' ||
+        resolution.kind === 'managed-started') {
+        return new KtxIngestEmbeddingPortAdapter(resolution.provider);
     }
-    const provider = (deps.createEmbeddingProvider ?? createLocalKtxEmbeddingProviderFromConfig)(project.config.ingest.embeddings);
-    return provider ? new KtxIngestEmbeddingPortAdapter(provider) : null;
+    return null;
 }
 async function printSlSources(input) {
     const { resolveOutputMode } = await import('./io/mode.js');
@@ -90,12 +92,24 @@ export async function runKtxSl(args, io = process, deps = {}) {
             return 0;
         }
         if (args.command === 'search') {
-            const sources = await searchLocalSlSources(project, {
+            const resolver = deps.resolveEmbeddingProvider ?? resolveProjectEmbeddingProvider;
+            const resolution = await resolver(project, {
+                mode: 'use-if-running',
+                cliVersion: args.cliVersion,
+                io,
+            });
+            const embeddingService = resolutionToEmbeddingPort(resolution);
+            const search = deps.searchLocalSlSources ?? defaultSearchLocalSlSources;
+            const sources = await search(project, {
                 connectionId: args.connectionId,
                 query: args.query,
-                embeddingService: slSearchEmbeddingService(project, deps),
+                embeddingService,
                 limit: args.limit,
             });
+            if (sources.length === 0 && resolution.kind === 'managed-unavailable' && !args.json) {
+                const { SYMBOLS } = await import('./io/symbols.js');
+                io.stderr.write(`embeddings: unavailable ${SYMBOLS.emDash} ${resolution.reason}\n`);
+            }
             await printSlSources({
                 rows: sources,
                 emptyMessage: `No semantic-layer sources matched "${args.query}" in ${project.projectDir}`,

package/dist/sl.test.js

@@ -55,10 +55,17 @@ describe('runKtxSl', () => {
         await expect(runKtxSl({ command: 'validate', projectDir, connectionId: 'warehouse', sourceName: 'orders' }, validateIo.io)).resolves.toBe(0);
         expect(validateIo.stdout()).toContain('Valid semantic-layer source: warehouse/orders');
         const listIo = makeIo();
-        await expect(runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse' }, listIo.io)).resolves.toBe(0);
+        await expect(runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse', cliVersion: '0.0.0-test' }, listIo.io)).resolves.toBe(0);
         expect(listIo.stdout()).toContain('warehouse\torders\tcolumns=1\tmeasures=0\tjoins=0');
         const searchIo = makeIo();
-        await expect(runKtxSl({ command: 'search', projectDir, connectionId: 'warehouse', query: 'order', json: true }, searchIo.io)).resolves.toBe(0);
+        await expect(runKtxSl({
+            command: 'search',
+            projectDir,
+            connectionId: 'warehouse',
+            query: 'order',
+            json: true,
+            cliVersion: '0.0.0-test',
+        }, searchIo.io)).resolves.toBe(0);
         expect(JSON.parse(searchIo.stdout())).toMatchObject({
             kind: 'list',
             data: {
@@ -77,7 +84,14 @@ describe('runKtxSl', () => {
         const projectDir = join(tempDir, 'rank-project');
         await seedSlSource({ projectDir });
         const searchIo = makeIo();
-        await expect(runKtxSl({ command: 'search', projectDir, connectionId: 'warehouse', query: 'order', output: 'pretty' }, searchIo.io)).resolves.toBe(0);
+        await expect(runKtxSl({
+            command: 'search',
+            projectDir,
+            connectionId: 'warehouse',
+            query: 'order',
+            output: 'pretty',
+            cliVersion: '0.0.0-test',
+        }, searchIo.io)).resolves.toBe(0);
         const stdout = stripVTControlCharacters(searchIo.stdout());
         expect(stdout).toMatch(/#1\s+orders/);
         expect(stdout).not.toContain('%');
@@ -99,7 +113,14 @@ describe('runKtxSl', () => {
             ].join('\n'),
         });
         const listIo = makeIo();
-        await expect(runKtxSl({ command: 'search', projectDir, connectionId: 'warehouse', query: 'paid', json: true }, listIo.io)).resolves.toBe(0);
+        await expect(runKtxSl({
+            command: 'search',
+            projectDir,
+            connectionId: 'warehouse',
+            query: 'paid',
+            json: true,
+            cliVersion: '0.0.0-test',
+        }, listIo.io)).resolves.toBe(0);
         expect(JSON.parse(listIo.stdout())).toMatchObject({
             kind: 'list',
             data: {
@@ -425,7 +446,7 @@ joins: []
         const projectDir = join(tempDir, 'project');
         await seedSlSource({ projectDir });
         const listIo = makeIo();
-        const code = await runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse', output: 'json' }, listIo.io);
+        const code = await runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse', output: 'json', cliVersion: '0.0.0-test' }, listIo.io);
         expect(code).toBe(0);
         expect(listIo.stderr()).toBe('');
         const parsed = JSON.parse(listIo.stdout());
@@ -447,11 +468,61 @@ joins: []
             joinCount: 0,
         });
     });
+    it('search prints embeddings status when results are empty', async () => {
+        const stderr = [];
+        const io = {
+            stdout: { write: (_chunk) => { } },
+            stderr: {
+                write: (chunk) => {
+                    stderr.push(chunk);
+                },
+            },
+        };
+        const projectDir = join(tempDir, 'empty-status');
+        const project = await initKtxProject({ projectDir });
+        await expect(runKtxSl({
+            command: 'search',
+            projectDir: project.projectDir,
+            query: 'nope',
+            cliVersion: '0.5.0',
+        }, io, {
+            loadProject: async () => project,
+            resolveEmbeddingProvider: async () => ({
+                kind: 'managed-unavailable',
+                reason: 'managed embeddings daemon is not running',
+            }),
+            searchLocalSlSources: async () => [],
+        })).resolves.toBe(0);
+        expect(stderr.join('')).toMatch(/embeddings: unavailable/);
+        expect(stderr.join('')).toMatch(/managed embeddings daemon is not running/);
+    });
+    it('passes a managed-daemon-backed embedding service into the search', async () => {
+        const projectDir = join(tempDir, 'resolver-project');
+        const project = await initKtxProject({ projectDir });
+        const search = vi.fn(async () => []);
+        const searchIo = makeIo();
+        await expect(runKtxSl({
+            command: 'search',
+            projectDir: project.projectDir,
+            query: 'income',
+            cliVersion: '0.5.0',
+            json: true,
+        }, searchIo.io, {
+            loadProject: async () => project,
+            resolveEmbeddingProvider: async () => ({
+                kind: 'managed-running',
+                provider: { id: 'fake' },
+                baseUrl: 'http://127.0.0.1:51234',
+            }),
+            searchLocalSlSources: search,
+        })).resolves.toBe(0);
+        expect(search).toHaveBeenCalledWith(project, expect.objectContaining({ embeddingService: expect.any(Object) }));
+    });
     it('emits sl list with grouping and Clack-style framing when output=pretty', async () => {
         const projectDir = join(tempDir, 'project');
         await seedSlSource({ projectDir });
         const listIo = makeIo();
-        const code = await runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse', output: 'pretty' }, listIo.io);
+        const code = await runKtxSl({ command: 'list', projectDir, connectionId: 'warehouse', output: 'pretty', cliVersion: '0.0.0-test' }, listIo.io);
         expect(code).toBe(0);
         const stripAnsi = (s) => s.replace(/\[[0-9;]*m/g, '');
         const out = stripAnsi(listIo.stdout());

package/node_modules/@ktx/context/dist/ingest/local-bundle-runtime.d.ts

@@ -2,6 +2,7 @@ import { type KtxSqlQueryExecutorPort } from '../connections/index.js';
 import type { KtxLogger } from '../core/index.js';
 import type { KtxSemanticLayerComputePort } from '../daemon/index.js';
 import { createLocalKtxLlmRuntimeFromConfig, type AgentRunnerPort, type KtxLlmRuntimePort } from '../llm/index.js';
+import type { KtxEmbeddingProvider } from '@ktx/llm';
 import type { KtxLocalProject } from '../project/index.js';
 import { SqliteContextEvidenceStore } from './context-evidence/index.js';
 import { IngestBundleRunner } from './ingest-bundle.runner.js';
@@ -20,6 +21,7 @@ export interface CreateLocalBundleIngestRuntimeOptions {
     queryExecutor?: KtxSqlQueryExecutorPort;
     jobIdFactory?: () => string;
     logger?: KtxLogger;
+    embeddingProvider?: KtxEmbeddingProvider | null;
 }
 export interface LocalBundleIngestRuntime {
     runner: IngestBundleRunner;

package/node_modules/@ktx/context/dist/ingest/local-bundle-runtime.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 import YAML from 'yaml';
 import { localConnectionInfoFromConfig } from '../connections/index.js';
 import { noopLogger, SessionWorktreeService } from '../core/index.js';
-import { createRuntimeToolDescriptorFromAiTool, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, KtxIngestEmbeddingPortAdapter, RuntimeAgentRunner, } from '../llm/index.js';
+import { createRuntimeToolDescriptorFromAiTool, createLocalKtxLlmRuntimeFromConfig, KtxIngestEmbeddingPortAdapter, RuntimeAgentRunner, } from '../llm/index.js';
 import { ktxLocalStateDbPath } from '../project/index.js';
 import { PromptService } from '../prompts/index.js';
 import { SkillsRegistryService } from '../skills/index.js';
@@ -490,7 +490,7 @@ export function createLocalBundleIngestRuntime(options) {
     mkdirSync(join(options.project.projectDir, '.ktx/cache/local-ingest'), { recursive: true });
     const store = new SqliteBundleIngestStore({ dbPath });
     const contextStore = new SqliteContextEvidenceStore({ dbPath });
-    const embeddingProvider = createLocalKtxEmbeddingProviderFromConfig(options.project.config.ingest.embeddings);
+    const embeddingProvider = options.embeddingProvider ?? null;
     const embedding = embeddingProvider ? new KtxIngestEmbeddingPortAdapter(embeddingProvider) : new NoopEmbeddingPort();
     const connections = new LocalConnectionCatalog(options.project, options.queryExecutor);
     const rootFileStore = options.project.fileStore;

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

@@ -24,6 +24,7 @@ export interface RunLocalIngestOptions {
     semanticLayerCompute?: KtxSemanticLayerComputePort;
     queryExecutor?: KtxSqlQueryExecutorPort;
     logger?: KtxLogger;
+    embeddingProvider?: import('@ktx/llm').KtxEmbeddingProvider | null;
 }
 export interface LocalIngestMcpOptions extends Pick<RunLocalIngestOptions, 'agentRunner' | 'llmRuntime' | 'memoryModel' | 'semanticLayerCompute' | 'queryExecutor' | 'logger' | 'pullConfigOptions'> {
     adapters?: SourceAdapter[];

package/node_modules/@ktx/context/dist/ingest/local-ingest.js

@@ -100,6 +100,7 @@ export async function runLocalIngest(options) {
             semanticLayerCompute: options.semanticLayerCompute,
             queryExecutor: options.queryExecutor,
             logger: options.logger,
+            embeddingProvider: options.embeddingProvider,
         });
     }
     const result = await runtime.runner.run({
@@ -252,6 +253,7 @@ export async function runLocalMetabaseIngest(options) {
                 semanticLayerCompute: options.semanticLayerCompute,
                 queryExecutor: options.queryExecutor,
                 logger: options.logger,
+                embeddingProvider: options.embeddingProvider,
             });
         }
         catch (error) {

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

@@ -10,4 +10,4 @@ export { RuntimeAgentRunner } from './runtime-port.js';
 export { createAiSdkToolSet, createClaudeSdkTools, createRuntimeToolDescriptorFromAiTool, createRuntimeToolSetFromAiSdkTools, normalizeKtxRuntimeToolOutput, } from './runtime-tools.js';
 export type { KtxLlmDebugProviderOptionsEntry, KtxLlmDebugRequest, KtxLlmDebugRequestRecorder, SummarizeKtxLlmDebugRequestInput, } from './debug-request-recorder.js';
 export { createJsonlKtxLlmDebugRequestRecorder, summarizeKtxLlmDebugRequest, } from './debug-request-recorder.js';
-export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
+export { createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';

package/node_modules/@ktx/context/dist/llm/index.js

@@ -7,4 +7,4 @@ export { generateKtxObject, generateKtxText } from './generation.js';
 export { RuntimeAgentRunner } from './runtime-port.js';
 export { createAiSdkToolSet, createClaudeSdkTools, createRuntimeToolDescriptorFromAiTool, createRuntimeToolSetFromAiSdkTools, normalizeKtxRuntimeToolOutput, } from './runtime-tools.js';
 export { createJsonlKtxLlmDebugRequestRecorder, summarizeKtxLlmDebugRequest, } from './debug-request-recorder.js';
-export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
+export { createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';

package/node_modules/@ktx/context/dist/llm/local-config.d.ts

@@ -12,7 +12,6 @@ interface LocalConfigDeps {
         llmProvider: KtxLlmProvider;
     }) => KtxLlmRuntimePort;
 }
-export declare const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL = "managed:local-embeddings";
 export declare function resolveLocalKtxLlmConfig(config: KtxProjectLlmConfig, env: NodeJS.ProcessEnv): KtxLlmConfig | null;
 export declare function createLocalKtxLlmProviderFromConfig(config: KtxProjectLlmConfig, deps?: LocalConfigDeps): KtxLlmProvider | null;
 export declare function createLocalKtxLlmRuntimeFromConfig(config: KtxProjectLlmConfig, deps?: LocalConfigDeps): KtxLlmRuntimePort | null;

package/node_modules/@ktx/context/dist/llm/local-config.js

@@ -2,7 +2,6 @@ import { createKtxEmbeddingProvider, createKtxLlmProvider, } from '@ktx/llm';
 import { resolveKtxConfigReference } from '../core/config-reference.js';
 import { AiSdkKtxLlmRuntime } from './ai-sdk-runtime.js';
 import { ClaudeCodeKtxLlmRuntime } from './claude-code-runtime.js';
-export const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL = 'managed:local-embeddings';
 function resolveOptional(value, env) {
     return resolveKtxConfigReference(value, env) || undefined;
 }
@@ -99,7 +98,7 @@ export function resolveLocalKtxEmbeddingConfig(config, env) {
     }
     if (config.backend === 'sentence-transformers') {
         const baseURL = config.sentenceTransformers?.base_url;
-        if (!baseURL || baseURL === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL) {
+        if (!baseURL) {
             return null;
         }
         return {