cogmem 3.6.2

package/dist/models/ModelRegistry.d.ts

@@ -0,0 +1,15 @@
+import type { EmbedFn, ModelRegistryConfig, ModelRoleConfig, ModelRoleName, TextGenerateFn } from './ModelRole.js';
+export declare class ModelRegistry {
+    private config;
+    constructor(config: ModelRegistryConfig);
+    static defaultConfig(): ModelRegistryConfig;
+    static defaults(): ModelRegistry;
+    getTextGenerator(role: 'memory' | 'reasoning'): TextGenerateFn;
+    getRoleConfig(role: ModelRoleName): ModelRoleConfig;
+    getEmbedder(): EmbedFn;
+    isRuleOnly(role: 'memory' | 'reasoning'): boolean;
+    private generateText;
+    private runFallback;
+    private resolveTextProvider;
+}
+//# sourceMappingURL=ModelRegistry.d.ts.map

package/dist/models/ModelRegistry.js

@@ -0,0 +1,132 @@
+import { AnthropicClient } from './providers/AnthropicClient.js';
+import { OpenAICompatibleClient } from './providers/OpenAICompatibleClient.js';
+export class ModelRegistry {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    static defaultConfig() {
+        return {
+            memory: {
+                role: 'memory',
+                provider: 'rule_only',
+                baseUrl: '',
+                apiKey: '',
+                modelName: 'rule_only',
+                timeoutMs: 60000,
+                fallback: 'rule_only'
+            },
+            reasoning: {
+                role: 'reasoning',
+                provider: 'rule_only',
+                baseUrl: '',
+                apiKey: '',
+                modelName: 'rule_only',
+                timeoutMs: 60000,
+                fallback: 'memory'
+            },
+            embedding: {
+                role: 'embedding',
+                provider: 'deterministic_local',
+                baseUrl: '',
+                apiKey: '',
+                modelName: 'deterministic_local',
+                timeoutMs: 30000
+            }
+        };
+    }
+    static defaults() {
+        return new ModelRegistry(ModelRegistry.defaultConfig());
+    }
+    getTextGenerator(role) {
+        return async (system, user) => {
+            return this.generateText(role, system, user, new Set());
+        };
+    }
+    getRoleConfig(role) {
+        return { ...this.config[role] };
+    }
+    getEmbedder() {
+        const role = this.config.embedding;
+        if (role.provider === 'deterministic_local') {
+            throw new Error('Embedding role uses deterministic_local; caller should use Embedder directly.');
+        }
+        if (role.provider !== 'openai_compatible') {
+            throw new Error(`Unsupported embedding provider: ${role.provider}`);
+        }
+        const client = new OpenAICompatibleClient({
+            baseUrl: role.baseUrl || 'http://localhost:11434/v1',
+            apiKey: role.apiKey,
+            timeoutMs: role.timeoutMs
+        });
+        return async (text) => client.embed({
+            model: role.modelName,
+            input: text
+        });
+    }
+    isRuleOnly(role) {
+        return this.resolveTextProvider(role, new Set()) === 'rule_only';
+    }
+    async generateText(roleName, system, user, visited) {
+        if (visited.has(roleName))
+            return '';
+        visited.add(roleName);
+        const role = this.config[roleName];
+        if (role.provider === 'openai_compatible') {
+            const client = new OpenAICompatibleClient({
+                baseUrl: role.baseUrl || 'http://localhost:11434/v1',
+                apiKey: role.apiKey,
+                timeoutMs: role.timeoutMs
+            });
+            const result = await client.chatComplete({
+                model: role.modelName,
+                systemPrompt: system,
+                userPrompt: user
+            });
+            if (result.trim())
+                return result;
+            return this.runFallback(role.fallback, system, user, visited);
+        }
+        if (role.provider === 'anthropic') {
+            if (!role.apiKey?.trim()) {
+                return this.runFallback(role.fallback, system, user, visited);
+            }
+            const client = new AnthropicClient({
+                apiKey: role.apiKey,
+                timeoutMs: role.timeoutMs
+            });
+            const result = await client.chatComplete({
+                model: role.modelName,
+                systemPrompt: system,
+                userPrompt: user
+            });
+            if (result.trim())
+                return result;
+            return this.runFallback(role.fallback, system, user, visited);
+        }
+        return this.runFallback(role.fallback, system, user, visited);
+    }
+    async runFallback(fallback, system, user, visited) {
+        if (!fallback || fallback === 'rule_only' || fallback === 'deterministic_local')
+            return '';
+        return this.generateText(fallback, system, user, visited);
+    }
+    resolveTextProvider(roleName, visited) {
+        if (visited.has(roleName))
+            return 'rule_only';
+        visited.add(roleName);
+        const role = this.config[roleName];
+        if (role.provider === 'rule_only') {
+            if (!role.fallback || role.fallback === 'rule_only' || role.fallback === 'deterministic_local') {
+                return 'rule_only';
+            }
+            if (role.fallback === 'memory' || role.fallback === 'reasoning') {
+                return this.resolveTextProvider(role.fallback, visited);
+            }
+            return 'rule_only';
+        }
+        if (role.provider === 'deterministic_local')
+            return 'rule_only';
+        return role.provider;
+    }
+}

