@kaelio/ktx 0.1.0-rc.6 → 0.1.0

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;

package/node_modules/@ktx/context/dist/ingest/ingest-bundle.runner.isolated-diff.test.js

@@ -104,24 +104,6 @@ function makeWikiService(root) {
                 content: content.trim(),
             };
         }),
-        writePage: vi.fn(async (_scope, _scopeId, key, frontmatter, content) => {
-            await mkdir(join(root, 'wiki/global'), { recursive: true });
-            const refs = (frontmatter.refs ?? []).map((ref) => `  - ${ref}`).join('\n');
-            const slRefs = (frontmatter.sl_refs ?? []).map((ref) => `  - ${ref}`).join('\n');
-            await writeFile(join(root, 'wiki/global', `${key}.md`), [
-                '---',
-                `summary: ${frontmatter.summary ?? key}`,
-                `usage_mode: ${frontmatter.usage_mode ?? 'auto'}`,
-                'refs:',
-                refs,
-                'sl_refs:',
-                slRefs,
-                '---',
-                '',
-                content,
-                '',
-            ].join('\n'));
-        }),
         syncFromCommit: vi.fn(),
     };
 }
@@ -1776,152 +1758,4 @@ describe('IngestBundleRunner isolated diff path', () => {
             await rm(runtime.homeDir, { recursive: true, force: true });
         }
     });
