@kaelio/ktx 0.1.0-rc.6 → 0.1.0

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

@@ -85,7 +85,6 @@ const makeDeps = () => {
         triageSupported: undefined,
         detect: vi.fn().mockResolvedValue(true),
         listTargetConnectionIds: undefined,
-        finalize: undefined,
         chunk: vi.fn().mockResolvedValue({
             workUnits: [{ unitKey: 'u1', rawFiles: ['a.yml'], peerFileIndex: [], dependencyPaths: [] }],
         }),
@@ -122,7 +121,6 @@ const makeDeps = () => {
         }),
         applyPatchFile3WayIndex: vi.fn(),
         diffNameStatus: vi.fn().mockResolvedValue([]),
-        changedPaths: vi.fn().mockResolvedValue([]),
     };
     const sessionWorktreeService = {
         create: vi.fn().mockResolvedValue({
@@ -1346,65 +1344,25 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             }),
         }));
     });
-    it('runs adapter finalization before squash, records the outcome, and reindexes touched sources', async () => {
+    it('runs a registered post-processor before squash, records the outcome, and reindexes touched sources after squash', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'metricflow';
         deps.registry.get.mockReturnValue(deps.adapter);
         deps.adapter.chunk.mockResolvedValue({
-            workUnits: [],
+            workUnits: [{ unitKey: 'u1', rawFiles: ['semantic_models.yml'], peerFileIndex: [], dependencyPaths: [] }],
             parseArtifacts: { semanticModels: [{ name: 'orders' }] },
         });
         deps.adapter.listTargetConnectionIds = vi.fn().mockResolvedValue(['warehouse-2']);
-        deps.adapter.finalize = vi.fn().mockResolvedValue({
-            result: { sourcesTouched: 1 },
-            warnings: ['kept going'],
-            errors: [],
-            touchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
-            changedWikiPageKeys: [],
-            actions: [
-                {
-                    target: 'sl',
-                    type: 'updated',
-                    key: 'orders',
-                    targetConnectionId: 'warehouse-2',
-                    detail: 'Finalized orders usage',
-                    rawPaths: ['semantic_models.yml'],
-                },
-            ],
-        });
         deps.semanticLayerService.loadAllSources.mockImplementation((connectionId) => Promise.resolve({ sources: [{ name: `${connectionId}_source` }], loadErrors: [] }));
-        let head = 'pre-finalization';
-        const git = {
-            revParseHead: vi.fn(async () => head),
-            commitFiles: vi.fn().mockImplementation(async (paths) => {
-                if (paths.includes('semantic-layer/warehouse-2/orders.yaml')) {
-                    head = 'post-finalization';
-                    return { created: true, commitHash: 'finalization-sha' };
-                }
-                return { created: true, commitHash: head };
-            }),
-            commitStaged: vi.fn().mockResolvedValue({ created: false, commitHash: 'post-finalization' }),
-            resetHardTo: vi.fn(),
-            assertWorktreeClean: vi.fn().mockResolvedValue(undefined),
-            writeBinaryNoRenamePatch: vi.fn(async (_base, _head, patchPath) => {
-                await writeFile(patchPath, '', 'utf-8');
+        const postProcessor = {
+            run: vi.fn().mockResolvedValue({
+                result: { sourcesCreated: 1 },
+                warnings: ['kept going'],
+                errors: [],
+                touchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
             }),
-            applyPatchFile3WayIndex: vi.fn(),
-            diffNameStatus: vi.fn().mockImplementation(async (from, to) => from === 'pre-finalization' && to === 'post-finalization'
-                ? [{ status: 'M', path: 'semantic-layer/warehouse-2/orders.yaml' }]
-                : []),
-            changedPaths: vi.fn().mockResolvedValue(['semantic-layer/warehouse-2/orders.yaml']),
         };
-        deps.sessionWorktreeService.create.mockResolvedValue({
-            chatId: 'j1',
-            workdir: '/tmp/wt',
-            branch: 'session/j1',
-            baseSha: 'b',
-            createdAt: new Date(),
-            git,
-            config: {},
-        });
-        const runner = buildRunner(deps);
+        const runner = buildRunner(deps, { postProcessors: { metricflow: postProcessor } });
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['semantic_models.yml', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/metricflow/s',
@@ -1417,7 +1375,7 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             trigger: 'upload',
             bundleRef: { kind: 'upload', uploadId: 'upload-x' },
         });
-        expect(deps.adapter.finalize).toHaveBeenCalledWith(expect.objectContaining({
+        expect(postProcessor.run).toHaveBeenCalledWith({
             connectionId: 'c1',
             sourceKey: 'metricflow',
             syncId: expect.any(String),
@@ -1425,25 +1383,24 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             runId: 'run-1',
             workdir: '/tmp/wt',
             parseArtifacts: { semanticModels: [{ name: 'orders' }] },
-        }));
+        });
         expect(deps.reportsRepo.create).toHaveBeenCalledWith(expect.objectContaining({
             body: expect.objectContaining({
-                finalization: expect.objectContaining({
+                postProcessor: {
                     sourceKey: 'metricflow',
                     status: 'success',
-                    commitSha: 'finalization-sha',
-                    touchedPaths: ['semantic-layer/warehouse-2/orders.yaml'],
-                    derivedTouchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
-                    declaredTouchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
-                    actions: [expect.objectContaining({ key: 'orders' })],
-                }),
+                    result: { sourcesCreated: 1 },
+                    warnings: ['kept going'],
+                    errors: [],
+                    touchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
+                },
             }),
         }));
         expect(deps.semanticLayerService.loadAllSources).toHaveBeenCalledWith('warehouse-2');
         expect(deps.slSearchService.indexSources).toHaveBeenCalledWith('warehouse-2', [{ name: 'warehouse-2_source' }]);
         expect(deps.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'success');
     });
-    it('includes finalization actions in memory-flow saved counts', async () => {
+    it('includes historic-sql post-processor output in memory-flow saved counts', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'historic-sql';
         deps.registry.get.mockReturnValue(deps.adapter);
@@ -1457,19 +1414,21 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
                 },
             ],
         });
-        deps.adapter.finalize = vi.fn().mockResolvedValue({
-            warnings: [],
-            errors: [],
-            touchedSources: [],
-            changedWikiPageKeys: [],
-            actions: [
-                { target: 'sl', type: 'updated', key: 'orders', detail: 'Merged usage' },
-                { target: 'sl', type: 'updated', key: 'customers', detail: 'Merged usage' },
-                { target: 'wiki', type: 'created', key: 'historic-sql-orders', detail: 'Projected pattern' },
-                { target: 'wiki', type: 'updated', key: 'historic-sql-customers', detail: 'Projected pattern' },
-            ],
-        });
-        const runner = buildRunner(deps);
+        const postProcessor = {
+            run: vi.fn().mockResolvedValue({
+                result: {
+                    tableUsageMerged: 2,
+                    staleTablesMarked: 1,
+                    patternPagesWritten: 3,
+                    stalePatternPagesMarked: 1,
+                    archivedPatternPages: 1,
+                },
+                warnings: [],
+                errors: [],
+                touchedSources: [{ connectionId: 'c1', sourceName: 'orders' }],
+            }),
+        };
+        const runner = buildRunner(deps, { postProcessors: { 'historic-sql': postProcessor } });
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['tables/public/orders.json', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/historic-sql/s',
@@ -1489,11 +1448,11 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
         });
         expect(memoryFlow.snapshot().events).toContainEqual(expect.objectContaining({
             type: 'saved',
-            wikiCount: 2,
-            slCount: 2,
+            wikiCount: 5,
+            slCount: 3,
         }));
     });
