@kaelio/ktx 0.4.0 → 0.4.1

package/assets/python/manifest.json

@@ -2,10 +2,10 @@
   "schemaVersion": 1,
   "distributionName": "kaelio-ktx",
   "normalizedName": "kaelio_ktx",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "wheel": {
-    "file": "kaelio_ktx-0.4.0-py3-none-any.whl",
-    "sha256": "f969fd507d6ac483ae8ce2aab8257a4cb73dec0b3edcdef9be38dc133eb9a377",
+    "file": "kaelio_ktx-0.4.1-py3-none-any.whl",
+    "sha256": "18209f0ec9434f0c4073691b6b311562b66209ddb33c83953eca88d90fd3de65",
     "bytes": 80523
   }
 }

package/dist/admin-reindex.js

@@ -1,8 +1,9 @@
-import { createLocalKtxEmbeddingProviderFromConfig, KtxIngestEmbeddingPortAdapter, } from '@ktx/context';
+import { KtxIngestEmbeddingPortAdapter } from '@ktx/context';
 import { reindexLocalIndexes } from '@ktx/context/index-sync';
+import { loadKtxProject } from '@ktx/context/project';
 import { Option } from '@commander-js/extra-typings';
 import { cancel, intro, log, note, outro } from '@clack/prompts';
-import { loadKtxCliProject } from './cli-project.js';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { resolveOutputMode } from './io/mode.js';
 import { green, red, SYMBOLS } from './io/symbols.js';
 export function registerAdminReindexCommand(admin, context) {
@@ -24,14 +25,6 @@ export function registerAdminReindexCommand(admin, context) {
         }, context.io));
     });
 }
