@kaelio/ktx 0.2.0 → 0.4.0

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/projection.js

@@ -177,6 +177,8 @@ export async function projectHistoricSqlEvidence(input) {
         stalePatternPagesMarked: 0,
         archivedPatternPages: 0,
         touchedSources: [],
+        changedWikiPageKeys: [],
+        actions: [],
         warnings: [],
     };
     const touchedKeys = new Set();
@@ -184,6 +186,14 @@ export async function projectHistoricSqlEvidence(input) {
     const manifest = stagedManifestSchema.parse(await readJson(join(rawDir, 'manifest.json')));
     const currentTables = await currentStagedTables(rawDir);
     const evidence = await loadEvidence(input.workdir, input.runId);
+    if (input.overrideReplay && evidence.length === 0) {
+        result.warnings.push('historic-sql finalization skipped stale/archive cleanup during override replay without current-run evidence');
+        return result;
+    }
+    if (evidence.length === 0) {
+        result.warnings.push('historic-sql finalization skipped because no current-run evidence was emitted');
+        return result;
+    }
     const tableEvidence = evidence.filter((entry) => entry.kind === 'table_usage');
     const patternEvidence = evidence.filter((entry) => entry.kind === 'pattern');
     const schemaRoot = join(input.workdir, 'semantic-layer', input.connectionId, '_schema');
@@ -207,6 +217,14 @@ export async function projectHistoricSqlEvidence(input) {
                         touchedKeys.add(key);
                         result.touchedSources.push({ connectionId: input.connectionId, sourceName });
                     }
+                    result.actions.push({
+                        target: 'sl',
+                        type: 'updated',
+                        key: sourceName,
+                        targetConnectionId: input.connectionId,
+                        detail: `Merged historic-SQL usage for ${matchingEvidence.table}`,
+                        rawPaths: [matchingEvidence.rawPath],
+                    });
                 }
             }
             else if (entry.usage && !currentTables.has(tableRef)) {
@@ -220,6 +238,13 @@ export async function projectHistoricSqlEvidence(input) {
                         touchedKeys.add(key);
                         result.touchedSources.push({ connectionId: input.connectionId, sourceName });
                     }
+                    result.actions.push({
+                        target: 'sl',
+                        type: 'updated',
+                        key: sourceName,
+                        targetConnectionId: input.connectionId,
+                        detail: `Marked historic-SQL usage stale for ${tableRef}`,
+                    });
                 }
             }
         }
@@ -254,6 +279,14 @@ export async function projectHistoricSqlEvidence(input) {
         await writeFile(pagePath, renderMarkdownPage(frontmatter, renderPatternMarkdown(pattern)), 'utf-8');
         writtenKeys.add(key);
         result.patternPagesWritten += 1;
+        result.changedWikiPageKeys.push(key);
+        result.actions.push({
+            target: 'wiki',
+            type: reusable ? 'updated' : 'created',
+            key,
+            detail: `Projected historic-SQL pattern ${pattern.pattern.title}`,
+            rawPaths: [pattern.rawPath],
+        });
     }
     for (const page of patternPages) {
         if (writtenKeys.has(page.key))
@@ -262,11 +295,26 @@ export async function projectHistoricSqlEvidence(input) {
             const tags = [...new Set([...stringArray(page.frontmatter.tags), 'archived'])];
             await writeFile(page.path, renderMarkdownPage({ ...page.frontmatter, tags, archived_since: manifest.fetchedAt }, page.content), 'utf-8');
             result.archivedPatternPages += 1;
+            result.changedWikiPageKeys.push(page.key);
+            result.actions.push({
+                target: 'wiki',
+                type: 'updated',
+                key: page.key,
+                detail: `Archived stale historic-SQL pattern page ${page.key}`,
+            });
             continue;
         }
         const tags = [...new Set([...stringArray(page.frontmatter.tags), 'stale'])];
         await writeFile(page.path, renderMarkdownPage({ ...page.frontmatter, tags, stale_since: manifest.fetchedAt }, page.content), 'utf-8');
         result.stalePatternPagesMarked += 1;
+        result.changedWikiPageKeys.push(page.key);
+        result.actions.push({
+            target: 'wiki',
+            type: 'updated',
+            key: page.key,
+            detail: `Marked historic-SQL pattern page ${page.key} stale`,
+        });
     }
