@kaelio/ktx 0.1.1 → 0.2.0

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/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`;

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/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 {

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) => ({

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

@@ -192,4 +192,65 @@ describe('SlSearchService', () => {
             },
         ]);
     });
+    it('indexSources reports stats and supports lexical-only indexing', async () => {
+        const repository = {
+            upsertSources: vi.fn().mockResolvedValue(undefined),
+            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
+                ['old_source', { searchText: 'old source', hasEmbedding: true }],
+            ])),
+            deleteStale: vi.fn().mockResolvedValue(1),
+            deleteByConnection: vi.fn().mockResolvedValue(0),
+            deleteByConnectionAndName: vi.fn(),
+            search: vi.fn(),
+        };
+        const service = new SlSearchService(null, repository);
+        const source = {
+            name: 'orders',
+            table: 'public.orders',
+            grain: ['id'],
+            columns: [{ name: 'id', type: 'number' }],
+            joins: [],
+            measures: [],
+        };
+        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
+            scanned: 1,
+            updated: 1,
+            deleted: 1,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', [
+            expect.objectContaining({ sourceName: 'orders', embedding: null }),
+        ]);
+    });
+    it('does not update unchanged lexical-only SL rows on repeated sync', async () => {
+        const repository = {
+            upsertSources: vi.fn().mockResolvedValue(undefined),
+            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
+                ['orders', { searchText: 'orders. table: public.orders. id (number)', hasEmbedding: false }],
+            ])),
+            deleteStale: vi.fn().mockResolvedValue(0),
+            deleteByConnection: vi.fn().mockResolvedValue(0),
+            deleteByConnectionAndName: vi.fn(),
+            search: vi.fn(),
+        };
+        const service = new SlSearchService(null, repository);
+        const source = {
+            name: 'orders',
+            table: 'public.orders',
+            grain: ['id'],
+            columns: [{ name: 'id', type: 'number' }],
+            joins: [],
+            measures: [],
+        };
+        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
+            scanned: 1,
+            updated: 0,
+            deleted: 0,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', []);
+        expect(repository.deleteStale).toHaveBeenCalledWith('warehouse', ['orders']);
+    });
 });

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.d.ts

@@ -28,9 +28,10 @@ export declare class SqliteSlSourcesIndex implements 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>;
+    clear(connectionId: string): Promise<number>;
+    deleteByConnectionAndName(connectionId: string, sourceName: string): Promise<number>;
     replaceDictionaryEntries(connectionId: string, entries: SlDictionaryEntry[]): Promise<void>;
     searchLexicalCandidates(input: {
         connectionIds?: readonly string[];

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.js

@@ -144,8 +144,7 @@ export class SqliteSlSourcesIndex {
     }
     async deleteStale(connectionId, keepNames) {
         if (keepNames.length === 0) {
-            await this.deleteByConnection(connectionId);
-            return;
+            return this.deleteByConnection(connectionId);
         }
         const placeholders = keepNames.map(() => '?').join(', ');
         const stale = this.db
@@ -173,16 +172,26 @@ export class SqliteSlSourcesIndex {
             }
         });
         remove(stale.map((row) => row.source_name));
+        return stale.length;
     }
     async deleteByConnection(connectionId) {
+        return this.clear(connectionId);
+    }
+    async clear(connectionId) {
+        const rows = this.db
+            .prepare('SELECT source_name FROM local_sl_sources WHERE connection_id = ?')
+            .all(connectionId);
         const remove = this.db.transaction(() => {
             this.db.prepare('DELETE FROM local_sl_sources_fts WHERE connection_id = ?').run(connectionId);
             this.db.prepare('DELETE FROM local_sl_sources WHERE connection_id = ?').run(connectionId);
+            this.db.prepare('DELETE FROM local_sl_dictionary_values_fts WHERE connection_id = ?').run(connectionId);
+            this.db.prepare('DELETE FROM local_sl_dictionary_values WHERE connection_id = ?').run(connectionId);
         });
         remove();
+        return rows.length;
     }
     async deleteByConnectionAndName(connectionId, sourceName) {
-        this.deleteByConnectionAndNameSync(connectionId, sourceName);
+        return this.deleteByConnectionAndNameSync(connectionId, sourceName);
     }
     async replaceDictionaryEntries(connectionId, entries) {
         const remove = this.db.transaction(() => {
@@ -406,14 +415,15 @@ export class SqliteSlSourcesIndex {
             AND source_name = ?
         `)
                 .run(connectionId, sourceName);
