@kaelio/ktx 0.0.0 → 0.1.0-rc.0

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

@@ -0,0 +1,436 @@
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import { AgentRunnerService as DefaultAgentRunnerService } from '../agent/index.js';
+import { localConnectionInfoFromConfig } from '../connections/index.js';
+import { noopLogger, SessionWorktreeService } from '../core/index.js';
+import { createJsonlKtxLlmDebugRequestRecorder, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, KtxIngestEmbeddingPortAdapter, } from '../llm/index.js';
+import { ktxLocalStateDbPath } from '../project/index.js';
+import { PromptService } from '../prompts/index.js';
+import { SkillsRegistryService } from '../skills/index.js';
+import { SemanticLayerService, SlDiscoverTool, SlEditSourceTool, SlReadSourceTool, SlRollbackTool, SlSearchService, SlValidateTool, SlWriteSourceTool, SqliteSlSourcesIndex, sourceDefinitionSchema, sourceOverlaySchema, } from '../sl/index.js';
+import { ContextCandidateMarkTool, ContextCandidateWriteTool, ContextEvidenceNeighborsTool, ContextEvidenceReadTool, ContextEvidenceSearchTool, } from '../tools/index.js';
+import { KnowledgeWikiService, searchLocalKnowledgePages, WikiListTagsTool, WikiReadTool, WikiRemoveTool, WikiSearchTool, WikiWriteTool, } from '../wiki/index.js';
+import { CandidateDedupService, ContextCandidateCarryforwardService, CuratorPaginationService, } from './context-candidates/index.js';
+import { ContextEvidenceIndexService, SqliteContextEvidenceStore } from './context-evidence/index.js';
+import { DiffSetService } from './diff-set.service.js';
+import { IngestBundleRunner } from './ingest-bundle.runner.js';
+import { PageTriageService } from './page-triage/index.js';
+import { SourceAdapterRegistry } from './source-adapter-registry.js';
+import { SqliteBundleIngestStore } from './sqlite-bundle-ingest-store.js';
+const promptsDir = fileURLToPath(new URL('../../prompts', import.meta.url));
+const skillsDir = fileURLToPath(new URL('../../skills', import.meta.url));
+const LOCAL_AUTHOR = { name: 'KTX Local', email: 'local@ktx.local' };
+const LOCAL_SHAPE_WARNING = 'Local ingest validates semantic-layer YAML shape only.';
+class NoopEmbeddingPort {
+    maxBatchSize = 64;
+    async computeEmbedding() {
+        return [];
+    }
+    async computeEmbeddingsBulk(texts) {
+        return texts.map(() => []);
+    }
+}
+class LocalIngestStorage {
+    project;
+    homeDir;
+    systemGitAuthor = LOCAL_AUTHOR;
+    constructor(project) {
+        this.project = project;
+        this.homeDir = join(project.projectDir, '.ktx');
+    }
+    resolveUploadDir(uploadId) {
+        return join(this.project.projectDir, '.ktx/cache/local-ingest', uploadId, 'upload');
+    }
+    resolvePullDir(jobId) {
+        return join(this.project.projectDir, '.ktx/cache/local-ingest', jobId, 'pull');
+    }
+    resolveTranscriptDir(jobId) {
+        return join(this.project.projectDir, '.ktx/ingest-transcripts', jobId);
+    }
+}
+class LocalIngestLock {
+    async withLock(_key, fn) {
+        return fn();
+    }
+}
+class LocalCommitMessagePort {
+    async enqueueForExternalCommit() { }
+}
+class LocalAuthorResolver {
+    async resolve() {
+        return LOCAL_AUTHOR;
+    }
+}
+class LocalConnectionCatalog {
+    project;
+    queryExecutor;
+    constructor(project, queryExecutor) {
+        this.project = project;
+        this.queryExecutor = queryExecutor;
+    }
+    async listEnabledConnections(ids) {
+        return ids
+            .map((id) => localConnectionInfoFromConfig(id, this.project.config.connections[id]))
+            .filter((connection) => connection !== null);
+    }
+    async getConnectionById(connectionId) {
+        const connection = localConnectionInfoFromConfig(connectionId, this.project.config.connections[connectionId]);
+        if (!connection) {
+            throw new Error(`Connection not found: ${connectionId}`);
+        }
+        return connection;
+    }
+    async executeQuery(connectionId, sql) {
+        if (!this.queryExecutor) {
+            throw new Error('Local ingest has no query executor configured');
+        }
+        return this.queryExecutor.execute({ connectionId, sql });
+    }
+}
+class LocalSlPythonPort {
+    compute;
+    constructor(compute) {
+        this.compute = compute;
+    }
+    async validateSources(input) {
+        if (!this.compute) {
+            return { data: { errors: [], warnings: [LOCAL_SHAPE_WARNING], per_source_warnings: {} } };
+        }
+        const result = await this.compute.validateSources({
+            sources: input.sources,
+            dialect: input.dialect,
+            recentlyTouched: input.recently_touched,
+        });
+        return {
+            data: {
+                errors: result.errors,
+                warnings: result.warnings,
+                per_source_warnings: result.perSourceWarnings,
+            },
+        };
+    }
+    async query(input) {
+        if (!this.compute) {
+            return { error: 'Local ingest has no semantic compute adapter configured' };
+        }
+        const result = await this.compute.query({
+            sources: input.sources,
+            dialect: input.dialect,
+            query: input.query,
+        });
+        return { data: { sql: result.sql, plan: result.plan } };
+    }
+}
+class LocalShapeOnlySlValidator {
+    async validateSingleSource(deps, connectionId, sourceName) {
+        try {
+            const file = await deps.semanticLayerService.readSourceFile(connectionId, sourceName);
+            const parsed = YAML.parse(file.content);
+            const isOverlay = parsed.table == null && parsed.sql == null;
+            const result = (isOverlay ? sourceOverlaySchema : sourceDefinitionSchema).safeParse(parsed);
+            return result.success
+                ? { errors: [], warnings: [LOCAL_SHAPE_WARNING] }
+                : {
+                    errors: result.error.issues.map((issue) => `${sourceName}: ${issue.path.join('.') || 'source'} ${issue.message}`),
+                    warnings: [],
+                };
+        }
+        catch (error) {
+            return { errors: [`${sourceName}: ${error instanceof Error ? error.message : String(error)}`], warnings: [] };
+        }
+    }
+}
+function parseWiki(raw) {
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) {
+        return { summary: '', content: raw.trim() };
+    }
+    const frontmatter = (YAML.parse(match[1]) ?? {});
+    return {
+        summary: typeof frontmatter.summary === 'string' ? frontmatter.summary : '',
+        content: match[2].trim(),
+    };
+}
+function scoreText(text, query) {
+    const normalized = query.toLowerCase().trim();
+    if (!normalized) {
+        return 0;
+    }
+    const haystack = text.toLowerCase();
+    if (haystack.includes(normalized)) {
+        return 1;
+    }
+    const words = normalized.split(/\s+/).filter(Boolean);
+    return words.filter((word) => haystack.includes(word)).length / Math.max(words.length, 1);
+}
+class LocalKnowledgeIndex {
+    project;
+    constructor(project) {
+        this.project = project;
+    }
+    async upsertPage() { }
+    async applyDiffTransactional() { }
+    async getExistingSearchTexts() {
+        return new Map();
+    }
+    async deleteStale() { }
+    async deleteByScope() { }
+    async deleteByKey() { }
+    async findPageByKey(scope, scopeId, pageKey) {
+        const path = scope === 'GLOBAL' ? `knowledge/global/${pageKey}.md` : `knowledge/user/${scopeId}/${pageKey}.md`;
+        try {
+            await this.project.fileStore.readFile(path);
+            return { page_key: pageKey };
+        }
+        catch {
+            return null;
+        }
+    }
+    async listPagesForUser(userId) {
+        const pages = [];
+        for (const scope of [
+            { scope: 'GLOBAL', scopeId: null, dir: 'knowledge/global' },
+            { scope: 'USER', scopeId: userId, dir: `knowledge/user/${userId}` },
+        ]) {
+            const listed = await this.project.fileStore.listFiles(scope.dir, true);
+            for (const file of listed.files.filter((entry) => entry.endsWith('.md'))) {
+                const pageKey = file.replace(/\.md$/, '');
+                const raw = await this.project.fileStore.readFile(`${scope.dir}/${file}`);
+                const parsed = parseWiki(raw.content);
+                pages.push({
+                    page_key: pageKey,
+                    summary: parsed.summary,
+                    scope: scope.scope,
+                    scope_id: scope.scopeId,
+                });
+            }
+        }
+        return pages.sort((left, right) => left.page_key.localeCompare(right.page_key));
+    }
+    async getUserPageCount(userId) {
+        return (await this.listPagesForUser(userId)).filter((page) => page.scope === 'USER').length;
+    }
+    async incrementUsageCount() { }
+    async searchRRF(userId, _embedding, queryText, limit) {
+        const pages = await this.listPagesForUser(userId);
+        return pages
+            .map((page) => ({
+            pageKey: page.page_key,
+            summary: page.summary,
+            rrfScore: scoreText(`${page.page_key} ${page.summary}`, queryText),
+        }))
+            .filter((page) => page.rrfScore > 0)
+            .sort((left, right) => right.rrfScore - left.rrfScore || left.pageKey.localeCompare(right.pageKey))
+            .slice(0, limit);
+    }
+}
+class NoopKnowledgeEventPort {
+    async createEvent() { }
+}
+class LocalIngestToolSet {
+    tools;
+    constructor(tools) {
+        this.tools = tools;
+    }
+    toAiSdkTools(context) {
+        return Object.fromEntries(this.tools.map((tool) => [tool.name, tool.toAiSdkTool(context)]));
+    }
+}
+class LocalIngestToolsetFactory {
+    baseTools;
+    contextTools;
+    constructor(deps) {
+        const slDeps = {
+            semanticLayerService: deps.semanticLayerService,
+            slSearchService: deps.slSearchService,
+            authorResolver: deps.authorResolver,
+        };
+        this.baseTools = [
+            new WikiReadTool(deps.wikiService, deps.knowledgeIndex),
+            new WikiSearchTool({
+                search: async (input) => {
+                    const results = await searchLocalKnowledgePages(deps.project, {
+                        userId: input.userId,
+                        query: input.query,
+                        limit: input.limit,
+                        embeddingService: deps.embedding,
+                    });
+                    return {
+                        results: results.slice(0, input.limit).map((result) => ({
+                            key: result.key,
+                            path: result.path,
+                            summary: result.summary,
+                            score: result.score,
+                            matchReasons: result.matchReasons,
+                            lanes: result.lanes,
+                        })),
+                        totalFound: results.length,
+                    };
+                },
+            }),
+            new WikiListTagsTool(deps.wikiService, deps.knowledgeIndex),
+            new WikiWriteTool(deps.wikiService, deps.knowledgeIndex, deps.knowledgeEvents),
+            new WikiRemoveTool(deps.wikiService, deps.knowledgeIndex, deps.knowledgeEvents),
+            new SlDiscoverTool(slDeps, { maxSources: 25, minRrfScore: 0, maxDetailedSources: 5 }),
+            new SlEditSourceTool(slDeps),
+            new SlReadSourceTool(slDeps),
+            new SlWriteSourceTool(slDeps),
+            new SlValidateTool(slDeps),
+            new SlRollbackTool(deps.slSourcesRepository, deps.connections, 0),
+        ];
+        this.contextTools = [
+            new ContextEvidenceSearchTool(deps.contextStore, deps.embedding),
+            new ContextEvidenceReadTool(deps.contextStore),
+            new ContextEvidenceNeighborsTool(deps.contextStore),
+            new ContextCandidateWriteTool(deps.contextStore, deps.embedding),
+            new ContextCandidateMarkTool(deps.contextStore),
+        ];
+    }
+    createIngestWuToolset(_session, options) {
+        return new LocalIngestToolSet(options?.includeContextEvidenceTools ? [...this.baseTools, ...this.contextTools] : this.baseTools);
+    }
+}
+function registerAdapters(adapters) {
+    const registry = new SourceAdapterRegistry();
+    for (const adapter of adapters) {
+        registry.register(adapter);
+    }
+    return registry;
+}
+function nextLocalJobId() {
+    return `local-${Date.now().toString(36)}`;
+}
+function resolveAgentRunner(options) {
+    const llmProvider = options.llmProvider ?? createLocalKtxLlmProviderFromConfig(options.project.config.llm) ?? undefined;
+    if (options.agentRunner) {
+        return { agentRunner: options.agentRunner, ...(llmProvider ? { llmProvider } : {}) };
+    }
+    if (!llmProvider) {
+        throw new Error('ktx dev ingest run requires llm.provider.backend: anthropic, vertex, or gateway, or an injected agentRunner');
+    }
+    return {
+        agentRunner: new DefaultAgentRunnerService({
+            llmProvider,
+            logger: options.logger ?? noopLogger,
+            ...(options.llmDebugRequestFile
+                ? { debugRequestRecorder: createJsonlKtxLlmDebugRequestRecorder(options.llmDebugRequestFile) }
+                : {}),
+        }),
+        llmProvider,
+    };
+}
+export function createLocalBundleIngestRuntime(options) {
+    const logger = options.logger ?? noopLogger;
+    const dbPath = ktxLocalStateDbPath(options.project);
+    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 embedding = embeddingProvider ? new KtxIngestEmbeddingPortAdapter(embeddingProvider) : new NoopEmbeddingPort();
+    const connections = new LocalConnectionCatalog(options.project, options.queryExecutor);
+    const rootFileStore = options.project.fileStore;
+    const semanticLayerService = new SemanticLayerService(rootFileStore, connections, new LocalSlPythonPort(options.semanticLayerCompute), logger);
+    const slSourcesRepository = new SqliteSlSourcesIndex({ dbPath });
+    const slSearchService = new SlSearchService(embedding, slSourcesRepository, logger);
+    const knowledgeIndex = new LocalKnowledgeIndex(options.project);
+    const knowledgeEvents = new NoopKnowledgeEventPort();
+    const wikiService = new KnowledgeWikiService(rootFileStore, embedding, knowledgeIndex, options.project.git, logger);
+    const { agentRunner, llmProvider } = resolveAgentRunner(options);
+    const promptService = new PromptService({ promptsDir, partials: [], logger });
+    const storage = new LocalIngestStorage(options.project);
+    const registry = registerAdapters(options.adapters);
+    const toolsetFactory = new LocalIngestToolsetFactory({
+        project: options.project,
+        wikiService,
+        knowledgeIndex,
+        knowledgeEvents,
+        semanticLayerService,
+        slSearchService,
+        authorResolver: new LocalAuthorResolver(),
+        slSourcesRepository,
+        connections,
+        contextStore,
+        embedding,
+    });
+    const deps = {
+        runs: store,
+        provenance: store,
+        reports: store,
+        canonicalPins: store,
+        registry,
+        diffSetService: new DiffSetService(store),
+        sessionWorktreeService: new SessionWorktreeService({
+            coreConfig: options.project.coreConfig,
+            gitService: options.project.git,
+            configService: rootFileStore,
+        }),
+        agentRunner,
+        gitService: options.project.git,
+        lockingService: new LocalIngestLock(),
+        storage,
+        settings: {
+            memoryIngestionModel: options.project.config.llm.models.default ?? 'local-ingest-model',
+            probeRowCount: 0,
+            workUnitMaxConcurrency: options.project.config.ingest.workUnits.maxConcurrency,
+            workUnitStepBudget: options.project.config.ingest.workUnits.stepBudget,
+            workUnitFailureMode: options.project.config.ingest.workUnits.failureMode,
+        },
+        skillsRegistry: new SkillsRegistryService({ skillsDir, logger }),
+        promptService,
+        wikiService,
+        knowledgeIndex,
+        semanticLayerService,
+        slSearchService,
+        slSourcesRepository,
+        connections,
+        slValidator: new LocalShapeOnlySlValidator(),
+        toolsetFactory,
+        commitMessages: new LocalCommitMessagePort(),
+        embedding,
+        contextEvidenceIndex: new ContextEvidenceIndexService({ store: contextStore, embeddings: embedding, logger }),
+        pageTriage: llmProvider
+            ? new PageTriageService({
+                store: contextStore,
+                llmProvider,
+                settings: {
+                    enabled: true,
+                    maxConcurrency: 2,
+                    lightExtractionEnabled: true,
+                    classifierModel: null,
+                    lightExtractionMaxCandidates: 5,
+                },
+                promptService,
+                logger,
+            })
+            : undefined,
+        contextEvidenceCandidates: contextStore,
+        candidateDedup: new CandidateDedupService({
+            store: contextStore,
+            embeddings: embedding,
+            settings: { enabled: true, topicSimilarityThreshold: 0.86, scoreAggregation: 'max' },
+            logger,
+        }),
+        contextCandidateCarryforward: new ContextCandidateCarryforwardService({
+            store: contextStore,
+            settings: { reExamineBudgetExhaustedOnRerun: true },
+            logger,
+        }),
+        curatorPagination: new CuratorPaginationService({
+            store: contextStore,
+            agentRunner,
+            settings: { batchSize: 8, maxPasses: 8, stepBudgetPerPass: 60 },
+            logger,
+        }),
+        logger,
+    };
+    return {
+        runner: new IngestBundleRunner(deps),
+        store,
+        contextStore,
+        storage,
+        registry,
+        nextJobId: options.jobIdFactory ?? nextLocalJobId,
+    };
+}

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

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

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

