@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/stages/stage-3-work-units.test.js

@@ -1,175 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { addTouchedSlSource, createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { executeWorkUnit } from './stage-3-work-units.js';
-const makeWu = (overrides = {}) => ({
-    unitKey: 'u1',
-    rawFiles: ['a.yml'],
-    peerFileIndex: [],
-    dependencyPaths: [],
-    ...overrides,
-});
-const makeDeps = () => {
-    const session = {
-        userId: 'system',
-        chatId: 'u1',
-        userMessage: '',
-        connectionId: 'c1',
-        userScopedEnabled: false,
-        forceGlobalScope: true,
-        touchedSlSources: createTouchedSlSources(),
-        preHead: null,
-    };
-    const sessionActions = [];
-    return {
-        sessionWorktreeGit: { revParseHead: vi.fn() },
-        agentRunner: { runLoop: vi.fn() },
-        validateTouchedSources: vi.fn().mockResolvedValue({ validSources: [], invalidSources: [] }),
-        resetHardTo: vi.fn(),
-        buildSystemPrompt: () => 'sys',
-        buildUserPrompt: () => 'usr',
-        buildToolSet: () => ({ noop: { description: 'x', inputSchema: {}, execute: vi.fn() } }),
-        captureSession: session,
-        sessionActions,
-        modelRole: 'candidateExtraction',
-        stepBudget: 40,
-        sourceKey: 'fake',
-        connectionId: 'c1',
-        jobId: 'j1',
-    };
-};
-describe('Stage 3 — executeWorkUnit', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('clean path — no touched sources, passes through as success with empty actions', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.preSha).toBe('pre');
-        expect(outcome.postSha).toBe('post');
-        expect(outcome.actions).toEqual([]);
-        expect(deps.validateTouchedSources).not.toHaveBeenCalled();
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-        expect(deps.agentRunner.runLoop).toHaveBeenCalledWith(expect.objectContaining({ modelRole: 'candidateExtraction' }));
-    });
-    it('validates touched sources and passes through as success when all are valid', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_good', detail: '' });
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_good');
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateTouchedSources = vi.fn().mockResolvedValue({ validSources: ['c1:src_good'], invalidSources: [] });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.actions.map((a) => a.key)).toEqual(['src_good']);
-        expect(outcome.touchedSlSources).toEqual([{ connectionId: 'c1', sourceName: 'src_good' }]);
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('any invalid source resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_bad', detail: '' });
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_good', detail: '' });
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_bad');
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_good');
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateTouchedSources = vi
-            .fn()
-            .mockResolvedValue({ validSources: ['c1:src_good'], invalidSources: ['c1:src_bad'] });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/src_bad/);
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('runner loop error resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'error', error: new Error('LLM down') });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/LLM down/);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('tool failures reset to the pre-WU SHA and mark WU failed even when the loop ends naturally', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        deps.toolFailureCount = vi.fn().mockReturnValue(2);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toContain('2 tool call(s) failed');
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('dangling wiki refs reset to the pre-WU SHA and mark WU failed after the agent loop', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-a', detail: 'Page A' });
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateWikiRefs = vi.fn().mockResolvedValue(['page-a -> page-b']);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toContain('wiki references target missing page(s): page-a -> page-b');
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('resolved wiki refs pass post-WU validation and preserve actions', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-a', detail: 'Page A' });
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-b', detail: 'Page B' });
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateWikiRefs = vi.fn().mockResolvedValue([]);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.actions.map((action) => action.key)).toEqual(['page-a', 'page-b']);
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('runner loop thrown exception resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockRejectedValue(new Error('provider disconnected'));
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome).toMatchObject({
-            unitKey: 'u1',
-            status: 'failed',
-            reason: 'provider disconnected',
-            preSha: 'pre',
-            postSha: 'post',
-            actions: [],
-            touchedSlSources: [],
-        });
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('fails before model execution when the assembled prompt is too large', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValue('pre');
-        deps.buildSystemPrompt = () => 'sys';
-        deps.buildUserPrompt = () => 'x'.repeat(260_000);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/prompt too large/i);
-        expect(deps.agentRunner.runLoop).not.toHaveBeenCalled();
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('no commits made during WU — skips resetHardTo even on runner error', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('same').mockResolvedValueOnce('same');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'error', error: new Error('bail') });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-});

