suemo 0.0.1

package/src/cli/commands/observe.ts

@@ -0,0 +1,40 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { observe } from '../../memory/write.ts'
+import { MemoryKindSchema } from '../../types.ts'
+import { app } from '../shared.ts'
+
+export const observeCmd = app.sub('observe')
+	.meta({ description: 'Store a new observation in memory' })
+	.args([{ name: 'content', type: 'string', required: true }])
+	.flags({
+		scope: { type: 'string', short: 's', description: 'Scope label' },
+		tags: { type: 'string', short: 't', description: 'Comma-separated tags' },
+		kind: { type: 'string', short: 'k', description: 'Memory kind', default: 'observation' },
+		confidence: { type: 'number', description: 'Confidence 0.0–1.0', default: 1.0 },
+		source: { type: 'string', description: 'Source label' },
+		session: { type: 'string', description: 'Session ID (attach to open episode)' },
+	})
+	.run(async ({ args, flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+
+		const kindParse = MemoryKindSchema.safeParse(flags.kind)
+		if (!kindParse.success) {
+			console.error(`Invalid kind "${flags.kind}". Valid: ${MemoryKindSchema.options.join(', ')}`)
+			process.exit(1)
+		}
+
+		const config = await loadConfig(process.cwd(), flags.config)
+		const db = await connect(config.surreal)
+		const node = await observe(db, {
+			content: args.content,
+			kind: kindParse.data,
+			tags: flags.tags ? flags.tags.split(',').map((t) => t.trim()) : [],
+			scope: flags.scope,
+			confidence: flags.confidence,
+			source: flags.source,
+		})
+		await disconnect()
+		console.log(JSON.stringify({ id: node.id, kind: node.kind, valid_from: node.valid_from }, null, 2))
+	})

package/src/cli/commands/query.ts

@@ -0,0 +1,31 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { query } from '../../memory/read.ts'
+import { app } from '../shared.ts'
+
+export const queryCmd = app.sub('query')
+	.meta({ description: 'Hybrid semantic search over memories' })
+	.args([{ name: 'input', type: 'string', required: true }])
+	.flags({
+		scope: { type: 'string', short: 's', description: 'Filter by scope' },
+		top: { type: 'number', short: 'n', description: 'Number of results', default: 5 },
+		json: { type: 'boolean', short: 'j', description: 'Output full JSON nodes' },
+	})
+	.run(async ({ args, flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		const db = await connect(config.surreal)
+		const nodes = await query(db, { input: args.input, scope: flags.scope, topK: flags.top })
+		await disconnect()
+		if (flags.json) {
+			console.log(JSON.stringify(nodes, null, 2))
+		} else {
+			for (const n of nodes) {
+				console.log(`[${n.kind}] ${n.id}`)
+				console.log(`  ${n.content.slice(0, 120)}`)
+				if (n.scope) console.log(`  scope: ${n.scope}`)
+				console.log()
+			}
+		}
+	})

package/src/cli/commands/recall.ts

@@ -0,0 +1,17 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { recall } from '../../memory/read.ts'
+import { app } from '../shared.ts'
+
+export const recallCmd = app.sub('recall')
+	.meta({ description: 'Fetch a single node + its neighbours (ticks FSRS)' })
+	.args([{ name: 'nodeId', type: 'string', required: true }])
+	.run(async ({ args, flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		const db = await connect(config.surreal)
+		const result = await recall(db, args.nodeId)
+		await disconnect()
+		console.log(JSON.stringify(result, null, 2))
+	})

package/src/cli/commands/serve.ts

@@ -0,0 +1,19 @@
+import { loadConfig } from '../../config.ts'
+import { initLogger } from '../../logger.ts'
+import { startMcpServer } from '../../mcp/server.ts'
+import { app } from '../shared.ts'
+
+export const serveCmd = app.sub('serve')
+	.meta({ description: 'Start the MCP server' })
+	.flags({
+		port: { type: 'number', short: 'p', description: 'Port to listen on (overrides config)' },
+		host: { type: 'string', description: 'Host to bind to (overrides config)' },
+	})
+	.run(async ({ flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		if (flags.port) config.mcp.port = flags.port
+		if (flags.host) config.mcp.host = flags.host
+		await startMcpServer(config)
+		// Server runs indefinitely — no disconnect
+	})

package/src/cli/commands/shared.ts

@@ -0,0 +1,20 @@
+import { Crust } from '@crustjs/core'
+
+// Root CLI — shared instance all commands are built off via .sub()
+// The two flags here are inherited by every subcommand.
+export const app = new Crust('suemo')
+	.meta({ description: 'Persistent semantic memory for AI agents — SurrealDB backend' })
+	.flags({
+		config: {
+			type: 'string',
+			short: 'c',
+			description: 'Path to suemo config file',
+			inherit: true,
+		},
+		debug: {
+			type: 'boolean',
+			short: 'd',
+			description: 'Enable verbose debug logging',
+			inherit: true,
+		},
+	})

package/src/cli/commands/sync.ts

@@ -0,0 +1,23 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { syncTo } from '../../sync.ts'
+import { app } from '../shared.ts'
+
+export const syncCmd = app.sub('sync')
+	.meta({ description: 'Push memories to remote SurrealDB (append-only)' })
+	.flags({
+		'dry-run': { type: 'boolean', description: 'Show what would be pushed without writing', default: false },
+	})
+	.run(async ({ flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		if (!config.sync) {
+			console.error('No sync.remote configured in suemo config.')
+			process.exit(1)
+		}
+		const db = await connect(config.surreal)
+		const result = await syncTo(db, config.sync.remote, { dryRun: flags['dry-run'] })
+		await disconnect()
+		console.log(JSON.stringify(result, null, 2))
+	})

package/src/cli/commands/timeline.ts

@@ -0,0 +1,37 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { timeline } from '../../memory/read.ts'
+import { app } from '../shared.ts'
+
+export const timelineCmd = app.sub('timeline')
+	.meta({ description: 'Chronological view of memories' })
+	.flags({
+		scope: { type: 'string', short: 's', description: 'Filter by scope' },
+		from: { type: 'string', description: 'Start datetime (ISO)' },
+		until: { type: 'string', description: 'End datetime (ISO)' },
+		limit: { type: 'number', short: 'n', description: 'Max results', default: 20 },
+		json: { type: 'boolean', short: 'j', description: 'Output full JSON' },
+	})
+	.run(async ({ flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		const db = await connect(config.surreal)
+		const nodes = await timeline(db, {
+			...(flags.scope ? { scope: flags.scope } : {}),
+			...(flags.from ? { from: flags.from } : {}),
+			...(flags.until ? { until: flags.until } : {}),
+			...(flags.limit ? { limit: flags.limit } : {}),
+		})
+		await disconnect()
+		if (flags.json) {
+			console.log(JSON.stringify(nodes, null, 2))
+		} else {
+			for (const n of nodes) {
+				const ts = new Date(n.created_at).toLocaleString()
+				console.log(`${ts}  [${n.kind}] ${n.id}`)
+				console.log(`  ${n.content.slice(0, 120)}`)
+				console.log()
+			}
+		}
+	})

package/src/cli/commands/wander.ts

@@ -0,0 +1,34 @@
+import { loadConfig } from '../../config.ts'
+import { connect, disconnect } from '../../db/client.ts'
+import { initLogger } from '../../logger.ts'
+import { wander } from '../../memory/read.ts'
+import { app } from '../shared.ts'
+
+export const wanderCmd = app.sub('wander')
+	.meta({ description: 'Spreading-activation walk through the memory graph' })
+	.flags({
+		from: { type: 'string', description: 'Anchor node ID (random if omitted)' },
+		hops: { type: 'number', description: 'Traversal depth', default: 3 },
+		scope: { type: 'string', short: 's', description: 'Filter by scope' },
+		json: { type: 'boolean', short: 'j', description: 'Output full JSON nodes' },
+	})
+	.run(async ({ flags }) => {
+		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		const config = await loadConfig(process.cwd(), flags.config)
+		const db = await connect(config.surreal)
+		const nodes = await wander(db, {
+			...(flags.from ? { anchor: flags.from } : {}),
+			...(flags.hops ? { hops: flags.hops } : {}),
+			...(flags.scope ? { scope: flags.scope } : {}),
+		})
+		await disconnect()
+		if (flags.json) {
+			console.log(JSON.stringify(nodes, null, 2))
+		} else {
+			for (const n of nodes) {
+				console.log(`[${n.kind}] ${n.id}  salience=${n.salience.toFixed(2)}`)
+				console.log(`  ${n.content.slice(0, 120)}`)
+				console.log()
+			}
+		}
+	})

package/src/cli/index.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+
+import { helpPlugin, versionPlugin } from '@crustjs/plugins'
+import { initLogger } from '../logger.ts'
+import { believeCmd } from './commands/believe.ts'
+import { consolidateCmd } from './commands/consolidate.ts'
+import { exportCmd, importCmd } from './commands/export-import.ts'
+import { goalCmd } from './commands/goal.ts'
+import { healthCmd } from './commands/health.ts'
+import { initCmd } from './commands/init.ts'
+import { observeCmd } from './commands/observe.ts'
+import { queryCmd } from './commands/query.ts'
+import { recallCmd } from './commands/recall.ts'
+import { serveCmd } from './commands/serve.ts'
+import { syncCmd } from './commands/sync.ts'
+import { timelineCmd } from './commands/timeline.ts'
+import { wanderCmd } from './commands/wander.ts'
+import { app } from './shared.ts'
+
+import packageJson from '../../package.json' with { type: 'json' }
+
+await initLogger({ level: 'info' })
+
+await app
+	.use(versionPlugin(packageJson.version ?? '0.0.0'))
+	.use(helpPlugin())
+	.command(initCmd)
+	.command(serveCmd)
+	.command(observeCmd)
+	.command(believeCmd)
+	.command(queryCmd)
+	.command(recallCmd)
+	.command(wanderCmd)
+	.command(timelineCmd)
+	.command(goalCmd) // goal is a container: goal set / goal list / goal resolve
+	.command(consolidateCmd)
+	.command(healthCmd)
+	.command(syncCmd)
+	.command(exportCmd)
+	.command(importCmd)
+	.execute()

package/src/cli/shared.ts

@@ -0,0 +1,9 @@
+// src/cli/shared.ts — single shared root, holds inheritable flags
+import { Crust } from '@crustjs/core'
+
+export const app = new Crust('suemo')
+	.meta({ description: 'Persistent semantic memory for AI agents' })
+	.flags({
+		config: { type: 'string', short: 'c', description: 'Path to config file', inherit: true },
+		debug: { type: 'boolean', short: 'd', description: 'Verbose debug logging', inherit: true },
+	})

package/src/cognitive/consolidate.ts

@@ -0,0 +1,349 @@
+import type { Surreal } from 'surrealdb'
+import type { LLMConfig } from '../config.ts'
+import { getLogger } from '../logger.ts'
+import type { ConsolidationRun, MemoryNode } from '../types.ts'
+
+const log = getLogger(['suemo', 'cognitive', 'consolidate'])
+
+// ── LLM helper — OpenAI-compatible chat completions ────────────────────────
+async function llmComplete(
+	llm: LLMConfig,
+	systemPrompt: string,
+	userContent: string,
+): Promise<string> {
+	const res = await fetch(`${llm.url}/chat/completions`, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'Authorization': `Bearer ${llm.apiKey}`,
+		},
+		body: JSON.stringify({
+			model: llm.model,
+			messages: [
+				{ role: 'system', content: systemPrompt },
+				{ role: 'user', content: userContent },
+			],
+			max_tokens: 512,
+			temperature: 0.2,
+		}),
+	})
+	if (!res.ok) {
+		const text = await res.text()
+		throw new Error(`LLM error ${res.status}: ${text}`)
+	}
+	const json = await res.json() as { choices: { message: { content: string } }[] }
+	return json.choices[0]?.message.content ?? ''
+}
+
+// ── NREM — compress clusters of similar unconsolidated nodes ───────────────
+async function runNREM(
+	db: Surreal,
+	llm: LLMConfig,
+	similarityThreshold: number,
+): Promise<{ nodesIn: number; nodesOut: number }> {
+	log.info('NREM phase starting')
+
+	// Fetch all unconsolidated nodes
+	const result = await db.query<[MemoryNode[]]>(`
+    SELECT * FROM memory
+    WHERE consolidated = false
+      AND kind != 'goal'
+      AND (valid_until = NONE OR valid_until > time::now())
+    ORDER BY created_at ASC
+    LIMIT 500
+  `)
+	const nodes = result[0] ?? []
+
+	if (nodes.length === 0) {
+		log.info('NREM: no unconsolidated nodes')
+		return { nodesIn: 0, nodesOut: 0 }
+	}
+
+	log.info(`NREM: processing ${nodes.length} nodes`)
+
+	// Simple greedy clustering: group nodes by cosine similarity
+	// to the first unassigned node in each cluster.
+	// Production would use k-means or DBSCAN; this is correct for v1.
+	const clusters: MemoryNode[][] = []
+	const assigned = new Set<string>()
+
+	for (const node of nodes) {
+		if (assigned.has(node.id)) continue
+		const cluster: MemoryNode[] = [node]
+		assigned.add(node.id)
+
+		// Find similar unassigned nodes using DB-side cosine
+		const similarResult = await db.query<[{ id: string; score: number }[]]>(
+			`
+      SELECT id, vector::similarity::cosine(embedding, $emb) AS score
+      FROM memory
+      WHERE consolidated = false
+        AND id != $self
+        AND (valid_until = NONE OR valid_until > time::now())
+      ORDER BY embedding <|10, 20|> $emb
+      LIMIT 10
+    `,
+			{ emb: node.embedding, self: node.id },
+		)
+
+		for (const candidate of similarResult[0] ?? []) {
+			if (!assigned.has(candidate.id) && candidate.score >= similarityThreshold) {
+				const full = nodes.find((n) => n.id === candidate.id)
+				if (full) {
+					cluster.push(full)
+					assigned.add(candidate.id)
+				}
+			}
+		}
+		clusters.push(cluster)
+	}
+
+	let nodesOut = 0
+
+	for (const cluster of clusters) {
+		if (cluster.length === 1) {
+			// Singleton — mark consolidated without compression
+			await db.query('UPDATE $id SET consolidated = true', { id: cluster[0]!.id })
+			nodesOut++
+			continue
+		}
+
+		// Multi-node cluster: LLM compression
+		const combinedContent = cluster.map((n, i) => `${i + 1}. ${n.content}`).join('\n')
+		let summary: string
+		try {
+			summary = await llmComplete(
+				llm,
+				'You are a memory compression assistant. Given a list of related observations, '
+					+ 'produce a single concise summary that retains all unique facts. '
+					+ 'Reply with only the summary — no preamble.',
+				combinedContent,
+			)
+		} catch (e) {
+			log.error('LLM compression failed — marking cluster nodes individually', { error: String(e) })
+			for (const n of cluster) {
+				await db.query('UPDATE $id SET consolidated = true', { id: n.id })
+			}
+			nodesOut += cluster.length
+			continue
+		}
+
+		// Create the compressed summary node
+		const created = await db.query<[MemoryNode[]]>(
+			`
+      CREATE memory CONTENT {
+        kind:       'observation',
+        content:    $summary,
+        summary:    $summary,
+        tags:       $tags,
+        scope:      $scope,
+        embedding:  fn::embed($summary),
+        confidence: 1.0,
+        salience:   0.7,
+        source:     'consolidation:nrem',
+        consolidated: true,
+        consolidated_into: NONE,
+        fsrs_stability:    NONE,
+        fsrs_difficulty:   NONE,
+        fsrs_next_review:  NONE
+      }
+    `,
+			{
+				summary,
+				tags: [...new Set(cluster.flatMap((n) => n.tags))],
+				scope: cluster[0]!.scope ?? null,
+			},
+		)
+		const summaryNode = created[0]?.[0]
+		if (!summaryNode) continue
+
+		// Mark originals as consolidated, point to summary
+		for (const n of cluster) {
+			await db.query(
+				`
+        UPDATE $id SET
+          consolidated      = true,
+          consolidated_into = $into,
+          updated_at        = time::now()
+      `,
+				{ id: n.id, into: summaryNode.id },
+			)
+
+			await db.query(
+				`
+        RELATE $from->relates_to->$to CONTENT {
+          kind:     'derived_from',
+          strength: 1.0
+        }
+      `,
+				{ from: summaryNode.id, to: n.id },
+			)
+		}
+		nodesOut++
+		log.debug('NREM cluster compressed', { clusterSize: cluster.length, summaryId: summaryNode.id })
+	}
+
+	return { nodesIn: nodes.length, nodesOut }
+}
+
+// ── REM — connect newly consolidated nodes to broader graph ───────────────
+async function runREM(
+	db: Surreal,
+	llm: LLMConfig,
+	relationThreshold: number,
+): Promise<void> {
+	log.info('REM phase starting')
+
+	// Get recently consolidated summary nodes (no incoming relations yet)
+	const result = await db.query<[MemoryNode[]]>(`
+    SELECT * FROM memory
+    WHERE consolidated = true
+      AND source = 'consolidation:nrem'
+      AND (valid_until = NONE OR valid_until > time::now())
+    ORDER BY created_at DESC
+    LIMIT 50
+  `)
+	const newNodes = result[0] ?? []
+	if (newNodes.length === 0) {
+		log.info('REM: no new nodes to integrate')
+		return
+	}
+
+	for (const node of newNodes) {
+		// Find top candidates from the full graph
+		const candidates = await db.query<[MemoryNode[]]>(
+			`
+      SELECT * FROM memory
+      WHERE id != $self
+        AND consolidated = true
+        AND (valid_until = NONE OR valid_until > time::now())
+      ORDER BY embedding <|10, 40|> $emb
+      LIMIT 10
+    `,
+			{ self: node.id, emb: node.embedding },
+		)
+
+		const topCandidates = candidates[0] ?? []
+		if (topCandidates.length === 0) continue
+
+		const candidateList = topCandidates
+			.map((c, i) => `${i + 1}. [${c.id}] ${c.content}`)
+			.join('\n')
+
+		let rawScores: string
+		try {
+			rawScores = await llmComplete(
+				llm,
+				'You are a knowledge graph assistant. For each candidate memory, score how strongly '
+					+ 'it relates to the source memory. Valid relation types: supports, contradicts, '
+					+ 'derived_from, caused_by, similar_to. '
+					+ 'Reply ONLY with JSON array: [{"id":"...","kind":"...","score":0.0}, ...]. '
+					+ 'Omit entries with score < 0.3.',
+				`Source: ${node.content}\n\nCandidates:\n${candidateList}`,
+			)
+		} catch (e) {
+			log.error('LLM relation scoring failed', { nodeId: node.id, error: String(e) })
+			continue
+		}
+
+		let relations: { id: string; kind: string; score: number }[]
+		try {
+			const cleaned = rawScores.replace(/```json|```/g, '').trim()
+			relations = JSON.parse(cleaned)
+		} catch {
+			log.error('Failed to parse LLM relation JSON', { raw: rawScores.slice(0, 200) })
+			continue
+		}
+
+		for (const rel of relations) {
+			if (rel.score < relationThreshold) continue
+			try {
+				await db.query(
+					`
+          RELATE $from->relates_to->$to CONTENT {
+            kind:     $kind,
+            strength: $strength
+          }
+        `,
+					{ from: node.id, to: rel.id, kind: rel.kind, strength: rel.score },
+				)
+			} catch (e) {
+				log.error('Failed to create relation', { from: node.id, to: rel.id, error: String(e) })
+			}
+		}
+
+		// Bump salience on newly connected node
+		await db.query(
+			'UPDATE $id SET salience = math::min(salience + 0.1, 1.0)',
+			{ id: node.id },
+		)
+	}
+}
+
+// ── Public entry point ─────────────────────────────────────────────────────
+export async function consolidate(
+	db: Surreal,
+	opts: {
+		nremOnly?: boolean
+		nremSimilarityThreshold?: number
+		remRelationThreshold?: number
+		llm: LLMConfig
+	},
+): Promise<ConsolidationRun> {
+	const phase = opts.nremOnly ? 'nrem' : 'full'
+	log.info('consolidate()', { phase })
+
+	// Create run log entry
+	const runResult = await db.query<[ConsolidationRun[]]>(
+		`
+    CREATE consolidation_run CONTENT {
+      phase:        $phase,
+      nodes_in:     0,
+      nodes_out:    0,
+      status:       'running',
+      error:        NONE
+    }
+  `,
+		{ phase },
+	)
+	const run = runResult[0]![0]!
+
+	try {
+		const { nodesIn, nodesOut } = await runNREM(
+			db,
+			opts.llm,
+			opts.nremSimilarityThreshold ?? 0.85,
+		)
+
+		if (!opts.nremOnly) {
+			await runREM(db, opts.llm, opts.remRelationThreshold ?? 0.4)
+		}
+
+		await db.query(
+			`
+      UPDATE $id SET
+        completed_at = time::now(),
+        status       = 'done',
+        nodes_in     = $nodesIn,
+        nodes_out    = $nodesOut
+    `,
+			{ id: run.id, nodesIn, nodesOut },
+		)
+
+		log.info('consolidate() complete', { nodesIn, nodesOut, phase })
+		return { ...run, status: 'done', nodes_in: nodesIn, nodes_out: nodesOut }
+	} catch (e) {
+		const errMsg = String(e)
+		log.error('consolidate() failed', { error: errMsg })
+		await db.query(
+			`
+      UPDATE $id SET
+        completed_at = time::now(),
+        status       = 'failed',
+        error        = $err
+    `,
+			{ id: run.id, err: errMsg },
+		)
+		throw e
+	}
+}

package/src/cognitive/contradiction.ts

@@ -0,0 +1,50 @@
+import type { Surreal } from 'surrealdb'
+import { getLogger } from '../logger.ts'
+import type { MemoryNode } from '../types.ts'
+
+const log = getLogger(['suemo', 'cognitive', 'contradiction'])
+
+/**
+ * Given a newly created belief node, find the most semantically similar
+ * existing active belief. If similarity > threshold AND an LLM call (or
+ * heuristic) determines they conflict, return the old node. Otherwise null.
+ *
+ * In v1, we use cosine similarity threshold only (no LLM call).
+ * The LLM contradiction scoring is a v2 enhancement.
+ */
+export async function detectContradiction(
+	db: Surreal,
+	newNode: MemoryNode,
+	similarityThreshold = 0.80,
+): Promise<MemoryNode | null> {
+	if (newNode.kind !== 'belief') return null
+
+	log.debug('detectContradiction()', { nodeId: newNode.id })
+
+	const candidates = await db.query<[{ id: string; score: number }[]]>(
+		`
+    SELECT id, vector::similarity::cosine(embedding, $emb) AS score
+    FROM memory
+    WHERE kind = 'belief'
+      AND id != $self
+      AND (valid_until = NONE OR valid_until > time::now())
+    ORDER BY embedding <|3, 20|> $emb
+    LIMIT 3
+  `,
+		{ emb: newNode.embedding, self: newNode.id },
+	)
+
+	const top = candidates[0]
+	if (!top || top.length === 0) return null
+
+	const best = top[0]!
+	if (best.score < similarityThreshold) return null
+
+	// Fetch full node
+	const result = await db.query<[MemoryNode[]]>('SELECT * FROM $id', { id: best.id })
+	const existing = result[0]?.[0]
+	if (!existing) return null
+
+	log.info('Potential contradiction found', { old: existing.id, score: best.score })
+	return existing
+}