@atomicmemory/core 1.0.0

package/dist/services/contradiction-surfacing.js

@@ -0,0 +1,111 @@
+/**
+ * BEAM CR fix — retrieval-side enrichment for AUDN bilateral preservation.
+ *
+ * Two responsibilities, both flag-gated by `contradictionSurfacingEnabled`:
+ *
+ *   1. enrichTopKWithContradictions: scan top-K SearchResults for
+ *      `contradiction_active=true`. For each such hit, look up its
+ *      active contradiction row and inject the counterpart memory into
+ *      the final set (deduplicated). Returns the augmented memory list
+ *      plus the resolved contradiction pairs so the prompt can quote both
+ *      sides verbatim.
+ *
+ *   2. buildContradictionsBlock: render the resolved pairs as a
+ *      `## CONTRADICTIONS_DETECTED` markdown section. Returns undefined
+ *      when there are no contradictions to surface, so callers can
+ *      conditionally prepend the block to the injection text.
+ *
+ * Pure functions plus one DB read via ContradictionsRepository.
+ * No fallback behavior — when the surfacing flag is off OR the store is
+ * missing, callers see `{ memories, pairs: [] }`.
+ */
+import { QuestionType } from './answer-format.js';
+/**
+ * Inspect top-K results for `contradiction_active=true` hits, fetch their
+ * counterparts, and produce an augmented memory list + the resolved pairs.
+ * Pure additive: never drops memories from the input list.
+ */
+export async function enrichTopKWithContradictions(input) {
+    if (!input.enabled || !input.contradictions) {
+        return { memories: input.memories, pairs: [] };
+    }
+    const activeHitIds = input.memories
+        .filter((m) => isContradictionActive(m))
+        .map((m) => m.id);
+    if (activeHitIds.length === 0) {
+        return { memories: input.memories, pairs: [] };
+    }
+    const rows = await input.contradictions.findActiveByUserAndMemoryIds(input.userId, activeHitIds);
+    if (rows.length === 0) {
+        return { memories: input.memories, pairs: [] };
+    }
+    const memoryById = new Map(input.memories.map((m) => [m.id, m]));
+    const augmented = [...input.memories];
+    const pairs = [];
+    for (const row of rows) {
+        const counterpartId = pickCounterpartId(row, memoryById);
+        if (counterpartId && !memoryById.has(counterpartId)) {
+            const fetched = await input.fetchCounterpart(counterpartId);
+            if (fetched) {
+                augmented.push(fetched);
+                memoryById.set(fetched.id, fetched);
+            }
+        }
+        pairs.push({
+            contradictionId: row.id,
+            leftMemoryId: row.leftMemoryId,
+            rightMemoryId: row.rightMemoryId,
+            leftSummary: row.leftSummary,
+            rightSummary: row.rightSummary,
+        });
+    }
+    return { memories: augmented, pairs: dedupePairs(pairs) };
+}
+/**
+ * Render the `## CONTRADICTIONS_DETECTED` markdown block. Returns undefined
+ * when there's nothing to render OR when the question type is not one of
+ * the contradiction-relevant types (e.g., simple summary). Per spec, the
+ * block is always rendered for CR queries OR when pairs are present.
+ */
+export function buildContradictionsBlock(pairs, questionType) {
+    if (pairs.length === 0)
+        return undefined;
+    const relevant = questionType === QuestionType.CONTRADICTION ||
+        questionType === QuestionType.SUMMARY ||
+        questionType === QuestionType.OTHER;
+    if (!relevant)
+        return undefined;
+    const lines = pairs.map((p) => `- You said: "${p.leftSummary}" but also: "${p.rightSummary}"`);
+    return `## CONTRADICTIONS_DETECTED\n${lines.join('\n')}\n\n`;
+}
+function isContradictionActive(memory) {
+    // The column was added by the audn_bilateral migration; some older rows
+    // may not surface it through the row normalizer. Treat absence as false.
+    const value = memory.contradiction_active;
+    return value === true;
+}
+function pickCounterpartId(row, memoryById) {
+    // Prefer the side that's NOT already in top-K. If both are in, return null
+    // (no extra fetch needed). If neither is in, prefer the left memory (the
+    // older side that AUDN would have discarded pre-fix).
+    const leftIn = memoryById.has(row.leftMemoryId);
+    const rightIn = memoryById.has(row.rightMemoryId);
+    if (leftIn && !rightIn)
+        return row.rightMemoryId;
+    if (!leftIn && rightIn)
+        return row.leftMemoryId;
+    if (!leftIn && !rightIn)
+        return row.leftMemoryId;
+    return null;
+}
+function dedupePairs(pairs) {
+    const seen = new Set();
+    const out = [];
+    for (const p of pairs) {
+        if (seen.has(p.contradictionId))
+            continue;
+        seen.add(p.contradictionId);
+        out.push(p);
+    }
+    return out;
+}

