@kaelio/ktx 0.4.1 → 0.6.0

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

@@ -1,413 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { validateSingleSource } from '../sl/index.js';
-import { createTouchedSlSources, hasTouchedSlSource } from '../tools/index.js';
-import { detectCaptureSignals, isWorthAnalyzing } from './capture-signals.js';
-import { MemoryAgentService } from './memory-agent.service.js';
-const passthroughValidator = {
-    validateSingleSource: (d, c, n) => validateSingleSource(d, c, n),
-};
-describe('MemoryAgentService.detectCaptureSignals', () => {
-    it('fires sl on a long user message + SQL aggregate in assistant message', () => {
-        const userMessage = `${'A'.repeat(120)} show me revenue by month`;
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage,
-            assistantMessage: 'SELECT SUM(amount) FROM orders GROUP BY month',
-        });
-        expect(result.sl).toBe(true);
-        expect(result.reasons).toContain('sql aggregate in assistant message');
-    });
-    it('does NOT fire sl from aggregate alone when user message is short', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'show revenue',
-            assistantMessage: 'SELECT SUM(amount) FROM orders',
-        });
-        expect(result.sl).toBe(false);
-    });
-    it('fires sl on definition keywords in user message regardless of length', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'going forward exclude cancelled orders from revenue',
-        });
-        expect(result.sl).toBe(true);
-        expect(result.reasons).toContain('sl-style definition keyword in user message');
-    });
-    it('fires knowledge on a definition keyword in user message', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'BYOL stands for Bring Your Own Lab',
-        });
-        expect(result.knowledge).toBe(true);
-        expect(result.reasons).toContain('definition keyword in user message');
-    });
-    it('fires both sl and knowledge when both signals hit', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'going forward, define revenue as sum of paid orders',
-        });
-        expect(result.sl).toBe(true);
-        expect(result.knowledge).toBe(true);
-    });
-    it('fires neither for a plain ad-hoc question', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'how many users signed up last week?',
-            assistantMessage: '12 users.',
-        });
-        expect(result.sl).toBe(false);
-        expect(result.knowledge).toBe(false);
-        expect(result.reasons).toEqual([]);
-    });
-    it('fires knowledge when assistant emits a markdown definition table', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'list our protocols',
-            assistantMessage: '| Term | Definition |\n|---|---|\n| TRT | Testosterone Replacement Therapy |',
-        });
-        expect(result.knowledge).toBe(true);
-        expect(result.reasons).toContain('definition table in assistant message');
-    });
-    it('accepts JOIN and CTE-style aggregates as sl signals', () => {
-        const userMessage = 'B'.repeat(150);
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage,
-            assistantMessage: 'WITH base AS (SELECT * FROM x) SELECT * FROM base',
-        });
-        expect(result.sl).toBe(true);
-    });
-    it('reasons array is empty when no signal fires', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'hello',
-        });
-        expect(result.reasons).toEqual([]);
-    });
-    it('detects LookML dialect from view/measure structural keywords', () => {
-        const result = detectCaptureSignals({
-            userId: 'u',
-            chatId: 'c',
-            userMessage: 'ingest this',
-            assistantMessage: 'view: fct_labs {\n  sql_table_name: analytics.fct_labs ;;\n  measure: count_lab_orders { type: count }\n}',
-        });
-        expect(result.dialect).toBe('lookml');
-        expect(result.sl).toBe(true);
-        expect(result.reasons).toContain('lookml structure in assistant message');
-    });
-});
-describe('MemoryAgentService.isWorthAnalyzing (C1 + F1)', () => {
-    const baseInput = (assistantMessage) => ({
-        userId: 'u',
-        chatId: 'c',
-        userMessage: 'Ingest the following content into memory.',
-        assistantMessage,
-    });
-    it('skips a pure LookML wrapper (only view + sql_table_name + dimensions + measure: count)', () => {
-        const wrapper = `view: timeline {
-  sql_table_name: analytics.timeline ;;
-  dimension_group: date { type: time; description: "m/d/Y" }
-  dimension: notes { type: string; description: "notes" }
-  measure: count { type: count }
-}`;
-        expect(isWorthAnalyzing(baseInput(wrapper))).toBe(false);
-    });
-    it('keeps a LookML view with a non-count aggregate (count_distinct, sum, avg, …)', () => {
-        const real = `view: fct_labs {
-  sql_table_name: analytics.fct_labs ;;
-  measure: count_lab_orders { type: count }
-  measure: count_distinct_patients { type: count_distinct; sql: \${admin_user_id} ;; }
-}`;
-        expect(isWorthAnalyzing(baseInput(real))).toBe(true);
-    });
-    it('keeps a LookML view with derived_table even if it has no non-count measures', () => {
-        const derived = `view: lab_results {
-  derived_table: { sql: SELECT * FROM analytics.raw WHERE status = 'final' ;; }
-  dimension: lab_order_id { primary_key: yes; type: string }
-  measure: count { type: count }
-}`;
-        expect(isWorthAnalyzing(baseInput(derived))).toBe(true);
-    });
-    it('keeps a LookML view with sql_always_where', () => {
-        const enforced = `view: rpt_daily_braze_email {
-  sql_table_name: analytics.fct_email_sends ;;
-  sql_always_where: \${TABLE}.channel = 'braze' ;;
-  measure: count { type: count }
-}`;
-        expect(isWorthAnalyzing(baseInput(enforced))).toBe(true);
-    });
-    it('keeps a LookML view with a join: block', () => {
-        const joined = `view: fct_labs {
-  sql_table_name: analytics.fct_labs ;;
-  join: dim_customers {
-    sql_on: \${fct_labs.admin_user_id} = \${dim_customers.admin_user_id} ;;
-    relationship: many_to_one
-  }
-}`;
-        expect(isWorthAnalyzing(baseInput(joined))).toBe(true);
-    });
-});
-describe('MemoryAgentService.reconcileCrossRefs', () => {
-    const buildService = (overrides) => {
-        const wikiService = {
-            readPage: overrides.readPage ?? vi.fn(),
-        };
-        const knowledgeSlRefsRepository = {
-            syncFromWiki: overrides.syncFromWiki ?? vi.fn().mockResolvedValue({ inserted: 0, deleted: 0 }),
-        };
-        const svc = new MemoryAgentService({
-            settings: {
-                knowledge: { userScopedKnowledgeEnabled: false },
-                slValidation: { probeRowCount: 1 },
-                llm: { memoryIngestionModel: 'test-model' },
-            },
-            promptService: undefined,
-            skillsRegistry: undefined,
-            wikiService: wikiService,
-            knowledgeIndex: undefined,
-            knowledgeSlRefs: knowledgeSlRefsRepository,
-            semanticLayerService: undefined,
-            slSearchService: undefined,
-            connections: undefined,
-            rootFileStore: undefined,
-            gitService: undefined,
-            lockingService: undefined,
-            slSourcesRepository: undefined,
-            sessionWorktreeService: undefined,
-            semanticLayerSourceReconciler: undefined,
-            agentRunner: undefined,
-            slValidator: undefined,
-            toolsetFactory: undefined,
-        });
-        return { svc, wikiService, knowledgeSlRefsRepository };
-    };
-    const session = {
-        userId: 'u',
-        chatId: 'c',
-        userMessage: 'test',
-        connectionId: 'conn-1',
-        userScopedEnabled: false,
-        forceGlobalScope: false,
-        touchedSlSources: createTouchedSlSources(),
-        preHead: null,
-    };
-    it('projects a wiki page.sl_refs into knowledge_sl_refs via syncFromWiki', async () => {
-        const { svc, knowledgeSlRefsRepository } = buildService({
-            readPage: vi.fn().mockResolvedValue({
-                pageKey: 'byol-definition',
-                frontmatter: { summary: 'byol', sl_refs: ['fct_labs', 'lab_results'] },
-                content: 'body',
-            }),
-            syncFromWiki: vi.fn().mockResolvedValue({ inserted: 2, deleted: 0 }),
-        });
-        const actions = [{ target: 'wiki', type: 'created', key: 'byol-definition', detail: '' }];
-        const synced = await svc.reconcileCrossRefs(actions, session);
-        expect(synced).toBe(2);
-        expect(knowledgeSlRefsRepository.syncFromWiki).toHaveBeenCalledWith({
-            wikiPageKey: 'byol-definition',
-            wikiScope: 'GLOBAL',
-            wikiScopeId: null,
-            refs: [
-                { connectionId: 'conn-1', sourceName: 'fct_labs' },
-                { connectionId: 'conn-1', sourceName: 'lab_results' },
-            ],
-        });
-    });
-    it('skips sync when the action has no connectionId in session', async () => {
-        const { svc, knowledgeSlRefsRepository } = buildService({
-            readPage: vi.fn().mockResolvedValue({
-                pageKey: 'byol-definition',
-                frontmatter: { summary: 'byol', sl_refs: ['fct_labs'] },
-                content: 'body',
-            }),
-        });
-        const actions = [{ target: 'wiki', type: 'created', key: 'byol-definition', detail: '' }];
-        const synced = await svc.reconcileCrossRefs(actions, { ...session, connectionId: undefined });
-        expect(synced).toBe(0);
-        expect(knowledgeSlRefsRepository.syncFromWiki).not.toHaveBeenCalled();
-    });
-    it('syncs an empty sl_refs list — clearing any stale rows for that wiki', async () => {
-        const { svc, knowledgeSlRefsRepository } = buildService({
-            readPage: vi.fn().mockResolvedValue({
-                pageKey: 'byol-definition',
-                frontmatter: { summary: 'byol' },
-                content: 'body',
-            }),
-            syncFromWiki: vi.fn().mockResolvedValue({ inserted: 0, deleted: 1 }),
-        });
-        const actions = [{ target: 'wiki', type: 'updated', key: 'byol-definition', detail: '' }];
-        const synced = await svc.reconcileCrossRefs(actions, session);
-        expect(synced).toBe(1);
-        expect(knowledgeSlRefsRepository.syncFromWiki).toHaveBeenCalledWith({
-            wikiPageKey: 'byol-definition',
-            wikiScope: 'GLOBAL',
-            wikiScopeId: null,
-            refs: [],
-        });
-    });
-    it('normalizes dotted sl_refs to bare source names, dedupes (H)', async () => {
-        const { svc, knowledgeSlRefsRepository } = buildService({
-            readPage: vi.fn().mockResolvedValue({
-                pageKey: 'fct-labs-overview',
-                frontmatter: {
-                    summary: 'fct_labs',
-                    sl_refs: ['fct_labs', 'fct_labs.count_lab_orders', 'fct_labs.count_distinct_patients', 'lab_results'],
-                },
-                content: 'body',
-            }),
-            syncFromWiki: vi.fn().mockResolvedValue({ inserted: 2, deleted: 0 }),
-        });
-        const actions = [{ target: 'wiki', type: 'created', key: 'fct-labs-overview', detail: '' }];
-        await svc.reconcileCrossRefs(actions, session);
-        expect(knowledgeSlRefsRepository.syncFromWiki).toHaveBeenCalledWith({
-            wikiPageKey: 'fct-labs-overview',
-            wikiScope: 'GLOBAL',
-            wikiScopeId: null,
-            refs: [
-                { connectionId: 'conn-1', sourceName: 'fct_labs' },
-                { connectionId: 'conn-1', sourceName: 'lab_results' },
-            ],
-        });
-    });
-    it('ignores sl-only actions — the DB index is driven from the wiki side', async () => {
-        const { svc, knowledgeSlRefsRepository } = buildService({});
-        const actions = [{ target: 'sl', type: 'updated', key: 'fct_labs', detail: '' }];
-        const synced = await svc.reconcileCrossRefs(actions, session);
-        expect(synced).toBe(0);
-        expect(knowledgeSlRefsRepository.syncFromWiki).not.toHaveBeenCalled();
-    });
-});
-describe('MemoryAgentService.gateRevertInvalidSources (J3)', () => {
-    // Build a service with the minimal deps the gate needs: semanticLayerService
-    // (readSourceFile, loadSource, writeSource for revert), dataSourcesService
-    // (executeQuery for dry-run), configService (writeFile/deleteFile for revert),
-    // gitService (getFileAtCommit).
-    const buildService = (overrides) => {
-        const semanticLayerService = {
-            readSourceFile: overrides.readSourceFile ?? vi.fn(),
-            isManifestBacked: vi.fn().mockResolvedValue(false),
-        };
-        const connections = {
-            listEnabledConnections: vi.fn().mockResolvedValue([]),
-            getConnectionById: vi.fn().mockResolvedValue({
-                id: 'conn-1',
-                name: 'Warehouse',
-                connectionType: 'POSTGRESQL',
-            }),
-            executeQuery: overrides.executeQuery ?? vi.fn(),
-        };
-        const configService = {
-            writeFile: overrides.writeFile ?? vi.fn().mockResolvedValue({}),
-            deleteFile: overrides.deleteFile ?? vi.fn().mockResolvedValue({}),
-        };
-        const gitService = {
-            getFileAtCommit: overrides.getFileAtCommit ?? vi.fn().mockRejectedValue(new Error('not present')),
-        };
-        const slSourcesRepository = {
-            deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined),
-        };
-        const svc = new MemoryAgentService({
-            settings: {
-                knowledge: { userScopedKnowledgeEnabled: false },
-                slValidation: { probeRowCount: 1 },
-                llm: { memoryIngestionModel: 'test-model' },
-            },
-            promptService: undefined,
-            skillsRegistry: undefined,
-            wikiService: undefined,
-            knowledgeIndex: undefined,
-            knowledgeSlRefs: undefined,
-            semanticLayerService: semanticLayerService,
-            slSearchService: undefined,
-            connections: connections,
-            rootFileStore: configService,
-            gitService: gitService,
-            lockingService: undefined,
-            slSourcesRepository: slSourcesRepository,
-            sessionWorktreeService: undefined,
-            semanticLayerSourceReconciler: undefined,
-            agentRunner: undefined,
-            slValidator: passthroughValidator,
-            toolsetFactory: undefined,
-        });
-        return { svc, semanticLayerService, connections, configService, gitService, slSourcesRepository };
-    };
-    const session = {
-        userId: 'u',
-        chatId: 'c',
-        userMessage: 'test',
-        connectionId: 'conn-1',
-        userScopedEnabled: false,
-        forceGlobalScope: false,
-        touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'broken_source' }]),
-        preHead: null,
-    };
-    it('reverts (deletes) a source whose dry-run fails and drops its action', async () => {
-        const badYaml = `name: broken_source
-source_type: sql
-sql: |
-  SELECT fake_col FROM analytics.x
-grain: [fake_col]
-columns: [{name: fake_col, type: string}]
-measures: []
-joins: []
-`;
-        const { svc, configService } = buildService({
-            readSourceFile: vi.fn().mockResolvedValue({ content: badYaml, path: 'x' }),
-            executeQuery: vi.fn().mockResolvedValue({
-                headers: [],
-                rows: [],
-                totalRows: 0,
-                error: 'Unrecognized name: fake_col',
-            }),
-        });
-        const actions = [
-            { target: 'sl', type: 'created', key: 'broken_source', detail: 'create' },
-            { target: 'wiki', type: 'created', key: 'some_wiki', detail: 'wiki' },
-        ];
-        const localSession = {
-            ...session,
-            touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'broken_source' }]),
-        };
-        const reverted = await svc.gateRevertInvalidSources(localSession, actions);
-        expect(reverted).toEqual(['broken_source']);
-        expect(configService.deleteFile).toHaveBeenCalledWith('semantic-layer/conn-1/broken_source.yaml', expect.any(String), expect.any(String), expect.any(String), { skipLock: true });
-        // Wiki action survives; SL action is scrubbed.
-        expect(actions.map((a) => `${a.target}:${a.key}`)).toEqual(['wiki:some_wiki']);
-        expect(hasTouchedSlSource(localSession.touchedSlSources, 'conn-1', 'broken_source')).toBe(false);
-    });
-    it('leaves a source alone when its dry-run passes', async () => {
-        const goodYaml = `name: good_source
-source_type: sql
-sql: |
-  SELECT id FROM analytics.x
-grain: [id]
-columns: [{name: id, type: string}]
-measures: []
-joins: []
-`;
-        const { svc, configService } = buildService({
-            readSourceFile: vi.fn().mockResolvedValue({ content: goodYaml, path: 'x' }),
-            executeQuery: vi.fn().mockResolvedValue({ headers: ['id'], rows: [], totalRows: 0, error: null }),
-        });
-        const actions = [{ target: 'sl', type: 'created', key: 'good_source', detail: 'create' }];
-        const localSession = {
-            ...session,
-            touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'good_source' }]),
-        };
-        const reverted = await svc.gateRevertInvalidSources(localSession, actions);
-        expect(reverted).toEqual([]);
-        expect(configService.writeFile).not.toHaveBeenCalled();
-        expect(configService.deleteFile).not.toHaveBeenCalled();
-        expect(actions).toHaveLength(1);
-    });
-});