package/dist/models/ModelRole.d.ts

@@ -0,0 +1,19 @@
+export type ModelRoleName = 'memory' | 'reasoning' | 'embedding';
+export type ProviderType = 'openai_compatible' | 'anthropic' | 'rule_only' | 'deterministic_local';
+export interface ModelRoleConfig {
+    role: ModelRoleName;
+    provider: ProviderType;
+    baseUrl?: string;
+    apiKey?: string;
+    modelName: string;
+    timeoutMs?: number;
+    fallback?: ModelRoleName | 'rule_only' | 'deterministic_local';
+}
+export interface ModelRegistryConfig {
+    memory: ModelRoleConfig;
+    reasoning: ModelRoleConfig;
+    embedding: ModelRoleConfig;
+}
+export type TextGenerateFn = (system: string, user: string) => Promise<string>;
+export type EmbedFn = (text: string) => Promise<number[]>;
+//# sourceMappingURL=ModelRole.d.ts.map

package/dist/models/ModelRole.js

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

package/dist/models/UserInsight.d.ts

@@ -0,0 +1,16 @@
+export type UserInsightCategory = 'preference' | 'habit' | 'domain_knowledge' | 'communication_style' | 'goal';
+export interface UserInsight {
+    id: string;
+    projectId: string;
+    category: UserInsightCategory;
+    content: string;
+    confidence: number;
+    initialConfidence?: number;
+    confidenceDelta?: number;
+    evidenceNeuronIds: string[];
+    createdAt: number;
+    lastConfirmedAt: number;
+    expiresAt?: number;
+}
+export declare function confidenceFromEvidenceCount(count: number): number;
+//# sourceMappingURL=UserInsight.d.ts.map

package/dist/models/UserInsight.js

@@ -0,0 +1,9 @@
+export function confidenceFromEvidenceCount(count) {
+    if (count <= 1)
+        return 0.3;
+    if (count <= 3)
+        return 0.5;
+    if (count <= 6)
+        return 0.7;
+    return 0.9;
+}

package/dist/models/UserInsightExtractor.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+import type { IterativeLLMClarifier } from '../routing/IterativeLLMClarifier.js';
+import { type UserInsight } from './UserInsight.js';
+import { UserModelStore } from './UserModelStore.js';
+export interface UserInsightExtractorOptions {
+    maxNeuronsPerRun?: number;
+    triggerThreshold?: number;
+}
+export declare class UserInsightExtractor {
+    private readonly memoryGraph;
+    private readonly userModelStore;
+    private readonly clarifier;
+    private readonly maxNeuronsPerRun;
+    private readonly triggerThreshold;
+    constructor(memoryGraph: MemoryGraph, userModelStore: UserModelStore, clarifier: IterativeLLMClarifier, options?: UserInsightExtractorOptions);
+    extract(projectId: string, windowMs?: number): Promise<UserInsight[]>;
+    private buildPrompt;
+}
+//# sourceMappingURL=UserInsightExtractor.d.ts.map

package/dist/models/UserInsightExtractor.js