-    it('runs finalization before wiki sl-ref repair and final gates', async () => {
-        const runtime = await makeRealGitRuntime();
-        try {
-            const { deps, adapter } = makeDeps(runtime);
-            adapter.chunk.mockResolvedValue({
-                workUnits: [{ unitKey: 'wiki-page', rawFiles: ['cards/source.json'], peerFileIndex: [], dependencyPaths: [] }],
-            });
-            adapter.finalize = vi.fn(async ({ workdir }) => {
-                await mkdir(join(workdir, 'semantic-layer/warehouse'), { recursive: true });
-                await mkdir(join(workdir, 'wiki/global'), { recursive: true });
-                await writeFile(join(workdir, 'semantic-layer/warehouse/mart_account_segments.yaml'), 'name: mart_account_segments\ngrain: [account_id]\ncolumns: [{name: account_id, type: string}]\njoins: []\nmeasures:\n  - name: total_contract_arr\n    expr: sum(contract_arr)\n');
-                await writeFile(join(workdir, 'wiki/global/finalized-accounts.md'), '---\nsummary: Finalized accounts\nusage_mode: auto\nsl_refs:\n  - mart_account_segments\n  - missing_source\n---\n\nAccounts use `mart_account_segments.total_contract_arr`.\n');
-                return {
-                    warnings: [],
-                    errors: [],
-                    touchedSources: [{ connectionId: 'warehouse', sourceName: 'mart_account_segments' }],
-                    changedWikiPageKeys: ['finalized-accounts'],
-                    actions: [
-                        {
-                            target: 'sl',
-                            type: 'created',
-                            key: 'mart_account_segments',
-                            detail: 'Finalized accounts',
-                            targetConnectionId: 'warehouse',
-                            rawPaths: ['cards/source.json'],
-                        },
-                        {
-                            target: 'wiki',
-                            type: 'created',
-                            key: 'finalized-accounts',
-                            detail: 'Finalized wiki',
-                            rawPaths: ['cards/source.json'],
-                        },
-                    ],
-                };
-            });
-            deps.agentRunner.runLoop = vi.fn(async () => ({ stopReason: 'natural' }));
-            const runner = new IngestBundleRunner(deps);
-            await mockStageRawFiles(runner, runtime, [['cards/source.json', 'h1']]);
-            await runner.run({
-                jobId: 'job-finalization',
-                connectionId: 'warehouse',
-                sourceKey: 'metabase',
-                trigger: 'upload',
-                bundleRef: { kind: 'upload', uploadId: 'upload' },
-            });
-            const trace = await readFile(join(runtime.configDir, '.ktx/ingest-traces/job-finalization/trace.jsonl'), 'utf-8');
-            expect(trace.indexOf('finalization_committed')).toBeLessThan(trace.indexOf('wiki_sl_refs_repaired'));
-            expect(trace.indexOf('wiki_sl_refs_repaired')).toBeLessThan(trace.indexOf('final_artifact_gates'));
-            await expect(readFile(join(runtime.configDir, 'wiki/global/finalized-accounts.md'), 'utf-8')).resolves.toContain('sl_refs:\n  - mart_account_segments');
-        }
-        finally {
-            await rm(runtime.homeDir, { recursive: true, force: true });
-        }
-    });
-    it('fails when finalization edits a path already changed earlier in the run', async () => {
-        const runtime = await makeRealGitRuntime();
-        try {
-            const { deps, adapter } = makeDeps(runtime);
-            adapter.chunk.mockResolvedValue({
-                workUnits: [{ unitKey: 'wiki-page', rawFiles: ['cards/source.json'], peerFileIndex: [], dependencyPaths: [] }],
-            });
-            let currentSession = null;
-            deps.toolsetFactory.createIngestWuToolset = vi.fn((toolSession) => {
-                currentSession = toolSession;
-                return { toRuntimeTools: vi.fn(() => ({})) };
-            });
-            deps.agentRunner.runLoop = vi.fn(async () => {
-                const root = rootOfConfig(currentSession.configService, runtime.configDir);
-                await mkdir(join(root, 'wiki/global'), { recursive: true });
-                await writeFile(join(root, 'wiki/global/orders.md'), '---\nsummary: Orders\nusage_mode: auto\n---\n\nWU body\n');
-                currentSession.actions.push({
-                    target: 'wiki',
-                    type: 'created',
-                    key: 'orders',
-                    detail: 'WU orders',
-                    rawPaths: ['cards/source.json'],
-                });
-                await currentSession.gitService.commitFiles(['wiki/global/orders.md'], 'wu orders', 'KTX Test', 'system@ktx.local');
-                return { stopReason: 'natural' };
-            });
-            adapter.finalize = vi.fn(async ({ workdir }) => {
-                await writeFile(join(workdir, 'wiki/global/orders.md'), '---\nsummary: Orders\nusage_mode: auto\n---\n\nFinalized body\n');
-                return {
-                    warnings: [],
-                    errors: [],
-                    touchedSources: [],
-                    changedWikiPageKeys: ['orders'],
-                    actions: [{ target: 'wiki', type: 'updated', key: 'orders', detail: 'Conflicting finalization' }],
-                };
-            });
-            const runner = new IngestBundleRunner(deps);
-            await mockStageRawFiles(runner, runtime, [['cards/source.json', 'h1']]);
-            await expect(runner.run({
-                jobId: 'job-finalization-overlap',
-                connectionId: 'warehouse',
-                sourceKey: 'metabase',
-                trigger: 'upload',
-                bundleRef: { kind: 'upload', uploadId: 'upload' },
-            })).rejects.toThrow(/finalization modified path\(s\) already changed earlier in this run: wiki\/global\/orders\.md/);
-        }
-        finally {
-            await rm(runtime.homeDir, { recursive: true, force: true });
-        }
-    });
-    it('rejects finalization writes to unauthorized semantic-layer targets', async () => {
-        const runtime = await makeRealGitRuntime();
-        try {
-            const { deps, adapter } = makeDeps(runtime);
-            adapter.chunk.mockResolvedValue({ workUnits: [] });
-            adapter.finalize = vi.fn(async ({ workdir }) => {
-                await mkdir(join(workdir, 'semantic-layer/other-warehouse'), { recursive: true });
-                await writeFile(join(workdir, 'semantic-layer/other-warehouse/orders.yaml'), 'name: orders\ngrain: [order_id]\ncolumns: [{name: order_id, type: string}]\njoins: []\nmeasures: []\n');
-                return {
-                    warnings: [],
-                    errors: [],
-                    touchedSources: [{ connectionId: 'other-warehouse', sourceName: 'orders' }],
-                    changedWikiPageKeys: [],
-                    actions: [
-                        {
-                            target: 'sl',
-                            type: 'created',
-                            key: 'orders',
-                            targetConnectionId: 'other-warehouse',
-                            detail: 'Forbidden target',
-                            rawPaths: ['cards/source.json'],
-                        },
-                    ],
-                };
-            });
-            const runner = new IngestBundleRunner(deps);
-            await mockStageRawFiles(runner, runtime, [['cards/source.json', 'h1']]);
-            await expect(runner.run({
-                jobId: 'job-finalization-target-policy',
-                connectionId: 'warehouse',
-                sourceKey: 'metabase',
-                trigger: 'upload',
-                bundleRef: { kind: 'upload', uploadId: 'upload' },
-            })).rejects.toThrow(/semantic-layer target connection not allowed/);
-            const trace = await readFile(join(runtime.configDir, '.ktx/ingest-traces/job-finalization-target-policy/trace.jsonl'), 'utf-8');
-            expect(trace).toContain('finalization_committed');
-            expect(trace).toContain('semantic_layer_target_policy');
-            expect(trace).toContain('ingest_failed');
-        }
-        finally {
-            await rm(runtime.homeDir, { recursive: true, force: true });
-        }
-    });
 });