package/node_modules/@ktx/context/dist/memory/memory-runs.d.ts

@@ -1,54 +0,0 @@
-import type { MemoryAgentInput, MemoryAgentResult, MemoryAgentService } from './index.js';
-export type MemoryRunStatus = 'running' | 'done' | 'error';
-export interface MemoryRunRecord {
-    id: string;
-    status: MemoryRunStatus;
-    stage: string;
-    inputHash: string;
-    chatId: string | null;
-    outputSummary: MemoryAgentResult | null;
-    error: string | null;
-}
-export interface MemoryRunStorePort {
-    createRunning(args: {
-        inputHash: string;
-        chatId?: string | null;
-    }): Promise<{
-        id: string;
-    }>;
-    markRunning(id: string, stage: string): Promise<void>;
-    markDone(id: string, outputSummary: MemoryAgentResult): Promise<void>;
-    markError(id: string, error: string): Promise<void>;
-    findById(id: string): Promise<MemoryRunRecord | null>;
-}
-export interface MemoryIngestServiceDeps {
-    memoryAgent: Pick<MemoryAgentService, 'ingest'>;
-    runs: MemoryRunStorePort;
-}
-export interface MemoryIngestStartResult {
-    runId: string;
-}
-export interface MemoryIngestStatus {
-    runId: string;
-    status: MemoryRunStatus;
-    stage: string;
-    done: boolean;
-    captured: {
-        wiki: string[];
-        sl: string[];
-        xrefs: string[];
-    };
-    error: string | null;
-    commitHash: string | null;
-    skillsLoaded: string[];
-    signalDetected: boolean;
-}
-export declare class MemoryIngestService {
-    private readonly deps;
-    private readonly inFlight;
-    constructor(deps: MemoryIngestServiceDeps);
-    ingest(input: MemoryAgentInput): Promise<MemoryIngestStartResult>;
-    waitForRun(runId: string): Promise<void>;
-    private runIngest;
-    status(runId: string): Promise<MemoryIngestStatus | null>;
-}

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

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

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