@@ -0,0 +1,99 @@
+import { confidenceFromEvidenceCount } from './UserInsight.js';
+export class UserInsightExtractor {
+    memoryGraph;
+    userModelStore;
+    clarifier;
+    maxNeuronsPerRun;
+    triggerThreshold;
+    constructor(memoryGraph, userModelStore, clarifier, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.userModelStore = userModelStore;
+        this.clarifier = clarifier;
+        this.maxNeuronsPerRun = options.maxNeuronsPerRun ?? 50;
+        this.triggerThreshold = options.triggerThreshold ?? 10;
+    }
+    async extract(projectId, windowMs = 24 * 60 * 60 * 1000) {
+        const end = Date.now();
+        const neurons = this.memoryGraph
+            .listNeuronsByTimeRange(end - windowMs, end + 1, projectId)
+            .filter((neuron) => neuron.metadata.type === 'chat' || neuron.metadata.type === 'agent_finding')
+            .slice(-this.maxNeuronsPerRun);
+        if (neurons.length < this.triggerThreshold)
+            return [];
+        const prompt = this.buildPrompt(projectId, neurons);
+        const result = await this.clarifier.clarify(prompt, emptyRecallResult(prompt));
+        const parsed = parseInsights(result.finalAnswer);
+        const now = Date.now();
+        const created = [];
+        for (const item of parsed) {
+            const evidenceNeuronIds = Array.from(new Set((item.evidenceNeuronIds?.length ? item.evidenceNeuronIds : neurons.map((n) => n.id))
+                .filter((id) => neurons.some((neuron) => neuron.id === id))));
+            if (!item.content.trim() || evidenceNeuronIds.length === 0)
+                continue;
+            const insight = {
+                id: `user-insight-${projectId}-${now}-${Math.random().toString(36).slice(2)}`,
+                projectId,
+                category: item.category,
+                content: item.content.trim(),
+                confidence: confidenceFromEvidenceCount(evidenceNeuronIds.length),
+                evidenceNeuronIds,
+                createdAt: now,
+                lastConfirmedAt: now,
+                expiresAt: item.expiresAt
+            };
+            this.userModelStore.upsert(insight);
+            created.push(insight);
+        }
+        return created;
+    }
+    buildPrompt(projectId, neurons) {
+        return [
+            'Extract durable user insights from these cogmem memories.',
+            'Return JSON array only. Each item: {category, content, evidenceNeuronIds, expiresAt?}.',
+            'Allowed categories: preference, habit, domain_knowledge, communication_style, goal.',
+            'Do not include confidence; CPU will calculate it.',
+            `Project: ${projectId}`,
+            JSON.stringify(neurons.map((neuron) => ({
+                id: neuron.id,
+                type: neuron.metadata.type,
+                tags: neuron.metadata.tags || [],
+                content: neuron.content.slice(0, 500)
+            })))
+        ].join('\n');
+    }
+}
+function parseInsights(raw) {
+    try {
+        const parsed = JSON.parse(raw.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, ''));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isParsedInsight);
+    }
+    catch {
+        return [];
+    }
+}
+function isParsedInsight(value) {
+    const item = value;
+    return Boolean(item)
+        && isCategory(item.category)
+        && typeof item.content === 'string';
+}
+function isCategory(value) {
+    return value === 'preference'
+        || value === 'habit'
+        || value === 'domain_knowledge'
+        || value === 'communication_style'
+        || value === 'goal';
+}
+function emptyRecallResult(query) {
+    return {
+        query,
+        strategy: { primaryLevel: 'compiled_memory', fallbackUsed: false },
+        compiledMemory: { beliefs: [], facts: [], events: [], entityTimeline: [] },
+        rawEvidence: [],
+        fallbackSnippets: [],
+        profileSignals: [],
+        profileSurface: { userProfile: [], agentPersona: [] }
+    };
+}

package/dist/models/UserModelManager.d.ts

@@ -0,0 +1,21 @@
+import type { UserInsight } from './UserInsight.js';
+import type { UserInsightExtractor } from './UserInsightExtractor.js';
+import type { UserModelStore } from './UserModelStore.js';
+import type { MemoryDelta, WorkingMemoryReporter } from './WorkingMemoryReporter.js';
+export interface UserContext {
+    projectId: string;
+    insights: UserInsight[];
+    delta?: MemoryDelta;
+    toPromptFragment(): string;
+}
+export declare class UserModelManager {
+    private readonly userModelStore;
+    private readonly extractor;
+    private readonly reporter?;
+    private readonly latestDeltaByProject;
+    constructor(userModelStore: UserModelStore, extractor: UserInsightExtractor, reporter?: WorkingMemoryReporter | undefined);
+    refresh(projectId: string): Promise<void>;
+    getUserContext(projectId: string, topK?: number): UserContext;
+    evict(): void;
+}
+//# sourceMappingURL=UserModelManager.d.ts.map

