cogmem 3.6.2

package/dist/models/adapters/MemoryReviewAdapter.js

@@ -0,0 +1,77 @@
+import { Phase1RuleAlgorithmReviewBackend } from '../../algorithm/AlgorithmReviewBackend.js';
+function truncate(value, maxLength = 1500) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength)}...`;
+}
+function safeParse(raw) {
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export class MemoryReviewAdapter {
+    generateFn;
+    constructor(generateFn) {
+        this.generateFn = generateFn;
+    }
+    async reviewProvisionalFactCandidates(input) {
+        const system = 'Return JSON only with {"adjudications":[],"aliasMergeSuggestions":[]}.';
+        const user = truncate(JSON.stringify({
+            rawEpisodes: input.rawEpisodes.map((episode) => ({
+                id: episode.id,
+                content: episode.content,
+                createdAt: episode.metadata.createdAt
+            })),
+            facts: input.facts,
+            entities: input.entities
+        }));
+        const parsed = safeParse(await this.generateFn(system, user));
+        return {
+            adjudications: Array.isArray(parsed.adjudications) ? parsed.adjudications : [],
+            aliasMergeSuggestions: Array.isArray(parsed.aliasMergeSuggestions) ? parsed.aliasMergeSuggestions : []
+        };
+    }
+    async reviewSelfCorrectionCandidates(input) {
+        const system = 'Return JSON only with {"suggestedFacts":[]}.';
+        const user = truncate(JSON.stringify({
+            rawEpisodes: input.rawEpisodes.map((episode) => ({
+                id: episode.id,
+                content: episode.content,
+                createdAt: episode.metadata.createdAt
+            })),
+            facts: input.facts,
+            entities: input.entities
+        }));
+        const parsed = safeParse(await this.generateFn(system, user));
+        return {
+            suggestedFacts: Array.isArray(parsed.suggestedFacts) ? parsed.suggestedFacts : []
+        };
+    }
+    async reviewMultiFactExtractionCandidates(input) {
+        const system = 'Return JSON only with {"suggestedEntities":[],"suggestedFacts":[]}.';
+        const user = truncate(JSON.stringify({
+            mode: input.mode,
+            rawEpisodes: input.rawEpisodes.map((episode) => ({
+                id: episode.id,
+                content: episode.content,
+                createdAt: episode.metadata.createdAt
+            })),
+            facts: input.facts,
+            entities: input.entities
+        }));
+        const parsed = safeParse(await this.generateFn(system, user));
+        return {
+            suggestedEntities: Array.isArray(parsed.suggestedEntities) ? parsed.suggestedEntities : [],
+            suggestedFacts: Array.isArray(parsed.suggestedFacts) ? parsed.suggestedFacts : []
+        };
+    }
+}
+export function createMemoryReviewAdapter(registry) {
+    if (registry.isRuleOnly('memory')) {
+        return new Phase1RuleAlgorithmReviewBackend();
+    }
+    return new MemoryReviewAdapter(registry.getTextGenerator('memory'));
+}

package/dist/models/index.d.ts

@@ -0,0 +1,8 @@
+export { ModelRegistry } from './ModelRegistry.js';
+export { OpenAICompatibleClient } from './providers/OpenAICompatibleClient.js';
+export { AnthropicClient } from './providers/AnthropicClient.js';
+export { MemoryReviewAdapter, createMemoryReviewAdapter } from './adapters/MemoryReviewAdapter.js';
+export { ModelCapabilityRouter } from './ModelCapabilityRouter.js';
+export type { ModelCapabilityRouterDecision } from './ModelCapabilityRouter.js';
+export type { ModelRoleName, ProviderType, ModelRoleConfig, ModelRegistryConfig, TextGenerateFn, EmbedFn } from './ModelRole.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/models/index.js

@@ -0,0 +1,5 @@
+export { ModelRegistry } from './ModelRegistry.js';
+export { OpenAICompatibleClient } from './providers/OpenAICompatibleClient.js';
+export { AnthropicClient } from './providers/AnthropicClient.js';
+export { MemoryReviewAdapter, createMemoryReviewAdapter } from './adapters/MemoryReviewAdapter.js';
+export { ModelCapabilityRouter } from './ModelCapabilityRouter.js';

package/dist/models/providers/AnthropicClient.d.ts

@@ -0,0 +1,17 @@
+interface AnthropicClientOptions {
+    apiKey: string;
+    timeoutMs?: number;
+}
+interface AnthropicChatCompleteParams {
+    model: string;
+    systemPrompt: string;
+    userPrompt: string;
+    maxTokens?: number;
+}
+export declare class AnthropicClient {
+    private options;
+    constructor(options: AnthropicClientOptions);
+    chatComplete(params: AnthropicChatCompleteParams): Promise<string>;
+}
+export {};
+//# sourceMappingURL=AnthropicClient.d.ts.map

package/dist/models/providers/AnthropicClient.js

@@ -0,0 +1,40 @@
+export class AnthropicClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async chatComplete(params) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 30000);
+        try {
+            const response = await globalThis.fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'anthropic-version': '2023-06-01',
+                    'x-api-key': this.options.apiKey
+                },
+                body: JSON.stringify({
+                    model: params.model,
+                    max_tokens: params.maxTokens ?? 512,
+                    system: params.systemPrompt,
+                    messages: [{ role: 'user', content: params.userPrompt }]
+                }),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                console.warn(`[cogmem] anthropic chat failed with HTTP ${response.status}`);
+                return '';
+            }
+            const payload = await response.json();
+            return payload.content?.[0]?.text ?? '';
+        }
+        catch (error) {
+            console.warn('[cogmem] anthropic chat failed', error);
+            return '';
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/models/providers/OpenAICompatibleClient.d.ts

@@ -0,0 +1,24 @@
+interface OpenAICompatibleClientOptions {
+    baseUrl: string;
+    apiKey?: string;
+    timeoutMs?: number;
+}
+interface OpenAIChatCompleteParams {
+    model: string;
+    systemPrompt: string;
+    userPrompt: string;
+    maxTokens?: number;
+}
+interface OpenAIEmbedParams {
+    model: string;
+    input: string;
+}
+export declare class OpenAICompatibleClient {
+    private options;
+    constructor(options: OpenAICompatibleClientOptions);
+    chatComplete(params: OpenAIChatCompleteParams): Promise<string>;
+    embed(params: OpenAIEmbedParams): Promise<number[]>;
+    private buildHeaders;
+}
+export {};
+//# sourceMappingURL=OpenAICompatibleClient.d.ts.map

package/dist/models/providers/OpenAICompatibleClient.js

@@ -0,0 +1,76 @@
+function normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+}
+export class OpenAICompatibleClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async chatComplete(params) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 30000);
+        try {
+            const response = await globalThis.fetch(`${normalizeBaseUrl(this.options.baseUrl)}/chat/completions`, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model: params.model,
+                    messages: [
+                        { role: 'system', content: params.systemPrompt },
+                        { role: 'user', content: params.userPrompt }
+                    ],
+                    temperature: 0,
+                    max_tokens: params.maxTokens ?? 512
+                }),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                console.warn(`[cogmem] openai_compatible chat failed with HTTP ${response.status}`);
+                return '';
+            }
+            const payload = await response.json();
+            return payload.choices?.[0]?.message?.content ?? '';
+        }
+        catch (error) {
+            console.warn('[cogmem] openai_compatible chat failed', error);
+            return '';
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async embed(params) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 30000);
+        try {
+            const response = await globalThis.fetch(`${normalizeBaseUrl(this.options.baseUrl)}/embeddings`, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model: params.model,
+                    input: params.input
+                }),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                throw new Error(`Embedding HTTP ${response.status}`);
+            }
+            const payload = await response.json();
+            return payload.data?.[0]?.embedding ?? [];
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    buildHeaders() {
+        return this.options.apiKey && this.options.apiKey.trim()
+            ? {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.options.apiKey}`
+            }
+            : {
+                'Content-Type': 'application/json'
+            };
+    }
+}