@@ -1,158 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { MemoryIngestService } 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 memoryAgentIngest = vi.fn().mockReturnValue(run.promise);
-    const memoryAgent = { ingest: memoryAgentIngest };
-    return {
-        ingest: new MemoryIngestService({ memoryAgent, runs: store }),
-        store,
-        memoryAgentIngest,
-        run,
-    };
-}
-describe('MemoryIngestService', () => {
-    it('creates a run, executes memory ingest, and stores a done summary', async () => {
-        const result = {
-            signalDetected: true,
-            actions: [{ target: 'wiki', type: 'created', key: 'revenue', detail: 'captured revenue definition' }],
-            skillsLoaded: ['wiki_capture'],
-            commitHash: 'abc123',
-        };
-        const { ingest, store, memoryAgentIngest, 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 ingest.ingest(input);
-        expect(started.runId).toBe('run-1');
-        expect(memoryAgentIngest).toHaveBeenCalledWith(input);
-        await expect(ingest.status(started.runId)).resolves.toMatchObject({
-            runId: 'run-1',
-            status: 'running',
-            stage: 'ingesting',
-            done: false,
-        });
-        run.resolve(result);
-        await ingest.waitForRun(started.runId);
-        const status = await ingest.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: ['wiki_capture'],
-            signalDetected: true,
-        });
-        expect(store.rows.get('run-1')?.inputHash).toHaveLength(64);
-    });
-    it('stores no-signal ingests as done with empty captured arrays', async () => {
-        const { ingest, run } = buildService();
-        const started = await ingest.ingest({
-            userId: 'user-1',
-            chatId: 'chat-2',
-            userMessage: 'Thanks.',
-        });
-        run.resolve({
-            signalDetected: false,
-            actions: [],
-            skillsLoaded: [],
-            commitHash: null,
-        });
-        await ingest.waitForRun(started.runId);
-        await expect(ingest.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 ingest = new MemoryIngestService({ memoryAgent, runs: store });
-        const started = await ingest.ingest({
-            userId: 'user-1',
-            chatId: 'chat-3',
-            userMessage: 'Remember this.',
-        });
-        await ingest.waitForRun(started.runId);
-        await expect(ingest.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 { ingest } = buildService();
-        await expect(ingest.status('missing')).resolves.toBeNull();
-    });
-});

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

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