package/dist/context/ingest/stages/stage-4-reconciliation.test.d.ts

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

package/dist/context/ingest/stages/stage-4-reconciliation.test.js

@@ -1,144 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { runReconciliationStage4 } from './stage-4-reconciliation.js';
-describe('Stage 4 — runReconciliationStage4', () => {
-    it('short-circuits when stage index is empty and eviction is empty', async () => {
-        const runLoop = vi.fn();
-        const result = await runReconciliationStage4({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-            evictionUnit: undefined,
-            agentRunner: { runLoop },
-            buildSystemPrompt: () => 's',
-            buildUserPrompt: () => 'u',
-            buildToolSet: () => ({}),
-            modelRole: 'reconcile',
-            stepBudget: 60,
-            sourceKey: 'fake',
-            jobId: 'j1',
-        });
-        expect(result.skipped).toBe(true);
-        expect(runLoop).not.toHaveBeenCalled();
-    });
-    it('invokes the agent when any WU wrote actions', async () => {
-        const runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        const result = await runReconciliationStage4({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [
-                    {
-                        unitKey: 'u1',
-                        rawFiles: ['a.yml'],
-                        status: 'success',
-                        actions: [{ target: 'sl', type: 'created', key: 'src_a', detail: 'x' }],
-                        touchedSlSources: [{ connectionId: 'c1', sourceName: 'src_a' }],
-                    },
-                ],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-            evictionUnit: undefined,
-            agentRunner: { runLoop },
-            buildSystemPrompt: () => 's',
-            buildUserPrompt: () => 'u',
-            buildToolSet: () => ({}),
-            modelRole: 'reconcile',
-            stepBudget: 60,
-            sourceKey: 'fake',
-            jobId: 'j1',
-        });
-        expect(result.skipped).toBe(false);
-        expect(runLoop).toHaveBeenCalledOnce();
-        expect(runLoop).toHaveBeenCalledWith(expect.objectContaining({ modelRole: 'reconcile' }));
-    });
-    it('invokes the agent when eviction set is non-empty even with no writes', async () => {
-        const runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        const result = await runReconciliationStage4({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-            evictionUnit: { deletedRawPaths: ['views/old.lkml'] },
-            agentRunner: { runLoop },
-            buildSystemPrompt: () => 's',
-            buildUserPrompt: () => 'u',
-            buildToolSet: () => ({}),
-            modelRole: 'reconcile',
-            stepBudget: 60,
-            sourceKey: 'fake',
-            jobId: 'j1',
-        });
-        expect(result.skipped).toBe(false);
-        expect(runLoop).toHaveBeenCalledOnce();
-    });
-    it('invokes the agent when forced for candidate reconciliation', async () => {
-        const runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        const result = await runReconciliationStage4({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-            evictionUnit: undefined,
-            agentRunner: { runLoop },
-            buildSystemPrompt: () => 's',
-            buildUserPrompt: () => 'u',
-            buildToolSet: () => ({}),
-            modelRole: 'reconcile',
-            stepBudget: 60,
-            sourceKey: 'fake',
-            jobId: 'j1',
-            forceRun: true,
-        });
-        expect(result.skipped).toBe(false);
-        expect(runLoop).toHaveBeenCalledOnce();
-    });
-    it('returns stopReason on runner error', async () => {
-        const err = new Error('LLM timeout');
-        const runLoop = vi.fn().mockResolvedValue({ stopReason: 'error', error: err });
-        const result = await runReconciliationStage4({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [
-                    {
-                        unitKey: 'u1',
-                        rawFiles: [],
-                        status: 'success',
-                        actions: [{ target: 'sl', type: 'created', key: 'k', detail: 'd' }],
-                        touchedSlSources: [],
-                    },
-                ],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-            evictionUnit: undefined,
-            agentRunner: { runLoop },
-            buildSystemPrompt: () => 's',
-            buildUserPrompt: () => 'u',
-            buildToolSet: () => ({}),
-            modelRole: 'reconcile',
-            stepBudget: 60,
-            sourceKey: 'fake',
-            jobId: 'j1',
-        });
-        expect(result.skipped).toBe(false);
-        expect(result.stopReason).toBe('error');
-        expect(result.error).toBe(err);
-    });
-});

