@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/memory/memory-runs.test.js

@@ -0,0 +1,158 @@
+import { describe, expect, it, vi } from 'vitest';
+import { MemoryCaptureService } from './memory-runs.js';
+class InMemoryRunStore {
+    rows = new Map();
+    async createRunning(args) {
+        const id = `run-${this.rows.size + 1}`;
+        this.rows.set(id, {
+            id,
+            status: 'running',
+            stage: 'queued',
+            inputHash: args.inputHash,
+            chatId: args.chatId ?? null,
+            outputSummary: null,
+            error: null,
+        });
+        return { id };
+    }
+    async markRunning(id, stage) {
+        const row = this.rows.get(id);
+        if (!row) {
+            throw new Error(`unknown run ${id}`);
+        }
+        row.stage = stage;
+    }
+    async markDone(id, outputSummary) {
+        const row = this.rows.get(id);
+        if (!row) {
+            throw new Error(`unknown run ${id}`);
+        }
+        row.status = 'done';
+        row.stage = 'done';
+        row.outputSummary = outputSummary;
+    }
+    async markError(id, error) {
+        const row = this.rows.get(id);
+        if (!row) {
+            throw new Error(`unknown run ${id}`);
+        }
+        row.status = 'error';
+        row.stage = 'error';
+        row.error = error;
+    }
+    async findById(id) {
+        return this.rows.get(id) ?? null;
+    }
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+function buildService() {
+    const store = new InMemoryRunStore();
+    const run = deferred();
+    const ingest = vi.fn().mockReturnValue(run.promise);
+    const memoryAgent = { ingest };
+    return {
+        capture: new MemoryCaptureService({ memoryAgent, runs: store }),
+        store,
+        ingest,
+        run,
+    };
+}
+describe('MemoryCaptureService', () => {
+    it('creates a run, executes memory capture, and stores a done summary', async () => {
+        const result = {
+            signalDetected: true,
+            actions: [{ target: 'wiki', type: 'created', key: 'revenue', detail: 'captured revenue definition' }],
+            skillsLoaded: ['knowledge_capture'],
+            commitHash: 'abc123',
+        };
+        const { capture, store, ingest, run } = buildService();
+        const input = {
+            userId: 'user-1',
+            chatId: 'chat-1',
+            userMessage: 'Revenue means paid order value.',
+            assistantMessage: 'Captured.',
+            connectionId: '00000000-0000-0000-0000-000000000001',
+        };
+        const started = await capture.capture(input);
+        expect(started.runId).toBe('run-1');
+        expect(ingest).toHaveBeenCalledWith(input);
+        await expect(capture.status(started.runId)).resolves.toMatchObject({
+            runId: 'run-1',
+            status: 'running',
+            stage: 'capturing',
+            done: false,
+        });
+        run.resolve(result);
+        await capture.waitForRun(started.runId);
+        const status = await capture.status(started.runId);
+        expect(status).toEqual({
+            runId: 'run-1',
+            stage: 'done',
+            done: true,
+            status: 'done',
+            captured: {
+                wiki: ['revenue'],
+                sl: [],
+                xrefs: [],
+            },
+            error: null,
+            commitHash: 'abc123',
+            skillsLoaded: ['knowledge_capture'],
+            signalDetected: true,
+        });
+        expect(store.rows.get('run-1')?.inputHash).toHaveLength(64);
+    });
+    it('stores no-signal captures as done with empty captured arrays', async () => {
+        const { capture, run } = buildService();
+        const started = await capture.capture({
+            userId: 'user-1',
+            chatId: 'chat-2',
+            userMessage: 'Thanks.',
+        });
+        run.resolve({
+            signalDetected: false,
+            actions: [],
+            skillsLoaded: [],
+            commitHash: null,
+        });
+        await capture.waitForRun(started.runId);
+        await expect(capture.status(started.runId)).resolves.toMatchObject({
+            done: true,
+            status: 'done',
+            captured: { wiki: [], sl: [], xrefs: [] },
+            signalDetected: false,
+        });
+    });
+    it('stores thrown errors and projects them as failed statuses', async () => {
+        const store = new InMemoryRunStore();
+        const memoryAgent = {
+            ingest: vi.fn().mockRejectedValue(new Error('LLM provider missing')),
+        };
+        const capture = new MemoryCaptureService({ memoryAgent, runs: store });
+        const started = await capture.capture({
+            userId: 'user-1',
+            chatId: 'chat-3',
+            userMessage: 'Remember this.',
+        });
+        await capture.waitForRun(started.runId);
+        await expect(capture.status(started.runId)).resolves.toMatchObject({
+            done: true,
+            status: 'error',
+            stage: 'error',
+            captured: { wiki: [], sl: [], xrefs: [] },
+            error: 'LLM provider missing',
+        });
+    });
+    it('returns null for an unknown run id', async () => {
+        const { capture } = buildService();
+        await expect(capture.status('missing')).resolves.toBeNull();
+    });
+});

package/node_modules/@ktx/context/dist/memory/memory-runtime-assets.test.d.ts

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

package/node_modules/@ktx/context/dist/memory/memory-runtime-assets.test.js

@@ -0,0 +1,83 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { PromptService } from '../prompts/index.js';
+import { SkillsRegistryService } from '../skills/index.js';
+import { DEFAULT_SKILL_NAMES, promptNameFor } from './index.js';
+const promptsDir = fileURLToPath(new URL('../../prompts', import.meta.url));
+const skillsDir = fileURLToPath(new URL('../../skills', import.meta.url));
+const memorySourceTypes = ['research', 'external_ingest', 'backfill'];
+const expectedSkillHeadings = {
+    knowledge_capture: '# Knowledge Capture',
+    sl: '# Semantic Layer',
+    sl_capture: '# Semantic Layer',
+};
+const expectedAdapterSkillHeadings = {
+    historic_sql_ingest: '# Historic SQL Ingest',
+    live_database_ingest: '# Live Database Ingest',
+    looker_ingest: '# Looker Runtime Ingest',
+    lookml_ingest: '# LookML to KTX Semantic Layer',
+    metabase_ingest: '# Metabase to KTX Semantic Layer',
+    metricflow_ingest: '# MetricFlow to KTX Semantic Layer',
+};
+function forbiddenProductPattern() {
+    return new RegExp([['Kae', 'lio'].join(''), ['kae', 'lio'].join(''), ['KAE', 'LIO_'].join('')].join('|'));
+}
+describe('memory runtime assets', () => {
+    it('packages every memory-agent base prompt referenced by promptNameFor()', async () => {
+        const prompts = new PromptService({ promptsDir, partials: [] });
+        for (const sourceType of memorySourceTypes) {
+            const promptName = promptNameFor(sourceType);
+            const prompt = await prompts.loadPrompt(promptName);
+            expect(prompt).toContain('<role>');
+            expect(prompt).toContain('<workflow>');
+            expect(prompt).not.toMatch(forbiddenProductPattern());
+        }
+    });
+    it('packages the default memory capture skills referenced by DEFAULT_SKILL_NAMES', async () => {
+        const registry = new SkillsRegistryService({ skillsDir });
+        const skills = await registry.listSkills([...DEFAULT_SKILL_NAMES], 'memory_agent');
+        expect(skills.map((skill) => skill.name).sort()).toEqual(['knowledge_capture', 'sl', 'sl_capture']);
+        for (const skill of skills) {
+            const body = await readFile(join(skill.path, 'SKILL.md'), 'utf-8');
+            const expectedHeading = expectedSkillHeadings[skill.name];
+            expect(expectedHeading).toBeDefined();
+            expect(body).toContain(expectedHeading);
+            expect(body).not.toMatch(forbiddenProductPattern());
+        }
+    });
+    it('keeps memory-only capture skills hidden from research callers', async () => {
+        const registry = new SkillsRegistryService({ skillsDir });
+        const skills = await registry.listSkills([...DEFAULT_SKILL_NAMES], 'research');
+        expect(skills.map((skill) => skill.name)).toEqual(['sl']);
+    });
+    it('packages ingest adapter skills referenced by bundled adapters', async () => {
+        const registry = new SkillsRegistryService({ skillsDir });
+        const skillNames = Object.keys(expectedAdapterSkillHeadings);
+        const skills = await registry.listSkills(skillNames, 'memory_agent');
+        expect(skills.map((skill) => skill.name).sort()).toEqual([...skillNames].sort());
+        for (const skill of skills) {
+            const body = await readFile(join(skill.path, 'SKILL.md'), 'utf-8');
+            expect(body).toContain(expectedAdapterSkillHeadings[skill.name]);
+            expect(body).not.toMatch(forbiddenProductPattern());
+        }
+    });
+    it('ships Looker runtime ingest guidance for warehouse target SL writes', async () => {
+        const body = await readFile(join(skillsDir, 'looker_ingest', 'SKILL.md'), 'utf-8');
+        expect(body).toContain('targetWarehouseConnectionId');
+        expect(body).toContain('targetTable.ok === true');
+        expect(body).toContain('targetTable.canonicalTable');
+        expect(body).toContain('source_tables preflight');
+        expect(body).toContain('emit_unmapped_fallback');
+        expect(body).toContain('no_connection_mapping');
+        expect(body).not.toContain('a standalone SL source only when raw evidence contains enough table or SQL structure');
+    });
+    it('packages LookML connection-mismatch SL gate guidance', async () => {
+        const body = await readFile(join(skillsDir, 'lookml_ingest', 'SKILL.md'), 'utf-8');
+        expect(body).toContain('[LOOKML SL WRITES DISALLOWED]');
+        expect(body).toContain('lookml_connection_mismatch');
+        expect(body).toContain('Do not call `sl_write_source` or `sl_edit_source`');
+        expect(body).toContain('LookML writes target the run connection directly');
+    });
+});

package/node_modules/@ktx/context/dist/memory/types.d.ts

@@ -0,0 +1,133 @@
+import type { Tool } from 'ai';
+import type { AgentRunnerService } from '../agent/index.js';
+import type { GitService, KtxFileStorePort, KtxLogger, SessionWorktreeService } from '../core/index.js';
+import type { PromptService } from '../prompts/index.js';
+import type { SkillsRegistryService } from '../skills/index.js';
+import type { KtxConnectionInfo, KtxQueryResult, SemanticLayerService, SemanticLayerSource, SlSearchService, SlSourcesIndexPort, SlValidationDeps, SlValidatorPort } from '../sl/index.js';
+import type { ToolContext, ToolSession, TouchedSlSourceSet } from '../tools/index.js';
+import type { KnowledgeIndexPort, KnowledgeWikiService } from '../wiki/index.js';
+export type MemoryAgentSourceType = 'research' | 'external_ingest' | 'backfill' | 'sql-review-migration';
+export interface MemoryAgentInput {
+    userId: string;
+    chatId: string;
+    userMessage: string;
+    assistantMessage?: string;
+    connectionId?: string;
+    userMessageId?: string;
+    sourceType?: MemoryAgentSourceType;
+}
+export interface MemoryAction {
+    target: 'wiki' | 'sl';
+    type: 'created' | 'updated' | 'removed';
+    key: string;
+    detail: string;
+    targetConnectionId?: string | null;
+}
+export interface MemoryAgentResult {
+    signalDetected: boolean;
+    actions: MemoryAction[];
+    skillsLoaded: string[];
+    commitHash: string | null;
+}
+export interface CaptureSignals {
+    knowledge: boolean;
+    sl: boolean;
+    dialect?: 'lookml';
+    reasons: string[];
+}
+export interface CaptureSession {
+    userId: string;
+    chatId: string;
+    userMessageId?: string;
+    userMessage: string;
+    connectionId?: string;
+    userScopedEnabled: boolean;
+    forceGlobalScope: boolean;
+    touchedSlSources: TouchedSlSourceSet;
+    preHead: string | null;
+}
+export interface MemoryAgentSettings {
+    knowledge: {
+        userScopedKnowledgeEnabled: boolean;
+    };
+    slValidation: {
+        probeRowCount: number;
+    };
+    llm: {
+        memoryIngestionModel: string;
+    };
+}
+export interface MemoryTelemetryPort {
+    trackMemoryIngestion(userId: string, properties: {
+        chat_id: string;
+        source_type: MemoryAgentSourceType;
+        action_count: number;
+        actions: string[];
+        skills_loaded: string[];
+        signals_detected: string[];
+        signals_acted_on: string[];
+        reconciled_cross_refs: number;
+        session_outcome: 'success' | 'empty' | 'conflict' | 'crash';
+    }): void;
+}
+export interface MemoryKnowledgeSlRefsPort {
+    syncFromWiki(args: {
+        wikiPageKey: string;
+        wikiScope: 'GLOBAL' | 'USER';
+        wikiScopeId: string | null;
+        refs: Array<{
+            connectionId: string;
+            sourceName: string;
+        }>;
+    }): Promise<{
+        inserted: number;
+        deleted: number;
+    }>;
+}
+export interface MemoryConnectionPort {
+    listEnabledConnections(ids: string[]): Promise<KtxConnectionInfo[]>;
+    getConnectionById(connectionId: string): Promise<KtxConnectionInfo>;
+    executeQuery(connectionId: string, sql: string): Promise<KtxQueryResult>;
+}
+export interface MemoryCommitMessagePort {
+    enqueueCommitMessageJobForExternalCommit(commit: {
+        commitHash: string;
+    }, message: string, pathFilter: string): Promise<void>;
+}
+export interface MemoryFileStorePort extends KtxFileStorePort<MemoryFileStorePort>, MemoryCommitMessagePort {
+}
+export interface MemoryToolSetLike {
+    toAiSdkTools(context: ToolContext): Record<string, Tool>;
+}
+export interface MemoryToolsetFactoryPort {
+    createIngestWuToolset(session: ToolSession): MemoryToolSetLike;
+    createToolset(capabilities: ['wiki']): MemoryToolSetLike;
+}
+export interface MemorySlSourceReconcilerPort {
+    upsertRow(parsed: SemanticLayerSource, path: string, contentHash: string): Promise<void>;
+}
+export interface MemoryLockPort {
+    withLock<T>(key: 'config:repo', fn: () => Promise<T>): Promise<T>;
+}
+export interface MemoryAgentServiceDeps {
+    settings: MemoryAgentSettings;
+    promptService: PromptService;
+    skillsRegistry: SkillsRegistryService;
+    wikiService: KnowledgeWikiService;
+    knowledgeIndex: KnowledgeIndexPort;
+    knowledgeSlRefs: MemoryKnowledgeSlRefsPort;
+    semanticLayerService: SemanticLayerService;
+    slSearchService: SlSearchService;
+    connections: MemoryConnectionPort;
+    rootFileStore: MemoryFileStorePort;
+    gitService: GitService;
+    lockingService: MemoryLockPort;
+    slSourcesRepository: SlSourcesIndexPort;
+    sessionWorktreeService: SessionWorktreeService<MemoryFileStorePort>;
+    semanticLayerSourceReconciler: MemorySlSourceReconcilerPort;
+    agentRunner: AgentRunnerService;
+    slValidator: SlValidatorPort<SlValidationDeps>;
+    toolsetFactory: MemoryToolsetFactoryPort;
+    telemetry?: MemoryTelemetryPort;
+    logger?: KtxLogger;
+}

package/node_modules/@ktx/context/dist/memory/types.js

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

package/node_modules/@ktx/context/dist/package-exports.test.d.ts

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

package/node_modules/@ktx/context/dist/package-exports.test.js

@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest';
+const scanTypeExportCoverage = {};
+describe('@ktx/context package exports', () => {
+    it('exports package entry points used by host adapters', async () => {
+        const core = await import('./core/index.js');
+        const connections = await import('./connections/index.js');
+        const scan = await import('./scan/index.js');
+        const search = await import('./search/index.js');
+        const agent = await import('./agent/index.js');
+        const prompts = await import('./prompts/index.js');
+        const skills = await import('./skills/index.js');
+        const sl = await import('./sl/index.js');
+        const wiki = await import('./wiki/index.js');
+        const tools = await import('./tools/index.js');
+        const memory = await import('./memory/index.js');
+        const ingest = await import('./ingest/index.js');
+        const memoryFlow = await import('./ingest/memory-flow/index.js');
+        const metabaseMapping = await import('./ingest/metabase-mapping.js');
+        const mcp = await import('./mcp/index.js');
+        const project = await import('./project/index.js');
+        const daemon = await import('./daemon/index.js');
+        const sqlAnalysis = await import('./sql-analysis/index.js');
+        const root = await import('./index.js');
+        expect(core).toBeDefined();
+        expect(connections.createPostgresQueryExecutor).toBeTypeOf('function');
+        expect(connections.createSqliteQueryExecutor).toBeTypeOf('function');
+        expect(connections.createDefaultLocalQueryExecutor).toBeTypeOf('function');
+        expect(connections.sqliteDatabasePathFromConnection).toBeTypeOf('function');
+        expect(connections.parseNotionConnectionConfig).toBeTypeOf('function');
+        expect(connections.redactNotionConnectionConfig).toBeTypeOf('function');
+        expect(connections.notionConnectionToPullConfig).toBeTypeOf('function');
+        expect(scan).toBeDefined();
+        expect(scanTypeExportCoverage).toEqual({});
+        expect(scan.createKtxConnectorCapabilities).toBeTypeOf('function');
+        expect(`liveDatabaseSnapshotToKtx${'SchemaSnapshot'}` in scan).toBe(false);
+        expect(scan.normalizeKtxNativeType).toBeTypeOf('function');
+        expect(scan.inferKtxDimensionType).toBeTypeOf('function');
+        expect(scan.redactKtxCredentialEnvelope).toBeTypeOf('function');
+        expect(scan.redactKtxScanReport).toBeTypeOf('function');
+        expect(scan.redactKtxScanWarning).toBeTypeOf('function');
+        expect(core.redactKtxSensitiveMetadata).toBeTypeOf('function');
+        expect(core.redactKtxSensitiveText).toBeTypeOf('function');
+        expect(scan.isKtxDataDictionaryCandidate).toBeTypeOf('function');
+        expect(scan.buildKtxColumnEmbeddingText).toBeTypeOf('function');
+        expect(scan.KtxDescriptionGenerator).toBeTypeOf('function');
+        expect(scan.KtxScanOrchestrator).toBeTypeOf('function');
+        expect(scan.runLocalScan).toBeTypeOf('function');
+        expect(scan.writeLocalScanEnrichmentArtifacts).toBeTypeOf('function');
+        expect(scan.readLocalScanStructuralSnapshot).toBeTypeOf('function');
+        expect(scan.writeLocalScanManifestShards).toBeTypeOf('function');
+        expect(scan.appendKtxWordLimitInstruction).toBeTypeOf('function');
+        expect(scan.buildKtxColumnDescriptionPrompt).toBeTypeOf('function');
+        expect(scan.buildKtxTableDescriptionPrompt).toBeTypeOf('function');
+        expect(scan.buildKtxDataSourceDescriptionPrompt).toBeTypeOf('function');
+        expect(scan.currentKtxRelationshipBenchmarkDetector).toBeTypeOf('function');
+        expect(scan.generateKtxRelationshipDiscoveryCandidates).toBeTypeOf('function');
+        expect(scan.inferKtxRelationshipTargetPks).toBeTypeOf('function');
+        expect(scan.mergeKtxRelationshipDiscoveryCandidates).toBeTypeOf('function');
+        expect(scan.normalizeKtxRelationshipName).toBeTypeOf('function');
+        expect(scan.tokenizeKtxRelationshipName).toBeTypeOf('function');
+        expect(scan.tokenSimilarity).toBeTypeOf('function');
+        expect(scan.localCandidateTables).toBeTypeOf('function');
+        expect(scan.scoreKtxRelationshipCandidate).toBeTypeOf('function');
+        expect(scan.defaultKtxRelationshipScoreWeights).toBeTypeOf('function');
+        expect(scan.normalizeKtxRelationshipScoreWeights).toBeTypeOf('function');
+        expect(scan.calibrateWeightsFromSyntheticFixtures).toBeTypeOf('function');
+        expect(scan.singularizeKtxRelationshipToken).toBeTypeOf('function');
+        expect(scan.pluralizeKtxRelationshipToken).toBeTypeOf('function');
+        expect(scan.collectKtxFormalMetadataRelationships).toBeTypeOf('function');
+        expect(scan.discoverKtxCompositeRelationships).toBeTypeOf('function');
+        expect(scan.proposeKtxRelationshipCandidatesWithLlm).toBeTypeOf('function');
+        expect(scan.profileKtxRelationshipSchema).toBeTypeOf('function');
+        expect(scan.quoteKtxRelationshipIdentifier).toBeTypeOf('function');
+        expect(scan.formatKtxRelationshipTableRef).toBeTypeOf('function');
+        expect(scan.validateKtxRelationshipDiscoveryCandidates).toBeTypeOf('function');
+        expect(scan.applyKtxRelationshipValidationBudget).toBeTypeOf('function');
+        expect(scan.defaultKtxRelationshipValidationBudget).toBeTypeOf('function');
+        expect(scan.resolveKtxRelationshipGraph).toBeTypeOf('function');
+        expect(scan.discoverKtxRelationships).toBeTypeOf('function');
+        expect('KtxRelationshipDetector' in scan).toBe(false);
+        expect('defaultKtxRelationshipDetectionSettings' in scan).toBe(false);
+        expect('KTX_RELATIONSHIP_DETECTION_CONFIDENCE' in scan).toBe(false);
+        expect(scan.buildKtxRelationshipArtifacts).toBeTypeOf('function');
+        expect(scan.buildKtxRelationshipDiagnostics).toBeTypeOf('function');
+        expect(scan.readLocalScanRelationshipArtifacts).toBeTypeOf('function');
+        expect(scan.writeLocalScanRelationshipReviewDecision).toBeTypeOf('function');
+        expect(scan.applyLocalScanRelationshipReviewDecisions).toBeTypeOf('function');
+        expect(scan.exportLocalRelationshipFeedbackLabels).toBeTypeOf('function');
+        expect(scan.formatKtxRelationshipFeedbackLabelsJsonl).toBeTypeOf('function');
+        expect(scan.buildKtxRelationshipFeedbackCalibrationReport).toBeTypeOf('function');
+        expect(scan.calibrateLocalRelationshipFeedbackLabels).toBeTypeOf('function');
+        expect(scan.formatKtxRelationshipFeedbackCalibrationMarkdown).toBeTypeOf('function');
+        expect(scan.buildKtxRelationshipThresholdAdviceReport).toBeTypeOf('function');
+        expect(scan.adviseLocalRelationshipFeedbackThresholds).toBeTypeOf('function');
+        expect(scan.formatKtxRelationshipThresholdAdviceMarkdown).toBeTypeOf('function');
+        expect(scan.emptyKtxRelationshipProfileArtifact).toBeTypeOf('function');
+        expect(scan.loadKtxRelationshipBenchmarkFixture).toBeTypeOf('function');
+        expect(scan.loadKtxRelationshipBenchmarkFixtures).toBeTypeOf('function');
+        expect(scan.maskKtxRelationshipBenchmarkSnapshot).toBeTypeOf('function');
+        expect(scan.runKtxRelationshipBenchmarkCase).toBeTypeOf('function');
+        expect(scan.runKtxRelationshipBenchmarkSuite).toBeTypeOf('function');
+        expect(scan.KTX_RELATIONSHIP_BENCHMARK_MODES).toEqual([
+            'metadata_present',
+            'declared_fks_removed',
+            'declared_pks_removed',
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        expect(scan.buildKtxRelationshipBenchmarkReport).toBeTypeOf('function');
+        expect(scan.formatKtxRelationshipBenchmarkReportMarkdown).toBeTypeOf('function');
+        expect(search).toBeDefined();
+        expect(search.HybridSearchCore).toBeTypeOf('function');
+        expect(search.normalizeSearchQuery).toBeTypeOf('function');
+        expect(search.rrfContribution).toBeTypeOf('function');
+        expect(search.assertSearchBackendConformanceCase).toBeTypeOf('function');
+        expect(search.assertSearchBackendCapabilities).toBeTypeOf('function');
+        expect(core.resolveKtxConfigReference).toBeTypeOf('function');
+        expect(root.HybridSearchCore).toBeTypeOf('function');
+        expect(root.assertSearchBackendConformanceCase).toBeTypeOf('function');
+        expect(root.assertSearchBackendCapabilities).toBeTypeOf('function');
+        expect(root.createLocalKtxEmbeddingProviderFromConfig).toBeTypeOf('function');
+        expect(root.MANAGED_SENTENCE_TRANSFORMERS_BASE_URL).toBe('managed:local-embeddings');
+        expect(root.MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV).toBe('KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL');
+        expect(agent).toBeDefined();
+        expect(agent.AgentRunnerService).toBeTypeOf('function');
+        expect(root.AgentRunnerService).toBeTypeOf('function');
+        expect(root.createLocalKtxLlmProviderFromConfig).toBeTypeOf('function');
+        expect(prompts).toBeDefined();
+        expect(skills).toBeDefined();
+        expect(sl).toBeDefined();
+        expect(sl.writeLocalSlSource).toBeTypeOf('function');
+        expect(sl.readLocalSlSource).toBeTypeOf('function');
+        expect(sl.validateLocalSlSource).toBeTypeOf('function');
+        expect(sl.searchLocalSlSources).toBeTypeOf('function');
+        expect(sl.SqliteSlSourcesIndex).toBeTypeOf('function');
+        expect('searchLocalSlSourcesWithPglitePrototype' in sl).toBe(false);
+        expect(sl.compileLocalSlQuery).toBeTypeOf('function');
+        expect(wiki).toBeDefined();
+        expect(wiki.writeLocalKnowledgePage).toBeTypeOf('function');
+        expect(wiki.readLocalKnowledgePage).toBeTypeOf('function');
+        expect(wiki.searchLocalKnowledgePages).toBeTypeOf('function');
+        expect(wiki.SqliteKnowledgeIndex).toBeTypeOf('function');
+        expect('WikiSearchMatchReason' in wiki).toBe(false);
+        expect(tools).toBeDefined();
+        expect(memory).toBeDefined();
+        expect(ingest).toBeDefined();
+        expect(memoryFlow.parseMemoryFlowReplayInput).toBeTypeOf('function');
+        expect(memoryFlow.renderMemoryFlowReplay).toBeTypeOf('function');
+        expect(ingest.LiveDatabaseSourceAdapter).toBeTypeOf('function');
+        expect(ingest.createDaemonLiveDatabaseIntrospection).toBeTypeOf('function');
+        expect(ingest.buildLiveDatabaseManifestShards).toBeTypeOf('function');
+        expect(ingest.planLiveDatabaseStructuralSync).toBeTypeOf('function');
+        expect(ingest.runLocalIngest).toBeTypeOf('function');
+        expect(ingest.runLocalMetabaseIngest).toBeTypeOf('function');
+        expect(ingest.getLocalIngestStatus).toBeTypeOf('function');
+        expect(ingest.createLocalBundleIngestRuntime).toBeTypeOf('function');
+        expect(ingest.runLocalStageOnlyIngest).toBeTypeOf('function');
+        expect(ingest.getLocalStageOnlyIngestStatus).toBeTypeOf('function');
+        expect(ingest.createDefaultLocalIngestAdapters).toBeTypeOf('function');
+        expect(ingest.createLookerQueryToSlTool).toBeTypeOf('function');
+        expect(ingest.buildLookerSlProposal).toBeTypeOf('function');
+        expect(ingest.describeLookerScope).toBeTypeOf('function');
+        expect(ingest.hashLookerScope).toBeTypeOf('function');
+        expect(ingest.readLookerFetchReport).toBeTypeOf('function');
+        expect(ingest.writeLookerFetchReport).toBeTypeOf('function');
+        expect(ingest.writeLookerEvidenceDocuments).toBeTypeOf('function');
+        expect(ingest.getLookerTriageSignals).toBeTypeOf('function');
+        expect(ingest.LookerClient).toBeTypeOf('function');
+        expect(ingest.DefaultLookerConnectionClientFactory).toBeTypeOf('function');
+        expect(ingest.DefaultLookerClientFactory).toBeTypeOf('function');
+        expect(ingest.LocalLookerRuntimeStore).toBeTypeOf('function');
+        expect(ingest.createDaemonLookerTableIdentifierParser).toBeTypeOf('function');
+        expect(ingest.createLocalLookerCredentialResolver).toBeTypeOf('function');
+        expect(ingest.discoverLookerConnections).toBeTypeOf('function');
+        expect(ingest.computeLookerMappingDrift).toBeTypeOf('function');
+        expect(ingest.validateLookerMappings).toBeTypeOf('function');
+        expect(ingest.refreshLookerMappingPlaceholders).toBeTypeOf('function');
+        expect(ingest.suggestKtxConnectionForLookerConnection).toBeTypeOf('function');
+        expect(ingest.buildLookerPullConfigFromInputs).toBeTypeOf('function');
+        expect(ingest.validateLookerWarehouseTarget).toBeTypeOf('function');
+        expect(ingest.sqlglotDialectForConnectionType).toBeTypeOf('function');
+        expect(ingest.lookerConnectionIdSchema).toBeDefined();
+        expect(ingest.lookerRuntimeCursorsSchema).toBeDefined();
+        expect(ingest.stagedSyncConfigSchema).toBeDefined();
+        expect(ingest.stagedLookerScopeFileSchema).toBeDefined();
+        expect(ingest.stagedLookerFetchReportSchema).toBeDefined();
+        expect(ingest.LocalMetabaseSourceStateReader).toBeTypeOf('function');
+        expect(ingest.createLocalMetabaseSourceAdapter).toBeTypeOf('function');
+        expect(ingest.metabaseRuntimeConfigFromLocalConnection).toBeTypeOf('function');
+        expect(ingest.IngestMetabaseClientFactory).toBeTypeOf('function');
+        expect(ingest.MetabaseClient).toBeTypeOf('function');
+        expect(ingest.DefaultMetabaseConnectionClientFactory).toBeTypeOf('function');
+        expect(ingest.DEFAULT_METABASE_CLIENT_CONFIG).toMatchObject({
+            maxRetries: 2,
+            timeoutMs: 60000,
+            retryableStatuses: [429, 500, 502, 503, 504],
+        });
+        expect(ingest.expandCardReferences).toBeTypeOf('function');
+        expect(ingest.CardReferenceCycleError).toBeTypeOf('function');
+        expect(ingest.parseMetabasePullConfig).toBeTypeOf('function');
+        expect(ingest.METABASE_ENGINE_TO_CONNECTION_TYPE).toMatchObject({
+            postgres: 'POSTGRESQL',
+            bigquery: 'BIGQUERY',
+            snowflake: 'SNOWFLAKE',
+        });
+        expect(metabaseMapping.METABASE_ENGINE_TO_CONNECTION_TYPE).toBe(ingest.METABASE_ENGINE_TO_CONNECTION_TYPE);
+        expect(metabaseMapping.validateMappingPhysicalMatch).toBeTypeOf('function');
+        expect(ingest.discoverMetabaseDatabases).toBeTypeOf('function');
+        expect(ingest.computeMetabaseMappingDrift).toBeTypeOf('function');
+        expect(ingest.computeMetabaseMappingPhysicalMismatches).toBeTypeOf('function');
+        expect(ingest.refreshMetabaseMapping).toBeTypeOf('function');
+        expect(ingest.validateMetabaseMappings).toBeTypeOf('function');
+        expect(ingest.validateMappingPhysicalMatch).toBeTypeOf('function');
+        expect(ingest.findBestMatch).toBeTypeOf('function');
+        expect(ingest.NotionSourceAdapter).toBeTypeOf('function');
+        expect(ingest.NotionClient).toBeTypeOf('function');
+        expect(ingest.HistoricSqlSourceAdapter).toBeTypeOf('function');
+        expect(ingest.SnowflakeHistoricSqlQueryHistoryReader).toBeTypeOf('function');
+        expect(ingest.BigQueryHistoricSqlQueryHistoryReader).toBeTypeOf('function');
+        expect(ingest.PostgresPgssQueryHistoryReader).toBeTypeOf('function');
+        expect(ingest.stagePgStatStatementsTemplates).toBeTypeOf('function');
+        expect(ingest.pgssBaselinePath).toBeTypeOf('function');
+        expect(ingest.readPgssBaseline).toBeTypeOf('function');
+        expect(ingest.writePgssBaselineAtomic).toBeTypeOf('function');
+        expect(ingest.HistoricSqlExtensionMissingError).toBeTypeOf('function');
+        expect(ingest.HistoricSqlVersionUnsupportedError).toBeTypeOf('function');
+        expect(ingest.HISTORIC_SQL_SOURCE_KEY).toBe('historic-sql');
+        expect(ingest.SqliteContextEvidenceStore).toBeTypeOf('function');
+        expect(ingest.SqliteBundleIngestStore).toBeTypeOf('function');
+        expect(ingest.CuratorPaginationService).toBeTypeOf('function');
+        expect(mcp).toBeDefined();
+        expect(project).toBeDefined();
+        expect(daemon).toBeDefined();
+        expect(mcp.registerKtxContextTools).toBeTypeOf('function');
+        expect(mcp.createLocalProjectMcpContextPorts).toBeTypeOf('function');
+        expect(project.buildDefaultKtxProjectConfig).toBeTypeOf('function');
+        expect(daemon.createHttpSemanticLayerComputePort).toBeTypeOf('function');
+        expect(daemon.createPythonSemanticLayerComputePort).toBeTypeOf('function');
+        expect(sqlAnalysis.createHttpSqlAnalysisPort).toBeTypeOf('function');
+        expect(root.createHttpSqlAnalysisPort).toBeTypeOf('function');
+    });
+});