@kaelio/ktx 0.1.0-rc.6 → 0.1.1

package/dist/standalone-smoke.test.js

@@ -76,7 +76,7 @@ async function writeSqliteScanConfig(projectDir, dbPath, enrich = false) {
                 '  enrichment:',
                 '    mode: deterministic',
                 '    embeddings:',
-                '      backend: deterministic',
+                '      backend: none',
                 '      dimensions: 6',
             ]
             : []),
@@ -94,7 +94,6 @@ async function runSetupNewProject(projectDir) {
         'setup',
         '--project-dir',
         projectDir,
-        '--new',
         '--no-input',
         '--yes',
         '--skip-llm',
@@ -135,7 +134,7 @@ describe('standalone built ktx CLI smoke', () => {
         expect(result.stderr).toContain("unknown command 'agent'");
     });
     it('runs status setup checks through the built binary', async () => {
-        const result = await runBuiltCli(['status', '--verbose', '--no-input']);
+        const result = await runBuiltCli(['status', '--verbose', '--no-input'], { cwd: tempDir });
         expect(result.stdout).toMatch(/KTX status/);
         if (result.stdout.includes('No project here yet.')) {
             expect(result.stdout).toContain('ktx setup');

package/dist/status-project.js

@@ -120,15 +120,6 @@ function buildEmbeddingsStatus(config, env) {
             detail: 'disabled — semantic search will be skipped',
         };
     }
-    if (backend === 'deterministic') {
-        return {
-            backend,
-            model,
-            dimensions,
-            status: 'warn',
-            detail: 'deterministic — semantic search degraded (lexical/dictionary lanes still work)',
-        };
-    }
     if (backend === 'openai') {
         const ref = config.openai?.api_key;
         const resolved = resolveRef(ref, env);
@@ -469,7 +460,7 @@ function buildVerdict(llm, embeddings, connections, queryHistory, warnings) {
     if (llm.status === 'warn')
         reasons.push('LLM credentials missing');
     if (embeddings.status === 'warn') {
-        if (embeddings.backend === 'deterministic' || embeddings.backend === 'none') {
+        if (embeddings.backend === 'none') {
             reasons.push('semantic search disabled');
         }
         else {

package/node_modules/@ktx/connector-clickhouse/dist/package-exports.test.js

@@ -6,5 +6,5 @@ describe('@ktx/connector-clickhouse package exports', () => {
         expect(connector.KtxClickHouseScanConnector).toBeTypeOf('function');
         expect(connector.clickHouseClientConfigFromConfig).toBeTypeOf('function');
         expect(connector.createClickHouseLiveDatabaseIntrospection).toBeTypeOf('function');
-    });
+    }, 20_000);
 });

package/node_modules/@ktx/context/dist/core/git.service.d.ts

@@ -101,7 +101,6 @@ export declare class GitService {
         status: 'A' | 'M' | 'D';
         path: string;
     }>>;
-    changedPaths(): Promise<string[]>;
     /**
      * List all paths under the working tree that match `pathSpec`, scoped to HEAD.
      * Used for the reconciler's first-ever run when there's no watermark to diff from.

package/node_modules/@ktx/context/dist/core/git.service.js

@@ -424,18 +424,6 @@ export class GitService {
         }
         return out;
     }
-    async changedPaths() {
-        const raw = await this.git.raw(['status', '--porcelain=v1', '-z']);
-        const fields = raw.split('\0').filter(Boolean);
-        const paths = [];
-        for (const field of fields) {
-            const path = field.slice(3);
-            if (path.length > 0) {
-                paths.push(path);
-            }
-        }
-        return [...new Set(paths)].sort();
-    }
     /**
      * List all paths under the working tree that match `pathSpec`, scoped to HEAD.
      * Used for the reconciler's first-ever run when there's no watermark to diff from.

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/historic-sql.adapter.d.ts

@@ -1,4 +1,4 @@
-import type { ChunkResult, DeterministicFinalizationContext, DiffSet, FetchContext, FinalizationResult, ScopeDescriptor, SourceAdapter } from '../../types.js';
+import type { ChunkResult, DiffSet, FetchContext, ScopeDescriptor, SourceAdapter } from '../../types.js';
 import { type HistoricSqlSourceAdapterDeps } from './types.js';
 export declare class HistoricSqlSourceAdapter implements SourceAdapter {
     private readonly deps;
@@ -11,5 +11,4 @@ export declare class HistoricSqlSourceAdapter implements SourceAdapter {
     fetch(pullConfig: unknown, stagedDir: string, ctx: FetchContext): Promise<void>;
     chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
     describeScope(stagedDir: string): Promise<ScopeDescriptor>;
-    finalize(ctx: DeterministicFinalizationContext): Promise<FinalizationResult>;
 }

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

@@ -1,6 +1,5 @@
 import { chunkHistoricSqlUnifiedStagedDir, describeHistoricSqlUnifiedScope } from './chunk-unified.js';
 import { detectHistoricSqlStagedDir } from './detect.js';
-import { projectHistoricSqlEvidence } from './projection.js';
 import { stageHistoricSqlAggregatedSnapshot } from './stage-unified.js';
 export class HistoricSqlSourceAdapter {
     deps;
@@ -31,21 +30,4 @@ export class HistoricSqlSourceAdapter {
     describeScope(stagedDir) {
         return describeHistoricSqlUnifiedScope(stagedDir);
     }
-    async finalize(ctx) {
-        const projection = await projectHistoricSqlEvidence({
-            workdir: ctx.workdir,
-            connectionId: ctx.connectionId,
-            syncId: ctx.syncId,
-            runId: ctx.runId,
-            overrideReplay: ctx.overrideReplay,
-        });
-        return {
-            result: projection,
-            warnings: projection.warnings,
-            errors: [],
-            touchedSources: projection.touchedSources,
-            changedWikiPageKeys: projection.changedWikiPageKeys,
-            actions: projection.actions,
-        };
-    }
 }

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

@@ -132,7 +132,7 @@ async function writeHistoricSqlProject(project) {
         '  adapters:',
         '    - historic-sql',
         '  embeddings:',
-        '    backend: deterministic',
+        '    backend: none',
         'storage:',
         '  state: sqlite',
         '  search: sqlite-fts5',
@@ -194,12 +194,12 @@ describe('historic-SQL local ingest retrieval acceptance', () => {
         expect(result.result.failedWorkUnits).toEqual([]);
         expect(result.result.workUnitCount).toBe(3);
         expect(agentRunner.runLoop).toHaveBeenCalledTimes(3);
-        const finalization = result.report.body.finalization;
-        expect(finalization).toBeDefined();
-        if (!finalization) {
-            throw new Error('Expected historic-SQL finalization result');
+        const postProcessor = result.report.body.postProcessor;
+        expect(postProcessor).toBeDefined();
+        if (!postProcessor) {
+            throw new Error('Expected historic-SQL post-processor result');
         }
-        expect(finalization).toMatchObject({
+        expect(postProcessor).toMatchObject({
             sourceKey: 'historic-sql',
             status: 'success',
             result: {
@@ -207,7 +207,7 @@ describe('historic-SQL local ingest retrieval acceptance', () => {
                 patternPagesWritten: 1,
             },
         });
-        expect(finalization.declaredTouchedSources).toEqual(expect.arrayContaining([
+        expect(postProcessor.touchedSources).toEqual(expect.arrayContaining([
             { connectionId: 'warehouse', sourceName: 'customers' },
             { connectionId: 'warehouse', sourceName: 'orders' },
         ]));

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.d.ts

@@ -0,0 +1,4 @@
+import type { IngestBundlePostProcessorInput, IngestBundlePostProcessorPort, IngestBundlePostProcessorResult } from '../../ports.js';
+export declare class HistoricSqlProjectionPostProcessor implements IngestBundlePostProcessorPort {
+    run(input: IngestBundlePostProcessorInput): Promise<IngestBundlePostProcessorResult>;
+}

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

@@ -0,0 +1,38 @@
+import { createSimpleGit } from '../../../core/git-env.js';
+import { projectHistoricSqlEvidence } from './projection.js';
+async function commitProjectionChanges(workdir) {
+    const git = createSimpleGit(workdir);
+    if (!(await git.checkIsRepo().catch(() => false))) {
+        return;
+    }
+    const status = await git.status();
+    const paths = status.files
+        .map((file) => file.path)
+        .filter((path) => path.startsWith('semantic-layer/') || path.startsWith('wiki/global/historic-sql'));
+    if (paths.length === 0) {
+        return;
+    }
+    await git.add(paths);
+    const staged = await git.diff(['--cached', '--name-only']);
+    if (!staged.trim()) {
+        return;
+    }
+    await git.commit('Project historic SQL evidence', { '--author': 'System User <system@example.com>' });
+}
+export class HistoricSqlProjectionPostProcessor {
+    async run(input) {
+        const projection = await projectHistoricSqlEvidence({
+            workdir: input.workdir,
+            connectionId: input.connectionId,
+            syncId: input.syncId,
+            runId: input.runId,
+        });
+        await commitProjectionChanges(input.workdir);
+        return {
+            result: projection,
+            warnings: projection.warnings,
+            errors: [],
+            touchedSources: projection.touchedSources,
+        };
+    }
+}

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.test.d.ts

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

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

@@ -0,0 +1,63 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { describe, expect, it } from 'vitest';
+import { HistoricSqlProjectionPostProcessor } from './post-processor.js';
+async function tempWorkdir() {
+    return mkdtemp(join(tmpdir(), 'historic-sql-post-processor-'));
+}
+async function writeJson(root, relPath, value) {
+    const target = join(root, relPath);
+    await mkdir(join(target, '..'), { recursive: true });
+    await writeFile(target, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+describe('HistoricSqlProjectionPostProcessor', () => {
+    it('projects current run evidence before the ingest squash commit', async () => {
+        const workdir = await tempWorkdir();
+        await mkdir(join(workdir, 'semantic-layer/warehouse/_schema'), { recursive: true });
+        await writeFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), YAML.stringify({ tables: { orders: { table: 'public.orders', columns: [{ name: 'id', type: 'string' }] } } }), 'utf-8');
+        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/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: 1,
+            touchedTableCount: 1,
+            parseFailures: 0,
+            warnings: [],
+            probeWarnings: [],
+            staleArchiveAfterDays: 90,
+        });
+        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.orders.json', { table: 'public.orders' });
+        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/orders.json', {
+            kind: 'table_usage',
+            connectionId: 'warehouse',
+            table: 'public.orders',
+            rawPath: 'tables/public.orders.json',
+            usage: {
+                narrative: 'Orders are repeatedly queried by lifecycle status.',
+                frequencyTier: 'high',
+                commonFilters: ['status'],
+                commonJoins: [],
+                staleSince: null,
+            },
+        });
+        const result = await new HistoricSqlProjectionPostProcessor().run({
+            connectionId: 'warehouse',
+            sourceKey: 'historic-sql',
+            syncId: 'sync-1',
+            jobId: 'job-1',
+            runId: 'run-1',
+            workdir,
+            parseArtifacts: null,
+        });
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([]);
+        expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
+        expect(result.result).toMatchObject({ tableUsageMerged: 1 });
+        await expect(readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8')).resolves.toContain('Orders are repeatedly queried by lifecycle status.');
+    });
+});

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

@@ -1,11 +1,8 @@
-import type { MemoryAction } from '../../../memory/index.js';
-import type { FinalizationOverrideReplay } from '../../types.js';
 export interface HistoricSqlProjectionInput {
     workdir: string;
     connectionId: string;
     syncId: string;
     runId: string;
-    overrideReplay?: FinalizationOverrideReplay;
 }
 export interface HistoricSqlProjectionResult {
     tableUsageMerged: number;
@@ -17,8 +14,6 @@ export interface HistoricSqlProjectionResult {
         connectionId: string;
         sourceName: string;
     }>;
-    changedWikiPageKeys: string[];
-    actions: MemoryAction[];
     warnings: string[];
 }
 export declare function projectHistoricSqlEvidence(input: HistoricSqlProjectionInput): Promise<HistoricSqlProjectionResult>;

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

@@ -177,8 +177,6 @@ export async function projectHistoricSqlEvidence(input) {
         stalePatternPagesMarked: 0,
         archivedPatternPages: 0,
         touchedSources: [],
-        changedWikiPageKeys: [],
-        actions: [],
         warnings: [],
     };
     const touchedKeys = new Set();
@@ -186,14 +184,6 @@ 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');
@@ -217,14 +207,6 @@ 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)) {
@@ -238,13 +220,6 @@ 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}`,
-                    });
                 }
             }
         }
@@ -279,14 +254,6 @@ 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))
@@ -295,26 +262,11 @@ 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,13 +64,6 @@ 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',
@@ -150,14 +143,6 @@ 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"');
     });
@@ -289,19 +274,6 @@ 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({
@@ -322,9 +294,6 @@ 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',
@@ -337,56 +306,4 @@ 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/index.d.ts

@@ -77,6 +77,7 @@ 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';
@@ -150,5 +151,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, DeterministicFinalizationContext, FinalizationOverrideReplay, FinalizationResult, } 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, } from './types.js';
 export * from './wiki-body-refs.js';

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

@@ -51,6 +51,7 @@ 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,13 +32,11 @@ 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;