-    it('marks finalization infrastructure failure as failed and preserves worktree cleanup state', async () => {
+    it('marks post-processor infrastructure failure as failed and preserves worktree cleanup state', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'metricflow';
         deps.registry.get.mockReturnValue(deps.adapter);
@@ -1501,8 +1460,8 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             workUnits: [{ unitKey: 'u1', rawFiles: ['semantic_models.yml'], peerFileIndex: [], dependencyPaths: [] }],
             parseArtifacts: { semanticModels: [{ name: 'orders' }] },
         });
-        deps.adapter.finalize = vi.fn().mockRejectedValue(new Error('worktree write failed'));
-        const runner = buildRunner(deps);
+        const postProcessor = { run: vi.fn().mockRejectedValue(new Error('worktree write failed')) };
+        const runner = buildRunner(deps, { postProcessors: { metricflow: postProcessor } });
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['semantic_models.yml', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/metricflow/s',
@@ -1519,120 +1478,6 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
         expect(deps.gitService.squashMergeIntoMain).not.toHaveBeenCalled();
         expect(deps.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'crash');
     });
-    it('reports finalization actions excluded from provenance when raw paths are not defensible', async () => {
-        const deps = makeDeps();
-        deps.adapter.finalize = vi.fn().mockResolvedValue({
-            warnings: [],
-            errors: [],
-            touchedSources: [],
-            changedWikiPageKeys: [],
-            actions: [
-                { target: 'wiki', type: 'updated', key: 'historic-sql-pattern', detail: 'No raw path' },
-                { target: 'sl', type: 'updated', key: 'orders', detail: 'Invalid raw path', rawPaths: ['missing.json'] },
-            ],
-        });
-        const runner = buildRunner(deps);
-        runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
-            currentHashes: new Map([['current.json', 'h1']]),
-            rawDirInWorktree: 'raw-sources/c1/fake/s',
-        });
-        runner.resolveStagedDir = vi.fn().mockResolvedValue('/tmp/stage/upload-x');
-        await runner.run({
-            jobId: 'j1',
-            connectionId: 'c1',
-            sourceKey: 'fake',
-            trigger: 'upload',
-            bundleRef: { kind: 'upload', uploadId: 'upload-x' },
-        });
-        expect(deps.reportsRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-            body: expect.objectContaining({
-                finalization: expect.objectContaining({
-                    provenanceExclusions: [
-                        expect.objectContaining({ reason: 'missing_raw_paths' }),
-                        expect.objectContaining({ reason: 'raw_path_not_defensible', invalidRawPaths: ['missing.json'] }),
-                    ],
-                }),
-            }),
-        }));
-        expect(deps.provenanceRepo.insertMany).not.toHaveBeenCalledWith(expect.arrayContaining([expect.objectContaining({ rawPath: 'missing.json' })]));
-    });
-    it('passes explicit override replay metadata and no current work unit outcomes', async () => {
-        const deps = makeDeps();
-        deps.reportsRepo.findByJobId.mockResolvedValue({
-            id: 'prior-report',
-            runId: 'prior-run',
-            jobId: 'prior-job',
-            connectionId: 'c1',
-            sourceKey: 'fake',
-            createdAt: '2026-05-18T00:00:00.000Z',
-            body: {
-                status: 'completed',
-                syncId: 'prior-sync',
-                diffSummary: { added: 0, modified: 0, deleted: 0, unchanged: 0 },
-                commitSha: 'prior-sha',
-                workUnits: [
-                    {
-                        unitKey: 'prior-unit',
-                        rawFiles: ['prior.json'],
-                        status: 'success',
-                        actions: [{ target: 'wiki', type: 'created', key: 'prior', detail: 'prior' }],
-                        touchedSlSources: [],
-                    },
-                ],
-                failedWorkUnits: [],
-                reconciliationSkipped: false,
-                conflictsResolved: [],
-                evictionsApplied: [
-                    {
-                        rawPath: 'do-not-replay.json',
-                        artifactKind: 'wiki',
-                        artifactKey: 'old',
-                        action: 'removed',
-                        reason: 'prior',
-                    },
-                ],
-                unmappedFallbacks: [],
-                artifactResolutions: [],
-                evictionInputs: ['evicted-from-prior-report.json'],
-                unresolvedCards: [],
-                supersededBy: null,
-                overrideOf: null,
-                provenanceRows: [],
-                toolTranscripts: [],
-            },
-        });
-        deps.adapter.finalize = vi.fn().mockResolvedValue({
-            warnings: [],
-            errors: [],
-            touchedSources: [],
-            changedWikiPageKeys: [],
-            actions: [],
-        });
-        deps.gitService.listFilesAtHead.mockResolvedValue(['raw-sources/c1/fake/prior-sync/prior.json']);
-        deps.gitService.getFileAtCommit.mockResolvedValue('{"id":1}\n');
-        const runner = buildRunner(deps);
-        runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
-            currentHashes: new Map([['prior.json', 'h1']]),
-            rawDirInWorktree: 'raw-sources/c1/fake/prior-sync',
-        });
-        runner.resolveStagedDir = vi.fn().mockResolvedValue('/tmp/stage/prior');
-        await runner.run({
-            jobId: 'override-job',
-            connectionId: 'c1',
-            sourceKey: 'fake',
-            trigger: 'manual_override',
-            bundleRef: { kind: 'override', priorJobId: 'prior-job' },
-        });
-        expect(deps.adapter.finalize).toHaveBeenCalledWith(expect.objectContaining({
-            workUnitOutcomes: [],
-            overrideReplay: {
-                priorJobId: 'prior-job',
-                priorRunId: 'prior-run',
-                priorSyncId: 'prior-sync',
-                evictionRawPaths: ['evicted-from-prior-report.json'],
-            },
-        }));
-    });
     it('includes existing global wiki pages in WorkUnit prompts', async () => {
         const deps = makeDeps();
         deps.knowledgeIndex.listPagesForUser.mockResolvedValue([

package/node_modules/@ktx/context/dist/ingest/local-bundle-ingest.test.js

@@ -7,7 +7,6 @@ import { initKtxProject, loadKtxProject } from '../project/index.js';
 import { makeLocalGitRepo } from '../test/make-local-git-repo.js';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { FakeSourceAdapter } from './adapters/fake/fake.adapter.js';
-import { projectHistoricSqlEvidence } from './adapters/historic-sql/projection.js';
 import { LocalLookerRuntimeStore } from './adapters/looker/local-runtime-store.js';
 import { createDefaultLocalIngestAdapters, localPullConfigForAdapter } from './local-adapters.js';
 import { getLocalIngestStatus, runLocalIngest } from './local-ingest.js';
@@ -160,23 +159,6 @@ class HistoricSqlEvidenceTestAdapter {
             ],
         });
     }
-    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,
-        };
-    }
 }
 function makeLookerRuntimeClient() {
     const lookerModels = {
@@ -444,7 +426,7 @@ describe('canonical local ingest', () => {
             },
         ]);
     });