package/dist/services/cost-telemetry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Lightweight per-call cost telemetry.
+ * Writes JSONL events for LLM and embedding calls when enabled.
+ */
+export type CostStage = 'extract' | 'answer' | 'judge' | 'embedding' | 'other';
+export interface CostUsage {
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    totalTokens?: number | null;
+}
+export interface CostEvent {
+    ts: string;
+    runId: string;
+    stage: CostStage;
+    provider: string;
+    model: string;
+    requestKind: 'chat' | 'embedding';
+    durationMs: number;
+    cacheHit: boolean;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+    estimatedCostUsd: number | null;
+    meta?: Record<string, unknown>;
+}
+export declare function getCostStage(): CostStage;
+export declare function withCostStage<T>(stage: CostStage, fn: () => Promise<T>): Promise<T>;
+export declare function estimateCostUsd(provider: string, model: string, usage?: CostUsage): number | null;
+/**
+ * Config subset consumed by writeCostEvent. Narrow Pick<> of the supported
+ * operator-config surface so callers only thread what the function reads.
+ */
+export interface WriteCostEventConfig {
+    costLoggingEnabled: boolean;
+    costRunId: string;
+    costLogDir: string;
+}
+export declare function writeCostEvent(event: Omit<CostEvent, 'ts' | 'runId'>, config: WriteCostEventConfig): void;
+export declare function summarizeUsage(inputTokens?: number | null, outputTokens?: number | null, totalTokens?: number | null): CostUsage;

package/dist/services/cost-telemetry.js