@@ -0,0 +1,107 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AgentRunnerService } from '../agent/index.js';
+import { initKtxProject, loadKtxProject } from '../project/index.js';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { FakeSourceAdapter } from './adapters/fake/fake.adapter.js';
+import { createLocalBundleIngestRuntime } from './local-bundle-runtime.js';
+describe('createLocalBundleIngestRuntime', () => {
+    let tempDir;
+    let project;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-bundle-runtime-'));
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir, projectName: 'warehouse' });
+        await writeFile(join(projectDir, 'ktx.yaml'), [
+            'project: warehouse',
+            'connections:',
+            '  warehouse:',
+            '    driver: postgres',
+            'ingest:',
+            '  adapters:',
+            '    - fake',
+            '  embeddings:',
+            '    backend: deterministic',
+            '',
+        ].join('\n'), 'utf-8');
+        project = await loadKtxProject({ projectDir });
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('requires an agent runner or configured local ingest LLM', () => {
+        expect(() => createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+        })).toThrow('ktx dev ingest run requires llm.provider.backend: anthropic, vertex, or gateway, or an injected agentRunner');
+    });
+    it('builds runner deps with local SQLite stores and context tools enabled', async () => {
+        const agentRunner = new AgentRunnerService({ llmProvider: { getModel: () => ({}) } });
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            agentRunner,
+            jobIdFactory: () => 'job-1',
+        });
+        expect(runtime.nextJobId()).toBe('job-1');
+        expect(runtime.storage.resolvePullDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/pull'));
+        expect(runtime.storage.resolveUploadDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/upload'));
+        expect(runtime.storage.resolveTranscriptDir('job-1')).toBe(join(project.projectDir, '.ktx/ingest-transcripts/job-1'));
+        await mkdir(runtime.storage.resolveUploadDir('job-1'), { recursive: true });
+    });
+    it('exposes canonical warehouse connection types to local ingest SL tools', async () => {
+        project.config.connections.warehouse = {
+            driver: 'postgres',
+            url: 'postgresql://readonly@db.example.test/analytics',
+        };
+        project.config.connections.bq = {
+            driver: 'bigquery',
+            project_id: 'acme',
+            dataset_id: 'warehouse',
+        };
+        const agentRunner = new AgentRunnerService({ llmProvider: { getModel: () => ({}) } });
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            agentRunner,
+        });
+        const connections = runtime.runner.deps.connections;
+        await expect(connections.getConnectionById('warehouse')).resolves.toMatchObject({
+            id: 'warehouse',
+            connectionType: 'POSTGRESQL',
+        });
+        await expect(connections.listEnabledConnections(['warehouse', 'bq'])).resolves.toEqual([
+            { id: 'warehouse', name: 'warehouse', connectionType: 'POSTGRESQL' },
+            { id: 'bq', name: 'bq', connectionType: 'BIGQUERY' },
+        ]);
+    });
+    it('accepts a debug LLM request file when constructing the default agent runner', async () => {
+        await writeFile(join(project.projectDir, 'ktx.yaml'), [
+            'project: warehouse',
+            'connections:',
+            '  warehouse:',
+            '    driver: postgres',
+            'llm:',
+            '  provider:',
+            '    backend: gateway',
+            '    gateway:',
+            '      base_url: https://gateway.example/v1',
+            '  models:',
+            '    default: anthropic/claude-sonnet-4-6',
+            'ingest:',
+            '  adapters:',
+            '    - fake',
+            '  embeddings:',
+            '    backend: deterministic',
+            '',
+        ].join('\n'), 'utf-8');
+        project = await loadKtxProject({ projectDir: project.projectDir });
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            llmDebugRequestFile: join(project.projectDir, '.ktx', 'llm-debug.jsonl'),
+        });
+        expect(runtime.storage.resolvePullDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/pull'));
+    });
+});

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

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

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