package/dist/context/ingest/stages/validate-wu-sources.test.d.ts

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

package/dist/context/ingest/stages/validate-wu-sources.test.js

@@ -1,27 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { validateWuTouchedSources } from './validate-wu-sources.js';
-describe('validateWuTouchedSources', () => {
-    it('validates each touched source against its own connection', async () => {
-        const validateSingleSource = vi
-            .fn()
-            .mockImplementation((_deps, conn, name) => Promise.resolve(conn === 'warehouse-a' && name === 'good'
-            ? { errors: [], warnings: [] }
-            : { errors: ['invalid measure'], warnings: [] }));
-        const deps = { slValidator: { validateSingleSource } };
-        const result = await validateWuTouchedSources(deps, [
-            { connectionId: 'warehouse-a', sourceName: 'good' },
-            { connectionId: 'warehouse-b', sourceName: 'bad' },
-        ]);
-        expect(result.validSources).toEqual(['warehouse-a:good']);
-        expect(result.invalidSources).toEqual(['warehouse-b:bad']);
-        expect(validateSingleSource).toHaveBeenNthCalledWith(1, deps, 'warehouse-a', 'good');
-        expect(validateSingleSource).toHaveBeenNthCalledWith(2, deps, 'warehouse-b', 'bad');
-    });
-    it('returns empty arrays when no sources are touched', async () => {
-        const validateSingleSource = vi.fn();
-        const deps = { slValidator: { validateSingleSource } };
-        const result = await validateWuTouchedSources(deps, []);
-        expect(result).toEqual({ validSources: [], invalidSources: [] });
-        expect(validateSingleSource).not.toHaveBeenCalled();
-    });
-});

package/dist/context/ingest/tools/emit-reconciliation-records.tool.test.d.ts

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

package/dist/context/ingest/tools/emit-reconciliation-records.tool.test.js