-function resolveReindexEmbeddingService(project) {
-    const config = project.config.ingest.embeddings;
-    if (config.backend === 'none') {
-        return null;
-    }
-    const provider = createLocalKtxEmbeddingProviderFromConfig(config);
-    return provider ? new KtxIngestEmbeddingPortAdapter(provider) : null;
-}
 function scopeKey(scope) {
     if (scope.kind === 'wiki') {
         return scope.scope === 'user' ? `wiki/user/${scope.scopeId ?? 'local'}` : 'wiki/global';
@@ -131,13 +124,15 @@ function renderReindexPretty(summary, io) {
 }
 async function runKtxAdminReindex(args, io = process) {
     try {
-        const project = await loadKtxCliProject({
-            projectDir: args.projectDir,
+        const project = await loadKtxProject({ projectDir: args.projectDir });
+        const resolution = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
             cliVersion: args.cliVersion,
-            installPolicy: 'never',
             io,
         });
-        const embeddingService = resolveReindexEmbeddingService(project);
+        const embeddingService = resolution.kind === 'configured' || resolution.kind === 'managed-running' || resolution.kind === 'managed-started'
+            ? new KtxIngestEmbeddingPortAdapter(resolution.provider)
+            : null;
         const summary = await reindexLocalIndexes(project, { force: args.force, embeddingService });
         const mode = resolveOutputMode({ explicit: args.output, json: args.json, io });
         if (!summary.embeddingsAvailable && mode === 'plain') {

package/dist/admin-reindex.test.js

@@ -1,6 +1,9 @@
+import { createRequire } from 'node:module';
 import { describe, expect, it, vi } from 'vitest';
 import { renderReindexJson, renderReindexPlain, reindexHasErrors } from './admin-reindex.js';
 import { runKtxCli } from './index.js';
+const cliVersion = createRequire(import.meta.url)('@ktx/cli/package.json')
+    .version;
 function makeIo(options = {}) {
     let stdout = '';
     let stderr = '';
@@ -110,7 +113,7 @@ describe('admin reindex Commander routing', () => {
             force: true,
             json: true,
             output: 'plain',
-            cliVersion: '0.0.0-private',
+            cliVersion,
         }, io.io);
     });
 });

package/dist/cli-project.d.ts

@@ -1,18 +1,12 @@
 import { loadKtxProject, type KtxLocalProject } from '@ktx/context/project';
-import type { KtxProjectConfig } from '@ktx/context/project';
-import type { KtxCliIo } from './cli-runtime.js';
-import { ensureManagedLocalEmbeddingsDaemon, type ManagedLocalEmbeddingsDaemon } from './managed-local-embeddings.js';
-import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
 export interface LoadKtxCliProjectOptions {
     projectDir: string;
-    cliVersion: string;
-    installPolicy: KtxManagedPythonInstallPolicy;
-    io: KtxCliIo;
 }
 export interface LoadKtxCliProjectDeps {
     loadProject?: typeof loadKtxProject;
-    ensureLocalEmbeddings?: (options: Parameters<typeof ensureManagedLocalEmbeddingsDaemon>[0]) => Promise<ManagedLocalEmbeddingsDaemon>;
 }
+/**
+ * Thin wrapper around `loadKtxProject`. Kept as a single entrypoint so the CLI can grow shared
+ * pre-load behavior later (telemetry, project lock, etc.). Today it does no extra work.
+ */
 export declare function loadKtxCliProject(options: LoadKtxCliProjectOptions, deps?: LoadKtxCliProjectDeps): Promise<KtxLocalProject>;
-export declare function projectNeedsManagedLocalEmbeddings(config: KtxProjectConfig): boolean;
-export declare function substituteManagedLocalEmbeddingsUrl(config: KtxProjectConfig, baseUrl: string): KtxProjectConfig;

package/dist/cli-project.js

@@ -1,52 +1,8 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 import { loadKtxProject } from '@ktx/context/project';
-import { ensureManagedLocalEmbeddingsDaemon, } from './managed-local-embeddings.js';
+/**
+ * Thin wrapper around `loadKtxProject`. Kept as a single entrypoint so the CLI can grow shared
+ * pre-load behavior later (telemetry, project lock, etc.). Today it does no extra work.
+ */
 export async function loadKtxCliProject(options, deps = {}) {
-    const loadProject = deps.loadProject ?? loadKtxProject;
-    const ensureLocalEmbeddings = deps.ensureLocalEmbeddings ?? ensureManagedLocalEmbeddingsDaemon;
-    const project = await loadProject({ projectDir: options.projectDir });
-    if (!projectNeedsManagedLocalEmbeddings(project.config)) {
-        return project;
-    }
-    const daemon = await ensureLocalEmbeddings({
-        cliVersion: options.cliVersion,
-        projectDir: options.projectDir,
-        installPolicy: options.installPolicy,
-        io: options.io,
-    });
-    return {
-        ...project,
-        config: substituteManagedLocalEmbeddingsUrl(project.config, daemon.baseUrl),
-    };
-}
-export function projectNeedsManagedLocalEmbeddings(config) {
-    return (embeddingUsesManagedSentinel(config.ingest.embeddings) ||
-        embeddingUsesManagedSentinel(config.scan.enrichment.embeddings));
-}
-export function substituteManagedLocalEmbeddingsUrl(config, baseUrl) {
-    const ingestEmbeddings = rewriteManagedEmbeddingConfig(config.ingest.embeddings, baseUrl);
-    const scanEnrichmentEmbeddings = rewriteManagedEmbeddingConfig(config.scan.enrichment.embeddings, baseUrl);
-    return {
-        ...config,
-        ingest: { ...config.ingest, embeddings: ingestEmbeddings },
-        scan: {
-            ...config.scan,
-            enrichment: { ...config.scan.enrichment, embeddings: scanEnrichmentEmbeddings },
-        },
-    };
-}
-function embeddingUsesManagedSentinel(embedding) {
-    return embedding?.sentenceTransformers?.base_url === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
-}
-function rewriteManagedEmbeddingConfig(embedding, baseUrl) {
-    if (!embedding || !embeddingUsesManagedSentinel(embedding)) {
-        return embedding;
-    }
-    return {
-        ...embedding,
-        sentenceTransformers: {
-            ...embedding.sentenceTransformers,
-            base_url: baseUrl,
-        },
-    };
+    return (deps.loadProject ?? loadKtxProject)({ projectDir: options.projectDir });
 }

package/dist/cli-project.test.js

@@ -1,22 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
-import { loadKtxCliProject, projectNeedsManagedLocalEmbeddings, substituteManagedLocalEmbeddingsUrl, } from './cli-project.js';
-const RESOLVED_BASE_URL = 'http://127.0.0.1:51234';
-function makeIo() {
-    let stderr = '';
-    return {
-        io: {
-            stdout: { write: (_chunk) => { } },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stderr: () => stderr,
-    };
-}
+import { loadKtxCliProject } from './cli-project.js';
 function projectWithConfig(config) {
     return {
         projectDir: '/work/proj',
@@ -27,123 +11,12 @@ function projectWithConfig(config) {
         fileStore: {},
     };
 }
-function withManagedIngestEmbedding(config) {
-    return {
-        ...config,
-        ingest: {
-            ...config.ingest,
-            embeddings: {
-                backend: 'sentence-transformers',
-                model: 'all-MiniLM-L6-v2',
-                dimensions: 384,
-                sentenceTransformers: { base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, pathPrefix: '' },
-            },
-        },
-    };
-}
-function withManagedScanEnrichmentEmbedding(config) {
-    return {
-        ...config,
-        scan: {
-            ...config.scan,
-            enrichment: {
-                ...config.scan.enrichment,
-                embeddings: {
-                    backend: 'sentence-transformers',
-                    model: 'all-MiniLM-L6-v2',
-                    dimensions: 384,
-                    sentenceTransformers: { base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, pathPrefix: '' },
-                },
-            },
-        },
-    };
-}
-const fakeDaemon = {
-    baseUrl: RESOLVED_BASE_URL,
-    stdoutLog: '/work/proj/.ktx/runtime/daemon.stdout.log',
-    stderrLog: '/work/proj/.ktx/runtime/daemon.stderr.log',
-};
-describe('projectNeedsManagedLocalEmbeddings', () => {
-    it('returns false when neither ingest nor scan embeddings reference the managed sentinel', () => {
-        expect(projectNeedsManagedLocalEmbeddings(buildDefaultKtxProjectConfig())).toBe(false);
-    });
-    it('returns true when ingest.embeddings uses the managed sentinel', () => {
-        expect(projectNeedsManagedLocalEmbeddings(withManagedIngestEmbedding(buildDefaultKtxProjectConfig()))).toBe(true);
-    });
-    it('returns true when scan.enrichment.embeddings uses the managed sentinel', () => {
-        expect(projectNeedsManagedLocalEmbeddings(withManagedScanEnrichmentEmbedding(buildDefaultKtxProjectConfig()))).toBe(true);
-    });
-});
-describe('substituteManagedLocalEmbeddingsUrl', () => {
-    it('rewrites the managed sentinel in both ingest.embeddings and scan.enrichment.embeddings', () => {
-        const config = withManagedScanEnrichmentEmbedding(withManagedIngestEmbedding(buildDefaultKtxProjectConfig()));
-        const resolved = substituteManagedLocalEmbeddingsUrl(config, RESOLVED_BASE_URL);
-        expect(resolved.ingest.embeddings.sentenceTransformers?.base_url).toBe(RESOLVED_BASE_URL);
-        expect(resolved.scan.enrichment.embeddings?.sentenceTransformers?.base_url).toBe(RESOLVED_BASE_URL);
-    });
-    it('returns the input unchanged when no sentinel is present', () => {
-        const config = buildDefaultKtxProjectConfig();
-        const resolved = substituteManagedLocalEmbeddingsUrl(config, RESOLVED_BASE_URL);
-        expect(resolved.ingest.embeddings).toEqual(config.ingest.embeddings);
-        expect(resolved.scan.enrichment.embeddings).toEqual(config.scan.enrichment.embeddings);
-    });
-    it('does not touch non-sentinel sentence-transformers URLs', () => {
-        const config = {
-            ...buildDefaultKtxProjectConfig(),
-            ingest: {
-                ...buildDefaultKtxProjectConfig().ingest,
-                embeddings: {
-                    backend: 'sentence-transformers',
-                    model: 'all-MiniLM-L6-v2',
-                    dimensions: 384,
-                    sentenceTransformers: { base_url: 'http://localhost:9999', pathPrefix: '' },
-                },
-            },
-        };
-        const resolved = substituteManagedLocalEmbeddingsUrl(config, RESOLVED_BASE_URL);
-        expect(resolved.ingest.embeddings.sentenceTransformers?.base_url).toBe('http://localhost:9999');
-    });
-});
 describe('loadKtxCliProject', () => {
-    it('returns the project unchanged and does not start the daemon when no sentinel is present', async () => {
-        const io = makeIo();
+    it('delegates to loadKtxProject and returns the project unchanged', async () => {
         const project = projectWithConfig(buildDefaultKtxProjectConfig());
         const loadProject = vi.fn(async () => project);
-        const ensureLocalEmbeddings = vi.fn(async () => fakeDaemon);
-        const result = await loadKtxCliProject({ projectDir: '/work/proj', cliVersion: '0.2.0', installPolicy: 'never', io: io.io }, { loadProject, ensureLocalEmbeddings });
+        const result = await loadKtxCliProject({ projectDir: '/work/proj' }, { loadProject });
         expect(result).toBe(project);
-        expect(ensureLocalEmbeddings).not.toHaveBeenCalled();
-    });
-    it('starts the daemon and substitutes the resolved URL when ingest.embeddings uses the sentinel', async () => {
-        const io = makeIo();
-        const project = projectWithConfig(withManagedIngestEmbedding(buildDefaultKtxProjectConfig()));
-        const loadProject = vi.fn(async () => project);
-        const ensureLocalEmbeddings = vi.fn(async () => fakeDaemon);
-        const result = await loadKtxCliProject({ projectDir: '/work/proj', cliVersion: '0.2.0', installPolicy: 'never', io: io.io }, { loadProject, ensureLocalEmbeddings });
-        expect(ensureLocalEmbeddings).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            projectDir: '/work/proj',
-            installPolicy: 'never',
-            io: io.io,
-        });
-        expect(result.config.ingest.embeddings.sentenceTransformers?.base_url).toBe(RESOLVED_BASE_URL);
-    });
-    it('does not mutate process.env', async () => {
-        const io = makeIo();
-        const before = process.env.KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
-        delete process.env.KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
-        try {
-            const project = projectWithConfig(withManagedIngestEmbedding(buildDefaultKtxProjectConfig()));
-            await loadKtxCliProject({ projectDir: '/work/proj', cliVersion: '0.2.0', installPolicy: 'never', io: io.io }, { loadProject: vi.fn(async () => project), ensureLocalEmbeddings: vi.fn(async () => fakeDaemon) });
-            expect(process.env.KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL).toBeUndefined();
-        }
-        finally {
-            if (before === undefined) {
-                delete process.env.KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
-            }
-            else {
-                process.env.KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL = before;
-            }
-        }
+        expect(loadProject).toHaveBeenCalledWith({ projectDir: '/work/proj' });
     });
 });

package/dist/commands/knowledge-commands.js

@@ -34,6 +34,7 @@ export function registerWikiCommands(program, context) {
                 userId: options.userId,
                 output: options.output,
                 json: options.json,
+                cliVersion: context.packageInfo.version,
             });
             return;
         }
@@ -46,6 +47,7 @@ export function registerWikiCommands(program, context) {
             json: options.json,
             ...(isDebugEnabled(command) ? { debug: true } : {}),
             ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            cliVersion: context.packageInfo.version,
         });
     });
 }

