@kaelio/ktx 0.2.0 → 0.4.0

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

@@ -85,6 +85,7 @@ 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: [] }],
         }),
@@ -121,6 +122,7 @@ const makeDeps = () => {
         }),
         applyPatchFile3WayIndex: vi.fn(),
         diffNameStatus: vi.fn().mockResolvedValue([]),
+        changedPaths: vi.fn().mockResolvedValue([]),
     };
     const sessionWorktreeService = {
         create: vi.fn().mockResolvedValue({
@@ -1344,25 +1346,65 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             }),
         }));
     });
-    it('runs a registered post-processor before squash, records the outcome, and reindexes touched sources after squash', async () => {
+    it('runs adapter finalization before squash, records the outcome, and reindexes touched sources', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'metricflow';
         deps.registry.get.mockReturnValue(deps.adapter);
         deps.adapter.chunk.mockResolvedValue({
-            workUnits: [{ unitKey: 'u1', rawFiles: ['semantic_models.yml'], peerFileIndex: [], dependencyPaths: [] }],
+            workUnits: [],
             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: [] }));
-        const postProcessor = {
-            run: vi.fn().mockResolvedValue({
-                result: { sourcesCreated: 1 },
-                warnings: ['kept going'],
-                errors: [],
-                touchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
+        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');
             }),
+            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']),
         };
-        const runner = buildRunner(deps, { postProcessors: { metricflow: postProcessor } });
+        deps.sessionWorktreeService.create.mockResolvedValue({
+            chatId: 'j1',
+            workdir: '/tmp/wt',
+            branch: 'session/j1',
+            baseSha: 'b',
+            createdAt: new Date(),
+            git,
+            config: {},
+        });
+        const runner = buildRunner(deps);
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['semantic_models.yml', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/metricflow/s',
@@ -1375,7 +1417,7 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             trigger: 'upload',
             bundleRef: { kind: 'upload', uploadId: 'upload-x' },
         });
-        expect(postProcessor.run).toHaveBeenCalledWith({
+        expect(deps.adapter.finalize).toHaveBeenCalledWith(expect.objectContaining({
             connectionId: 'c1',
             sourceKey: 'metricflow',
             syncId: expect.any(String),
@@ -1383,24 +1425,25 @@ 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({
-                postProcessor: {
+                finalization: expect.objectContaining({
                     sourceKey: 'metricflow',
                     status: 'success',
-                    result: { sourcesCreated: 1 },
-                    warnings: ['kept going'],
-                    errors: [],
-                    touchedSources: [{ connectionId: 'warehouse-2', sourceName: 'orders' }],
-                },
+                    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' })],
+                }),
             }),
         }));
         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 historic-sql post-processor output in memory-flow saved counts', async () => {
+    it('includes finalization actions in memory-flow saved counts', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'historic-sql';
         deps.registry.get.mockReturnValue(deps.adapter);
@@ -1414,21 +1457,19 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
                 },
             ],
         });
-        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 } });
+        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);
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['tables/public/orders.json', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/historic-sql/s',
@@ -1448,11 +1489,11 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
         });
         expect(memoryFlow.snapshot().events).toContainEqual(expect.objectContaining({
             type: 'saved',
-            wikiCount: 5,
-            slCount: 3,
+            wikiCount: 2,
+            slCount: 2,
         }));
     });