@@ -1,237 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createEmitArtifactResolutionTool } from './emit-artifact-resolution.tool.js';
-import { createEmitConflictResolutionTool } from './emit-conflict-resolution.tool.js';
-import { createEmitEvictionDecisionTool } from './emit-eviction-decision.tool.js';
-import { createEmitUnmappedFallbackTool } from './emit-unmapped-fallback.tool.js';
-function makeStageIndex() {
-    return {
-        jobId: 'job-1',
-        connectionId: 'c1',
-        workUnits: [],
-        conflictsResolved: [],
-        evictionsApplied: [],
-        unmappedFallbacks: [],
-    };
-}
-async function executeTool(tool, input) {
-    if (!tool.execute) {
-        throw new Error('tool is not executable');
-    }
-    return (await tool.execute(input, { toolCallId: 'tool-call-1', messages: [] }));
-}
-describe('reconciliation emit tools', () => {
-    it('records conflict resolutions on the shared stage index', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitConflictResolutionTool({ stageIndex });
-        const output = await executeTool(tool, {
-            unitKey: 'wu-orders',
-            kind: 'near_duplicate',
-            contestedKey: 'gross_revenue',
-            artifactKey: 'sl:orders.gross_revenue',
-            detail: 'orders and order_facts compute the same revenue metric; retained orders as canonical',
-            flaggedForHuman: true,
-        });
-        expect(stageIndex.conflictsResolved).toEqual([
-            {
-                unitKey: 'wu-orders',
-                kind: 'near_duplicate',
-                contestedKey: 'gross_revenue',
-                artifactKey: 'sl:orders.gross_revenue',
-                detail: 'orders and order_facts compute the same revenue metric; retained orders as canonical',
-                flaggedForHuman: true,
-            },
-        ]);
-        expect(output).toBe('recorded conflict resolution for sl:orders.gross_revenue');
-    });
-    it('records eviction decisions only for deleted raw paths in the current eviction set', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitEvictionDecisionTool({
-            stageIndex,
-            deletedRawPaths: ['views/old_orders.view.lkml'],
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'views/old_orders.view.lkml',
-            artifactKind: 'sl',
-            artifactKey: 'old_orders',
-            action: 'removed',
-            reason: 'source raw file was deleted and no retained artifacts are required',
-        });
-        expect(output).toContain('recorded eviction decision for views/old_orders.view.lkml');
-        expect(stageIndex.evictionsApplied).toEqual([
-            {
-                rawPath: 'views/old_orders.view.lkml',
-                artifactKind: 'sl',
-                artifactKey: 'old_orders',
-                action: 'removed',
-                reason: 'source raw file was deleted and no retained artifacts are required',
-            },
-        ]);
-    });
-    it('updates an existing eviction decision for the same raw path and artifact', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitEvictionDecisionTool({
-            stageIndex,
-            deletedRawPaths: ['views/old_orders.view.lkml'],
-        });
-        await executeTool(tool, {
-            rawPath: 'views/old_orders.view.lkml',
-            artifactKind: 'wiki',
-            artifactKey: 'orders/old',
-            action: 'removed',
-            reason: 'first pass',
-        });
-        await executeTool(tool, {
-            rawPath: 'views/old_orders.view.lkml',
-            artifactKind: 'wiki',
-            artifactKey: 'orders/old',
-            action: 'removed',
-            reason: 'second pass after checking references',
-        });
-        expect(stageIndex.evictionsApplied).toEqual([
-            {
-                rawPath: 'views/old_orders.view.lkml',
-                artifactKind: 'wiki',
-                artifactKey: 'orders/old',
-                action: 'removed',
-                reason: 'second pass after checking references',
-            },
-        ]);
-    });
-    it('rejects eviction decisions for raw paths outside the current eviction set', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitEvictionDecisionTool({
-            stageIndex,
-            deletedRawPaths: ['views/old_orders.view.lkml'],
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'views/not_deleted.view.lkml',
-            artifactKind: 'sl',
-            artifactKey: 'not_deleted',
-            action: 'removed',
-            reason: 'bad input',
-        });
-        expect(output).toContain('Error: rawPath "views/not_deleted.view.lkml" is not in the current eviction set');
-        expect(stageIndex.evictionsApplied).toEqual([]);
-    });
-    it('records unmapped fallback decisions for allowed raw paths', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitUnmappedFallbackTool({
-            stageIndex,
-            allowedPaths: new Set(['metrics/conversion.yml']),
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'metrics/conversion.yml',
-            reason: 'no_physical_table',
-            fallback: 'flagged',
-        });
-        expect(output).toContain('recorded unmapped fallback for metrics/conversion.yml');
-        expect(stageIndex.unmappedFallbacks).toEqual([
-            {
-                rawPath: 'metrics/conversion.yml',
-                reason: 'no_physical_table',
-                detail: expect.stringContaining('not present as a source'),
-                fallback: 'flagged',
-            },
-        ]);
-    });
-    it('deduplicates identical unmapped fallback decisions', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitUnmappedFallbackTool({
-            stageIndex,
-            allowedPaths: new Set(['metrics/conversion.yml']),
-        });
-        await executeTool(tool, {
-            rawPath: 'metrics/conversion.yml',
-            reason: 'no_physical_table',
-            fallback: 'flagged',
-        });
-        await executeTool(tool, {
-            rawPath: 'metrics/conversion.yml',
-            reason: 'no_physical_table',
-            fallback: 'flagged',
-        });
-        expect(stageIndex.unmappedFallbacks).toEqual([
-            {
-                rawPath: 'metrics/conversion.yml',
-                reason: 'no_physical_table',
-                detail: expect.stringContaining('not present as a source'),
-                fallback: 'flagged',
-            },
-        ]);
-    });
-    it('records MetricFlow-specific unsupported fallback reasons', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitUnmappedFallbackTool({
-            stageIndex,
-            allowedPaths: new Set(['metrics/conversion.yml']),
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'metrics/conversion.yml',
-            reason: 'conversion_metric_unsupported',
-            fallback: 'flagged',
-        });
-        expect(output).toContain('conversion metric');
-        expect(stageIndex.unmappedFallbacks).toEqual([
-            {
-                rawPath: 'metrics/conversion.yml',
-                reason: 'conversion_metric_unsupported',
-                detail: expect.stringContaining('conversion metric'),
-                fallback: 'flagged',
-            },
-        ]);
-    });
-    it('rejects unmapped fallback decisions for raw paths outside the allowed set', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitUnmappedFallbackTool({
-            stageIndex,
-            allowedPaths: new Set(['metrics/conversion.yml']),
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'metrics/not-in-this-work-unit.yml',
-            reason: 'no_physical_table',
-            fallback: 'flagged',
-        });
-        expect(output).toContain('Error: rawPath "metrics/not-in-this-work-unit.yml" is not available to this ingest stage');
-        expect(stageIndex.unmappedFallbacks).toEqual([]);
-    });
-    it('rejects missing-table fallback decisions when the table resolves to an existing semantic source', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitUnmappedFallbackTool({
-            stageIndex,
-            allowedPaths: new Set(['cards/revenue.json']),
-            tableRefExists: async (tableRef) => tableRef === 'orbit_analytics.mart_revenue_daily',
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'cards/revenue.json',
-            reason: 'no_physical_table',
-            tableRef: 'orbit_analytics.mart_revenue_daily',
-            fallback: 'wiki_only',
-        });
-        expect(output).toContain('Error: tableRef "orbit_analytics.mart_revenue_daily" already resolves to a semantic source');
-        expect(stageIndex.unmappedFallbacks).toEqual([]);
-    });
-    it('records explicit artifact resolutions for provenance rows', async () => {
-        const stageIndex = makeStageIndex();
-        const tool = createEmitArtifactResolutionTool({
-            stageIndex,
-            allowedPaths: new Set(['explores/b2b/sales_pipeline.json']),
-        });
-        const output = await executeTool(tool, {
-            rawPath: 'explores/b2b/sales_pipeline.json',
-            artifactKind: 'sl',
-            artifactKey: 'looker__b2b__sales_pipeline',
-            actionType: 'subsumed',
-            reason: 'File-adapter source b2b__sales_pipeline is canonical for this explore.',
-        });
-        expect(output).toBe('recorded artifact resolution for sl:looker__b2b__sales_pipeline');
-        expect(stageIndex.artifactResolutions).toEqual([
-            {
-                rawPath: 'explores/b2b/sales_pipeline.json',
-                artifactKind: 'sl',
-                artifactKey: 'looker__b2b__sales_pipeline',
-                actionType: 'subsumed',
-                reason: 'File-adapter source b2b__sales_pipeline is canonical for this explore.',
-            },
-        ]);
-    });
-});