package/dist/commands/sl-commands.js

@@ -48,6 +48,7 @@ export function registerSlCommands(program, context, commandName = 'sl') {
                 connectionId: options.connectionId,
                 output: options.output,
                 json: options.json,
+                cliVersion: context.packageInfo.version,
             });
             return;
         }
@@ -59,6 +60,7 @@ export function registerSlCommands(program, context, commandName = 'sl') {
             ...(options.limit !== undefined ? { limit: options.limit } : {}),
             output: options.output,
             json: options.json,
+            cliVersion: context.packageInfo.version,
         });
     });
     sl.command('validate')

package/dist/embedding-resolution.d.ts

@@ -0,0 +1,36 @@
+import { type KtxEmbeddingProvider, createKtxEmbeddingProvider as defaultCreateKtxEmbeddingProvider } from '@ktx/llm';
+import type { KtxLocalProject } from '@ktx/context/project';
+import type { KtxCliIo } from './cli-runtime.js';
+import { ensureManagedLocalEmbeddingsDaemon as defaultEnsureManagedDaemon, tryUseManagedLocalEmbeddingsDaemon as defaultTryUseManagedDaemon } from './managed-local-embeddings.js';
+import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
+type EmbeddingResolutionMode = 'ensure' | 'use-if-running';
+export type EmbeddingProviderResolution = {
+    kind: 'disabled';
+} | {
+    kind: 'configured';
+    provider: KtxEmbeddingProvider;
+    baseUrl: string;
+} | {
+    kind: 'managed-running';
+    provider: KtxEmbeddingProvider;
+    baseUrl: string;
+} | {
+    kind: 'managed-started';
+    provider: KtxEmbeddingProvider;
+    baseUrl: string;
+} | {
+    kind: 'managed-unavailable';
+    reason: string;
+};
+export interface ResolveProjectEmbeddingProviderOptions {
+    mode: EmbeddingResolutionMode;
+    cliVersion: string;
+    io: KtxCliIo;
+    /** Required when mode === 'ensure'. */
+    installPolicy?: KtxManagedPythonInstallPolicy;
+    tryUseManagedDaemon?: typeof defaultTryUseManagedDaemon;
+    ensureManagedDaemon?: typeof defaultEnsureManagedDaemon;
+    createKtxEmbeddingProvider?: typeof defaultCreateKtxEmbeddingProvider;
+}
+export declare function resolveProjectEmbeddingProvider(project: KtxLocalProject, options: ResolveProjectEmbeddingProviderOptions): Promise<EmbeddingProviderResolution>;
+export {};