+    result.changedWikiPageKeys = [...new Set(result.changedWikiPageKeys)].sort();
     return result;
 }

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

@@ -64,6 +64,13 @@ describe('projectHistoricSqlEvidence', () => {
         });
         const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
         expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
+        expect(result.actions).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                target: 'sl',
+                key: 'orders',
+                rawPaths: ['tables/public.orders.json'],
+            }),
+        ]));
         const shard = YAML.parse(await readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8'));
         expect(shard.tables.orders.usage).toEqual({
             ownerNote: 'keep me',
@@ -143,6 +150,14 @@ describe('projectHistoricSqlEvidence', () => {
         });
         const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
         expect(result.patternPagesWritten).toBe(1);
+        expect(result.changedWikiPageKeys).toContain('historic-sql-old-order-lifecycle');
+        expect(result.actions).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                target: 'wiki',
+                key: 'historic-sql-old-order-lifecycle',
+                rawPaths: ['patterns-input.json'],
+            }),
+        ]));
         await expect(readFile(join(workdir, 'wiki/global/historic-sql-old-order-lifecycle.md'), 'utf-8')).resolves.toContain('Order Lifecycle Analysis');
         await expect(readFile(join(workdir, 'wiki/global/historic-sql-retired-pattern.md'), 'utf-8')).resolves.toContain('stale_since: "2026-05-11T00:00:00.000Z"');
     });
@@ -274,6 +289,19 @@ describe('projectHistoricSqlEvidence', () => {
             probeWarnings: [],
             staleArchiveAfterDays: 90,
         });