package/dist/context/ingest/tools/eviction-list.tool.test.d.ts

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

package/dist/context/ingest/tools/eviction-list.tool.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createEvictionListTool } from './eviction-list.tool.js';
-describe('eviction_list tool', () => {
-    it('returns artifacts produced for each deleted raw path', async () => {
-        const provenance = {
-            findLatestArtifactsForRawPaths: vi.fn().mockResolvedValue(new Map([
-                [
-                    'views/old.lkml',
-                    [{ artifact_kind: 'sl', artifact_key: 'old_metric', action_type: 'source_created' }],
-                ],
-                ['views/gone.lkml', []],
-            ])),
-        };
-        const tool = createEvictionListTool({
-            provenance: provenance,
-            connectionId: 'c1',
-            sourceKey: 'lookml',
-            deletedRawPaths: ['views/old.lkml', 'views/gone.lkml'],
-        });
-        const out = (await tool.execute({}, { toolCallId: 't', messages: [] }));
-        expect(out).toContain('views/old.lkml');
-        expect(out).toContain('old_metric');
-        expect(out).toContain('views/gone.lkml');
-    });
-    it('returns empty string when no deletions', async () => {
-        const tool = createEvictionListTool({
-            provenance: {},
-            connectionId: 'c1',
-            sourceKey: 'lookml',
-            deletedRawPaths: [],
-        });
-        const out = (await tool.execute({}, { toolCallId: 't', messages: [] }));
-        expect(out).toMatch(/empty/i);
-    });
-    it('tells curators to record decisions', () => {
-        const tool = createEvictionListTool({
-            provenance: {},
-            connectionId: 'c1',
-            sourceKey: 'lookml',
-            deletedRawPaths: [],
-        });
-        expect(tool.description).toContain('emit_eviction_decision');
-    });
-});

package/dist/context/ingest/tools/read-raw-file.tool.test.d.ts

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