package/dist/models/UserModelManager.js

@@ -0,0 +1,41 @@
+export class UserModelManager {
+    userModelStore;
+    extractor;
+    reporter;
+    latestDeltaByProject = new Map();
+    constructor(userModelStore, extractor, reporter) {
+        this.userModelStore = userModelStore;
+        this.extractor = extractor;
+        this.reporter = reporter;
+    }
+    async refresh(projectId) {
+        const previousSnapshot = this.reporter
+            ? this.userModelStore.query(projectId, { minConfidence: 0, limit: Number.MAX_SAFE_INTEGER })
+            : [];
+        await this.extractor.extract(projectId);
+        if (this.reporter)
+            this.latestDeltaByProject.set(projectId, this.reporter.computeDelta(projectId, previousSnapshot));
+    }
+    getUserContext(projectId, topK = 5) {
+        const insights = this.userModelStore.query(projectId, { minConfidence: 0.3, limit: topK });
+        const delta = this.latestDeltaByProject.get(projectId);
+        return {
+            projectId,
+            insights,
+            delta,
+            toPromptFragment: () => formatPromptFragment(projectId, insights, this.reporter?.formatDelta(delta || emptyDelta()))
+        };
+    }
+    evict() {
+        this.userModelStore.evictExpired();
+    }
+}
+function formatPromptFragment(projectId, insights, deltaFragment = '') {
+    if (insights.length === 0)
+        return '';
+    const lines = insights.map((insight) => `- [${insight.category}, confidence=${insight.confidence.toFixed(1)}] ${insight.content}`);
+    return ['【用户模型】', `projectId=${projectId}`, deltaFragment, ...lines].filter(Boolean).join('\n');
+}
+function emptyDelta() {
+    return { newInsights: [], strengthenedInsights: [], weakenedInsights: [], expiredInsights: [], snapshotAt: Date.now() };
+}

package/dist/models/UserModelStore.d.ts

@@ -0,0 +1,20 @@
+import type Database from 'bun:sqlite';
+import { type UserInsight, type UserInsightCategory } from './UserInsight.js';
+export declare class UserModelStore {
+    private readonly db;
+    constructor(db: Database);
+    initSchema(): void;
+    upsert(insight: UserInsight): void;
+    query(projectId: string, options?: {
+        categories?: UserInsightCategory[];
+        minConfidence?: number;
+        limit?: number;
+    }): UserInsight[];
+    reinforce(insightId: string, newEvidenceNeuronIds: string[]): void;
+    evictExpired(now?: number): number;
+    get(insightId: string): UserInsight | null;
+    private findByIdentity;
+    private mapRow;
+    private ensureColumn;
+}
+//# sourceMappingURL=UserModelStore.d.ts.map

package/dist/models/UserModelStore.js

