@kaelio/ktx 0.1.0 → 0.2.0

package/node_modules/@ktx/context/dist/index-sync/reindex.d.ts

@@ -0,0 +1,20 @@
+import { type KtxLocalProject } from '../project/index.js';
+import type { ReindexOptions, ReindexSummary } from './types.js';
+type DiscoveredScope = {
+    kind: 'wiki';
+    scope: 'GLOBAL';
+    scopeId: null;
+    label: 'global';
+} | {
+    kind: 'wiki';
+    scope: 'USER';
+    scopeId: string;
+    label: `user/${string}`;
+} | {
+    kind: 'sl';
+    connectionId: string;
+    label: string;
+};
+export declare function discoverReindexScopes(project: KtxLocalProject): Promise<DiscoveredScope[]>;
+export declare function reindexLocalIndexes(project: KtxLocalProject, options: ReindexOptions): Promise<ReindexSummary>;
+export {};

package/node_modules/@ktx/context/dist/index-sync/reindex.js

@@ -0,0 +1,141 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { ktxLocalStateDbPath } from '../project/index.js';
+import { loadLocalSlSourceRecords, SlSearchService, SqliteSlSourcesIndex } from '../sl/index.js';
+import { KnowledgeWikiService, SqliteKnowledgeIndex } from '../wiki/index.js';
+const ZERO = {
+    scanned: 0,
+    updated: 0,
+    deleted: 0,
+    embeddingsRecomputed: 0,
+    embeddingsFailed: 0,
+};
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function childDirectories(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function discoverReindexScopes(project) {
+    const scopes = [];
+    if (await directoryExists(join(project.projectDir, 'wiki/global'))) {
+        scopes.push({ kind: 'wiki', scope: 'GLOBAL', scopeId: null, label: 'global' });
+    }
+    for (const userId of await childDirectories(join(project.projectDir, 'wiki/user'))) {
+        scopes.push({ kind: 'wiki', scope: 'USER', scopeId: userId, label: `user/${userId}` });
+    }
+    for (const connectionId of await childDirectories(join(project.projectDir, 'semantic-layer'))) {
+        if (connectionId !== '_schema') {
+            scopes.push({ kind: 'sl', connectionId, label: connectionId });
+        }
+    }
+    return scopes;
+}
+function errorMessage(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    return error.name && error.name !== 'Error' ? `${error.name}: ${error.message}` : error.message;
+}
+function addTotals(left, right) {
+    return {
+        scanned: left.scanned + right.scanned,
+        updated: left.updated + right.updated,
+        deleted: left.deleted + right.deleted,
+        embeddingsRecomputed: left.embeddingsRecomputed + right.embeddingsRecomputed,
+        embeddingsFailed: left.embeddingsFailed + right.embeddingsFailed,
+    };
+}
+function durationSince(startedAt) {
+    return Number((process.hrtime.bigint() - startedAt) / 1000000n);
+}
+function embeddingFailureError(work) {
+    if (work.embeddingsFailed === 0) {
+        return undefined;
+    }
+    return `${work.embeddingsFailed} embedding recomputation${work.embeddingsFailed === 1 ? '' : 's'} failed`;
+}
+export async function reindexLocalIndexes(project, options) {
+    const startedAt = process.hrtime.bigint();
+    const dbPath = ktxLocalStateDbPath(project);
+    const scopes = await discoverReindexScopes(project);
+    const wikiIndex = new SqliteKnowledgeIndex({ dbPath });
+    const slIndex = new SqliteSlSourcesIndex({ dbPath });
+    const wikiService = new KnowledgeWikiService(project.fileStore, options.embeddingService, wikiIndex, project.git);
+    const slService = new SlSearchService(options.embeddingService, slIndex);
+    const results = [];
+    for (const scope of scopes) {
+        const scopeStartedAt = process.hrtime.bigint();
+        try {
+            let work;
+            if (scope.kind === 'wiki') {
+                if (options.force) {
+                    wikiIndex.clear(scope.scope, scope.scopeId);
+                }
+                work = await wikiService.syncIndex(scope.scope, scope.scopeId);
+                results.push({
+                    kind: 'wiki',
+                    label: scope.label,
+                    scope: scope.scope === 'GLOBAL' ? 'global' : 'user',
+                    scopeId: scope.scopeId,
+                    ...work,
+                    ...(options.force ? { deleted: 0 } : {}),
+                    ...(options.embeddingService && work.embeddingsFailed > 0 ? { error: embeddingFailureError(work) } : {}),
+                    durationMs: durationSince(scopeStartedAt),
+                });
+                continue;
+            }
+            if (options.force) {
+                await slIndex.clear(scope.connectionId);
+            }
+            const records = await loadLocalSlSourceRecords(project, { connectionId: scope.connectionId });
+            work = await slService.indexSources(scope.connectionId, records.map((record) => record.source));
+            results.push({
+                kind: 'sl',
+                label: scope.label,
+                connectionId: scope.connectionId,
+                ...work,
+                ...(options.force ? { deleted: 0 } : {}),
+                ...(options.embeddingService && work.embeddingsFailed > 0 ? { error: embeddingFailureError(work) } : {}),
+                durationMs: durationSince(scopeStartedAt),
+            });
+        }
+        catch (error) {
+            results.push({
+                kind: scope.kind,
+                label: scope.label,
+                ...(scope.kind === 'wiki'
+                    ? { scope: scope.scope === 'GLOBAL' ? 'global' : 'user', scopeId: scope.scopeId }
+                    : { connectionId: scope.connectionId }),
+                ...ZERO,
+                durationMs: durationSince(scopeStartedAt),
+                error: errorMessage(error),
+            });
+        }
+    }
+    return {
+        scopes: results,
+        totals: results.reduce(addTotals, ZERO),
+        dbPath: relative(project.projectDir, dbPath) || dbPath,
+        force: options.force,
+        embeddingsAvailable: options.embeddingService !== null,
+        durationMs: durationSince(startedAt),
+    };
+}

package/node_modules/@ktx/context/dist/index-sync/reindex.test.d.ts

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

package/node_modules/@ktx/context/dist/index-sync/reindex.test.js

@@ -0,0 +1,139 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { initKtxProject, loadKtxProject } from '../project/index.js';
+import { SqliteKnowledgeIndex } from '../wiki/sqlite-knowledge-index.js';
+import { reindexLocalIndexes } from './reindex.js';
+class FakeEmbeddingPort {
+    maxBatchSize = 8;
+    async computeEmbedding(text) {
+        return [text.length, 1];
+    }
+    async computeEmbeddingsBulk(texts) {
+        return texts.map((text) => [text.length, 1]);
+    }
+}
+async function createProject(tempDir) {
+    await initKtxProject({ projectDir: tempDir, force: true });
+    return loadKtxProject({ projectDir: tempDir });
+}
+describe('reindexLocalIndexes', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-reindex-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('returns an empty summary when no wiki or semantic-layer directories exist', async () => {
+        const project = await createProject(tempDir);
+        await rm(join(project.projectDir, 'wiki'), { recursive: true, force: true });
+        await rm(join(project.projectDir, 'semantic-layer'), { recursive: true, force: true });
+        await expect(reindexLocalIndexes(project, { force: false, embeddingService: null })).resolves.toMatchObject({
+            scopes: [],
+            totals: { scanned: 0, updated: 0, deleted: 0, embeddingsRecomputed: 0, embeddingsFailed: 0 },
+            force: false,
+            embeddingsAvailable: false,
+        });
+    });
+    it('discovers empty directories as zero-row scopes', async () => {
+        const project = await createProject(tempDir);
+        await mkdir(join(project.projectDir, 'wiki/user/local'), { recursive: true });
+        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
+        const summary = await reindexLocalIndexes(project, { force: false, embeddingService: null });
+        expect(summary.scopes.map((scope) => scope.label)).toEqual(['global', 'user/local', 'warehouse']);
+        expect(summary.totals.scanned).toBe(0);
+    });
+    it('indexes mixed wiki and SL sources and reports totals', async () => {
+        const project = await createProject(tempDir);
+        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
+        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
+        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/orders.yaml'), 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: number\njoins: []\nmeasures: []\n', 'utf-8');
+        const summary = await reindexLocalIndexes(project, {
+            force: false,
+            embeddingService: new FakeEmbeddingPort(),
+        });
+        expect(summary.scopes).toHaveLength(2);
+        expect(summary.totals).toMatchObject({ scanned: 2, updated: 2, deleted: 0, embeddingsRecomputed: 2 });
+        expect(summary.embeddingsAvailable).toBe(true);
+    });
+    it('does not report unchanged lexical-only rows as updated on repeated runs', async () => {
+        const project = await createProject(tempDir);
+        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
+        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
+        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/orders.yaml'), 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: number\njoins: []\nmeasures: []\n', 'utf-8');
+        const first = await reindexLocalIndexes(project, { force: false, embeddingService: null });
+        expect(first.totals).toMatchObject({
+            scanned: 2,
+            updated: 2,
+            deleted: 0,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        const second = await reindexLocalIndexes(project, { force: false, embeddingService: null });
+        expect(second.totals).toMatchObject({
+            scanned: 2,
+            updated: 0,
+            deleted: 0,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(second.scopes.map((scope) => [scope.label, scope.updated])).toEqual([
+            ['global', 0],
+            ['warehouse', 0],
+        ]);
+    });
+    it('force clears stale rows before rebuilding each discovered scope', async () => {
+        const project = await createProject(tempDir);
+        const wikiIndex = new SqliteKnowledgeIndex({ dbPath: join(project.projectDir, '.ktx/db.sqlite') });
+        wikiIndex.sync([
+            {
+                path: 'wiki/global/stale.md',
+                key: 'stale',
+                scope: 'GLOBAL',
+                scopeId: null,
+                summary: 'Stale',
+                content: 'Stale content',
+                tags: [],
+                embedding: [1, 0],
+            },
+        ]);
+        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
+        const summary = await reindexLocalIndexes(project, {
+            force: true,
+            embeddingService: new FakeEmbeddingPort(),
+        });
+        expect(summary.force).toBe(true);
+        expect(summary.totals).toMatchObject({ scanned: 1, updated: 1, deleted: 0 });
+        expect(wikiIndex.search('Stale', 10)).toEqual([]);
+    });
+    it('captures a per-scope error and continues other scopes', async () => {
+        const project = await createProject(tempDir);
+        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
+        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
+        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/broken.yaml'), 'not: [valid', 'utf-8');
+        const summary = await reindexLocalIndexes(project, { force: false, embeddingService: null });
+        expect(summary.scopes.find((scope) => scope.label === 'global')?.error).toBeUndefined();
+        expect(summary.scopes.find((scope) => scope.label === 'warehouse')?.error).toContain('YAML');
+    });
+    it('marks a scope errored when configured embeddings fail', async () => {
+        const project = await createProject(tempDir);
+        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
+        const embeddingService = {
+            maxBatchSize: 8,
+            async computeEmbedding() {
+                throw new Error('embedding provider unavailable');
+            },
+            async computeEmbeddingsBulk() {
+                throw new Error('embedding provider unavailable');
+            },
+        };
+        const summary = await reindexLocalIndexes(project, { force: false, embeddingService });
+        expect(summary.scopes[0]).toMatchObject({
+            label: 'global',
+            embeddingsFailed: 1,
+            error: '1 embedding recomputation failed',
+        });
+    });
+});

package/node_modules/@ktx/context/dist/index-sync/types.d.ts

@@ -0,0 +1,29 @@
+import type { KtxEmbeddingPort } from '../core/index.js';
+export interface ReindexOptions {
+    force: boolean;
+    embeddingService: KtxEmbeddingPort | null;
+}
+export interface ReindexWorkResult {
+    scanned: number;
+    updated: number;
+    deleted: number;
+    embeddingsRecomputed: number;
+    embeddingsFailed: number;
+}
+export interface ReindexScopeResult extends ReindexWorkResult {
+    kind: 'wiki' | 'sl';
+    label: string;
+    scope?: 'global' | 'user';
+    scopeId?: string | null;
+    connectionId?: string;
+    durationMs: number;
+    error?: string;
+}
+export interface ReindexSummary {
+    scopes: ReindexScopeResult[];
+    totals: ReindexWorkResult;
+    dbPath: string;
+    force: boolean;
+    embeddingsAvailable: boolean;
+    durationMs: number;
+}

package/node_modules/@ktx/context/dist/index-sync/types.js

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

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

@@ -7,6 +7,7 @@ export * from './agent/index.js';
 export * from './core/index.js';
 export * from './daemon/index.js';
 export * from './ingest/index.js';
+export * from './index-sync/index.js';
 export * from './llm/index.js';
 export type { CaptureSession, CaptureSignals, MemoryAgentInput, MemoryAgentResult, MemoryAgentServiceDeps, MemoryAgentSettings, MemoryAgentSourceType, MemoryCommitMessagePort, MemoryConnectionPort, MemoryFileStorePort, MemoryKnowledgeSlRefsPort, MemoryLockPort, MemorySlSourceReconcilerPort, MemoryTelemetryPort, MemoryToolSetLike, MemoryToolsetFactoryPort, } from './memory/index.js';
 export * from './project/index.js';

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

@@ -6,6 +6,7 @@ export * from './agent/index.js';
 export * from './core/index.js';
 export * from './daemon/index.js';
 export * from './ingest/index.js';
+export * from './index-sync/index.js';
 export * from './llm/index.js';
 export * from './project/index.js';
 export * from './prompts/index.js';

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/local-ingest-acceptance.test.js

@@ -132,7 +132,7 @@ async function writeHistoricSqlProject(project) {
         '  adapters:',
         '    - historic-sql',
         '  embeddings:',
-        '    backend: deterministic',
+        '    backend: none',
         'storage:',
         '  state: sqlite',
         '  search: sqlite-fts5',

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

@@ -262,7 +262,7 @@ describe('canonical local ingest', () => {
             '  adapters:',
             '    - fake',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         project = await loadKtxProject({ projectDir });
@@ -348,9 +348,9 @@ describe('canonical local ingest', () => {
         expect(result.result.failedWorkUnits).toEqual([]);
         const db = new Database(join(project.projectDir, '.ktx', 'db.sqlite'), { readonly: true });
         try {
-            expect(db.prepare('SELECT key, summary, embedding_json IS NOT NULL AS has_embedding FROM knowledge_pages ORDER BY key').all()).toEqual([
-                { key: 'orders_context', summary: 'Orders source context', has_embedding: 1 },
-            ]);
+            expect(db
+                .prepare('SELECT key, summary, embedding_json IS NOT NULL AS has_embedding FROM knowledge_pages ORDER BY key')
+                .all()).toEqual([{ key: 'orders_context', summary: 'Orders source context', has_embedding: 0 }]);
         }
         finally {
             db.close();
@@ -437,7 +437,7 @@ describe('canonical local ingest', () => {
             '  adapters:',
             '    - historic-sql',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             'storage:',
             '  state: sqlite',
             '  search: sqlite-fts5',
@@ -496,7 +496,7 @@ describe('canonical local ingest', () => {
             '  adapters:',
             '    - metabase',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         const metabaseProject = await loadKtxProject({ projectDir });
@@ -556,7 +556,7 @@ describe('canonical local ingest', () => {
             '  adapters:',
             '    - metricflow',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             'storage:',
             '  state: sqlite',
             '  search: sqlite-fts5',
@@ -656,7 +656,7 @@ describe('canonical local ingest', () => {
             '  adapters:',
             '    - looker',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             'storage:',
             '  state: sqlite',
             '  search: sqlite-fts5',

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

@@ -256,12 +256,15 @@ class LocalKnowledgeIndex {
     }
     async deleteStale() {
         await this.syncAllPagesFromDisk();
+        return 0;
     }
     async deleteByScope() {
         await this.syncAllPagesFromDisk();
+        return 0;
     }
     async deleteByKey() {
         await this.syncAllPagesFromDisk();
+        return 0;
     }
     async findPageByKey(scope, scopeId, pageKey) {
         const path = scope === 'GLOBAL' ? `wiki/global/${pageKey}.md` : `wiki/user/${scopeId}/${pageKey}.md`;
@@ -461,7 +464,7 @@ function localIngestLlmProviderGuardMessage(projectDir) {
         'ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, or claude-code, or an injected agentRunner.',
         'Configure a local Claude Code session or API-backed LLM, then rerun ingest:',
         `  ktx setup --project-dir ${projectDir} --llm-backend claude-code --no-input`,
-        `  ktx setup --project-dir ${projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --anthropic-model claude-sonnet-4-6 --no-input`,
+        `  ktx setup --project-dir ${projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --llm-model claude-sonnet-4-6 --no-input`,
     ].join('\n');
 }
 function resolveAgentRunner(options) {

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

@@ -23,7 +23,7 @@ describe('createLocalBundleIngestRuntime', () => {
             '  adapters:',
             '    - fake',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         project = await loadKtxProject({ projectDir });
@@ -39,7 +39,7 @@ describe('createLocalBundleIngestRuntime', () => {
             'ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, or claude-code, or an injected agentRunner.',
             'Configure a local Claude Code session or API-backed LLM, then rerun ingest:',
             `  ktx setup --project-dir ${project.projectDir} --llm-backend claude-code --no-input`,
-            `  ktx setup --project-dir ${project.projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --anthropic-model claude-sonnet-4-6 --no-input`,
+            `  ktx setup --project-dir ${project.projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --llm-model claude-sonnet-4-6 --no-input`,
         ].join('\n'));
     });
     it('uses a runtime-backed agent runner when claude-code is configured', () => {
@@ -211,7 +211,7 @@ describe('createLocalBundleIngestRuntime', () => {
             '  adapters:',
             '    - fake',
             '  embeddings:',
-            '    backend: deterministic',
+            '    backend: none',
             '',
         ].join('\n'), 'utf-8');
         project = await loadKtxProject({ projectDir: project.projectDir });

package/node_modules/@ktx/context/dist/ingest/local-embedding-provider.integration.test.js

@@ -2,7 +2,6 @@ import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { createLocalKtxEmbeddingProviderFromConfig, KtxIngestEmbeddingPortAdapter } from '../llm/index.js';
 import { CandidateDedupService } from './context-candidates/candidate-dedup.service.js';
 import { ContextEvidenceIndexService } from './context-evidence/context-evidence-index.service.js';
 import { SqliteContextEvidenceStore } from './context-evidence/sqlite-context-evidence-store.js';
@@ -31,15 +30,15 @@ describe('local ingest embedding providers with SQLite ingest stores', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     function embeddings() {
-        const provider = createLocalKtxEmbeddingProviderFromConfig({
-            backend: 'deterministic',
-            dimensions: 8,
-            batchSize: 4,
-        });
-        if (!provider) {
-            throw new Error('deterministic local embedding provider was not created');
-        }
-        return new KtxIngestEmbeddingPortAdapter(provider);
+        return {
+            maxBatchSize: 4,
+            async computeEmbedding() {
+                return [1, 0, 0];
+            },
+            async computeEmbeddingsBulk(texts) {
+                return texts.map(() => [1, 0, 0]);
+            },
+        };
     }
     it('indexes and searches context evidence using a package-owned local embedding provider', async () => {
         const store = new SqliteContextEvidenceStore({ dbPath });

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.d.ts

@@ -143,8 +143,8 @@ export declare const memoryFlowActionDetailSchema: z.ZodObject<{
     }>;
     action: z.ZodEnum<{
         created: "created";
-        removed: "removed";
         updated: "updated";
+        removed: "removed";
     }>;
     key: z.ZodString;
     summary: z.ZodString;
@@ -163,8 +163,8 @@ export declare const memoryFlowDetailSectionsSchema: z.ZodObject<{
         }>;
         action: z.ZodEnum<{
             created: "created";
-            removed: "removed";
             updated: "updated";
+            removed: "removed";
         }>;
         key: z.ZodString;
         summary: z.ZodString;

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

@@ -103,8 +103,8 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
                 }>;
                 type: z.ZodEnum<{
                     created: "created";
-                    removed: "removed";
                     updated: "updated";
+                    removed: "removed";
                 }>;
                 key: z.ZodString;
                 detail: z.ZodString;
@@ -129,8 +129,8 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
             }>;
             type: z.ZodEnum<{
                 created: "created";
-                removed: "removed";
                 updated: "updated";
+                removed: "removed";
             }>;
             key: z.ZodString;
             detail: z.ZodString;

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

@@ -130,26 +130,13 @@ export function resolveLocalKtxEmbeddingConfig(config, env) {
         }
         return {
             backend: config.backend,
-            model: config.model ?? 'deterministic',
+            model: config.model ?? 'text-embedding-3-small',
             dimensions: config.dimensions,
             openai,
             batchSize: config.batchSize,
         };
     }
-    return {
-        backend: config.backend,
-        model: config.model ?? 'deterministic',
-        dimensions: config.dimensions,
-        ...(config.sentenceTransformers
-            ? {
-                sentenceTransformers: {
-                    baseURL: config.sentenceTransformers.base_url,
-                    pathPrefix: config.sentenceTransformers.pathPrefix,
-                },
-            }
-            : {}),
-        batchSize: config.batchSize,
-    };
+    throw new Error(`Unsupported KTX embedding backend: ${String(config.backend)}`);
 }
 export function createLocalKtxEmbeddingProviderFromConfig(config, deps = {}) {
     const resolved = resolveLocalKtxEmbeddingConfig(config, deps.env ?? process.env);

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

@@ -173,15 +173,11 @@ describe('local KTX embedding config', () => {
             batchSize: undefined,
         });
     });
-    it('constructs deterministic embeddings from the default project config', () => {
+    it('returns null for the default disabled project embedding config', () => {
         const createKtxEmbeddingProvider = vi.fn(() => ({}));
         const provider = createLocalKtxEmbeddingProviderFromConfig(buildDefaultKtxProjectConfig().ingest.embeddings, { createKtxEmbeddingProvider });
-        expect(provider).not.toBeNull();
-        expect(createKtxEmbeddingProvider).toHaveBeenCalledWith(expect.objectContaining({
-            backend: 'deterministic',
-            model: 'deterministic',
-            dimensions: 8,
-        }));
+        expect(provider).toBeNull();
+        expect(createKtxEmbeddingProvider).not.toHaveBeenCalled();
     });
     it('returns null when embeddings are disabled', () => {
         expect(createLocalKtxEmbeddingProviderFromConfig({ backend: 'none', dimensions: 8 })).toBeNull();

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

@@ -128,9 +128,15 @@ class LocalKnowledgeIndex {
     async getExistingSearchTexts() {
         return new Map();
     }
-    async deleteStale() { }
-    async deleteByScope() { }
-    async deleteByKey() { }
+    async deleteStale() {
+        return 0;
+    }
+    async deleteByScope() {
+        return 0;
+    }
+    async deleteByKey() {
+        return 0;
+    }
     async findPageByKey(scope, scopeId, pageKey) {
         const path = this.pagePath(scope, scopeId, pageKey);
         try {