package/dist/embedding-resolution.js

@@ -0,0 +1,63 @@
+import { createKtxEmbeddingProvider as defaultCreateKtxEmbeddingProvider, } from '@ktx/llm';
+import { resolveLocalKtxEmbeddingConfig } from '@ktx/context';
+import { ensureManagedLocalEmbeddingsDaemon as defaultEnsureManagedDaemon, tryUseManagedLocalEmbeddingsDaemon as defaultTryUseManagedDaemon, } from './managed-local-embeddings.js';
+function usesManagedDaemon(embeddings) {
+    if (embeddings.backend !== 'sentence-transformers') {
+        return false;
+    }
+    const baseUrl = embeddings.sentenceTransformers?.base_url;
+    return baseUrl === undefined || baseUrl === '';
+}
+export async function resolveProjectEmbeddingProvider(project, options) {
+    const embeddings = project.config.ingest.embeddings;
+    if (embeddings.backend === 'none') {
+        return { kind: 'disabled' };
+    }
+    const createProvider = options.createKtxEmbeddingProvider ?? defaultCreateKtxEmbeddingProvider;
+    if (!usesManagedDaemon(embeddings)) {
+        const resolved = resolveLocalKtxEmbeddingConfig(embeddings, process.env);
+        if (!resolved) {
+            return { kind: 'managed-unavailable', reason: 'embedding config missing required fields' };
+        }
+        const provider = createProvider(resolved);
+        const baseUrl = embeddings.sentenceTransformers?.base_url ?? '';
+        return { kind: 'configured', provider, baseUrl };
+    }
+    const tryUse = options.tryUseManagedDaemon ?? defaultTryUseManagedDaemon;
+    const running = await tryUse({ cliVersion: options.cliVersion, projectDir: project.projectDir });
+    if (running) {
+        const provider = buildManagedProvider(embeddings, running.baseUrl, createProvider);
+        return provider
+            ? { kind: 'managed-running', provider, baseUrl: running.baseUrl }
+            : { kind: 'managed-unavailable', reason: 'failed to build embedding provider from running daemon' };
+    }
+    if (options.mode === 'use-if-running') {
+        return { kind: 'managed-unavailable', reason: 'managed embeddings daemon is not running' };
+    }
+    const ensure = options.ensureManagedDaemon ?? defaultEnsureManagedDaemon;
+    if (!options.installPolicy) {
+        throw new Error("installPolicy is required when mode === 'ensure'");
+    }
+    const daemon = await ensure({
+        cliVersion: options.cliVersion,
+        projectDir: project.projectDir,
+        installPolicy: options.installPolicy,
+        io: options.io,
+    });
+    const provider = buildManagedProvider(embeddings, daemon.baseUrl, createProvider);
+    return provider
+        ? { kind: 'managed-started', provider, baseUrl: daemon.baseUrl }
+        : { kind: 'managed-unavailable', reason: 'failed to build embedding provider after starting daemon' };
+}
+function buildManagedProvider(embeddings, baseUrl, createProvider) {
+    const merged = {
+        ...embeddings,
+        sentenceTransformers: {
+            ...embeddings.sentenceTransformers,
+            base_url: baseUrl,
+            pathPrefix: '',
+        },
+    };
+    const resolved = resolveLocalKtxEmbeddingConfig(merged, process.env);
+    return resolved ? createProvider(resolved) : null;
+}