@@ -0,0 +1,136 @@
+import { confidenceFromEvidenceCount } from './UserInsight.js';
+export class UserModelStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS user_insights (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        category TEXT NOT NULL,
+        content TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        initial_confidence REAL,
+        confidence_delta REAL,
+        evidence_neuron_ids TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        last_confirmed_at INTEGER NOT NULL,
+        expires_at INTEGER,
+        UNIQUE(project_id, category, content)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_user_insights_project_confidence
+        ON user_insights(project_id, confidence DESC);
+    `);
+        this.ensureColumn('initial_confidence', 'ALTER TABLE user_insights ADD COLUMN initial_confidence REAL');
+        this.ensureColumn('confidence_delta', 'ALTER TABLE user_insights ADD COLUMN confidence_delta REAL');
+    }
+    upsert(insight) {
+        const existing = this.findByIdentity(insight.projectId, insight.category, insight.content);
+        if (existing) {
+            this.db.prepare(`
+        UPDATE user_insights
+        SET confidence = ?,
+            initial_confidence = COALESCE(initial_confidence, ?),
+            confidence_delta = ?,
+            evidence_neuron_ids = ?,
+            last_confirmed_at = ?,
+            expires_at = ?
+        WHERE id = ?
+      `).run(insight.confidence, existing.initialConfidence ?? existing.confidence, insight.confidence - existing.confidence, JSON.stringify(Array.from(new Set([...existing.evidenceNeuronIds, ...insight.evidenceNeuronIds]))), insight.lastConfirmedAt, insight.expiresAt ?? null, existing.id);
+            return;
+        }
+        this.db.prepare(`
+      INSERT INTO user_insights (
+        id, project_id, category, content, confidence, evidence_neuron_ids,
+        initial_confidence, confidence_delta, created_at, last_confirmed_at, expires_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(insight.id, insight.projectId, insight.category, insight.content, insight.confidence, JSON.stringify(Array.from(new Set(insight.evidenceNeuronIds))), insight.initialConfidence ?? insight.confidence, insight.confidenceDelta ?? 0, insight.createdAt, insight.lastConfirmedAt, insight.expiresAt ?? null);
+    }
+    query(projectId, options = {}) {
+        const clauses = ['project_id = ?'];
+        const params = [projectId];
+        if (options.categories?.length) {
+            clauses.push(`category IN (${options.categories.map(() => '?').join(', ')})`);
+            params.push(...options.categories);
+        }
+        if (options.minConfidence !== undefined) {
+            clauses.push('confidence >= ?');
+            params.push(options.minConfidence);
+        }
+        params.push(options.limit ?? 20);
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM user_insights
+      WHERE ${clauses.join(' AND ')}
+      ORDER BY confidence DESC, last_confirmed_at DESC, created_at DESC
+      LIMIT ?
+    `).all(...params);
+        return rows.map((row) => this.mapRow(row));
+    }
+    reinforce(insightId, newEvidenceNeuronIds) {
+        const current = this.get(insightId);
+        if (!current)
+            return;
+        const evidence = Array.from(new Set([...current.evidenceNeuronIds, ...newEvidenceNeuronIds]));
+        this.db.prepare(`
+      UPDATE user_insights
+      SET evidence_neuron_ids = ?,
+          confidence = ?,
+          initial_confidence = COALESCE(initial_confidence, ?),
+          confidence_delta = ?,
+          last_confirmed_at = ?
+      WHERE id = ?
+    `).run(JSON.stringify(evidence), confidenceFromEvidenceCount(evidence.length), current.initialConfidence ?? current.confidence, confidenceFromEvidenceCount(evidence.length) - current.confidence, Date.now(), insightId);
+    }
+    evictExpired(now = Date.now()) {
+        const result = this.db.prepare(`
+      DELETE FROM user_insights
+      WHERE expires_at IS NOT NULL AND expires_at < ?
+    `).run(now);
+        return result.changes;
+    }
+    get(insightId) {
+        const row = this.db.prepare(`SELECT * FROM user_insights WHERE id = ?`).get(insightId);
+        return row ? this.mapRow(row) : null;
+    }
+    findByIdentity(projectId, category, content) {
+        const row = this.db.prepare(`
+      SELECT * FROM user_insights
+      WHERE project_id = ? AND category = ? AND content = ?
+    `).get(projectId, category, content);
+        return row ? this.mapRow(row) : null;
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            category: row.category,
+            content: row.content,
+            confidence: row.confidence,
+            initialConfidence: row.initial_confidence ?? undefined,
+            confidenceDelta: row.confidence_delta ?? undefined,
+            evidenceNeuronIds: parseEvidence(row.evidence_neuron_ids),
+            createdAt: row.created_at,
+            lastConfirmedAt: row.last_confirmed_at,
+            expiresAt: row.expires_at ?? undefined
+        };
+    }
+    ensureColumn(columnName, alterSql) {
+        const columns = this.db.prepare('PRAGMA table_info(user_insights)').all();
+        if (!columns.some((column) => column.name === columnName))
+            this.db.exec(alterSql);
+    }
+}
+function parseEvidence(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/models/WorkingMemoryReporter.d.ts

@@ -0,0 +1,16 @@
+import type { UserInsight } from './UserInsight.js';
+import type { UserModelStore } from './UserModelStore.js';
+export interface MemoryDelta {
+    newInsights: UserInsight[];
+    strengthenedInsights: UserInsight[];
+    weakenedInsights: UserInsight[];
+    expiredInsights: UserInsight[];
+    snapshotAt: number;
+}
+export declare class WorkingMemoryReporter {
+    private readonly userModelStore;
+    constructor(userModelStore: UserModelStore);
+    computeDelta(projectId: string, previousSnapshot: UserInsight[]): MemoryDelta;
+    formatDelta(delta: MemoryDelta): string;
+}
+//# sourceMappingURL=WorkingMemoryReporter.d.ts.map

package/dist/models/WorkingMemoryReporter.js

@@ -0,0 +1,38 @@
+export class WorkingMemoryReporter {
+    userModelStore;
+    constructor(userModelStore) {
+        this.userModelStore = userModelStore;
+    }
+    computeDelta(projectId, previousSnapshot) {
+        const current = this.userModelStore.query(projectId, { minConfidence: 0, limit: Number.MAX_SAFE_INTEGER });
+        const previousByKey = new Map(previousSnapshot.map((insight) => [insightKey(insight), insight]));
+        const currentByKey = new Map(current.map((insight) => [insightKey(insight), insight]));
+        const newInsights = current.filter((insight) => !previousByKey.has(insightKey(insight)));
+        const strengthenedInsights = current.filter((insight) => (insight.confidence - (previousByKey.get(insightKey(insight))?.confidence ?? insight.confidence)) >= 0.2);
+        const weakenedInsights = current.filter((insight) => (insight.confidence - (previousByKey.get(insightKey(insight))?.confidence ?? insight.confidence)) <= -0.2);
+        const expiredInsights = previousSnapshot.filter((insight) => !currentByKey.has(insightKey(insight)));
+        return { newInsights, strengthenedInsights, weakenedInsights, expiredInsights, snapshotAt: Date.now() };
+    }
+    formatDelta(delta) {
+        const lines = [];
+        if (delta.newInsights.length)
+            lines.push(`新出现：${delta.newInsights.map(formatInsight).join('；')}`);
+        if (delta.strengthenedInsights.length)
+            lines.push(`增强：${delta.strengthenedInsights.map(formatTrend).join('；')}`);
+        if (delta.weakenedInsights.length)
+            lines.push(`减弱：${delta.weakenedInsights.map(formatTrend).join('；')}`);
+        if (delta.expiredInsights.length)
+            lines.push(`过期：${delta.expiredInsights.map((insight) => insight.content).join('；')}`);
+        return lines.length ? ['[近期变化]', ...lines].join('\n') : '';
+    }
+}
+function insightKey(insight) {
+    return `${insight.projectId}|${insight.category}|${insight.content}`;
+}
+function formatInsight(insight) {
+    return `${insight.content}（置信度 ${insight.confidence.toFixed(1)}）`;
+}
+function formatTrend(insight) {
+    const from = Math.max(0, Math.min(1, insight.confidence - (insight.confidenceDelta ?? 0)));
+    return `${insight.content}（${from.toFixed(1)} -> ${insight.confidence.toFixed(1)}）`;
+}

package/dist/models/adapters/MemoryReviewAdapter.d.ts

@@ -0,0 +1,12 @@
+import { type AlgorithmReviewBackend, type ReviewMultiFactExtractionCandidatesInput, type ReviewMultiFactExtractionCandidatesResult, type ReviewProvisionalFactCandidatesInput, type ReviewProvisionalFactCandidatesResult, type ReviewSelfCorrectionCandidatesInput, type ReviewSelfCorrectionCandidatesResult } from '../../algorithm/AlgorithmReviewBackend.js';
+import { ModelRegistry } from '../ModelRegistry.js';
+import type { TextGenerateFn } from '../ModelRole.js';
+export declare class MemoryReviewAdapter implements AlgorithmReviewBackend {
+    private generateFn;
+    constructor(generateFn: TextGenerateFn);
+    reviewProvisionalFactCandidates(input: ReviewProvisionalFactCandidatesInput): Promise<ReviewProvisionalFactCandidatesResult>;
+    reviewSelfCorrectionCandidates(input: ReviewSelfCorrectionCandidatesInput): Promise<ReviewSelfCorrectionCandidatesResult>;
+    reviewMultiFactExtractionCandidates(input: ReviewMultiFactExtractionCandidatesInput): Promise<ReviewMultiFactExtractionCandidatesResult>;
+}
+export declare function createMemoryReviewAdapter(registry: ModelRegistry): AlgorithmReviewBackend;
+//# sourceMappingURL=MemoryReviewAdapter.d.ts.map