-    it('marks post-processor infrastructure failure as failed and preserves worktree cleanup state', async () => {
+    it('marks finalization infrastructure failure as failed and preserves worktree cleanup state', async () => {
         const deps = makeDeps();
         deps.adapter.source = 'metricflow';
         deps.registry.get.mockReturnValue(deps.adapter);
@@ -1460,8 +1501,8 @@ describe('IngestBundleRunner — Stages 1 → 7', () => {
             workUnits: [{ unitKey: 'u1', rawFiles: ['semantic_models.yml'], peerFileIndex: [], dependencyPaths: [] }],
             parseArtifacts: { semanticModels: [{ name: 'orders' }] },
         });
-        const postProcessor = { run: vi.fn().mockRejectedValue(new Error('worktree write failed')) };
-        const runner = buildRunner(deps, { postProcessors: { metricflow: postProcessor } });
+        deps.adapter.finalize = vi.fn().mockRejectedValue(new Error('worktree write failed'));
+        const runner = buildRunner(deps);
         runner.stageRawFilesStage1 = vi.fn().mockResolvedValue({
             currentHashes: new Map([['semantic_models.yml', 'h1']]),
             rawDirInWorktree: 'raw-sources/c1/metricflow/s',
@@ -1478,6 +1519,120 @@ 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,6 +7,7 @@ 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';
@@ -159,6 +160,23 @@ 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 = {
@@ -426,7 +444,7 @@ describe('canonical local ingest', () => {
             },
         ]);
     });
-    it('runs historic-SQL evidence projection through the local bundle post-processor', async () => {
+    it('runs historic-SQL evidence projection through local bundle finalization', async () => {
         const projectDir = join(tempDir, 'historic-sql-project');
         await initKtxProject({ projectDir });
         await writeFile(join(projectDir, 'ktx.yaml'), [
@@ -477,11 +495,12 @@ describe('canonical local ingest', () => {
             agentRunner,
         });
         expect(result.result.failedWorkUnits).toEqual([]);
-        expect(result.report.body.postProcessor).toMatchObject({
+        expect(result.report.body.finalization).toMatchObject({
             sourceKey: 'historic-sql',
             status: 'success',
             result: { tableUsageMerged: 1 },
-            touchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            declaredTouchedSources: [{ connectionId: 'warehouse', sourceName: 'orders' }],
+            derivedTouchedSources: [{ 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,7 +13,6 @@ 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';
@@ -589,9 +588,6 @@ 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,13 +178,6 @@ 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/local-stage-ingest.js

@@ -117,6 +117,11 @@ async function pruneStaleRawFiles(input) {
     }
     return staleRawPaths;
 }
+async function rawSnapshotContainsFiles(project, rawPrefix, relativeFiles) {
+    const existing = await project.fileStore.listFiles(rawPrefix);
+    const existingFiles = new Set(existing.files);
+    return relativeFiles.every((file) => existingFiles.has(`${rawPrefix}/${file}`));
+}
 async function prepareLocalStagedDir(project, adapter, stagedDir, sourceDir, connectionId) {
     await rm(stagedDir, { recursive: true, force: true });
     await mkdir(stagedDir, { recursive: true });
@@ -184,12 +189,17 @@ async function runLocalStageOnlyIngestInner(options) {
     const scopeDescriptor = adapter.describeScope ? await adapter.describeScope(stagedDir) : null;
     options.memoryFlow?.emit({ type: 'scope_detected', fingerprint: scopeDescriptor?.fingerprint ?? null });
     const diffSet = computeDiffSetFromHashes(hashes, priorHashes, scopeDescriptor ? scopeDescriptor.isPathInScope.bind(scopeDescriptor) : undefined);
-    const unchangedFromLatestCompletedRun = !existingRun &&
+    const matchesLatestCompletedRun = !existingRun &&
         !!latestReport &&
         diffSet.added.length === 0 &&
         diffSet.modified.length === 0 &&
         diffSet.deleted.length === 0;
-    const syncId = existingRun?.syncId ?? (unchangedFromLatestCompletedRun ? latestReport.syncId : buildSyncId(started, jobId));
+    const reusableLatestSyncId = matchesLatestCompletedRun ? latestReport.syncId : null;
+    const latestRawPrefix = reusableLatestSyncId
+        ? `raw-sources/${connectionId}/${adapter.source}/${reusableLatestSyncId}`
+        : null;
+    const canReuseLatestCompletedRun = latestRawPrefix !== null && (await rawSnapshotContainsFiles(options.project, latestRawPrefix, relativeFiles));
+    const syncId = existingRun?.syncId ?? (canReuseLatestCompletedRun && reusableLatestSyncId ? reusableLatestSyncId : buildSyncId(started, jobId));
     options.memoryFlow?.update({ syncId });
     options.memoryFlow?.emit({ type: 'raw_snapshot_written', syncId, rawFileCount: relativeFiles.length });
     options.memoryFlow?.emit({
@@ -209,7 +219,7 @@ async function runLocalStageOnlyIngestInner(options) {
     });
     const rawPrefix = `raw-sources/${connectionId}/${adapter.source}/${syncId}`;
     const rawPaths = relativeFiles.map((file) => `${rawPrefix}/${file}`);
-    const staleRawPaths = options.dryRun || unchangedFromLatestCompletedRun
+    const staleRawPaths = options.dryRun || canReuseLatestCompletedRun
         ? []
         : await pruneStaleRawFiles({
             project: options.project,
@@ -220,7 +230,7 @@ async function runLocalStageOnlyIngestInner(options) {
     for (const file of relativeFiles) {
         const absolutePath = assertInside(stagedDir, join(stagedDir, file));
         const rawPath = `${rawPrefix}/${file}`;
-        if (!options.dryRun && !unchangedFromLatestCompletedRun) {
+        if (!options.dryRun && !canReuseLatestCompletedRun) {
             await options.project.fileStore.writeFile(rawPath, await readFile(absolutePath, 'utf-8'), LOCAL_AUTHOR, LOCAL_AUTHOR_EMAIL, `Stage ${adapter.source} raw file: ${file}`, { skipLock: true });
         }
     }
@@ -266,7 +276,7 @@ async function runLocalStageOnlyIngestInner(options) {
             record,
             rawContentHashes: Object.fromEntries(hashes),
         });
-        const commitPaths = unchangedFromLatestCompletedRun ? [] : [...rawPaths, ...staleRawPaths].sort();
+        const commitPaths = canReuseLatestCompletedRun ? [] : [...rawPaths, ...staleRawPaths].sort();
         if (commitPaths.length > 0) {
             await options.project.git.commitFiles(commitPaths, `ingest(${adapter.source}): ${jobId} syncId=${syncId}`, LOCAL_AUTHOR, LOCAL_AUTHOR_EMAIL);
         }

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

@@ -277,6 +277,35 @@ describe('local ingest', () => {
         await expect(readFile(join(project.projectDir, '.ktx', 'ingest-runs', 'local-job-3.json'), 'utf-8')).rejects.toThrow();
         await expect(readFile(join(project.projectDir, '.ktx', 'ingest-reports', 'local-job-3.json'), 'utf-8')).rejects.toThrow();
     });
+    it('writes a new raw snapshot when an unchanged latest snapshot is missing from disk', async () => {
+        const sourceDir = join(tempDir, 'missing-snapshot-source');
+        await mkdir(join(sourceDir, 'orders'), { recursive: true });
+        await writeFile(join(sourceDir, 'orders', 'orders.json'), '{"name":"orders","version":1}\n', 'utf-8');
+        const first = await runLocalStageOnlyIngest({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            adapter: 'fake',
+            connectionId: 'warehouse',
+            sourceDir,
+            jobId: 'local-missing-snapshot-1',
+            now: () => new Date('2026-04-27T12:20:00.000Z'),
+        });
+        await rm(join(project.projectDir, 'raw-sources/warehouse/fake', first.syncId), { recursive: true, force: true });
+        const rerun = await runLocalStageOnlyIngest({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            adapter: 'fake',
+            connectionId: 'warehouse',
+            sourceDir,
+            jobId: 'local-missing-snapshot-2',
+            now: () => new Date('2026-04-27T12:25:00.000Z'),
+        });
+        expect(rerun.previousRunId).toBe(first.runId);
+        expect(rerun.syncId).toBe('2026-04-27-122500-local-missing-snapshot-2');
+        expect(rerun.diffSummary).toEqual({ added: 0, modified: 0, deleted: 0, unchanged: 1 });
+        expect(rerun.workUnitCount).toBe(0);
+        await expect(readFile(join(project.projectDir, 'raw-sources/warehouse/fake', rerun.syncId, 'orders/orders.json'), 'utf-8')).resolves.toBe('{"name":"orders","version":1}\n');
+    });
     it('reuses the existing sync id when the same local run id is retried', async () => {
         const sourceDir = join(tempDir, 'idempotent-source');
         await mkdir(join(sourceDir, 'orders'), { recursive: true });

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";
-        actions: "actions";
         chunks: "chunks";
+        actions: "actions";
         gates: "gates";
         saved: "saved";
     }>;
@@ -58,7 +58,7 @@ export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         report: "report";
         integration: "integration";
         reconciliation: "reconciliation";
-        post_processor: "post_processor";
+        finalization: "finalization";
         wiki_sl_ref_repair: "wiki_sl_ref_repair";
         final_gates: "final_gates";
         save: "save";

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

@@ -53,7 +53,7 @@ export const memoryFlowEventSchema = z.discriminatedUnion('type', [
             'source',
             'integration',
             'reconciliation',
-            'post_processor',
+            'finalization',
             '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' | 'post_processor' | 'wiki_sl_ref_repair' | 'final_gates' | 'save' | 'provenance' | 'report';
+    stage: 'source' | 'integration' | 'reconciliation' | 'finalization' | '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, TouchedSlSource } from '../tools/index.js';
+import type { ToolContext, ToolSession } 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,24 +281,6 @@ 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;
@@ -332,7 +314,6 @@ export interface IngestBundleRunnerDeps {
     candidateDedup?: CandidateDedupPort;
     contextCandidateCarryforward?: ContextCandidateCarryforwardPort;
     curatorPagination?: CuratorPaginationPort;
-    postProcessors?: Record<string, IngestBundlePostProcessorPort>;
     logger?: KtxLogger;
 }
 export interface IngestCaptureState {