+        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/customers.json', {
+            kind: 'table_usage',
+            connectionId: 'warehouse',
+            table: 'public.customers',
+            rawPath: 'tables/public.customers.json',
+            usage: {
+                narrative: 'Customers were queried.',
+                frequencyTier: 'low',
+                commonFilters: [],
+                commonJoins: [],
+                staleSince: null,
+            },
+        });
         await writeText(workdir, 'wiki/global/historic-sql-old-template.md', [
             '---',
             YAML.stringify({
@@ -294,6 +322,9 @@ describe('projectHistoricSqlEvidence', () => {
         const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
         expect(result.staleTablesMarked).toBe(1);
         expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
+        const staleAction = result.actions.find((action) => action.target === 'sl' && action.key === 'orders');
+        expect(staleAction).toEqual(expect.objectContaining({ target: 'sl', key: 'orders' }));
+        expect(staleAction?.rawPaths).toBeUndefined();
         const shard = YAML.parse(await readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8'));
         expect(shard.tables.orders.usage).toEqual({
             ownerNote: 'keep analyst annotation',
@@ -306,4 +337,56 @@ describe('projectHistoricSqlEvidence', () => {
         });
         await expect(readFile(join(workdir, 'wiki/global/historic-sql-old-template.md'), 'utf-8')).resolves.toContain('Old body');
     });
+    it('does not mark stale or archive pages when override replay has no current-run evidence', async () => {
+        const workdir = await tempWorkdir();
+        await writeText(workdir, 'semantic-layer/warehouse/_schema/public.yaml', YAML.stringify({
+            tables: {
+                orders: {
+                    table: 'public.orders',
+                    usage: {
+                        narrative: 'Orders were active before.',
+                        frequencyTier: 'high',
+                        commonFilters: ['status'],
+                        commonGroupBys: ['status'],
+                        commonJoins: [],
+                    },
+                    columns: [{ name: 'id', type: 'string' }],
+                },
+            },
+        }));
+        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/override-sync/manifest.json', {
+            source: 'historic-sql',
+            connectionId: 'warehouse',
+            dialect: 'postgres',
+            fetchedAt: '2026-05-11T00:00:00.000Z',
+            windowStart: '2026-02-10T00:00:00.000Z',
+            windowEnd: '2026-05-11T00:00:00.000Z',
+            snapshotRowCount: 0,
+            touchedTableCount: 0,
+            parseFailures: 0,
+            warnings: [],
+            probeWarnings: [],
+            staleArchiveAfterDays: 90,
+        });
+        const result = await projectHistoricSqlEvidence({
+            workdir,
+            connectionId: 'warehouse',
+            syncId: 'override-sync',
+            runId: 'override-run',
+            overrideReplay: {
+                priorJobId: 'prior-job',
+                priorRunId: 'prior-run',
+                priorSyncId: 'prior-sync',
+                evictionRawPaths: ['tables/public/orders.json'],
+            },
+        });
+        expect(result.tableUsageMerged).toBe(0);
+        expect(result.staleTablesMarked).toBe(0);
+        expect(result.patternPagesWritten).toBe(0);
+        expect(result.stalePatternPagesMarked).toBe(0);
+        expect(result.archivedPatternPages).toBe(0);
+        expect(result.touchedSources).toEqual([]);
+        expect(result.changedWikiPageKeys).toEqual([]);
+        expect(result.actions).toEqual([]);
+    });
 });

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
+import { filterSnapshotTables, resolveEnabledTables } from '../../../scan/enabled-tables.js';
 import { inferKtxDimensionType, normalizeKtxNativeType } from '../../../scan/type-normalization.js';
 const DEFAULT_SCHEMAS = ['public'];
 function parseJsonObject(raw, subcommand) {
@@ -177,11 +178,13 @@ export function createDaemonLiveDatabaseIntrospection(options) {
             const raw = requestJson
                 ? await requestJson('/database/introspect', payload)
                 : await runJson('database-introspect', payload);
-            return mapDaemonSnapshot(raw, {
+            const snapshot = mapDaemonSnapshot(raw, {
                 connectionId,
                 extractedAt: now().toISOString(),
                 schemas,
             });
+            const enabledTables = resolveEnabledTables(connection);
+            return enabledTables ? filterSnapshotTables(snapshot, enabledTables) : snapshot;
         },
     };
 }

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.test.js

@@ -201,4 +201,36 @@ describe('createDaemonLiveDatabaseIntrospection', () => {
         await expect(introspection.extractSchema('warehouse')).rejects.toThrow('Local live-database ingest cannot run driver "snowflake".');
         expect(runJson).not.toHaveBeenCalled();
     });
+    it('filters out tables not on the enabled_tables allowlist', async () => {
+        const runJson = vi.fn(async () => daemonResponse);
+        const introspection = createDaemonLiveDatabaseIntrospection({
+            connections: {
+                warehouse: {
+                    driver: 'postgres',
+                    url: 'postgres://localhost:5432/warehouse',
+                    enabled_tables: ['public.orders'],
+                },
+            },
+            schemas: ['public'],
+            runJson,
+        });
+        const snapshot = await introspection.extractSchema('warehouse');
+        expect(snapshot.tables.map((table) => `${table.db}.${table.name}`)).toEqual(['public.orders']);
+    });
+    it('passes through every table when enabled_tables is omitted or empty', async () => {
+        const runJson = vi.fn(async () => daemonResponse);
+        const introspection = createDaemonLiveDatabaseIntrospection({
+            connections: {
+                warehouse: {
+                    driver: 'postgres',
+                    url: 'postgres://localhost:5432/warehouse',
+                    enabled_tables: [],
+                },
+            },
+            schemas: ['public'],
+            runJson,
+        });
+        const snapshot = await introspection.extractSchema('warehouse');
+        expect(snapshot.tables.map((table) => table.name)).toEqual(['customers', 'orders']);
+    });
 });

package/node_modules/@ktx/context/dist/ingest/finalization-scope.d.ts

@@ -0,0 +1,22 @@
+import type { SemanticLayerSource } from '../sl/index.js';
+import type { TouchedSlSource } from '../tools/index.js';
+import type { IngestReportFinalizationMismatch } from './reports.js';
+interface DeriveTouchedSourcesInput {
+    changedPaths: string[];
+    beforeSourcesByConnection: Map<string, SemanticLayerSource[]>;
+    afterSourcesByConnection: Map<string, SemanticLayerSource[]>;
+}
+interface DeriveTouchedSourcesResult {
+    touchedSources: TouchedSlSource[];
+    unresolvedPaths: string[];
+}
+interface CompareFinalizationDeclarationsInput {
+    declaredTouchedSources: TouchedSlSource[];
+    derivedTouchedSources: TouchedSlSource[];
+    declaredChangedWikiPageKeys: string[];
+    derivedChangedWikiPageKeys: string[];
+}
+export declare function deriveFinalizationWikiPageKeys(paths: string[]): string[];
+export declare function deriveFinalizationTouchedSources(input: DeriveTouchedSourcesInput): Promise<DeriveTouchedSourcesResult>;
+export declare function compareFinalizationDeclarations(input: CompareFinalizationDeclarationsInput): IngestReportFinalizationMismatch[];
+export {};

package/node_modules/@ktx/context/dist/ingest/finalization-scope.js

@@ -0,0 +1,95 @@
+function uniqueSorted(values) {
+    return [...new Set(values.filter((value) => value.length > 0))].sort();
+}
+function touchedKey(source) {
+    return `${source.connectionId}:${source.sourceName}`;
+}
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function changedSourceNames(beforeSources, afterSources) {
+    const before = new Map(beforeSources.map((source) => [source.name, stableJson(source)]));
+    const after = new Map(afterSources.map((source) => [source.name, stableJson(source)]));
+    return uniqueSorted(uniqueSorted([...before.keys(), ...after.keys()]).filter((sourceName) => before.get(sourceName) !== after.get(sourceName)));
+}
+export function deriveFinalizationWikiPageKeys(paths) {
+    return uniqueSorted(paths
+        .filter((path) => path.startsWith('wiki/global/') && path.endsWith('.md'))
+        .filter((path) => !path.slice('wiki/global/'.length, -'.md'.length).includes('/'))
+        .map((path) => path.slice('wiki/global/'.length, -'.md'.length)));
+}
+export async function deriveFinalizationTouchedSources(input) {
+    const touched = new Map();
+    const unresolvedPaths = [];
+    for (const path of input.changedPaths) {
+        if (!path.startsWith('semantic-layer/') || !(path.endsWith('.yaml') || path.endsWith('.yml'))) {
+            continue;
+        }
+        const parts = path.split('/');
+        const connectionId = parts[1] ?? '';
+        if (!connectionId) {
+            unresolvedPaths.push(path);
+            continue;
+        }
+        if (parts[2] !== '_schema') {
+            const fileName = parts.at(-1) ?? '';
+            const sourceName = fileName.replace(/\.ya?ml$/, '');
+            if (!sourceName) {
+                unresolvedPaths.push(path);
+                continue;
+            }
+            touched.set(`${connectionId}:${sourceName}`, { connectionId, sourceName });
+            continue;
+        }
+        const changedNames = changedSourceNames(input.beforeSourcesByConnection.get(connectionId) ?? [], input.afterSourcesByConnection.get(connectionId) ?? []);
+        if (changedNames.length === 0) {
+            unresolvedPaths.push(path);
+            continue;
+        }
+        for (const sourceName of changedNames) {
+            touched.set(`${connectionId}:${sourceName}`, { connectionId, sourceName });
+        }
+    }
+    return {
+        touchedSources: [...touched.values()].sort((left, right) => touchedKey(left).localeCompare(touchedKey(right))),
+        unresolvedPaths: uniqueSorted(unresolvedPaths),
+    };
+}
+export function compareFinalizationDeclarations(input) {
+    const mismatches = [];
+    const declaredSl = new Set(input.declaredTouchedSources.map(touchedKey));
+    const derivedSl = new Set(input.derivedTouchedSources.map(touchedKey));
+    const declaredWiki = new Set(input.declaredChangedWikiPageKeys);
+    const derivedWiki = new Set(input.derivedChangedWikiPageKeys);
+    for (const key of [...derivedSl].sort()) {
+        if (!declaredSl.has(key)) {
+            mismatches.push({ artifactKind: 'sl', key, direction: 'missing_from_adapter_declaration' });
+        }
+    }
+    for (const key of [...declaredSl].sort()) {
+        if (!derivedSl.has(key)) {
+            mismatches.push({ artifactKind: 'sl', key, direction: 'extra_in_adapter_declaration' });
+        }
+    }
+    for (const key of [...derivedWiki].sort()) {
+        if (!declaredWiki.has(key)) {
+            mismatches.push({ artifactKind: 'wiki', key, direction: 'missing_from_adapter_declaration' });
+        }
+    }
+    for (const key of [...declaredWiki].sort()) {
+        if (!derivedWiki.has(key)) {
+            mismatches.push({ artifactKind: 'wiki', key, direction: 'extra_in_adapter_declaration' });
+        }
+    }
+    return mismatches;
+}

package/node_modules/@ktx/context/dist/ingest/finalization-scope.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/finalization-scope.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+import { compareFinalizationDeclarations, deriveFinalizationTouchedSources, deriveFinalizationWikiPageKeys, } from './finalization-scope.js';
+describe('deriveFinalizationWikiPageKeys', () => {
+    it('maps changed global wiki markdown paths to page keys', () => {
+        expect(deriveFinalizationWikiPageKeys([
+            'wiki/global/historic-sql-orders.md',
+            'wiki/global/nested/page.md',
+            'README.md',
+        ])).toEqual(['historic-sql-orders']);
+    });
+});
+describe('deriveFinalizationTouchedSources', () => {
+    it('maps standalone semantic-layer files directly', async () => {
+        const result = await deriveFinalizationTouchedSources({
+            changedPaths: ['semantic-layer/warehouse/orders.yaml'],
+            beforeSourcesByConnection: new Map(),
+            afterSourcesByConnection: new Map(),
+        });
+        expect(result).toEqual({
+            touchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            unresolvedPaths: [],
+        });
+    });
+    it('resolves aggregate _schema changes by comparing loaded source snapshots', async () => {
+        const beforeSourcesByConnection = new Map([
+            [
+                'warehouse',
+                [
+                    {
+                        name: 'orders',
+                        grain: ['order_id'],
+                        columns: [{ name: 'order_id', type: 'string' }],
+                        joins: [],
+                        measures: [],
+                        usage: {
+                            narrative: 'old',
+                            frequencyTier: 'low',
+                            commonFilters: [],
+                            commonJoins: [],
+                        },
+                    },
+                ],
+            ],
+        ]);
+        const afterSourcesByConnection = new Map([
+            [
+                'warehouse',
+                [
+                    {
+                        name: 'orders',
+                        grain: ['order_id'],
+                        columns: [{ name: 'order_id', type: 'string' }],
+                        joins: [],
+                        measures: [],
+                        usage: {
+                            narrative: 'new',
+                            frequencyTier: 'high',
+                            commonFilters: [],
+                            commonJoins: [],
+                        },
+                    },
+                ],
+            ],
+        ]);
+        const result = await deriveFinalizationTouchedSources({
+            changedPaths: ['semantic-layer/warehouse/_schema/public.yaml'],
+            beforeSourcesByConnection,
+            afterSourcesByConnection,
+        });
+        expect(result).toEqual({
+            touchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            unresolvedPaths: [],
+        });
+    });
+    it('flags aggregate _schema changes that cannot be resolved to logical sources', async () => {
+        const beforeSourcesByConnection = new Map([['warehouse', []]]);
+        const afterSourcesByConnection = new Map([['warehouse', []]]);
+        const result = await deriveFinalizationTouchedSources({
+            changedPaths: ['semantic-layer/warehouse/_schema/public.yaml'],
+            beforeSourcesByConnection,
+            afterSourcesByConnection,
+        });
+        expect(result).toEqual({
+            touchedSources: [],
+            unresolvedPaths: ['semantic-layer/warehouse/_schema/public.yaml'],
+        });
+    });
+});
+describe('compareFinalizationDeclarations', () => {
+    it('reports missing and extra adapter declarations', () => {
+        expect(compareFinalizationDeclarations({
+            declaredTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            derivedTouchedSources: [{ connectionId: 'warehouse', sourceName: 'customers' }],
+            declaredChangedWikiPageKeys: ['orders'],
+            derivedChangedWikiPageKeys: ['orders', 'patterns'],
+        })).toEqual([
+            {
+                artifactKind: 'sl',
+                key: 'warehouse:customers',
+                direction: 'missing_from_adapter_declaration',
+            },
+            {
+                artifactKind: 'sl',
+                key: 'warehouse:orders',
+                direction: 'extra_in_adapter_declaration',
+            },
+            {
+                artifactKind: 'wiki',
+                key: 'patterns',
+                direction: 'missing_from_adapter_declaration',
+            },
+        ]);
+    });
+});

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

@@ -77,7 +77,6 @@ export { stageHistoricSqlAggregatedSnapshot } from './adapters/historic-sql/stag
 export { historicSqlEvidenceEnvelopeSchema, historicSqlEvidencePath, historicSqlPatternEvidenceSchema, historicSqlTableUsageEvidenceSchema, serializeHistoricSqlEvidence, } from './adapters/historic-sql/evidence.js';
 export type { HistoricSqlEvidenceEnvelope, HistoricSqlPatternEvidence, HistoricSqlTableUsageEvidence, } from './adapters/historic-sql/evidence.js';
 export { createEmitHistoricSqlEvidenceTool } from './adapters/historic-sql/evidence-tool.js';
-export { HistoricSqlProjectionPostProcessor } from './adapters/historic-sql/post-processor.js';
 export { projectHistoricSqlEvidence } from './adapters/historic-sql/projection.js';
 export type { HistoricSqlProjectionInput, HistoricSqlProjectionResult } from './adapters/historic-sql/projection.js';
 export { patternOutputSchema, patternsArraySchema, tableUsageOutputSchema, } from './adapters/historic-sql/skill-schemas.js';
@@ -151,5 +150,5 @@ export { buildReconcileSystemPrompt, buildReconcileToolSet, buildReconcileUserPr
 export type { ReconciliationOutcome } from './stages/stage-4-reconciliation.js';
 export { runReconciliationStage4 } from './stages/stage-4-reconciliation.js';
 export type { StageIndex } from './stages/stage-index.types.js';
-export type { ChunkResult, DiffSet, EvictionUnit, FetchContext, IngestBundleJob, IngestBundleRef, IngestBundleResult, IngestDiffSummary, IngestJobContext, IngestJobPhase, IngestTrigger, ScopeDescriptor, SourceAdapter, SourceFetchIssue, SourceFetchReport, TriageLane, TriageSignals, UnresolvedCardInfo, WorkUnit, DeterministicProjectionContext, ProjectionResult, } from './types.js';
+export type { ChunkResult, DiffSet, EvictionUnit, FetchContext, IngestBundleJob, IngestBundleRef, IngestBundleResult, IngestDiffSummary, IngestJobContext, IngestJobPhase, IngestTrigger, ScopeDescriptor, SourceAdapter, SourceFetchIssue, SourceFetchReport, TriageLane, TriageSignals, UnresolvedCardInfo, WorkUnit, DeterministicProjectionContext, ProjectionResult, DeterministicFinalizationContext, FinalizationOverrideReplay, FinalizationResult, } from './types.js';
 export * from './wiki-body-refs.js';

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

@@ -51,7 +51,6 @@ export { SnowflakeHistoricSqlQueryHistoryReader } from './adapters/historic-sql/
 export { stageHistoricSqlAggregatedSnapshot } from './adapters/historic-sql/stage-unified.js';
 export { historicSqlEvidenceEnvelopeSchema, historicSqlEvidencePath, historicSqlPatternEvidenceSchema, historicSqlTableUsageEvidenceSchema, serializeHistoricSqlEvidence, } from './adapters/historic-sql/evidence.js';
 export { createEmitHistoricSqlEvidenceTool } from './adapters/historic-sql/evidence-tool.js';
-export { HistoricSqlProjectionPostProcessor } from './adapters/historic-sql/post-processor.js';
 export { projectHistoricSqlEvidence } from './adapters/historic-sql/projection.js';
 export { patternOutputSchema, patternsArraySchema, tableUsageOutputSchema, } from './adapters/historic-sql/skill-schemas.js';
 export { HISTORIC_SQL_SOURCE_KEY, aggregatedTemplateSchema, historicSqlUnifiedPullConfigSchema, stagedManifestSchema, stagedPatternsInputSchema, stagedTableInputSchema, } from './adapters/historic-sql/types.js';

package/node_modules/@ktx/context/dist/ingest/ingest-bundle.runner.d.ts

@@ -32,11 +32,13 @@ export declare class IngestBundleRunner {
     private buildWikiIndex;
     private buildSlIndex;
     private tableRefExistsInSemanticLayer;
+    private loadSourcesByConnection;
     private resolveContextCuratorBudget;
     private filterWorkUnitsForTriage;
     private createTrace;
     private errorMessage;
     private buildProvenancePlan;
+    private partitionFinalizationActionsForProvenance;
     private toReportProvenanceRows;
     private toReportWorkUnits;
     private provenanceValidationTraceData;