cogmem 3.6.2

package/dist/batch/SourceOnboarding.js

@@ -0,0 +1,366 @@
+import { basename, extname } from 'node:path';
+import { parseNormalizationMetadata } from '../utils/ConversationMarkdownNormalization.js';
+import { ConversationMarkdownAdapter, MarkdownSourceLoader, OpenClawDailyMemoryAdapter, OpenClawMemoryIndexAdapter, OpenClawPersonaAdapter, OpenClawSessionAdapter, OpenClawUserProfileAdapter, SoulMarkdownAdapter } from '../adapters/index.js';
+const loader = new MarkdownSourceLoader();
+const adapters = new Map([
+    ['conversation_markdown', new ConversationMarkdownAdapter()],
+    ['soul_markdown', new SoulMarkdownAdapter()],
+    ['openclaw_daily_memory', new OpenClawDailyMemoryAdapter()],
+    ['openclaw_session', new OpenClawSessionAdapter()],
+    ['openclaw_memory_index', new OpenClawMemoryIndexAdapter()],
+    ['openclaw_user_profile', new OpenClawUserProfileAdapter()],
+    ['openclaw_persona', new OpenClawPersonaAdapter()]
+]);
+export function classifyLane(source) {
+    const name = basename(source.sourcePath).toLowerCase();
+    if (source.adapterKind === 'openclaw_user_profile' || source.tags?.includes('namespace:user_profile') || name === 'user.md') {
+        return 'user_profile';
+    }
+    if (source.adapterKind === 'openclaw_persona'
+        || source.tags?.includes('namespace:agent_persona')
+        || name === 'soul.md'
+        || name === 'identity.md') {
+        return 'agent_persona';
+    }
+    if (source.adapterKind === 'openclaw_memory_index' || name === 'memory.md') {
+        return 'memory_index';
+    }
+    if (source.adapterKind === 'conversation_markdown' || source.adapterKind === 'openclaw_session') {
+        return 'conversation_source';
+    }
+    if (source.adapterKind === 'soul_markdown' || source.adapterKind === 'openclaw_daily_memory') {
+        return 'soul_like_source';
+    }
+    return 'unknown';
+}
+function hasContractMismatch(diagnostics) {
+    return diagnostics.some((item) => /_contract_mismatch$/.test(item.code));
+}
+function hasWarning(diagnostics) {
+    return diagnostics.some((item) => item.severity === 'warning');
+}
+function buildAlternateSource(source, adapterKind) {
+    return {
+        ...source,
+        adapterKind
+    };
+}
+function safeAdapt(source, window, applyWindow) {
+    const adapter = adapters.get(source.adapterKind);
+    if (!adapter) {
+        throw new Error(`Unsupported adapter kind: ${source.adapterKind}`);
+    }
+    const snapshot = loader.read(source);
+    return adapter.adapt(source, snapshot, applyWindow && !source.tags?.includes('ingest:profile_only')
+        ? { start: window.start, end: window.end }
+        : undefined);
+}
+function looksLikeNormalizationOnlyPath(sourcePath) {
+    const ext = extname(sourcePath).toLowerCase();
+    return ext === '.jsonl' || ext === '.json' || ext === '.csv' || ext === '.tsv' || ext === '.log' || ext === '.txt';
+}
+function suggestedNormalizerForPath(sourcePath) {
+    const ext = extname(sourcePath).toLowerCase();
+    if (ext === '.jsonl')
+        return 'bun run normalize:jsonl -- --input ... --output ...';
+    if (ext === '.json')
+        return 'bun run normalize:json-array -- --input ... --output ...';
+    if (ext === '.csv' || ext === '.tsv')
+        return 'bun run normalize:csv -- --input ... --output ...';
+    if (ext === '.log' || ext === '.txt')
+        return 'export/preprocess outside the brain, then run a custom normalizer script';
+    return undefined;
+}
+function looksLikeAppPrivateJsonExport(content, sourcePath) {
+    if (extname(sourcePath).toLowerCase() !== '.json')
+        return false;
+    try {
+        const parsed = JSON.parse(content);
+        return Array.isArray(parsed.events)
+            && (typeof parsed.app === 'string'
+                || typeof parsed.workspace === 'string'
+                || typeof parsed.conversation === 'object');
+    }
+    catch {
+        return false;
+    }
+}
+function describeNormalizationFamily(family) {
+    switch (family) {
+        case 'jsonl_transcript_export':
+            return 'JSONL transcript export';
+        case 'json_array_transcript_export':
+            return 'JSON array transcript export';
+        case 'csv_transcript_export':
+            return 'CSV transcript export';
+        case 'tsv_transcript_export':
+            return 'TSV transcript export';
+        case 'app_private_mixed_event_export':
+            return 'app-private mixed-event export';
+        case 'jsonl_mixed_event_log_export':
+            return 'JSONL-like mixed-event log export';
+        default:
+            return 'unknown export';
+    }
+}
+function probeReroute(source, window, snapshotContent) {
+    const recommendations = [];
+    const loweredName = basename(source.sourcePath).toLowerCase();
+    if (looksLikeNormalizationOnlyPath(source.sourcePath)) {
+        if (snapshotContent && looksLikeAppPrivateJsonExport(snapshotContent, source.sourcePath)) {
+            return {
+                normalizationRequired: true,
+                recommendations: [
+                    'This looks like an app-private / proprietary JSON dump, not direct conversation markdown. Recommended onboarding order: export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall. First step: bun run normalize:app-private -- --input ... --output ...'
+                ]
+            };
+        }
+        const suggested = suggestedNormalizerForPath(source.sourcePath);
+        return {
+            normalizationRequired: true,
+            recommendations: [
+                suggested
+                    ? `This looks like a non-markdown export. Recommended onboarding order: export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall. First step: ${suggested}.`
+                    : 'Normalize or export this source into minimal conversation markdown before batch ingest.'
+            ]
+        };
+    }
+    if (source.adapterKind === 'conversation_markdown') {
+        const alt = safeAdapt(buildAlternateSource(source, 'soul_markdown'), window, false);
+        if (alt.records.length > 0) {
+            recommendations.push('This file is note/profile shaped; reroute it through repeated --soul.');
+            return {
+                rerouteSuggestion: '--soul',
+                normalizationRequired: false,
+                recommendations
+            };
+        }
+        if (loweredName === 'user.md' || loweredName === 'soul.md' || loweredName === 'identity.md' || loweredName === 'memory.md') {
+            recommendations.push('Profile/persona and memory-index markdown should not be passed through --conversation.');
+            return {
+                rerouteSuggestion: '--soul',
+                normalizationRequired: false,
+                recommendations
+            };
+        }
+    }
+    if (source.adapterKind === 'soul_markdown') {
+        const alt = safeAdapt(buildAlternateSource(source, 'conversation_markdown'), window, false);
+        if (alt.records.length > 0) {
+            recommendations.push('This file is transcript-shaped; reroute it through repeated --conversation.');
+            return {
+                rerouteSuggestion: '--conversation',
+                normalizationRequired: false,
+                recommendations
+            };
+        }
+    }
+    recommendations.push('Normalize or export this source into the supported markdown contract before ingest.');
+    return {
+        normalizationRequired: true,
+        recommendations
+    };
+}
+export function inspectSources(sources, window, seenHashesBySourceId = new Map()) {
+    const sourceReports = sources.map((source) => {
+        const snapshot = loader.read(source);
+        const normalizationMetadata = parseNormalizationMetadata(snapshot.content);
+        const adapted = safeAdapt(source, window, false);
+        const windowed = safeAdapt(source, window, true);
+        const seenHashes = seenHashesBySourceId.get(source.sourceId) || new Set();
+        const recordsPending = windowed.records.filter((record) => !seenHashes.has(record.provenance.recordHash)).length;
+        const diagnostics = adapted.diagnostics || [];
+        const lane = classifyLane(source);
+        const mismatch = hasContractMismatch(diagnostics);
+        const rerouteProbe = mismatch ? probeReroute(source, window, snapshot.content) : {
+            rerouteSuggestion: undefined,
+            normalizationRequired: false,
+            recommendations: []
+        };
+        const obviousProfileMisroute = source.adapterKind === 'conversation_markdown' && (lane === 'user_profile' || lane === 'agent_persona');
+        const routeStatus = mismatch
+            ? rerouteProbe.rerouteSuggestion
+                ? 'reroute'
+                : rerouteProbe.normalizationRequired
+                    ? 'normalize'
+                    : 'blocked'
+            : hasWarning(diagnostics) || obviousProfileMisroute
+                ? 'warning'
+                : 'supported';
+        const recommendations = [...rerouteProbe.recommendations];
+        if (normalizationMetadata.isNormalized && source.adapterKind === 'conversation_markdown' && !mismatch) {
+            const normalizedFamilyLabel = normalizationMetadata.originalInputFamily
+                ? describeNormalizationFamily(normalizationMetadata.originalInputFamily)
+                : 'normalized export';
+            recommendations.push(`Normalized ${normalizedFamilyLabel} detected. Recommended onboarding path: export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall.`);
+        }
+        if (obviousProfileMisroute) {
+            recommendations.push('Route profile/persona markdown through repeated --soul so it stays in the profile lane.');
+        }
+        if (!mismatch && adapted.records.length > 0 && recordsPending === 0) {
+            recommendations.push('This source is parseable, but the selected window currently yields no new records.');
+        }
+        if (!mismatch && hasWarning(diagnostics) && diagnostics.some((item) => item.code === 'soul_missing_frontmatter_fields')) {
+            recommendations.push('The file is ingestable, but add frontmatter if timestamp placement matters.');
+        }
+        return {
+            sourceId: source.sourceId,
+            sourcePath: source.sourcePath,
+            adapterKind: source.adapterKind,
+            lane,
+            recordsParsed: adapted.records.length,
+            recordsPending,
+            diagnostics,
+            shouldContinue: !mismatch,
+            rerouteSuggestion: rerouteProbe.rerouteSuggestion,
+            normalizationRequired: rerouteProbe.normalizationRequired,
+            isNormalizedOutput: normalizationMetadata.isNormalized,
+            normalizationContract: normalizationMetadata.contractVersion,
+            normalizedSourceFamily: normalizationMetadata.normalizedSourceFamily,
+            originalInputFamily: normalizationMetadata.originalInputFamily,
+            normalizedFrom: normalizationMetadata.originalInputFamily,
+            routeStatus,
+            recommendations
+        };
+    });
+    return {
+        window,
+        sourcesScanned: sourceReports.length,
+        conversationSources: sourceReports.filter((item) => item.lane === 'conversation_source').map((item) => item.sourcePath),
+        soulLikeSources: sourceReports.filter((item) => item.lane === 'soul_like_source' || item.lane === 'memory_index').map((item) => item.sourcePath),
+        userProfileSources: sourceReports.filter((item) => item.lane === 'user_profile').map((item) => item.sourcePath),
+        agentPersonaSources: sourceReports.filter((item) => item.lane === 'agent_persona').map((item) => item.sourcePath),
+        memoryIndexSources: sourceReports.filter((item) => item.lane === 'memory_index').map((item) => item.sourcePath),
+        contractMismatchFiles: sourceReports.filter((item) => hasContractMismatch(item.diagnostics)).map((item) => item.sourcePath),
+        rerouteToConversation: sourceReports.filter((item) => item.rerouteSuggestion === '--conversation').map((item) => item.sourcePath),
+        rerouteToSoul: sourceReports.filter((item) => item.rerouteSuggestion === '--soul').map((item) => item.sourcePath),
+        normalizationRequired: sourceReports.filter((item) => item.normalizationRequired).map((item) => item.sourcePath),
+        shouldProceed: sourceReports.every((item) => item.shouldContinue),
+        sourceReports
+    };
+}
+function isCriticalSource(source) {
+    return source.metadata?.strictCritical === true;
+}
+export function evaluateStrictPreflightFailures(sources, preflight) {
+    const failures = [];
+    for (const source of sources) {
+        if (!isCriticalSource(source))
+            continue;
+        const report = preflight.sourceReports.find((item) => item.sourceId === source.sourceId);
+        if (!report)
+            continue;
+        if (report.normalizationRequired) {
+            const snapshot = loader.read(source);
+            if (looksLikeAppPrivateJsonExport(snapshot.content, source.sourcePath)) {
+                failures.push({
+                    sourcePath: source.sourcePath,
+                    reason: 'Source requires export/preprocess before ingest. Recommended onboarding order: export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall. First step: bun run normalize:app-private -- --input ... --output ...'
+                });
+                continue;
+            }
+            const suggested = suggestedNormalizerForPath(source.sourcePath);
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: suggested
+                    ? `Source requires normalization/export before ingest. Recommended onboarding order: export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall. First step: ${suggested}`
+                    : 'Source requires normalization/export before ingest.'
+            });
+            continue;
+        }
+        if (report.diagnostics.some((item) => item.code === 'conversation_contract_mismatch')) {
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: 'Explicit --conversation source does not match the conversation contract.'
+            });
+            continue;
+        }
+        if (source.adapterKind === 'conversation_markdown' && (report.lane === 'user_profile' || report.lane === 'agent_persona')) {
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: 'Profile/persona markdown was routed through --conversation.'
+            });
+            continue;
+        }
+        if (report.rerouteSuggestion) {
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: `Source should be rerouted through ${report.rerouteSuggestion}.`
+            });
+            continue;
+        }
+    }
+    return failures;
+}
+export function evaluateStrictPostIngestFailures(sources, preflight, sourceResults) {
+    const failures = [];
+    for (const source of sources) {
+        if (!isCriticalSource(source))
+            continue;
+        const report = preflight.sourceReports.find((item) => item.sourceId === source.sourceId);
+        const result = sourceResults.find((item) => item.sourceId === source.sourceId);
+        if (!report || !result)
+            continue;
+        const misroutingDiagnostic = result.diagnostics.some((item) => item.code === 'conversation_contract_mismatch' || item.code === 'soul_contract_mismatch');
+        if (result.recordsIngested === 0 && misroutingDiagnostic) {
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: 'Critical source did not ingest any records because the current route is mismatched.'
+            });
+            continue;
+        }
+        if (result.recordsIngested === 0 && report.recordsPending > 0 && report.diagnostics.every((item) => item.severity === 'warning')) {
+            failures.push({
+                sourcePath: source.sourcePath,
+                reason: 'Critical source produced warning-only output but no records reached the brain.'
+            });
+        }
+    }
+    return failures;
+}
+export function formatPreflightSummary(preflight) {
+    const lines = [];
+    const addGroup = (label, paths) => {
+        lines.push(`${label}: ${paths.length}`);
+        for (const path of paths) {
+            lines.push(`  - ${path}`);
+        }
+    };
+    lines.push(`Batch preflight for ${preflight.window.label}`);
+    lines.push(`Proceed: ${preflight.shouldProceed ? 'yes' : 'no'}`);
+    lines.push(`Recommended onboarding path: ${preflight.normalizationRequired.length > 0 ? 'export/preprocess -> normalize -> ' : ''}batch:preflight -> batch:consolidate --strict -> recall`);
+    lines.push('');
+    addGroup('Conversation sources', preflight.conversationSources);
+    addGroup('Soul-like sources', preflight.soulLikeSources);
+    addGroup('User profile sources', preflight.userProfileSources);
+    addGroup('Agent persona sources', preflight.agentPersonaSources);
+    if (preflight.contractMismatchFiles.length > 0) {
+        lines.push('');
+        addGroup('Contract mismatches', preflight.contractMismatchFiles);
+    }
+    if (preflight.rerouteToConversation.length > 0) {
+        lines.push('');
+        addGroup('Should reroute to --conversation', preflight.rerouteToConversation);
+    }
+    if (preflight.rerouteToSoul.length > 0) {
+        lines.push('');
+        addGroup('Should reroute to --soul', preflight.rerouteToSoul);
+    }
+    if (preflight.normalizationRequired.length > 0) {
+        lines.push('');
+        addGroup('Normalization/export required', preflight.normalizationRequired);
+    }
+    lines.push('');
+    lines.push('Per-source details:');
+    for (const report of preflight.sourceReports) {
+        lines.push(`- ${report.sourcePath}`);
+        lines.push(`  lane=${report.lane} status=${report.routeStatus} parsed=${report.recordsParsed} pending=${report.recordsPending}${report.isNormalizedOutput ? ` normalized_output=true` : ''}${report.normalizationContract ? ` normalization_contract=${report.normalizationContract}` : ''}${report.normalizedSourceFamily ? ` normalized_source_family=${report.normalizedSourceFamily}` : ''}${report.originalInputFamily ? ` original_input_family=${report.originalInputFamily}` : ''}`);
+        for (const diagnostic of report.diagnostics) {
+            lines.push(`  diagnostic=${diagnostic.severity}:${diagnostic.code} ${diagnostic.message}`);
+        }
+        for (const recommendation of report.recommendations) {
+            lines.push(`  suggestion=${recommendation}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/belief/BeliefGovernanceService.d.ts

@@ -0,0 +1,59 @@
+import Database from 'bun:sqlite';
+export type BeliefOwnership = 'user' | 'project' | 'system';
+export type GovernedBeliefType = 'preference' | 'goal' | 'boundary' | 'decision' | 'fact' | 'observation';
+export type GovernedBeliefStatus = 'active' | 'weak' | 'needs_confirmation' | 'possible_conflict' | 'superseded' | 'rejected';
+export type BeliefRelation = 'assert' | 'reinforce' | 'correct' | 'contradict';
+export interface BeliefEvidenceRecord {
+    eventId: string;
+    projectId?: string;
+    role?: string;
+}
+export interface GovernedBeliefRecord {
+    beliefId: string;
+    projectId?: string;
+    ownership: BeliefOwnership;
+    beliefType: GovernedBeliefType;
+    canonicalKey: string;
+    statement: string;
+    status: GovernedBeliefStatus;
+    confidence: number;
+    version: number;
+    validFrom: number;
+    validTo?: number;
+    supersedesBeliefId?: string;
+    supersededByBeliefId?: string;
+    evidenceEventIds: string[];
+    sourceRoles: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ApplyBeliefInput {
+    projectId?: string;
+    ownership: BeliefOwnership;
+    beliefType: GovernedBeliefType;
+    canonicalKey: string;
+    statement: string;
+    evidenceEventIds: string[];
+    relation?: BeliefRelation;
+    confidence?: number;
+    reason?: string;
+    occurredAt?: number;
+}
+export type BeliefEvidenceLookup = (eventId: string) => BeliefEvidenceRecord | undefined;
+export declare class BeliefGovernanceService {
+    private readonly db;
+    private readonly findEvidence;
+    constructor(db: Database, findEvidence: BeliefEvidenceLookup);
+    apply(input: ApplyBeliefInput): GovernedBeliefRecord;
+    getById(beliefId: string): GovernedBeliefRecord | null;
+    getCurrent(projectId: string | undefined, canonicalKey: string): GovernedBeliefRecord[];
+    getHistory(projectId: string | undefined, canonicalKey: string): GovernedBeliefRecord[];
+    private reinforce;
+    private insertEvidence;
+    private insertVersion;
+    private mapRow;
+    private normalizeStatement;
+    private clamp;
+    private initializeSchema;
+}
+//# sourceMappingURL=BeliefGovernanceService.d.ts.map

package/dist/belief/BeliefGovernanceService.js

@@ -0,0 +1,183 @@
+import { randomUUID } from 'node:crypto';
+export class BeliefGovernanceService {
+    db;
+    findEvidence;
+    constructor(db, findEvidence) {
+        this.db = db;
+        this.findEvidence = findEvidence;
+        this.initializeSchema();
+    }
+    apply(input) {
+        const canonicalKey = input.canonicalKey.trim().toLowerCase();
+        const statement = input.statement.trim();
+        if (!canonicalKey || !statement)
+            throw new Error('belief_key_and_statement_required');
+        if (input.evidenceEventIds.length === 0)
+            throw new Error('missing_evidence');
+        const evidence = input.evidenceEventIds.map((eventId) => this.findEvidence(eventId));
+        if (evidence.some((item) => !item))
+            throw new Error('unknown_evidence');
+        if (input.projectId && evidence.some((item) => item?.projectId && item.projectId !== input.projectId)) {
+            throw new Error('project_boundary_violation');
+        }
+        if (input.ownership === 'user' && !evidence.some((item) => item?.role === 'user')) {
+            throw new Error('user_ownership_requires_user_evidence');
+        }
+        const relation = input.relation ?? 'assert';
+        const current = this.getCurrent(input.projectId, canonicalKey)[0];
+        const sameStatement = current && this.normalizeStatement(current.statement) === this.normalizeStatement(statement);
+        if (current && (relation === 'reinforce' || (relation === 'assert' && sameStatement))) {
+            return this.reinforce(current, input, evidence);
+        }
+        const status = current && relation !== 'correct'
+            ? 'possible_conflict'
+            : 'active';
+        const now = input.occurredAt ?? Date.now();
+        const beliefId = `belief-${randomUUID()}`;
+        const confidence = this.clamp(input.confidence ?? (input.ownership === 'user' ? 0.86 : 0.72));
+        const transaction = this.db.transaction(() => {
+            if (current && relation === 'correct') {
+                this.db.prepare(`
+          UPDATE belief_graph_nodes
+          SET status = 'superseded', valid_to = ?, superseded_by_belief_id = ?, updated_at = ?
+          WHERE belief_id = ? AND status = 'active'
+        `).run(now, beliefId, now, current.beliefId);
+            }
+            this.db.prepare(`
+        INSERT INTO belief_graph_nodes (
+          belief_id, project_id, ownership, belief_type, canonical_key, statement, status,
+          confidence, version, valid_from, valid_to, supersedes_belief_id,
+          superseded_by_belief_id, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, NULL, ?, NULL, ?, ?)
+      `).run(beliefId, input.projectId ?? null, input.ownership, input.beliefType, canonicalKey, statement, status, confidence, now, relation === 'correct' ? current?.beliefId ?? null : null, now, now);
+            this.insertEvidence(beliefId, evidence, relation === 'contradict' ? 'contradicts' : 'supports', now);
+            this.insertVersion(beliefId, 1, input.reason ?? relation, input.evidenceEventIds[0], now);
+            if (current && relation === 'correct') {
+                this.db.prepare(`
+          INSERT INTO belief_graph_conflicts (
+            conflict_id, project_id, prior_belief_id, proposed_belief_id, relation,
+            status, reason, evidence_event_ids_json, created_at
+          ) VALUES (?, ?, ?, ?, 'corrects', 'resolved', ?, ?, ?)
+        `).run(`conflict-${randomUUID()}`, input.projectId ?? null, current.beliefId, beliefId, input.reason ?? null, JSON.stringify(input.evidenceEventIds), now);
+            }
+            else if (current) {
+                this.db.prepare(`
+          INSERT INTO belief_graph_conflicts (
+            conflict_id, project_id, prior_belief_id, proposed_belief_id, relation,
+            status, reason, evidence_event_ids_json, created_at
+          ) VALUES (?, ?, ?, ?, 'contradicts', 'pending', ?, ?, ?)
+        `).run(`conflict-${randomUUID()}`, input.projectId ?? null, current.beliefId, beliefId, input.reason ?? null, JSON.stringify(input.evidenceEventIds), now);
+            }
+        });
+        transaction();
+        return this.getById(beliefId);
+    }
+    getById(beliefId) {
+        const row = this.db.prepare(`SELECT * FROM belief_graph_nodes WHERE belief_id = ?`).get(beliefId);
+        return row ? this.mapRow(row) : null;
+    }
+    getCurrent(projectId, canonicalKey) {
+        const rows = this.db.prepare(`
+      SELECT * FROM belief_graph_nodes
+      WHERE canonical_key = ? AND status = 'active'
+        AND ((? IS NULL AND project_id IS NULL) OR project_id = ?)
+      ORDER BY updated_at DESC
+    `).all(canonicalKey.trim().toLowerCase(), projectId ?? null, projectId ?? null);
+        return rows.map((row) => this.mapRow(row));
+    }
+    getHistory(projectId, canonicalKey) {
+        const rows = this.db.prepare(`
+      SELECT * FROM belief_graph_nodes
+      WHERE canonical_key = ? AND ((? IS NULL AND project_id IS NULL) OR project_id = ?)
+      ORDER BY CASE status WHEN 'active' THEN 0 WHEN 'possible_conflict' THEN 1 ELSE 2 END, updated_at DESC
+    `).all(canonicalKey.trim().toLowerCase(), projectId ?? null, projectId ?? null);
+        return rows.map((row) => this.mapRow(row));
+    }
+    reinforce(current, input, evidence) {
+        const now = input.occurredAt ?? Date.now();
+        const version = current.version + 1;
+        const confidence = this.clamp(Math.max(current.confidence, input.confidence ?? 0) + 0.03);
+        const transaction = this.db.transaction(() => {
+            this.db.prepare(`UPDATE belief_graph_nodes SET confidence = ?, version = ?, updated_at = ? WHERE belief_id = ?`)
+                .run(confidence, version, now, current.beliefId);
+            this.insertEvidence(current.beliefId, evidence, 'supports', now);
+            this.insertVersion(current.beliefId, version, input.reason ?? 'reinforced', input.evidenceEventIds[0], now);
+        });
+        transaction();
+        return this.getById(current.beliefId);
+    }
+    insertEvidence(beliefId, evidence, evidenceType, now) {
+        const statement = this.db.prepare(`
+      INSERT OR IGNORE INTO belief_graph_evidence (belief_id, event_id, source_role, evidence_type, weight, created_at)
+      VALUES (?, ?, ?, ?, 1.0, ?)
+    `);
+        for (const item of evidence)
+            statement.run(beliefId, item.eventId, item.role ?? 'unknown', evidenceType, now);
+    }
+    insertVersion(beliefId, version, reason, eventId, now) {
+        const row = this.db.prepare(`SELECT * FROM belief_graph_nodes WHERE belief_id = ?`).get(beliefId);
+        this.db.prepare(`
+      INSERT INTO belief_graph_versions (belief_id, version, snapshot_json, reason, evidence_event_id, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(beliefId, version, JSON.stringify(row ?? {}), reason, eventId ?? null, now);
+    }
+    mapRow(row) {
+        const evidence = this.db.prepare(`
+      SELECT event_id, source_role FROM belief_graph_evidence WHERE belief_id = ? ORDER BY created_at, event_id
+    `).all(String(row.belief_id));
+        return {
+            beliefId: String(row.belief_id),
+            projectId: row.project_id == null ? undefined : String(row.project_id),
+            ownership: row.ownership,
+            beliefType: row.belief_type,
+            canonicalKey: String(row.canonical_key),
+            statement: String(row.statement),
+            status: row.status,
+            confidence: Number(row.confidence),
+            version: Number(row.version),
+            validFrom: Number(row.valid_from),
+            validTo: row.valid_to == null ? undefined : Number(row.valid_to),
+            supersedesBeliefId: row.supersedes_belief_id == null ? undefined : String(row.supersedes_belief_id),
+            supersededByBeliefId: row.superseded_by_belief_id == null ? undefined : String(row.superseded_by_belief_id),
+            evidenceEventIds: evidence.map((item) => item.event_id),
+            sourceRoles: [...new Set(evidence.map((item) => item.source_role))],
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+        };
+    }
+    normalizeStatement(value) {
+        return value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+    }
+    clamp(value) {
+        return Math.max(0, Math.min(1, value));
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS belief_graph_nodes (
+        belief_id TEXT PRIMARY KEY, project_id TEXT, ownership TEXT NOT NULL, belief_type TEXT NOT NULL,
+        canonical_key TEXT NOT NULL, statement TEXT NOT NULL, status TEXT NOT NULL, confidence REAL NOT NULL,
+        version INTEGER NOT NULL DEFAULT 1, valid_from INTEGER NOT NULL, valid_to INTEGER,
+        supersedes_belief_id TEXT, superseded_by_belief_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_belief_graph_current
+        ON belief_graph_nodes(project_id, canonical_key) WHERE status = 'active';
+      CREATE INDEX IF NOT EXISTS idx_belief_graph_history
+        ON belief_graph_nodes(project_id, canonical_key, updated_at DESC);
+      CREATE TABLE IF NOT EXISTS belief_graph_evidence (
+        belief_id TEXT NOT NULL, event_id TEXT NOT NULL, source_role TEXT NOT NULL,
+        evidence_type TEXT NOT NULL, weight REAL NOT NULL DEFAULT 1.0, created_at INTEGER NOT NULL,
+        PRIMARY KEY (belief_id, event_id, evidence_type)
+      );
+      CREATE TABLE IF NOT EXISTS belief_graph_versions (
+        belief_id TEXT NOT NULL, version INTEGER NOT NULL, snapshot_json TEXT NOT NULL,
+        reason TEXT NOT NULL, evidence_event_id TEXT, created_at INTEGER NOT NULL,
+        PRIMARY KEY (belief_id, version)
+      );
+      CREATE TABLE IF NOT EXISTS belief_graph_conflicts (
+        conflict_id TEXT PRIMARY KEY, project_id TEXT, prior_belief_id TEXT NOT NULL,
+        proposed_belief_id TEXT NOT NULL, relation TEXT NOT NULL, status TEXT NOT NULL,
+        reason TEXT, evidence_event_ids_json TEXT NOT NULL, created_at INTEGER NOT NULL
+      );
+    `);
+    }
+}