-    it('runs historic-SQL evidence projection through local bundle finalization', async () => {
+    it('runs historic-SQL evidence projection through the local bundle post-processor', async () => {
         const projectDir = join(tempDir, 'historic-sql-project');
         await initKtxProject({ projectDir });
         await writeFile(join(projectDir, 'ktx.yaml'), [
@@ -495,12 +477,11 @@ describe('canonical local ingest', () => {
             agentRunner,
         });
         expect(result.result.failedWorkUnits).toEqual([]);
-        expect(result.report.body.finalization).toMatchObject({
+        expect(result.report.body.postProcessor).toMatchObject({
             sourceKey: 'historic-sql',
             status: 'success',
             result: { tableUsageMerged: 1 },
-            declaredTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
-            derivedTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            touchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
         });
         await expect(readFile(join(projectDir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8')).resolves.toContain('Orders are repeatedly queried by lifecycle status.');
     });

package/node_modules/@ktx/context/dist/ingest/local-bundle-runtime.js

@@ -13,6 +13,7 @@ import { ContextCandidateMarkTool, ContextCandidateWriteTool, ContextEvidenceNei
 import { buildKnowledgeSearchText, KnowledgeWikiService, searchLocalKnowledgePages, SqliteKnowledgeIndex, WikiListTagsTool, WikiReadTool, WikiRemoveTool, WikiSearchTool, WikiWriteTool, } from '../wiki/index.js';
 import { CandidateDedupService, ContextCandidateCarryforwardService, CuratorPaginationService, } from './context-candidates/index.js';
 import { createEmitHistoricSqlEvidenceTool } from './adapters/historic-sql/evidence-tool.js';
+import { HistoricSqlProjectionPostProcessor } from './adapters/historic-sql/post-processor.js';
 import { ContextEvidenceIndexService, SqliteContextEvidenceStore } from './context-evidence/index.js';
 import { DiffSetService } from './diff-set.service.js';
 import { ingestTracePathForJob } from './ingest-trace.js';
@@ -585,6 +586,9 @@ export function createLocalBundleIngestRuntime(options) {
             settings: { batchSize: 8, maxPasses: 8, stepBudgetPerPass: 60 },
             logger,
         }),
+        postProcessors: {
+            'historic-sql': new HistoricSqlProjectionPostProcessor(),
+        },
         logger,
     };
     return {

package/node_modules/@ktx/context/dist/ingest/local-ingest.js

@@ -178,6 +178,13 @@ async function recordLocalMetabaseChildFailure(options) {
         overrideOf: null,
         provenanceRows: [],
         toolTranscripts: [],
+        postProcessor: {
+            sourceKey: 'metabase',
+            status: 'failed',
+            errors: [reason],
+            warnings: [],
+            touchedSources: [],
+        },
     };
     const report = await store.create({
         runId: run.id,

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.d.ts

@@ -43,8 +43,8 @@ export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     stage: z.ZodEnum<{
         source: "source";
         workUnits: "workUnits";
-        chunks: "chunks";
         actions: "actions";
+        chunks: "chunks";
         gates: "gates";
         saved: "saved";
     }>;
@@ -58,7 +58,7 @@ export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         report: "report";
         integration: "integration";
         reconciliation: "reconciliation";
-        finalization: "finalization";
+        post_processor: "post_processor";
         wiki_sl_ref_repair: "wiki_sl_ref_repair";
         final_gates: "final_gates";
         save: "save";
@@ -143,8 +143,8 @@ export declare const memoryFlowActionDetailSchema: z.ZodObject<{
     }>;
     action: z.ZodEnum<{
         created: "created";
-        updated: "updated";
         removed: "removed";
+        updated: "updated";
     }>;
     key: z.ZodString;
     summary: z.ZodString;
@@ -163,8 +163,8 @@ export declare const memoryFlowDetailSectionsSchema: z.ZodObject<{
         }>;
         action: z.ZodEnum<{
             created: "created";
-            updated: "updated";
             removed: "removed";
+            updated: "updated";
         }>;
         key: z.ZodString;
         summary: z.ZodString;

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.js

@@ -53,7 +53,7 @@ export const memoryFlowEventSchema = z.discriminatedUnion('type', [
             'source',
             'integration',
             'reconciliation',
-            'finalization',
+            'post_processor',
             'wiki_sl_ref_repair',
             'final_gates',
             'save',

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

@@ -40,7 +40,7 @@ type MemoryFlowEventPayload = {
     reason: string;
 } | {
     type: 'stage_progress';
-    stage: 'source' | 'integration' | 'reconciliation' | 'finalization' | 'wiki_sl_ref_repair' | 'final_gates' | 'save' | 'provenance' | 'report';
+    stage: 'source' | 'integration' | 'reconciliation' | 'post_processor' | 'wiki_sl_ref_repair' | 'final_gates' | 'save' | 'provenance' | 'report';
     percent: number;
     message: string;
     transient?: boolean;

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

@@ -6,7 +6,7 @@ import type { CaptureSession, MemoryAction, MemoryKnowledgeSlRefsPort } from '..
 import type { PromptService } from '../prompts/index.js';
 import type { SkillsRegistryService } from '../skills/index.js';
 import type { SemanticLayerService, SlConnectionCatalogPort, SlSearchService, SlSourcesIndexPort, SlValidationDeps, SlValidatorPort } from '../sl/index.js';
-import type { ToolContext, ToolSession } from '../tools/index.js';
+import type { ToolContext, ToolSession, TouchedSlSource } from '../tools/index.js';
 import type { KnowledgeIndexPort, KnowledgeWikiService } from '../wiki/index.js';
 import type { CanonicalPin } from './canonical-pins.js';
 import type { IngestTraceLevel } from './ingest-trace.js';
@@ -281,6 +281,24 @@ export interface CuratorPaginationPort {
         warnings: string[];
     }>;
 }
+export interface IngestBundlePostProcessorInput {
+    connectionId: string;
+    sourceKey: string;
+    syncId: string;
+    jobId: string;
+    runId: string;
+    workdir: string;
+    parseArtifacts: unknown;
+}
+export interface IngestBundlePostProcessorResult {
+    result?: unknown;
+    warnings: string[];
+    errors: string[];
+    touchedSources: TouchedSlSource[];
+}
+export interface IngestBundlePostProcessorPort {
+    run(input: IngestBundlePostProcessorInput): Promise<IngestBundlePostProcessorResult>;
+}
 export interface IngestBundleRunnerDeps {
     runs: IngestRunsPort;
     provenance: IngestProvenancePort;
@@ -314,6 +332,7 @@ export interface IngestBundleRunnerDeps {
     candidateDedup?: CandidateDedupPort;
     contextCandidateCarryforward?: ContextCandidateCarryforwardPort;
     curatorPagination?: CuratorPaginationPort;
+    postProcessors?: Record<string, IngestBundlePostProcessorPort>;
     logger?: KtxLogger;
 }
 export interface IngestCaptureState {

package/node_modules/@ktx/context/dist/ingest/report-snapshot.d.ts

@@ -103,8 +103,8 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
                 }>;
                 type: z.ZodEnum<{
                     created: "created";
-                    updated: "updated";
                     removed: "removed";
+                    updated: "updated";
                 }>;
                 key: z.ZodString;
                 detail: z.ZodString;
@@ -129,8 +129,8 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
             }>;
             type: z.ZodEnum<{
                 created: "created";
-                updated: "updated";
                 removed: "removed";
+                updated: "updated";
             }>;
             key: z.ZodString;
             detail: z.ZodString;
@@ -221,77 +221,6 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
             errorCount: z.ZodNumber;
             toolNames: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>>;
-        finalization: z.ZodOptional<z.ZodObject<{
-            sourceKey: z.ZodString;
-            status: z.ZodEnum<{
-                success: "success";
-                skipped: "skipped";
-                failed: "failed";
-            }>;
-            commitSha: z.ZodNullable<z.ZodString>;
-            touchedPaths: z.ZodArray<z.ZodString>;
-            declaredTouchedSources: z.ZodArray<z.ZodObject<{
-                connectionId: z.ZodString;
-                sourceName: z.ZodString;
-            }, z.core.$strip>>;
-            derivedTouchedSources: z.ZodArray<z.ZodObject<{
-                connectionId: z.ZodString;
-                sourceName: z.ZodString;
-            }, z.core.$strip>>;
-            declaredChangedWikiPageKeys: z.ZodArray<z.ZodString>;
-            derivedChangedWikiPageKeys: z.ZodArray<z.ZodString>;
-            mismatches: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                artifactKind: z.ZodEnum<{
-                    wiki: "wiki";
-                    sl: "sl";
-                }>;
-                key: z.ZodString;
-                direction: z.ZodEnum<{
-                    missing_from_adapter_declaration: "missing_from_adapter_declaration";
-                    extra_in_adapter_declaration: "extra_in_adapter_declaration";
-                }>;
-            }, z.core.$strip>>>;
-            result: z.ZodOptional<z.ZodUnknown>;
-            errors: z.ZodArray<z.ZodString>;
-            warnings: z.ZodArray<z.ZodString>;
-            actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                target: z.ZodEnum<{
-                    wiki: "wiki";
-                    sl: "sl";
-                }>;
-                type: z.ZodEnum<{
-                    created: "created";
-                    updated: "updated";
-                    removed: "removed";
-                }>;
-                key: z.ZodString;
-                detail: z.ZodString;
-                targetConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>>;
-            provenanceExclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                action: z.ZodObject<{
-                    target: z.ZodEnum<{
-                        wiki: "wiki";
-                        sl: "sl";
-                    }>;
-                    type: z.ZodEnum<{
-                        created: "created";
-                        updated: "updated";
-                        removed: "removed";
-                    }>;
-                    key: z.ZodString;
-                    detail: z.ZodString;
-                    targetConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                    rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                }, z.core.$strip>;
-                reason: z.ZodEnum<{
-                    missing_raw_paths: "missing_raw_paths";
-                    raw_path_not_defensible: "raw_path_not_defensible";
-                }>;
-                invalidRawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
         memoryFlow: z.ZodOptional<z.ZodType<import("./index.js").MemoryFlowReplayInput, unknown, z.core.$ZodTypeInternals<import("./index.js").MemoryFlowReplayInput, unknown>>>;
     }, z.core.$loose>;
 }, z.core.$loose>;

package/node_modules/@ktx/context/dist/ingest/report-snapshot.js

@@ -114,32 +114,6 @@ const ingestReportFailureSchema = z.object({
     message: z.string().min(1),
     details: z.record(z.string(), z.unknown()).optional(),
 });
-const finalizationMismatchSchema = z.object({
-    artifactKind: z.enum(['sl', 'wiki']),
-    key: z.string().min(1),
-    direction: z.enum(['missing_from_adapter_declaration', 'extra_in_adapter_declaration']),
-});
-const finalizationProvenanceExclusionSchema = z.object({
-    action: ingestActionSchema,
-    reason: z.enum(['missing_raw_paths', 'raw_path_not_defensible']),
-    invalidRawPaths: z.array(z.string()).optional(),
-});
-const finalizationOutcomeSchema = z.object({
-    sourceKey: z.string().min(1),
-    status: z.enum(['success', 'failed', 'skipped']),
-    commitSha: z.string().nullable(),
-    touchedPaths: z.array(z.string()),
-    declaredTouchedSources: z.array(touchedSlSourceSchema),
-    derivedTouchedSources: z.array(touchedSlSourceSchema),
-    declaredChangedWikiPageKeys: z.array(z.string()),
-    derivedChangedWikiPageKeys: z.array(z.string()),
-    mismatches: z.array(finalizationMismatchSchema).default([]),
-    result: z.unknown().optional(),
-    errors: z.array(z.string()),
-    warnings: z.array(z.string()),
-    actions: z.array(ingestActionSchema).default([]),
-    provenanceExclusions: z.array(finalizationProvenanceExclusionSchema).default([]),
-});
 export const ingestReportSnapshotSchema = z
     .object({
     id: z.string().min(1),
@@ -197,7 +171,6 @@ export const ingestReportSnapshotSchema = z
         overrideOf: z.string().nullable().default(null),
         provenanceRows: z.array(provenanceDetailSchema).default([]),
         toolTranscripts: z.array(toolTranscriptSummarySchema).default([]),
-        finalization: finalizationOutcomeSchema.optional(),
         memoryFlow: memoryFlowReplayInputSchema.optional(),
     })
         .passthrough(),