@@ -0,0 +1,58 @@
+/**
+ * Lightweight per-call cost telemetry.
+ * Writes JSONL events for LLM and embedding calls when enabled.
+ */
+import { mkdirSync, appendFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+let currentStage = 'other';
+const PRICE_PER_MILLION = {
+    'openai:gpt-4.1-mini': { input: 0.4, output: 1.6 },
+};
+function setCostStage(stage) {
+    currentStage = stage;
+}
+export function getCostStage() {
+    return currentStage;
+}
+export async function withCostStage(stage, fn) {
+    const prev = currentStage;
+    currentStage = stage;
+    try {
+        return await fn();
+    }
+    finally {
+        currentStage = prev;
+    }
+}
+export function estimateCostUsd(provider, model, usage) {
+    if (!usage)
+        return null;
+    const price = PRICE_PER_MILLION[`${provider}:${model}`];
+    if (!price)
+        return null;
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    return (input / 1_000_000) * price.input + (output / 1_000_000) * price.output;
+}
+export function writeCostEvent(event, config) {
+    if (!config.costLoggingEnabled)
+        return;
+    const runId = config.costRunId || `adhoc-${new Date().toISOString().slice(0, 10)}`;
+    const logPath = resolve(config.costLogDir, `${runId}.jsonl`);
+    mkdirSync(dirname(logPath), { recursive: true });
+    const fullEvent = {
+        ts: new Date().toISOString(),
+        runId,
+        ...event,
+    };
+    appendFileSync(logPath, JSON.stringify(fullEvent) + '\n', 'utf-8');
+}
+export function summarizeUsage(inputTokens, outputTokens, totalTokens) {
+    return {
+        inputTokens: inputTokens ?? null,
+        outputTokens: outputTokens ?? null,
+        totalTokens: totalTokens ?? ((inputTokens ?? null) !== null || (outputTokens ?? null) !== null
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : null),
+    };
+}

package/dist/services/counter-evidence.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Counter-evidence retrieval (Sprint 3 v1.1, V2 backlog item 1).
+ *
+ * After RRF + MMR selects top-K candidates, look up the belief_edges graph
+ * for any COUNTER edges where the target is a top-K memory. Fetch the
+ * counter-source memories (which represent the *other side* of a recorded
+ * contradiction) and append them to the result set.
+ *
+ * Surfaces both halves of a contradiction by construction, fixing the
+ * failure pattern we diagnosed on AMB BEAM-100K conv 1 question
+ * "Have I integrated Flask-Login?" where retrieval surfaced only the
+ * affirmative memory and the contradicting denial was scored 0.
+ *
+ * Feature flag: counterEvidenceEnabled (default OFF). Requires TBC to have
+ * been ON at ingest so belief_edges rows exist.
+ */
+import pg from 'pg';
+import type { SearchResult } from '../db/repository-types.js';
+export interface CounterEvidenceDeps {
+    pool: pg.Pool;
+}
+/**
+ * Expand a result list with counter-evidence linked memories.
+ *
+ * For each candidate, find belief_edges where target_id = candidate.id AND
+ * edge_type='counter'. Fetch the unique counter-source memories. Tag each
+ * appended row with metadata.counter_evidence_for = [target_ids] so the
+ * answer LLM can recognize them as contradicting claims.
+ *
+ * Returns the original candidates + the expanded set (deduped by id).
+ * The expansion preserves the existing top-K order and appends new IDs
+ * at the end; downstream MMR/packaging is unchanged.
+ */
+export declare function expandWithCounterEvidence(deps: CounterEvidenceDeps, userId: string, candidates: SearchResult[]): Promise<SearchResult[]>;

package/dist/services/counter-evidence.js

@@ -0,0 +1,92 @@
+/**
+ * Counter-evidence retrieval (Sprint 3 v1.1, V2 backlog item 1).
+ *
+ * After RRF + MMR selects top-K candidates, look up the belief_edges graph
+ * for any COUNTER edges where the target is a top-K memory. Fetch the
+ * counter-source memories (which represent the *other side* of a recorded
+ * contradiction) and append them to the result set.
+ *
+ * Surfaces both halves of a contradiction by construction, fixing the
+ * failure pattern we diagnosed on AMB BEAM-100K conv 1 question
+ * "Have I integrated Flask-Login?" where retrieval surfaced only the
+ * affirmative memory and the contradicting denial was scored 0.
+ *
+ * Feature flag: counterEvidenceEnabled (default OFF). Requires TBC to have
+ * been ON at ingest so belief_edges rows exist.
+ */
+/** Max counter-source memories to append per result. Keeps the answer
+ *  context from exploding when there are many recorded contradictions. */
+const MAX_COUNTER_PER_TARGET = 2;
+/**
+ * Expand a result list with counter-evidence linked memories.
+ *
+ * For each candidate, find belief_edges where target_id = candidate.id AND
+ * edge_type='counter'. Fetch the unique counter-source memories. Tag each
+ * appended row with metadata.counter_evidence_for = [target_ids] so the
+ * answer LLM can recognize them as contradicting claims.
+ *
+ * Returns the original candidates + the expanded set (deduped by id).
+ * The expansion preserves the existing top-K order and appends new IDs
+ * at the end; downstream MMR/packaging is unchanged.
+ */
+export async function expandWithCounterEvidence(deps, userId, candidates) {
+    if (candidates.length === 0)
+        return candidates;
+    const candidateIds = candidates.map((c) => c.id);
+    const counterSources = await fetchCounterSources(deps.pool, userId, candidateIds);
+    if (counterSources.size === 0)
+        return candidates;
+    const existingIds = new Set(candidateIds);
+    const sourceIdsToFetch = Array.from(counterSources.keys()).filter((id) => !existingIds.has(id));
+    if (sourceIdsToFetch.length === 0)
+        return candidates;
+    const fetched = await fetchMemoriesByIds(deps.pool, userId, sourceIdsToFetch);
+    // Tag each fetched memory with which target(s) it counters.
+    const tagged = fetched.map((m) => {
+        const targets = counterSources.get(m.id) ?? [];
+        const extraMeta = { counter_evidence_for: targets, counter_evidence_source: true };
+        return {
+            ...m,
+            metadata: { ...(m.metadata ?? {}), ...extraMeta },
+        };
+    });
+    return [...candidates, ...tagged];
+}
+/** Returns a map source_id → list of target_ids that source counters. */
+async function fetchCounterSources(pool, userId, targetIds) {
+    if (targetIds.length === 0)
+        return new Map();
+    const result = await pool.query(`SELECT source_id, target_id
+     FROM belief_edges
+     WHERE user_id = $1
+       AND target_id = ANY($2::uuid[])
+       AND edge_type = 'counter'
+     ORDER BY created_at DESC
+     LIMIT $3`, [userId, targetIds, targetIds.length * MAX_COUNTER_PER_TARGET]);
+    const out = new Map();
+    for (const row of result.rows) {
+        const existing = out.get(row.source_id) ?? [];
+        if (!existing.includes(row.target_id)) {
+            existing.push(row.target_id);
+        }
+        out.set(row.source_id, existing);
+    }
+    return out;
+}
+async function fetchMemoriesByIds(pool, userId, ids) {
+    if (ids.length === 0)
+        return [];
+    const result = await pool.query(`SELECT *,
+            0.5 AS similarity,
+            0.5 AS score,
+            0.5 AS semantic_similarity,
+            0.5 AS relevance,
+            0.5 AS ranking_score
+     FROM memories
+     WHERE id = ANY($1::uuid[])
+       AND user_id = $2
+       AND deleted_at IS NULL
+       AND expired_at IS NULL
+       AND status = 'active'`, [ids, userId]);
+    return result.rows;
+}

package/dist/services/current-state-ranking.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Present-state reranking for queries asking what is true now.
+ *
+ * Detects implicit current-state queries ("What database does the project use?")
+ * and applies recency-based boosting so newer facts outrank older superseded ones.
+ *
+ * Key signals:
+ *   - Recency rank: newer results get higher boost
+ *   - Transition detection: facts describing state changes ("migrated to X",
+ *     "switched to Y") get a bonus — they establish current state
+ *   - Historical-only penalty: facts about old state without transition markers
+ *     ("uses Angular 15") get no boost
+ */
+import type { SearchResult } from '../db/memory-repository.js';
+export interface CurrentStateRankingResult {
+    triggered: boolean;
+    results: SearchResult[];
+}
+export declare function applyCurrentStateRanking(query: string, results: SearchResult[]): CurrentStateRankingResult;
+export declare function isHistoricalQuery(query: string): boolean;
+export declare function isCurrentStateQuery(query: string): boolean;

package/dist/services/current-state-ranking.js

@@ -0,0 +1,152 @@
+/**
+ * Present-state reranking for queries asking what is true now.
+ *
+ * Detects implicit current-state queries ("What database does the project use?")
+ * and applies recency-based boosting so newer facts outrank older superseded ones.
+ *
+ * Key signals:
+ *   - Recency rank: newer results get higher boost
+ *   - Transition detection: facts describing state changes ("migrated to X",
+ *     "switched to Y") get a bonus — they establish current state
+ *   - Historical-only penalty: facts about old state without transition markers
+ *     ("uses Angular 15") get no boost
+ */
+const CURRENT_QUERY_MARKERS = [' now', ' current ', ' currently', ' right now', ' at the moment', ' latest '];
+const HISTORICAL_QUERY_MARKERS = ['used to', 'previously', 'former', 'old ', 'history', 'timeline', 'before switching', 'before migrating', 'before moving', 'earlier '];
+const CURRENT_QUERY_STARTERS = [' what ', ' where ', ' who '];
+const CURRENT_DOMAIN_MARKERS = [
+    ' use', ' using', ' backend', ' system', ' engine', ' framework',
+    ' database', ' employer', ' work', ' live', ' salary', ' library',
+    ' orm', ' stack', ' tool',
+];
+/**
+ * Quantity/frequency/duration starters that implicitly ask about the latest value.
+ * "How many X do I have?" → current count. "How often do I X?" → current frequency.
+ * These bypass the domain-marker requirement because the question structure
+ * itself implies current-state intent.
+ */
+const QUANTITY_STARTERS = ['how many ', 'how often ', 'how long ', 'how much '];
+const TEMPORAL_COMPARISON_MARKERS = [
+    ' between ', ' first ', ' second ', ' before ', ' after ',
+    ' elapsed ', ' lapsed ', ' passed ',
+];
+/**
+ * Markers in result content indicating the fact describes current state.
+ * "uses X" or "is using X" → this is what's true now.
+ */
+const CURRENT_RESULT_MARKERS = [
+    'current ', 'currently ', ' now ', 'uses ', 'is using ',
+    'started at', 'started working', 'new package', 'new company',
+    'just moved', 'moved to', 'renting',
+];
+/**
+ * Transition markers — facts that describe a change FROM old state TO new state.
+ * These establish current state and should be boosted, not penalized.
+ * Pattern: "migrated from X to Y", "switched to Y", "completed migration"
+ */
+const TRANSITION_MARKERS = [
+    'switched to', 'migrated to', 'migration to', 'completed migration',
+    'completed the migration', 'moved from', 'changed to', 'upgraded to',
+    'transitioned to', 'replaced with', 'rewritten', 'left ',
+    'all data has been migrated', 'migration is complete',
+    'have been rewritten', 'instead of',
+    'correction:', 'correction ',
+];
+/**
+ * Markers indicating purely historical content without transition context.
+ * Only applied when the fact does NOT also contain a transition marker.
+ */
+const HISTORICAL_ONLY_MARKERS = [
+    'previously ', 'used to ', 'former ', 'at that time',
+    'earlier ', 'was an earlier', 'an earlier ',
+];
+const RECENCY_BONUS = 2.5;
+const CURRENT_TEXT_BONUS = 0.45;
+const TRANSITION_BONUS = 1.5;
+const HISTORICAL_ONLY_PENALTY = 0.6;
+export function applyCurrentStateRanking(query, results) {
+    if (results.length === 0)
+        return { triggered: false, results };
+    if (isHistoricalQuery(query)) {
+        return applyHistoricalRanking(results);
+    }
+    if (!isCurrentStateQuery(query)) {
+        return { triggered: false, results };
+    }
+    const rankMap = buildRecencyRankMap(results);
+    const rescored = results
+        .map((result) => ({ ...result, score: result.score + computeBoost(result, rankMap, results.length) }))
+        .sort((left, right) => right.score - left.score);
+    return { triggered: true, results: rescored };
+}
+const HISTORICAL_OLDNESS_BONUS = 1.5;
+const HISTORICAL_TRANSITION_PENALTY = 1.2;
+/**
+ * Historical query ranking — inverse of current-state ranking.
+ * Boosts older results and penalizes transition/current-state content.
+ */
+function applyHistoricalRanking(results) {
+    const rankMap = buildRecencyRankMap(results);
+    const total = results.length;
+    const rescored = results
+        .map((result) => {
+        const recencyRank = rankMap.get(result.id) ?? total - 1;
+        const oldnessBoost = HISTORICAL_OLDNESS_BONUS * (recencyRank / total);
+        const transitionPenalty = hasTransitionMarker(result.content) ? HISTORICAL_TRANSITION_PENALTY : 0;
+        const currentPenalty = hasCurrentMarker(result.content) ? CURRENT_TEXT_BONUS : 0;
+        const historicalBoost = hasHistoricalOnlyMarker(result.content) ? HISTORICAL_ONLY_PENALTY : 0;
+        return { ...result, score: result.score + oldnessBoost + historicalBoost - transitionPenalty - currentPenalty };
+    })
+        .sort((left, right) => right.score - left.score);
+    return { triggered: true, results: rescored };
+}
+export function isHistoricalQuery(query) {
+    const padded = ` ${query.toLowerCase()} `;
+    return HISTORICAL_QUERY_MARKERS.some((marker) => padded.includes(marker));
+}
+export function isCurrentStateQuery(query) {
+    const padded = ` ${query.toLowerCase()} `;
+    if (HISTORICAL_QUERY_MARKERS.some((marker) => padded.includes(marker)))
+        return false;
+    if (CURRENT_QUERY_MARKERS.some((marker) => padded.includes(marker)))
+        return true;
+    if (QUANTITY_STARTERS.some((starter) => padded.trimStart().startsWith(starter))) {
+        const isTemporalComparison = TEMPORAL_COMPARISON_MARKERS.some((marker) => padded.includes(marker));
+        return !isTemporalComparison;
+    }
+    const startsWithQuestionWord = CURRENT_QUERY_STARTERS.some((starter) => padded.startsWith(starter));
+    return startsWithQuestionWord && CURRENT_DOMAIN_MARKERS.some((marker) => padded.includes(marker));
+}
+/** Build a map from memory id to its recency rank (0 = most recent). */
+function buildRecencyRankMap(results) {
+    const recencyOrder = [...results]
+        .map((result) => result.id)
+        .sort((left, right) => compareRecency(results, left, right));
+    return new Map(recencyOrder.map((id, index) => [id, index]));
+}
+function compareRecency(results, leftId, rightId) {
+    const left = results.find((result) => result.id === leftId);
+    const right = results.find((result) => result.id === rightId);
+    return right.created_at.getTime() - left.created_at.getTime();
+}
+function computeBoost(result, rankMap, total) {
+    const recencyRank = rankMap.get(result.id) ?? total - 1;
+    const recencyBoost = RECENCY_BONUS * ((total - recencyRank) / total);
+    const isTransition = hasTransitionMarker(result.content);
+    const transitionBoost = isTransition ? TRANSITION_BONUS : 0;
+    const textBoost = hasCurrentMarker(result.content) ? CURRENT_TEXT_BONUS : 0;
+    const historicalPenalty = !isTransition && hasHistoricalOnlyMarker(result.content) ? HISTORICAL_ONLY_PENALTY : 0;
+    return recencyBoost + transitionBoost + textBoost - historicalPenalty;
+}
+function hasCurrentMarker(text) {
+    const lower = text.toLowerCase();
+    return CURRENT_RESULT_MARKERS.some((marker) => lower.includes(marker));
+}
+function hasTransitionMarker(text) {
+    const lower = text.toLowerCase();
+    return TRANSITION_MARKERS.some((marker) => lower.includes(marker));
+}
+function hasHistoricalOnlyMarker(text) {
+    const lower = text.toLowerCase();
+    return HISTORICAL_ONLY_MARKERS.some((marker) => lower.includes(marker));
+}

package/dist/services/deferred-audn.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Deferred AUDN Reconciliation Service.
+ *
+ * When DEFERRED_AUDN_ENABLED=true, facts with conflict candidates
+ * (0.7 ≤ similarity < 0.95) are stored immediately as ADD and flagged
+ * for background reconciliation. This eliminates the 500–2000ms LLM
+ * AUDN call from the synchronous ingest path.
+ *
+ * The reconciliation pass processes flagged memories in batches,
+ * running the full LLM AUDN pipeline and applying decisions
+ * (NOOP → delete, SUPERSEDE → soft-delete original, UPDATE → merge).
+ *
+ * Expected latency improvement: 60–80% reduction for ingest batches
+ * with moderate conflict rates (30–70% of facts hitting candidates).
+ */
+import type pg from 'pg';
+import type { MemoryStore } from '../db/stores.js';
+import { type CandidateMemory } from './conflict-policy.js';
+export interface ReconciliationResult {
+    processed: number;
+    resolved: number;
+    noops: number;
+    updates: number;
+    supersedes: number;
+    deletes: number;
+    adds: number;
+    errors: number;
+    durationMs: number;
+}
+/**
+ * Check whether a set of candidates should be deferred rather than
+ * resolved via LLM AUDN synchronously.
+ */
+export declare function shouldDeferAudn(fastDecisionResolved: boolean, candidateCount: number): boolean;
+/**
+ * Mark a newly stored memory for deferred reconciliation.
+ */
+export declare function deferMemoryForReconciliation(pool: pg.Pool, memoryId: string, candidates: CandidateMemory[]): Promise<void>;
+/** Run a reconciliation pass for a single user. */
+export declare function reconcileUser(pool: pg.Pool, repo: MemoryStore, userId: string, batchSize?: number): Promise<ReconciliationResult>;
+/** Run a reconciliation pass across all users. */
+export declare function reconcileAll(pool: pg.Pool, repo: MemoryStore, batchSize?: number): Promise<ReconciliationResult>;
+/** Get reconciliation status for a user. */
+export declare function getReconciliationStatus(pool: pg.Pool, userId: string): Promise<{
+    pending: number;
+    enabled: boolean;
+}>;