@@ -0,0 +1,140 @@
+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';
+describe('local ingest embedding providers with SQLite ingest stores', () => {
+    let tempDir;
+    let dbPath;
+    let stagedDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-ingest-embedding-'));
+        dbPath = join(tempDir, '.ktx', 'db.sqlite');
+        stagedDir = join(tempDir, 'staged');
+        await mkdir(join(stagedDir, 'pages', 'revenue'), { recursive: true });
+        await writeFile(join(stagedDir, 'pages', 'revenue', 'metadata.json'), `${JSON.stringify({
+            objectType: 'page',
+            id: 'page-revenue',
+            title: 'Revenue Policy',
+            path: 'Revenue Policy',
+            url: 'https://notion.test/revenue',
+            parentId: null,
+            lastEditedAt: '2026-04-30T12:00:00.000Z',
+            properties: {},
+        })}\n`, 'utf8');
+        await writeFile(join(stagedDir, 'pages', 'revenue', 'page.md'), ['# Approval', '', 'Owner approval is required before enterprise discounts are granted.', ''].join('\n'), 'utf8');
+    });
+    afterEach(async () => {
+        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);
+    }
+    it('indexes and searches context evidence using a package-owned local embedding provider', async () => {
+        const store = new SqliteContextEvidenceStore({ dbPath });
+        const embeddingPort = embeddings();
+        const indexer = new ContextEvidenceIndexService({ store, embeddings: embeddingPort });
+        const diffSet = {
+            added: ['pages/revenue/metadata.json', 'pages/revenue/page.md'],
+            modified: [],
+            deleted: [],
+            unchanged: [],
+        };
+        const summary = await indexer.indexStagedDir({
+            stagedDir,
+            runId: 'run-1',
+            connectionId: 'docs',
+            sourceKey: 'notion',
+            syncId: 'sync-1',
+            diffSet,
+            currentHashes: new Map([
+                ['pages/revenue/metadata.json', 'metadata-hash'],
+                ['pages/revenue/page.md', 'page-hash'],
+            ]),
+        });
+        expect(summary).toMatchObject({
+            documentsIndexed: 1,
+            embeddingFailures: 0,
+        });
+        expect(summary.chunksIndexed).toBeGreaterThan(0);
+        const queryText = [
+            'Revenue Policy',
+            'Revenue Policy',
+            'Approval',
+            'Owner approval is required before enterprise discounts are granted.',
+        ].join('\n');
+        const queryEmbedding = await embeddingPort.computeEmbedding(queryText);
+        const results = await store.searchRRF({
+            connectionId: 'docs',
+            sourceKey: 'notion',
+            queryEmbedding,
+            queryText,
+            limit: 5,
+            includeDeleted: false,
+            currentRunId: 'run-1',
+        });
+        expect(results[0]?.title).toBe('Revenue Policy');
+        expect(results[0]?.stableCitationKey).toContain('notion:page-revenue');
+        expect(results[0]).toMatchObject({
+            matchReasons: expect.arrayContaining(['semantic']),
+            lanes: expect.arrayContaining([
+                expect.objectContaining({ lane: 'semantic', status: 'available' }),
+                expect.objectContaining({ lane: 'lexical', status: 'available' }),
+                expect.objectContaining({ lane: 'token', status: 'available' }),
+            ]),
+        });
+    });
+    it('deduplicates candidates using package-owned local embeddings and SQLite persistence', async () => {
+        const store = new SqliteContextEvidenceStore({ dbPath });
+        const embeddingPort = embeddings();
+        const candidateBase = {
+            runId: 'run-1',
+            connectionId: 'docs',
+            sourceKey: 'notion',
+            topic: 'Enterprise discount approval',
+            assertion: 'Owner approval is required before enterprise discounts are granted.',
+            rationale: 'The source policy states that approval is required.',
+            evidenceChunkIds: [],
+            evidenceRefs: [],
+            suggestedPageKey: 'revenue-policy',
+            actionHint: 'create',
+            durabilityScore: 3,
+            authorityScore: 3,
+            reuseScore: 3,
+            noveltyScore: 2,
+            riskScore: 0,
+            promotionScore: 11,
+            status: 'pending',
+            rejectionReason: null,
+            lane: 'full',
+            embedding: null,
+        };
+        await store.insertCandidate({ ...candidateBase, candidateKey: 'discount-policy-a' });
+        await store.insertCandidate({ ...candidateBase, candidateKey: 'discount-policy-b' });
+        const result = await new CandidateDedupService({
+            store,
+            embeddings: embeddingPort,
+            settings: {
+                enabled: true,
+                topicSimilarityThreshold: -1,
+                scoreAggregation: 'max',
+            },
+        }).deduplicateRun('run-1');
+        expect(result.enabled).toBe(true);
+        expect(result.embeddingFailures).toBe(0);
+        expect(result.candidatesIn).toBe(2);
+        expect(result.clustersOut).toBe(1);
+        expect(result.mergedCount).toBe(1);
+    });
+});