package/dist/observability/DecisionExplainer.d.ts

@@ -0,0 +1,5 @@
+import type { TraceEvent } from './TraceEvent.js';
+export declare class DecisionExplainer {
+    explain(events: TraceEvent[]): string;
+}
+//# sourceMappingURL=DecisionExplainer.d.ts.map

package/dist/observability/DecisionExplainer.js

@@ -0,0 +1,62 @@
+function pad(value) {
+    return value.toString().padStart(2, '0');
+}
+function formatTime(timestamp) {
+    const date = new Date(timestamp);
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function quoteIfString(value) {
+    return typeof value === 'string' ? `"${value}"` : String(value);
+}
+function compactEventType(eventType) {
+    return eventType.endsWith('.decision') ? eventType.replace(/\.decision$/, '') : eventType;
+}
+function buildDetails(event) {
+    const payload = event.payload;
+    switch (event.eventType) {
+        case 'recall.request':
+            return payload.query ? `query=${quoteIfString(payload.query)}` : '';
+        case 'recall.result':
+            return `returned ${payload.factCount ?? 0} facts`;
+        case 'confidence_gate.decision':
+            return `verdict=${payload.verdict ?? 'unknown'}, score=${payload.score ?? 'n/a'}`;
+        case 'risk_gate.decision':
+            return `decision=${payload.decision ?? 'unknown'}, risk=${payload.riskLevel ?? 'n/a'}`;
+        case 'task_router.plan':
+            return `intent=${payload.intentType ?? 'unknown'}, steps=${payload.stepCount ?? 0}`;
+        case 'capability.invoke':
+            return `capability=${payload.capabilityId ?? 'unknown'}`;
+        case 'capability.result':
+            return `capability=${payload.capabilityId ?? 'unknown'}, success=${payload.success ?? false}`;
+        case 'observation_filter.decision':
+            return `shouldIngest=${payload.shouldIngest ?? false}, reason=${quoteIfString(payload.reason ?? '')}`;
+        case 'memory.promote':
+            return `count=${payload.count ?? 0}, type=${payload.memoryType ?? 'unknown'}`;
+        case 'approval.request':
+            return `capability=${payload.capabilityId ?? 'unknown'}, risk=${payload.riskLevel ?? 'n/a'}`;
+        case 'approval.resolve':
+            return `status=${payload.status ?? 'unknown'}`;
+        case 'task_state.transition':
+            return `${payload.from ?? 'unknown'} → ${payload.to ?? 'unknown'}`;
+        default: {
+            const entries = Object.entries(payload).slice(0, 3);
+            return entries.map(([key, value]) => `${key}=${quoteIfString(value)}`).join(', ');
+        }
+    }
+}
+export class DecisionExplainer {
+    explain(events) {
+        if (events.length === 0)
+            return 'No events';
+        const sorted = [...events].sort((left, right) => left.timestamp - right.timestamp || left.id.localeCompare(right.id));
+        const taskId = sorted.find((event) => event.taskId)?.taskId ?? 'unknown';
+        const lines = [`Task ${taskId}`];
+        sorted.forEach((event, index) => {
+            const branch = index === sorted.length - 1 ? '└─' : '├─';
+            const details = buildDetails(event);
+            const suffix = details ? `  ${details}` : '';
+            lines.push(`  ${branch} [${formatTime(event.timestamp)}] ${compactEventType(event.eventType)}${suffix}`);
+        });
+        return lines.join('\n');
+    }
+}

package/dist/observability/TraceEvent.d.ts

@@ -0,0 +1,11 @@
+export type TraceEventType = 'recall.request' | 'recall.result' | 'confidence_gate.decision' | 'risk_gate.decision' | 'task_router.plan' | 'capability.invoke' | 'capability.result' | 'observation_filter.decision' | 'memory.promote' | 'memory.topic_reclassified' | 'approval.request' | 'approval.resolve' | 'task_state.transition' | 'notification_dispatch' | 'scheduler_job_run' | 'skill.loaded' | 'skill.unloaded' | 'proposal.approved' | 'proposal.apply' | 'proposal.rollback' | 'proposal.rejected' | 'autonomy.action_approved' | 'autonomy.action_rejected' | 'autonomy.batch_collected' | 'autonomy.budget_exhausted' | 'procedure.started' | 'procedure.step.started' | 'procedure.step.executed' | 'procedure.step.failed' | 'procedure.step.retried' | 'procedure.step.skipped' | 'procedure.step.pending_approval' | 'procedure.step.requires_control' | 'procedure.approval_flushed' | 'procedure.resume_consumed' | 'procedure.completed' | 'procedure.failed' | 'runtime_self.projected' | 'runtime_self.refreshed' | 'runtime_self.diff' | 'runtime_self.failed';
+export interface TraceEvent {
+    id: string;
+    timestamp: number;
+    taskId?: string;
+    projectId?: string;
+    eventType: TraceEventType;
+    payload: Record<string, unknown>;
+    parentEventId?: string;
+}
+//# sourceMappingURL=TraceEvent.d.ts.map

package/dist/observability/TraceEvent.js

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

package/dist/observability/TraceQuery.d.ts

@@ -0,0 +1,15 @@
+import type { TraceEvent } from './TraceEvent.js';
+import { TraceStore } from './TraceStore.js';
+export declare class TraceQuery {
+    private store;
+    constructor(store: TraceStore);
+    forTask(taskId: string): TraceEvent[];
+    forProject(projectId: string, limit?: number): TraceEvent[];
+    decisionChain(rootEventId: string): TraceEvent[];
+    summary(taskId: string): {
+        eventCount: number;
+        eventTypes: string[];
+        durationMs: number;
+    };
+}
+//# sourceMappingURL=TraceQuery.d.ts.map

package/dist/observability/TraceQuery.js

@@ -0,0 +1,28 @@
+export class TraceQuery {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    forTask(taskId) {
+        return this.store.queryByTaskId(taskId);
+    }
+    forProject(projectId, limit) {
+        const events = this.store.queryByProjectId(projectId);
+        return typeof limit === 'number' ? events.slice(0, Math.max(limit, 0)) : events;
+    }
+    decisionChain(rootEventId) {
+        return this.store.getDecisionChain(rootEventId);
+    }
+    summary(taskId) {
+        const events = this.forTask(taskId);
+        const eventTypes = Array.from(new Set(events.map((event) => event.eventType)));
+        const durationMs = events.length > 1
+            ? Math.max(0, events[events.length - 1].timestamp - events[0].timestamp)
+            : 0;
+        return {
+            eventCount: events.length,
+            eventTypes,
+            durationMs
+        };
+    }
+}

package/dist/observability/TraceStore.d.ts

@@ -0,0 +1,15 @@
+import type Database from 'bun:sqlite';
+import type { TraceEvent, TraceEventType } from './TraceEvent.js';
+export declare class TraceStore {
+    private db;
+    constructor(db: Database);
+    initSchema(): void;
+    append(event: TraceEvent): void;
+    queryByTaskId(taskId: string): TraceEvent[];
+    queryByEventType(eventType: TraceEventType): TraceEvent[];
+    queryByProjectId(projectId: string): TraceEvent[];
+    getDecisionChain(eventId: string): TraceEvent[];
+    private mapRow;
+    private parsePayload;
+}
+//# sourceMappingURL=TraceStore.d.ts.map

package/dist/observability/TraceStore.js

@@ -0,0 +1,110 @@
+export class TraceStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS trace_events (
+        id TEXT PRIMARY KEY,
+        timestamp INTEGER NOT NULL,
+        task_id TEXT,
+        project_id TEXT,
+        event_type TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        parent_event_id TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_trace_events_task_id_timestamp
+        ON trace_events(task_id, timestamp);
+
+      CREATE INDEX IF NOT EXISTS idx_trace_events_project_id_timestamp
+        ON trace_events(project_id, timestamp);
+
+      CREATE INDEX IF NOT EXISTS idx_trace_events_event_type_timestamp
+        ON trace_events(event_type, timestamp);
+
+      CREATE INDEX IF NOT EXISTS idx_trace_events_parent_event_id
+        ON trace_events(parent_event_id);
+    `);
+    }
+    append(event) {
+        this.db.prepare(`
+      INSERT INTO trace_events (
+        id,
+        timestamp,
+        task_id,
+        project_id,
+        event_type,
+        payload,
+        parent_event_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(event.id, event.timestamp, event.taskId ?? null, event.projectId ?? null, event.eventType, JSON.stringify(event.payload), event.parentEventId ?? null);
+    }
+    queryByTaskId(taskId) {
+        const rows = this.db.prepare(`
+      SELECT id, timestamp, task_id, project_id, event_type, payload, parent_event_id
+      FROM trace_events
+      WHERE task_id = ?
+      ORDER BY timestamp ASC, id ASC
+    `).all(taskId);
+        return rows.map((row) => this.mapRow(row));
+    }
+    queryByEventType(eventType) {
+        const rows = this.db.prepare(`
+      SELECT id, timestamp, task_id, project_id, event_type, payload, parent_event_id
+      FROM trace_events
+      WHERE event_type = ?
+      ORDER BY timestamp ASC, id ASC
+    `).all(eventType);
+        return rows.map((row) => this.mapRow(row));
+    }
+    queryByProjectId(projectId) {
+        const rows = this.db.prepare(`
+      SELECT id, timestamp, task_id, project_id, event_type, payload, parent_event_id
+      FROM trace_events
+      WHERE project_id = ?
+      ORDER BY timestamp ASC, id ASC
+    `).all(projectId);
+        return rows.map((row) => this.mapRow(row));
+    }
+    getDecisionChain(eventId) {
+        const chain = [];
+        const visited = new Set();
+        let currentId = eventId;
+        while (currentId && !visited.has(currentId)) {
+            visited.add(currentId);
+            const row = this.db.prepare(`
+        SELECT id, timestamp, task_id, project_id, event_type, payload, parent_event_id
+        FROM trace_events
+        WHERE id = ?
+      `).get(currentId);
+            if (!row)
+                break;
+            const event = this.mapRow(row);
+            chain.push(event);
+            currentId = event.parentEventId;
+        }
+        return chain.reverse();
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            timestamp: row.timestamp,
+            taskId: row.task_id ?? undefined,
+            projectId: row.project_id ?? undefined,
+            eventType: row.event_type,
+            payload: this.parsePayload(row.payload),
+            parentEventId: row.parent_event_id ?? undefined
+        };
+    }
+    parsePayload(value) {
+        try {
+            const parsed = JSON.parse(value);
+            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/observability/TraceWriter.d.ts

@@ -0,0 +1,8 @@
+import type { TraceEvent } from './TraceEvent.js';
+import { TraceStore } from './TraceStore.js';
+export declare class TraceWriter {
+    private store;
+    constructor(store: TraceStore);
+    emit(event: Omit<TraceEvent, 'id' | 'timestamp'>): void;
+}
+//# sourceMappingURL=TraceWriter.d.ts.map

package/dist/observability/TraceWriter.js

@@ -0,0 +1,14 @@
+import { randomUUID } from 'crypto';
+export class TraceWriter {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    emit(event) {
+        this.store.append({
+            ...event,
+            id: randomUUID(),
+            timestamp: Date.now()
+        });
+    }
+}

package/dist/ontology/MemoryOntology.d.ts

@@ -0,0 +1,4 @@
+export declare const MEMORY_ONTOLOGY_CLASSES: readonly ["Time", "Person", "Object", "Place", "Project", "Event", "Decision", "Goal", "Preference", "Correction", "Plan", "Evidence", "Conversation", "Topic", "Entity", "Relation"];
+export type MemoryOntologyClass = typeof MEMORY_ONTOLOGY_CLASSES[number];
+export declare function isMemoryOntologyClass(value: unknown): value is MemoryOntologyClass;
+//# sourceMappingURL=MemoryOntology.d.ts.map

package/dist/ontology/MemoryOntology.js

@@ -0,0 +1,7 @@
+export const MEMORY_ONTOLOGY_CLASSES = [
+    'Time', 'Person', 'Object', 'Place', 'Project', 'Event', 'Decision', 'Goal',
+    'Preference', 'Correction', 'Plan', 'Evidence', 'Conversation', 'Topic', 'Entity', 'Relation',
+];
+export function isMemoryOntologyClass(value) {
+    return typeof value === 'string' && MEMORY_ONTOLOGY_CLASSES.includes(value);
+}

package/dist/prospective/ProspectiveMemoryService.d.ts

@@ -0,0 +1,79 @@
+import Database from 'bun:sqlite';
+export type ProspectiveMemoryType = 'intention' | 'commitment' | 'reminder' | 'open_loop' | 'plan';
+export type ProspectiveMemoryStatus = 'pending' | 'confirmed' | 'deferred' | 'rejected' | 'completed' | 'expired';
+export type ProspectiveMemoryProposer = 'deterministic' | 'model_candidate' | 'operator';
+export interface ProspectiveEvidenceRecord {
+    eventId: string;
+    projectId?: string;
+    role?: string;
+    globalSeq?: number;
+    content?: string;
+}
+export interface ProspectiveMemoryRecord {
+    candidateId: string;
+    projectId: string;
+    candidateType: ProspectiveMemoryType;
+    canonicalKey: string;
+    title: string;
+    details?: string;
+    status: ProspectiveMemoryStatus;
+    proposedBy: ProspectiveMemoryProposer;
+    evidenceEventIds: string[];
+    confirmationEvidenceEventId?: string;
+    dueAt?: number;
+    deferredUntil?: number;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ProposeProspectiveMemoryInput {
+    projectId: string;
+    candidateType: ProspectiveMemoryType;
+    canonicalKey: string;
+    title: string;
+    details?: string;
+    evidenceEventIds: string[];
+    proposedBy: ProspectiveMemoryProposer;
+    dueAt?: number;
+}
+export type ResolveProspectiveMemoryInput = {
+    action: 'confirm';
+    confirmationEvidenceEventId: string;
+} | {
+    action: 'reject';
+} | {
+    action: 'defer';
+    deferredUntil: number;
+} | {
+    action: 'complete';
+} | {
+    action: 'expire';
+};
+export interface ProspectiveMemoryListOptions {
+    projectId: string;
+    statuses?: ProspectiveMemoryStatus[];
+    limit?: number;
+}
+export type ProspectiveEvidenceLookup = (eventId: string) => ProspectiveEvidenceRecord | undefined;
+export declare class ProspectiveMemoryService {
+    private readonly db;
+    private readonly findEvidence;
+    constructor(db: Database, findEvidence: ProspectiveEvidenceLookup);
+    propose(input: ProposeProspectiveMemoryInput): ProspectiveMemoryRecord;
+    private proposeInTransaction;
+    resolve(candidateId: string, input: ResolveProspectiveMemoryInput, projectId: string): ProspectiveMemoryRecord;
+    private resolveInTransaction;
+    get(candidateId: string, projectId: string): ProspectiveMemoryRecord | null;
+    list(options: ProspectiveMemoryListOptions): ProspectiveMemoryRecord[];
+    listDue(input: {
+        projectId: string;
+        atTime?: number;
+        limit?: number;
+    }): ProspectiveMemoryRecord[];
+    private getLatest;
+    private getUnscoped;
+    private recordTransition;
+    private mapRow;
+    private initializeSchema;
+}
+//# sourceMappingURL=ProspectiveMemoryService.d.ts.map