-            this.db
+            const result = this.db
                 .prepare(`
           DELETE FROM local_sl_sources
           WHERE connection_id = ?
             AND source_name = ?
         `)
                 .run(connectionId, sourceName);
+            return Number(result.changes);
         });
-        remove();
+        return remove();
     }
 }

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.test.js

@@ -86,6 +86,30 @@ describe('SqliteSlSourcesIndex', () => {
         await index.deleteByConnection('finance');
         expect(await index.search('finance', null, 'revenue', 10)).toEqual([]);
     });
+    it('clear removes sources and dictionary rows for one connection only', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            { sourceName: 'orders', searchText: 'orders revenue paid', embedding: null },
+        ]);
+        await index.upsertSources('finance', [
+            { sourceName: 'invoices', searchText: 'invoices revenue paid', embedding: null },
+        ]);
+        await index.replaceDictionaryEntries('warehouse', [
+            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'paid', cardinality: 1 },
+        ]);
+        await index.replaceDictionaryEntries('finance', [
+            { connectionId: 'finance', sourceName: 'invoices', columnName: 'status', value: 'paid', cardinality: 1 },
+        ]);
+        await expect(index.clear('warehouse')).resolves.toBe(1);
+        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([]);
+        expect(await index.search('finance', null, 'revenue', 10)).toEqual([
+            expect.objectContaining({ sourceName: 'invoices' }),
+        ]);
+        await expect(index.searchDictionaryCandidates({ connectionIds: ['warehouse'], queryText: 'paid', limit: 10 }))
+            .resolves.toEqual([]);
+        await expect(index.searchDictionaryCandidates({ connectionIds: ['finance'], queryText: 'paid', limit: 10 }))
+            .resolves.toEqual([expect.objectContaining({ connectionId: 'finance', sourceName: 'invoices' })]);
+    });
     it('returns lane candidates with stable connection-scoped IDs', async () => {
         const index = new SqliteSlSourcesIndex({ dbPath });
         await index.upsertSources('warehouse', [

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.d.ts

@@ -1,4 +1,5 @@
 import type { KtxEmbeddingPort, KtxFileStorePort, KtxLogger } from '../core/index.js';
+import type { ReindexWorkResult } from '../index-sync/types.js';
 import type { KnowledgeGitDiffPort, KnowledgeIndexPort } from './ports.js';
 import type { WikiFrontmatter, WikiPage, WikiPageWithScope } from './types.js';
 export type { WikiFrontmatter };
@@ -9,7 +10,7 @@ export declare class KnowledgeWikiService {
     private readonly gitService;
     private readonly logger;
     private isWorktreeScoped;
-    constructor(configService: KtxFileStorePort, embeddingService: KtxEmbeddingPort, pagesRepository: KnowledgeIndexPort, gitService: KnowledgeGitDiffPort, logger?: KtxLogger);
+    constructor(configService: KtxFileStorePort, embeddingService: KtxEmbeddingPort | null, pagesRepository: KnowledgeIndexPort, gitService: KnowledgeGitDiffPort, logger?: KtxLogger);
     /**
      * Return a clone of this service whose disk writes go through a worktree-scoped
      * ConfigService AND whose DB-index writes are no-ops. Used by memory-agent
@@ -56,7 +57,7 @@ export declare class KnowledgeWikiService {
      * Full sync: load all pages from disk for a scope, reindex changed pages, clean stale entries.
      * Mirrors SlSearchService.indexSources() pattern.
      */
-    syncIndex(scope: string, scopeId?: string | null): Promise<void>;
+    syncIndex(scope: string, scopeId?: string | null): Promise<ReindexWorkResult>;
     /**
      * Delete a page from the DB index (after file deletion).
      */