@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/ingest/context-candidates/candidate-dedup.service.test.js

@@ -1,216 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CandidateDedupService } from './candidate-dedup.service.js';
-const vector = (...values) => JSON.stringify(values);
-const candidate = (overrides) => ({
-    id: `${overrides.candidateKey}-id`,
-    candidateKey: overrides.candidateKey,
-    topic: overrides.topic ?? overrides.candidateKey,
-    assertion: overrides.assertion ?? `Assertion for ${overrides.candidateKey}`,
-    promotionScore: overrides.promotionScore ?? 1,
-    createdAt: overrides.createdAt ?? new Date('2026-04-29T10:00:00.000Z'),
-    evidenceChunkIds: overrides.evidenceChunkIds ?? [],
-    evidenceRefs: overrides.evidenceRefs ?? [],
-    embedding: 'embedding' in overrides ? (overrides.embedding ?? null) : vector(1, 0, 0),
-    lane: overrides.lane ?? null,
-});
-function buildHarness(overrides = {}) {
-    const store = {
-        listPendingCandidatesForDedup: vi.fn().mockResolvedValue(overrides.candidates ?? []),
-        updateCandidateEmbedding: vi.fn().mockResolvedValue(undefined),
-        markCandidatesAsMergedToCluster: vi.fn().mockResolvedValue(undefined),
-        listBudgetExhaustedCandidatesForCarryForward: vi.fn(),
-        listCurrentRunEvidenceChunksForCarryForward: vi.fn(),
-        insertCandidate: vi.fn(),
-    };
-    const embeddings = {
-        maxBatchSize: 100,
-        computeEmbedding: vi.fn(),
-        computeEmbeddingsBulk: vi.fn(),
-    };
-    const service = new CandidateDedupService({
-        store: store,
-        embeddings: embeddings,
-        settings: {
-            enabled: overrides.enabled ?? true,
-            topicSimilarityThreshold: overrides.threshold ?? 0.85,
-            scoreAggregation: overrides.scoreAggregation ?? 'max',
-        },
-    });
-    return { service, store, embeddings };
-}
-describe('CandidateDedupService', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('returns raw representatives without writes when dedup is disabled', async () => {
-        const first = candidate({ candidateKey: 'first', embedding: vector(1, 0, 0) });
-        const duplicate = candidate({ candidateKey: 'duplicate', embedding: vector(0.99, 0.01, 0) });
-        const { service, store, embeddings } = buildHarness({
-            enabled: false,
-            candidates: [first, duplicate],
-        });
-        const result = await service.deduplicateRun('run-1');
-        expect(result).toMatchObject({
-            enabled: false,
-            candidatesIn: 2,
-            clustersOut: 2,
-            mergedCount: 0,
-            largestClusterSize: 1,
-            embeddingFailures: 0,
-        });
-        expect(result.representatives.map((item) => item.candidateKey)).toEqual(['first', 'duplicate']);
-        expect(store.markCandidatesAsMergedToCluster).not.toHaveBeenCalled();
-        expect(embeddings.computeEmbeddingsBulk).not.toHaveBeenCalled();
-    });
-    it('clusters near duplicates and persists representative evidence unions', async () => {
-        const rep = candidate({
-            candidateKey: 'icp-primary',
-            topic: 'ICP',
-            assertion: 'Finance operators are the ICP.',
-            promotionScore: 11,
-            evidenceChunkIds: ['00000000-0000-0000-0000-000000000001'],
-            evidenceRefs: [{ stableCitationKey: 'icp-a', rawPath: 'pages/a/page.md' }],
-            embedding: vector(1, 0, 0),
-        });
-        const duplicate = candidate({
-            candidateKey: 'icp-duplicate',
-            topic: 'Ideal customer profile',
-            assertion: 'The ICP is finance teams.',
-            promotionScore: 7,
-            evidenceChunkIds: ['00000000-0000-0000-0000-000000000002'],
-            evidenceRefs: [{ stableCitationKey: 'icp-b', rawPath: 'pages/b/page.md' }],
-            embedding: vector(0.99, 0.02, 0),
-        });
-        const unique = candidate({
-            candidateKey: 'pricing-policy',
-            promotionScore: 6,
-            evidenceChunkIds: ['00000000-0000-0000-0000-000000000003'],
-            evidenceRefs: [{ stableCitationKey: 'price-a', rawPath: 'pages/pricing/page.md' }],
-            embedding: vector(0, 1, 0),
-        });
-        const { service, store } = buildHarness({ candidates: [rep, duplicate, unique] });
-        const result = await service.deduplicateRun('run-1');
-        expect(result).toMatchObject({
-            enabled: true,
-            candidatesIn: 3,
-            clustersOut: 2,
-            mergedCount: 1,
-            largestClusterSize: 2,
-            embeddingFailures: 0,
-        });
-        expect(result.representatives.map((item) => item.candidateKey)).toEqual(['icp-primary', 'pricing-policy']);
-        expect(store.markCandidatesAsMergedToCluster).toHaveBeenCalledWith({
-            representativeId: rep.id,
-            memberIds: [duplicate.id],
-            evidenceChunkIds: ['00000000-0000-0000-0000-000000000001', '00000000-0000-0000-0000-000000000002'],
-            evidenceRefs: [
-                { stableCitationKey: 'icp-a', rawPath: 'pages/a/page.md' },
-                { stableCitationKey: 'icp-b', rawPath: 'pages/b/page.md' },
-            ],
-            promotionScore: 11,
-        });
-    });
-    it('uses the configured similarity threshold', async () => {
-        const base = candidate({ candidateKey: 'base', embedding: vector(1, 0, 0), promotionScore: 5 });
-        const borderline = candidate({ candidateKey: 'borderline', embedding: vector(0.8, 0.6, 0), promotionScore: 4 });
-        const strict = buildHarness({ candidates: [base, borderline], threshold: 0.95 });
-        const strictResult = await strict.service.deduplicateRun('run-1');
-        expect(strictResult.clustersOut).toBe(2);
-        expect(strict.store.markCandidatesAsMergedToCluster).not.toHaveBeenCalled();
-        const loose = buildHarness({ candidates: [base, borderline], threshold: 0.75 });
-        const looseResult = await loose.service.deduplicateRun('run-1');
-        expect(looseResult.clustersOut).toBe(1);
-        expect(loose.store.markCandidatesAsMergedToCluster).toHaveBeenCalledTimes(1);
-    });
-    it('fills missing embeddings in batches and persists them before clustering', async () => {
-        const first = candidate({ candidateKey: 'missing-a', embedding: null });
-        const second = candidate({ candidateKey: 'missing-b', embedding: null });
-        const { service, store, embeddings } = buildHarness({ candidates: [first, second] });
-        embeddings.computeEmbeddingsBulk.mockResolvedValueOnce([
-            [1, 0, 0],
-            [0, 1, 0],
-        ]);
-        const result = await service.deduplicateRun('run-1');
-        expect(result.embeddingFailures).toBe(0);
-        expect(embeddings.computeEmbeddingsBulk).toHaveBeenCalledWith([
-            'missing-a - Assertion for missing-a',
-            'missing-b - Assertion for missing-b',
-        ]);
-        expect(store.updateCandidateEmbedding).toHaveBeenCalledWith(first.id, [1, 0, 0]);
-        expect(store.updateCandidateEmbedding).toHaveBeenCalledWith(second.id, [0, 1, 0]);
-    });
-    it('isolates a single embedding failure and keeps that candidate as a singleton', async () => {
-        const first = candidate({ candidateKey: 'embed-ok', embedding: null });
-        const second = candidate({ candidateKey: 'embed-fail', embedding: null });
-        const { service, store, embeddings } = buildHarness({ candidates: [first, second] });
-        embeddings.computeEmbeddingsBulk.mockRejectedValueOnce(new Error('bulk provider unavailable'));
-        embeddings.computeEmbedding
-            .mockResolvedValueOnce([1, 0, 0])
-            .mockRejectedValueOnce(new Error('single candidate failed'));
-        const result = await service.deduplicateRun('run-1');
-        expect(result.embeddingFailures).toBe(1);
-        expect(result.clustersOut).toBe(2);
-        expect(result.warnings).toEqual(expect.arrayContaining([
-            expect.stringContaining('embedding bulk failed: bulk provider unavailable; falling back to per-candidate embedding for 2 candidates'),
-            expect.stringContaining('Embedding failed for candidate embed-fail'),
-        ]));
-        expect(store.updateCandidateEmbedding).toHaveBeenCalledTimes(1);
-        expect(store.updateCandidateEmbedding).toHaveBeenCalledWith(first.id, [1, 0, 0]);
-    });
-    it('applies mean and sum score aggregation modes', async () => {
-        const rep = candidate({ candidateKey: 'score-rep', promotionScore: 9, embedding: vector(1, 0, 0) });
-        const duplicate = candidate({
-            candidateKey: 'score-duplicate',
-            promotionScore: 3,
-            embedding: vector(0.99, 0.02, 0),
-        });
-        const mean = buildHarness({ candidates: [rep, duplicate], scoreAggregation: 'mean' });
-        await mean.service.deduplicateRun('run-1');
-        expect(mean.store.markCandidatesAsMergedToCluster).toHaveBeenCalledWith(expect.objectContaining({ promotionScore: 6 }));
-        const sum = buildHarness({ candidates: [rep, duplicate], scoreAggregation: 'sum' });
-        await sum.service.deduplicateRun('run-1');
-        expect(sum.store.markCandidatesAsMergedToCluster).toHaveBeenCalledWith(expect.objectContaining({ promotionScore: 12 }));
-    });
-    it('rounds mean score aggregation for the integer promotion score column', async () => {
-        const rep = candidate({ candidateKey: 'rounded-rep', promotionScore: 10, embedding: vector(1, 0, 0) });
-        const duplicate = candidate({
-            candidateKey: 'rounded-duplicate',
-            promotionScore: 7,
-            embedding: vector(0.99, 0.02, 0),
-        });
-        const { service, store } = buildHarness({ candidates: [rep, duplicate], scoreAggregation: 'mean' });
-        await service.deduplicateRun('run-1');
-        expect(store.markCandidatesAsMergedToCluster).toHaveBeenCalledWith(expect.objectContaining({ promotionScore: 9 }));
-    });
-    it('is a no-op on a rerun after non-representatives are already merged', async () => {
-        const rep = candidate({ candidateKey: 'rerun-rep', promotionScore: 9, embedding: vector(1, 0, 0) });
-        const duplicate = candidate({
-            candidateKey: 'rerun-duplicate',
-            promotionScore: 3,
-            embedding: vector(0.99, 0.02, 0),
-        });
-        const { service, store } = buildHarness();
-        store.listPendingCandidatesForDedup.mockResolvedValueOnce([rep, duplicate]).mockResolvedValueOnce([rep]);
-        const first = await service.deduplicateRun('run-1');
-        const second = await service.deduplicateRun('run-1');
-        expect(first.mergedCount).toBe(1);
-        expect(second.mergedCount).toBe(0);
-        expect(second.clustersOut).toBe(1);
-        expect(store.markCandidatesAsMergedToCluster).toHaveBeenCalledTimes(1);
-    });
-    it('returns raw candidates with a warning when cluster persistence throws', async () => {
-        const rep = candidate({ candidateKey: 'persist-rep', promotionScore: 9, embedding: vector(1, 0, 0) });
-        const duplicate = candidate({
-            candidateKey: 'persist-duplicate',
-            promotionScore: 3,
-            embedding: vector(0.99, 0.02, 0),
-        });
-        const { service, store } = buildHarness({ candidates: [rep, duplicate] });
-        store.markCandidatesAsMergedToCluster.mockRejectedValueOnce(new Error('database unavailable'));
-        const result = await service.deduplicateRun('run-1');
-        expect(result.clustersOut).toBe(2);
-        expect(result.mergedCount).toBe(0);
-        expect(result.representatives.map((item) => item.candidateKey)).toEqual(['persist-rep', 'persist-duplicate']);
-        expect(result.warnings).toEqual([expect.stringContaining('Dedup failed for run run-1')]);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/context-candidates/context-candidate-carryforward.service.d.ts

@@ -1,31 +0,0 @@
-import { type KtxLogger } from '../../core/index.js';
-import type { ContextCandidateStorePort } from './store.js';
-import type { ContextCandidateCarryforwardSettings } from './types.js';
-export interface ContextCandidateCarryforwardArgs {
-    runId: string;
-    connectionId: string;
-    sourceKey: string;
-}
-export interface ContextCandidateCarryforwardResult {
-    considered: number;
-    carriedForward: number;
-    skippedNotReemitted: number;
-    remappedEvidenceRefs: number;
-    staleEvidenceRefs: number;
-    warnings: string[];
-}
-export interface ContextCandidateCarryforwardServiceDeps {
-    store: ContextCandidateStorePort;
-    settings: ContextCandidateCarryforwardSettings;
-    logger?: KtxLogger;
-}
-export declare class ContextCandidateCarryforwardService {
-    private readonly deps;
-    private readonly logger;
-    constructor(deps: ContextCandidateCarryforwardServiceDeps);
-    carryForward(args: ContextCandidateCarryforwardArgs): Promise<ContextCandidateCarryforwardResult>;
-    private remapEvidence;
-    private stableCitationKey;
-    private currentEvidenceRef;
-    private buildWarnings;
-}

package/node_modules/@ktx/context/dist/ingest/context-candidates/context-candidate-carryforward.service.js

@@ -1,131 +0,0 @@
-import { createHash } from 'node:crypto';
-import { noopLogger } from '../../core/index.js';
-export class ContextCandidateCarryforwardService {
-    deps;
-    logger;
-    constructor(deps) {
-        this.deps = deps;
-        this.logger = deps.logger ?? noopLogger;
-    }
-    async carryForward(args) {
-        const candidates = await this.deps.store.listBudgetExhaustedCandidatesForCarryForward({
-            connectionId: args.connectionId,
-            sourceKey: args.sourceKey,
-            currentRunId: args.runId,
-        });
-        const chunks = await this.deps.store.listCurrentRunEvidenceChunksForCarryForward(args.runId);
-        const chunksByStableKey = new Map(chunks.map((chunk) => [chunk.stableCitationKey, chunk]));
-        const allowStaleEvidence = this.deps.settings.reExamineBudgetExhaustedOnRerun;
-        let carriedForward = 0;
-        let skippedNotReemitted = 0;
-        let remappedEvidenceRefs = 0;
-        let staleEvidenceRefs = 0;
-        for (const candidate of candidates) {
-            const remap = this.remapEvidence(candidate, chunksByStableKey);
-            if (remap.remappedCount === 0 && !allowStaleEvidence) {
-                skippedNotReemitted += 1;
-                continue;
-            }
-            await this.deps.store.insertCandidate({
-                runId: args.runId,
-                connectionId: args.connectionId,
-                sourceKey: args.sourceKey,
-                candidateKey: candidate.candidateKey,
-                topic: candidate.topic,
-                assertion: candidate.assertion,
-                rationale: candidate.rationale,
-                evidenceChunkIds: remap.evidenceChunkIds,
-                evidenceRefs: remap.evidenceRefs,
-                suggestedPageKey: candidate.suggestedPageKey,
-                actionHint: candidate.actionHint,
-                durabilityScore: candidate.durabilityScore,
-                authorityScore: candidate.authorityScore,
-                reuseScore: candidate.reuseScore,
-                noveltyScore: candidate.noveltyScore,
-                riskScore: candidate.riskScore,
-                promotionScore: candidate.promotionScore,
-                status: 'pending',
-                rejectionReason: null,
-                lane: candidate.lane,
-                embedding: null,
-            });
-            carriedForward += 1;
-            remappedEvidenceRefs += remap.remappedCount;
-            staleEvidenceRefs += remap.staleCount;
-        }
-        const warnings = this.buildWarnings({ carriedForward, skippedNotReemitted, staleEvidenceRefs });
-        if (carriedForward > 0 || skippedNotReemitted > 0) {
-            this.logger.log(`Budget carryforward: considered ${candidates.length}, carried ${carriedForward}, skipped ${skippedNotReemitted}`);
-        }
-        return {
-            considered: candidates.length,
-            carriedForward,
-            skippedNotReemitted,
-            remappedEvidenceRefs,
-            staleEvidenceRefs,
-            warnings,
-        };
-    }
-    remapEvidence(candidate, chunksByStableKey) {
-        const refs = Array.isArray(candidate.evidenceRefs) ? candidate.evidenceRefs : [];
-        const remappedRefs = [];
-        const remappedChunkIds = [];
-        for (const ref of refs) {
-            const stableKey = this.stableCitationKey(ref);
-            const currentChunk = stableKey ? chunksByStableKey.get(stableKey) : undefined;
-            if (!currentChunk) {
-                continue;
-            }
-            remappedChunkIds.push(currentChunk.chunkId);
-            remappedRefs.push(this.currentEvidenceRef(currentChunk));
-        }
-        if (remappedRefs.length > 0) {
-            return {
-                evidenceChunkIds: [...new Set(remappedChunkIds)],
-                evidenceRefs: remappedRefs,
-                remappedCount: remappedRefs.length,
-                staleCount: 0,
-            };
-        }
-        return {
-            evidenceChunkIds: candidate.evidenceChunkIds,
-            evidenceRefs: candidate.evidenceRefs,
-            remappedCount: 0,
-            staleCount: refs.length,
-        };
-    }
-    stableCitationKey(ref) {
-        if (!ref || typeof ref !== 'object' || Array.isArray(ref)) {
-            return null;
-        }
-        const value = ref.stableCitationKey;
-        return typeof value === 'string' ? value : null;
-    }
-    currentEvidenceRef(chunk) {
-        return {
-            chunkId: chunk.chunkId,
-            stableCitationKey: chunk.stableCitationKey,
-            syncId: chunk.syncId,
-            rawPath: chunk.rawPath,
-            title: chunk.title,
-            path: chunk.path,
-            url: chunk.url,
-            lastEditedAt: chunk.lastEditedAt?.toISOString() ?? null,
-            snippetHash: createHash('sha256').update(chunk.content).digest('hex'),
-            citation: chunk.citation,
-        };
-    }
-    buildWarnings(params) {
-        const warnings = [];
-        if (params.carriedForward > 0) {
-            warnings.push(`Re-examined ${params.carriedForward} prior budget-exhausted context candidate${params.carriedForward === 1 ? '' : 's'}.`);
-        }
-        if (params.skippedNotReemitted > 0) {
-            warnings.push(`Skipped ${params.skippedNotReemitted} budget-exhausted context candidate${params.skippedNotReemitted === 1 ? '' : 's'} because its evidence was not re-emitted in this run.`);
-        }
-        if (params.staleEvidenceRefs > 0) {
-            warnings.push(`Carried ${params.staleEvidenceRefs} budget-exhausted evidence ref${params.staleEvidenceRefs === 1 ? '' : 's'} without a current-run chunk remap.`);
-        }
-        return warnings;
-    }
-}

package/node_modules/@ktx/context/dist/ingest/context-candidates/context-candidate-carryforward.service.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/context-candidates/context-candidate-carryforward.service.test.js

@@ -1,161 +0,0 @@
-import { createHash } from 'node:crypto';
-import { describe, expect, it, vi } from 'vitest';
-import { ContextCandidateCarryforwardService } from './context-candidate-carryforward.service.js';
-function candidate(overrides = {}) {
-    return {
-        sourceRunId: 'prior-run-1',
-        candidateKey: 'budget-revenue-policy',
-        topic: 'Revenue policy',
-        assertion: 'Booked revenue excludes refunds.',
-        rationale: 'The finance handbook states this reusable rule.',
-        evidenceChunkIds: ['prior-chunk-1'],
-        evidenceRefs: [
-            {
-                chunkId: 'prior-chunk-1',
-                stableCitationKey: 'notion:page-1:revenue-policy',
-                syncId: 'sync-prior',
-                rawPath: 'pages/page-1/page.md',
-            },
-        ],
-        suggestedPageKey: 'revenue-policy',
-        actionHint: 'create',
-        durabilityScore: 3,
-        authorityScore: 3,
-        reuseScore: 3,
-        noveltyScore: 2,
-        riskScore: 1,
-        promotionScore: 10,
-        lane: 'full',
-        ...overrides,
-    };
-}
-function chunk(overrides = {}) {
-    return {
-        chunkId: 'current-chunk-1',
-        stableCitationKey: 'notion:page-1:revenue-policy',
-        syncId: 'sync-current',
-        rawPath: 'pages/page-1/page.md',
-        title: 'Revenue Policy',
-        path: 'Company / Revenue Policy',
-        url: 'https://notion.example/page-1',
-        lastEditedAt: new Date('2026-04-30T12:00:00.000Z'),
-        citation: {
-            source: 'notion',
-            pageId: 'page-1',
-            syncId: 'sync-current',
-            rawPath: 'pages/page-1/page.md',
-        },
-        content: 'Booked revenue excludes refunds and test accounts.',
-        ...overrides,
-    };
-}
-function buildHarness(reExamineBudgetExhaustedOnRerun) {
-    const store = {
-        listPendingCandidatesForDedup: vi.fn(),
-        updateCandidateEmbedding: vi.fn(),
-        markCandidatesAsMergedToCluster: vi.fn(),
-        listBudgetExhaustedCandidatesForCarryForward: vi.fn(),
-        listCurrentRunEvidenceChunksForCarryForward: vi.fn(),
-        insertCandidate: vi.fn().mockResolvedValue({ id: 'new-candidate-1' }),
-    };
-    const service = new ContextCandidateCarryforwardService({
-        store: store,
-        settings: { reExamineBudgetExhaustedOnRerun },
-    });
-    return { service, store };
-}
-describe('ContextCandidateCarryforwardService', () => {
-    it('carries a prior budget-exhausted candidate with remapped current evidence', async () => {
-        const { service, store } = buildHarness(true);
-        store.listBudgetExhaustedCandidatesForCarryForward.mockResolvedValueOnce([candidate()]);
-        store.listCurrentRunEvidenceChunksForCarryForward.mockResolvedValueOnce([chunk()]);
-        const result = await service.carryForward({
-            runId: 'current-run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-        });
-        expect(result).toMatchObject({
-            considered: 1,
-            carriedForward: 1,
-            skippedNotReemitted: 0,
-            remappedEvidenceRefs: 1,
-            staleEvidenceRefs: 0,
-        });
-        expect(store.insertCandidate).toHaveBeenCalledWith(expect.objectContaining({
-            runId: 'current-run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            candidateKey: 'budget-revenue-policy',
-            evidenceChunkIds: ['current-chunk-1'],
-            evidenceRefs: [
-                expect.objectContaining({
-                    chunkId: 'current-chunk-1',
-                    stableCitationKey: 'notion:page-1:revenue-policy',
-                    syncId: 'sync-current',
-                    snippetHash: createHash('sha256')
-                        .update('Booked revenue excludes refunds and test accounts.')
-                        .digest('hex'),
-                }),
-            ],
-            status: 'pending',
-            rejectionReason: null,
-            lane: 'full',
-            embedding: null,
-        }));
-        expect(result.warnings).toEqual(['Re-examined 1 prior budget-exhausted context candidate.']);
-    });
-    it('skips stale prior candidates when config requires current evidence re-emission', async () => {
-        const { service, store } = buildHarness(false);
-        store.listBudgetExhaustedCandidatesForCarryForward.mockResolvedValueOnce([candidate()]);
-        store.listCurrentRunEvidenceChunksForCarryForward.mockResolvedValueOnce([]);
-        const result = await service.carryForward({
-            runId: 'current-run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-        });
-        expect(result).toMatchObject({
-            considered: 1,
-            carriedForward: 0,
-            skippedNotReemitted: 1,
-            remappedEvidenceRefs: 0,
-            staleEvidenceRefs: 0,
-        });
-        expect(store.insertCandidate).not.toHaveBeenCalled();
-        expect(result.warnings).toEqual([
-            'Skipped 1 budget-exhausted context candidate because its evidence was not re-emitted in this run.',
-        ]);
-    });
-    it('carries stale prior evidence when reExamineBudgetExhaustedOnRerun is enabled', async () => {
-        const { service, store } = buildHarness(true);
-        store.listBudgetExhaustedCandidatesForCarryForward.mockResolvedValueOnce([candidate()]);
-        store.listCurrentRunEvidenceChunksForCarryForward.mockResolvedValueOnce([]);
-        const result = await service.carryForward({
-            runId: 'current-run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-        });
-        expect(result).toMatchObject({
-            considered: 1,
-            carriedForward: 1,
-            skippedNotReemitted: 0,
-            remappedEvidenceRefs: 0,
-            staleEvidenceRefs: 1,
-        });
-        expect(store.insertCandidate).toHaveBeenCalledWith(expect.objectContaining({
-            runId: 'current-run-1',
-            evidenceChunkIds: ['prior-chunk-1'],
-            evidenceRefs: [
-                {
-                    chunkId: 'prior-chunk-1',
-                    stableCitationKey: 'notion:page-1:revenue-policy',
-                    syncId: 'sync-prior',
-                    rawPath: 'pages/page-1/page.md',
-                },
-            ],
-        }));
-        expect(result.warnings).toEqual([
-            'Re-examined 1 prior budget-exhausted context candidate.',
-            'Carried 1 budget-exhausted evidence ref without a current-run chunk remap.',
-        ]);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/context-candidates/curator-pagination.service.d.ts

@@ -1,64 +0,0 @@
-import type { KtxModelRole } from '@ktx/llm';
-import { type KtxLogger } from '../../core/index.js';
-import type { AgentRunnerPort, KtxRuntimeToolSet } from '../../llm/index.js';
-import type { MemoryAction } from '../../memory/index.js';
-import type { ContextCandidateForDedup, CuratorPaginationPort, CuratorPaginationReport } from '../ports.js';
-import type { ReconcileCandidateForPrompt, ReconcileCandidateSummary, ReconcilePromptRunState } from '../stages/build-reconcile-context.js';
-import { type ReconciliationOutcome } from '../stages/stage-4-reconciliation.js';
-import type { StageIndex } from '../stages/stage-index.types.js';
-import type { EvictionUnit } from '../types.js';
-import type { ContextCandidateStorePort } from './store.js';
-import type { CuratorPaginationSettings } from './types.js';
-interface CuratorPaginationBudget {
-    creates: number;
-    updates: number;
-}
-interface CuratorPaginationPromptInput {
-    summary: ReconcileCandidateSummary;
-    items: ReconcileCandidateForPrompt[];
-    runState: ReconcilePromptRunState;
-}
-export interface CuratorPaginationInput {
-    runId: string;
-    sourceKey: string;
-    jobId: string;
-    stageIndex: StageIndex;
-    evictionUnit: EvictionUnit | undefined;
-    representatives: ContextCandidateForDedup[];
-    initialBudget: CuratorPaginationBudget;
-    modelRole: KtxModelRole;
-    buildSystemPrompt: () => string;
-    buildUserPrompt: (input: CuratorPaginationPromptInput) => string;
-    buildToolSet: (passNumber: number) => KtxRuntimeToolSet;
-    getReconciliationActions: () => MemoryAction[];
-    onStepFinish?: (info: {
-        passNumber: number;
-        stepIndex: number;
-        stepBudget: number;
-    }) => void;
-}
-interface CuratorPaginationResult extends ReconciliationOutcome {
-    report: CuratorPaginationReport;
-    warnings: string[];
-}
-export interface CuratorPaginationServiceDeps {
-    store: ContextCandidateStorePort;
-    agentRunner: AgentRunnerPort;
-    settings: CuratorPaginationSettings;
-    logger?: KtxLogger;
-}
-export declare class CuratorPaginationService implements CuratorPaginationPort {
-    private readonly deps;
-    private readonly logger;
-    constructor(deps: CuratorPaginationServiceDeps);
-    reconcile(input: CuratorPaginationInput): Promise<CuratorPaginationResult>;
-    private runPass;
-    private batchSummary;
-    private hasNonCandidateReconcileWork;
-    private consumeBudget;
-    private toWikiRefs;
-    private reportFromVerdicts;
-    private emptyReport;
-    private result;
-}
-export {};