package/dist/embedding-resolution.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/embedding-resolution.test.js

@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
+function projectWithConfig(config) {
+    return {
+        projectDir: '/work/proj',
+        configPath: '/work/proj/ktx.yaml',
+        config,
+        coreConfig: {},
+        git: {},
+        fileStore: {},
+    };
+}
+function withManagedEmbedding(config, base_url) {
+    return {
+        ...config,
+        ingest: {
+            ...config.ingest,
+            embeddings: {
+                backend: 'sentence-transformers',
+                model: 'all-MiniLM-L6-v2',
+                dimensions: 384,
+                ...(base_url === undefined
+                    ? {}
+                    : { sentenceTransformers: { base_url, pathPrefix: '' } }),
+            },
+        },
+    };
+}
+const noopIo = {
+    stdout: { write: (_chunk) => { } },
+    stderr: { write: (_chunk) => { } },
+};
+const fakeDaemon = {
+    baseUrl: 'http://127.0.0.1:51234',
+    stdoutLog: '/tmp/o',
+    stderrLog: '/tmp/e',
+};
+describe('resolveProjectEmbeddingProvider', () => {
+    it('returns disabled when backend is none', async () => {
+        const project = projectWithConfig(buildDefaultKtxProjectConfig());
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+        });
+        expect(result.kind).toBe('disabled');
+    });
+    it('returns a configured provider when base_url is explicit', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), 'http://my-st:8080'));
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+        });
+        expect(result.kind).toBe('configured');
+        expect(createKtxEmbeddingProvider).toHaveBeenCalledOnce();
+    });
+    it('connects to the running managed daemon when base_url is omitted', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-running');
+        expect(tryUseManaged).toHaveBeenCalledOnce();
+        expect(ensureManaged).not.toHaveBeenCalled();
+    });
+    it('passes pathPrefix="" to the embedding provider when targeting the managed daemon', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+        });
+        expect(createKtxEmbeddingProvider).toHaveBeenCalledWith(expect.objectContaining({
+            sentenceTransformers: expect.objectContaining({
+                baseURL: fakeDaemon.baseUrl,
+                pathPrefix: '',
+            }),
+        }));
+    });
+    it('returns managed-unavailable when no daemon is running and mode is use-if-running', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), ''));
+        const tryUseManaged = vi.fn(async () => null);
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-unavailable');
+        expect(ensureManaged).not.toHaveBeenCalled();
+    });
+    it('starts the managed daemon when mode is ensure', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => null);
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'ensure',
+            installPolicy: 'auto',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-started');
+        expect(ensureManaged).toHaveBeenCalledWith({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            installPolicy: 'auto',
+            io: noopIo,
+        });
+    });
+});

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { runKtxRuntime, type KtxRuntimeArgs, type KtxRuntimeDeps } from './runti
 export { runKtxSql, type KtxSqlArgs, type KtxSqlDeps } from './sql.js';
 export { allocateDaemonPort, readManagedPythonDaemonStatus, stopAllManagedPythonDaemons, startManagedPythonDaemon, stopManagedPythonDaemon, } from './managed-python-daemon.js';
 export type { ManagedPythonDaemonProcessInfo, ManagedPythonDaemonStartResult, ManagedPythonDaemonState, ManagedPythonDaemonStatus, ManagedPythonDaemonStopAllEntry, ManagedPythonDaemonStopAllFailure, ManagedPythonDaemonStopAllResult, ManagedPythonDaemonStopResult, } from './managed-python-daemon.js';
-export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, type ManagedLocalEmbeddingsDaemon, type ManagedLocalEmbeddingsOptions, } from './managed-local-embeddings.js';
+export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, type ManagedLocalEmbeddingsDaemon, type ManagedLocalEmbeddingsOptions, } from './managed-local-embeddings.js';
 export type { KtxMemoryFlowTuiIo, MemoryFlowTuiLiveSession } from './memory-flow-tui.js';
 export { renderMemoryFlowTui, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
 export { rendererUnavailableVizFallback, resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';

package/dist/index.js

@@ -7,7 +7,7 @@ export { runKtxSetupSourcesStep } from './setup-sources.js';
 export { runKtxRuntime } from './runtime.js';
 export { runKtxSql } from './sql.js';
 export { allocateDaemonPort, readManagedPythonDaemonStatus, stopAllManagedPythonDaemons, startManagedPythonDaemon, stopManagedPythonDaemon, } from './managed-python-daemon.js';
-export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, } from './managed-local-embeddings.js';
 export { renderMemoryFlowTui, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
 export { rendererUnavailableVizFallback, resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';
 profileMark('module:index');