suemo 0.0.3 → 0.0.4

package/README.md

@@ -96,6 +96,14 @@ suemo serve
 # Listening on http://127.0.0.1:4242
 ```
 
+For development with automatic restart on file changes:
+
+```sh
+suemo serve --dev
+```
+
+`--dev` re-runs `suemo serve` under Bun watch mode and restarts MCP when source files change.
+
 ---
 
 ## CLI Reference
@@ -161,8 +169,8 @@ export default defineConfig({
 		},
 	},
 	embedding: {
-		provider: 'surreal', // fn::embed() — configured in SurrealDB
-		dimension: 1536,
+		provider: 'surrealml', // fn::embed() — configured in SurrealDB
+		dimension: 384,
 	},
 	consolidation: {
 		trigger: 'timer',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suemo",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"description": "Persistent semantic memory for AI agents — backed by SurrealDB.",
 	"author": {
 		"name": "Umar Alfarouk",

package/src/cli/commands/serve.ts

@@ -5,15 +5,77 @@ import { app, initCliCommand } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'serve'])
 
+function printDevRestartBanner(): void {
+	if (process.env.SUEMO_DEV_WATCH !== '1') return
+	const now = new Date().toISOString()
+	console.log(`\n[suemo:dev] MCP restarted (${now})\n`)
+}
+
+async function runServeDevMode(): Promise<never> {
+	const scriptPath = process.argv[1] ?? 'src/cli/index.ts'
+	const forwardedArgs = process.argv.slice(2).filter((arg) => arg !== '--dev')
+	const bunExecutable = process.execPath.includes('bun') ? process.execPath : 'bun'
+	const cmd = [bunExecutable, '--watch', scriptPath, ...forwardedArgs]
+
+	log.info('Starting serve dev mode (bun --watch)', {
+		scriptPath,
+		forwardedArgs,
+	})
+
+	const child = Bun.spawn({
+		cmd,
+		env: { ...process.env, SUEMO_DEV_WATCH: '1' },
+		stdin: 'inherit',
+		stdout: 'inherit',
+		stderr: 'inherit',
+	})
+
+	const shutdown = (signal: NodeJS.Signals): void => {
+		log.info('Stopping dev watcher', { signal })
+		try {
+			child.kill(signal)
+		} catch {
+			// noop
+		}
+	}
+
+	process.once('SIGINT', () => {
+		shutdown('SIGINT')
+	})
+	process.once('SIGTERM', () => {
+		shutdown('SIGTERM')
+	})
+
+	const exitCode = await child.exited
+	process.exit(exitCode)
+}
+
+async function maybeDelayDevStartup(): Promise<void> {
+	if (process.env.SUEMO_DEV_WATCH !== '1') return
+	const rawDelay = process.env.SUEMO_DEV_RESTART_DELAY_MS ?? '250'
+	const parsed = Number(rawDelay)
+	const delayMs = Number.isFinite(parsed) && parsed > 0 ? parsed : 250
+	if (delayMs > 0) {
+		log.debug('Delaying startup for dev restart stability', { delayMs })
+		await Bun.sleep(delayMs)
+	}
+}
+
 export const serveCmd = app.sub('serve')
 	.meta({ description: 'Start the MCP server (HTTP or stdio)' })
 	.flags({
 		port: { type: 'number', short: 'p', description: 'Port to listen on (overrides config)' },
 		host: { type: 'string', description: 'Host to bind to (overrides config)' },
 		stdio: { type: 'boolean', description: 'Use stdio transport instead of HTTP' },
+		dev: { type: 'boolean', description: 'Restart MCP server on code changes (bun --watch)' },
 	})
 	.run(async ({ flags }) => {
+		printDevRestartBanner()
+		await maybeDelayDevStartup()
 		await initCliCommand('serve', { debug: flags.debug, config: flags.config })
+		if (flags.dev) {
+			await runServeDevMode()
+		}
 		const config = await loadConfig(process.cwd(), flags.config)
 		const sync = resolveSyncConfig(config)
 		if (sync?.auto.enabled) {

package/src/cli/commands/wander.ts

@@ -33,6 +33,10 @@ export const wanderCmd = app.sub('wander')
 			if (flags.json) {
 				console.log(JSON.stringify(nodes, null, 2))
 			} else {
+				if (nodes.length === 0) {
+					console.log('No memories found for this wander query.')
+					return
+				}
 				for (const n of nodes) {
 					console.log(`[${n.kind}] ${n.id}  salience=${n.salience.toFixed(2)}`)
 					console.log(`  ${n.content.slice(0, 120)}`)

package/src/cognitive/consolidate.ts

@@ -77,22 +77,16 @@ async function runNREM(
 		// Find similar unassigned nodes using DB-side cosine
 		const similarResult = await db.query<[{ id: string; score: number }[]]>(
 			`
-      LET $cand = (
-        SELECT id, embedding
+      SELECT id, score
+      FROM (
+        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())
-          AND embedding <|10, 20|> $emb
-      );
-
-      SELECT id, score
-      FROM (
-        SELECT id, vector::similarity::cosine(embedding, $emb) AS score
-        FROM $cand
       )
       ORDER BY score DESC
-      LIMIT 10
+      LIMIT 500
     `,
 			{ emb: node.embedding, self: node.id },
 		)
@@ -238,13 +232,10 @@ async function runREM(
 		const candidates = await db.query<[MemoryNode[]]>(
 			`
       SELECT * FROM memory
-      WHERE id IN (
-        SELECT VALUE id FROM memory
-        WHERE id != $self
-          AND consolidated = true
-          AND (valid_until = NONE OR valid_until > time::now())
-          AND embedding <|10, 40|> $emb
-      )
+      WHERE id != $self
+        AND consolidated = true
+        AND (valid_until = NONE OR valid_until > time::now())
+      ORDER BY vector::similarity::cosine(embedding, $emb) DESC
       LIMIT 10
     `,
 			{ self: node.id, emb: node.embedding },

package/src/cognitive/contradiction.ts

@@ -21,21 +21,15 @@ export async function detectContradiction(
 
 	log.debug('detectContradiction()', { nodeId: newNode.id })
 
-	const candidates = await db.query<[{ id: string; score: number }[]]>(
+	const candidates = await db.query<unknown[]>(
 		`
-    LET $cand = (
-      SELECT id, embedding
+    SELECT id, score
+    FROM (
+      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())
-        AND embedding <|3, 20|> $emb
-    );
-
-    SELECT id, score
-    FROM (
-      SELECT id, vector::similarity::cosine(embedding, $emb) AS score
-      FROM $cand
     )
     ORDER BY score DESC
     LIMIT 3
@@ -43,7 +37,7 @@ export async function detectContradiction(
 		{ emb: newNode.embedding, self: newNode.id },
 	)
 
-	const top = candidates[0]
+	const top = candidates.at(-1) as { id: string; score: number }[] | undefined
 	if (!top || top.length === 0) return null
 
 	const best = top[0]!

package/src/cognitive/health.ts

@@ -161,11 +161,11 @@ export async function suemoStats(db: Surreal): Promise<SuemoStats> {
 export async function incrementWriteStats(db: Surreal): Promise<void> {
 	await db.query(
 		`
-    UPSERT suemo_stats:default SET
-      ns_db        = $nsDb,
-      total_writes = total_writes + 1,
-      last_write   = time::now()
-  `,
+	  UPSERT suemo_stats:default SET
+	    ns_db        = $nsDb,
+	    total_writes = IF total_writes = NONE THEN 1 ELSE total_writes + 1 END,
+	    last_write   = time::now()
+	  `,
 		{ nsDb: 'default' },
 	)
 }
@@ -173,11 +173,11 @@ export async function incrementWriteStats(db: Surreal): Promise<void> {
 export async function incrementQueryStats(db: Surreal): Promise<void> {
 	await db.query(
 		`
-    UPSERT suemo_stats:default SET
-      ns_db         = $nsDb,
-      total_queries = total_queries + 1,
-      last_query    = time::now()
-  `,
+	  UPSERT suemo_stats:default SET
+	    ns_db         = $nsDb,
+	    total_queries = IF total_queries = NONE THEN 1 ELSE total_queries + 1 END,
+	    last_query    = time::now()
+	  `,
 		{ nsDb: 'default' },
 	)
 }

package/src/config.ts

@@ -19,7 +19,7 @@ export interface SurrealTarget {
 
 export type EmbeddingProvider =
 	| { provider: 'openai-compatible'; url: string; model: string; dimension: number; apiKey?: string }
-	| { provider: 'surreal'; dimension: number }
+	| { provider: 'surrealml'; dimension: number }
 	| { provider: 'stub'; dimension: number }
 
 export interface LLMConfig {
@@ -216,9 +216,9 @@ export async function loadConfig(
 async function importConfig(path: string): Promise<SuemoConfig> {
 	log.debug('Importing config module', { path })
 	const mod = await import(pathToFileURL(path).href)
-	const cfg: unknown = mod.default ?? mod
-	if (!cfg || typeof cfg !== 'object') {
+	const cfgRaw: unknown = mod.default ?? mod
+	if (!cfgRaw || typeof cfgRaw !== 'object') {
 		throw new Error(`Config at ${path} does not export a default object`)
 	}
-	return cfg as SuemoConfig // trust defineConfig() for now; add Zod parse if needed
+	return cfgRaw as SuemoConfig // trust defineConfig() for now; add Zod parse if needed
 }

package/src/db/preflight.ts

@@ -65,7 +65,7 @@ export async function checkCompatibility(
 	// We CREATE a sentinel record, query it with VERSION, then DELETE it.
 	// If VERSION errors, the storage engine is not SurrealKV.
 	try {
-		await db.query('CREATE suemo_preflight:probe SET checked_at = time::now()')
+		await db.query('UPSERT suemo_preflight:probe SET checked_at = time::now()')
 		// VERSION at a past datetime should return an empty result set (or the record
 		// if it was around then), not throw. An error means VERSION is unsupported.
 		await db.query("SELECT * FROM suemo_preflight:probe VERSION d'2020-01-01T00:00:00Z'")
@@ -97,7 +97,7 @@ export async function checkCompatibility(
 	if (surrealkv) {
 		try {
 			const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString()
-			await db.query('CREATE suemo_retention_probe:v SET t = time::now()')
+			await db.query('UPSERT suemo_retention_probe:v SET t = time::now()')
 			await db.query(`SELECT * FROM suemo_retention_probe:v VERSION d'${ninetyDaysAgo}'`)
 			retention_ok = true
 			log.debug('Retention probe passed', { ninetyDaysAgo })
@@ -152,9 +152,13 @@ export async function checkCompatibility(
 	}
 
 	const ok = errors.length === 0
+	const embedSkipped = !requireEmbedding && !embedding
 
 	if (ok) {
 		log.info('All preflight checks passed', { surrealVersion, surrealkv, retention_ok, embedding })
+		if (embedSkipped) {
+			log.info('fn::embed preflight check skipped due to non-surrealml embedding profile', { context })
+		}
 	} else {
 		log.error('Preflight checks failed', { errors })
 	}

package/src/db/schema.surql

@@ -90,7 +90,7 @@ DEFINE FIELD OVERWRITE session_id  ON episode TYPE string;
 DEFINE FIELD OVERWRITE started_at  ON episode TYPE datetime DEFAULT time::now();
 DEFINE FIELD OVERWRITE ended_at    ON episode TYPE option<datetime> DEFAULT NONE;
 DEFINE FIELD OVERWRITE summary     ON episode TYPE option<string>;
-DEFINE FIELD OVERWRITE context     ON episode TYPE option<object> DEFAULT NONE;
+DEFINE FIELD OVERWRITE context     ON episode TYPE option<object> FLEXIBLE DEFAULT NONE;
 
 -- REFERENCES: bidirectional array of memory links
 DEFINE FIELD OVERWRITE memory_ids  ON episode

package/src/db/schema.ts

@@ -5,6 +5,29 @@ import SCHEMA from './schema.surql' with { type: 'text' }
 
 const log = getLogger(['suemo', 'db', 'schema'])
 
+const MAX_RETRY_ATTEMPTS = 6
+const BASE_RETRY_DELAY_MS = 100
+const MAX_RETRY_DELAY_MS = 1500
+
+function isRetryableSchemaError(error: unknown): boolean {
+	const message = String(error).toLowerCase()
+	return message.includes('transaction conflict')
+		|| message.includes('write conflict')
+		|| message.includes('serialization')
+		|| message.includes('temporarily unavailable')
+		|| message.includes('can be retried')
+}
+
+function computeRetryDelayMs(attempt: number): number {
+	const raw = Math.min(MAX_RETRY_DELAY_MS, BASE_RETRY_DELAY_MS * (2 ** attempt))
+	const jitterFactor = 0.8 + Math.random() * 0.4
+	return Math.round(raw * jitterFactor)
+}
+
+async function sleep(ms: number): Promise<void> {
+	await new Promise((resolve) => setTimeout(resolve, ms))
+}
+
 // schema.surql is inlined as a template string to avoid filesystem read concerns
 // at runtime. Each statement is separated by ";\n" and executed individually.
 
@@ -13,15 +36,40 @@ export async function runSchema(db: Surreal): Promise<void> {
 	const statements = SCHEMA.split(/;\s*\n/).map((s) => s.trim()).filter(Boolean)
 	log.debug('Prepared schema statements', { count: statements.length, schemaBytes: SCHEMA.length })
 	for (const [index, stmt] of statements.entries()) {
-		try {
-			const snippet = stmt.length > 160 ? `${stmt.slice(0, 160)}…` : stmt
-			log.debug('Executing schema statement', { index, snippet })
-			await db.query(stmt)
-			log.debug('Schema statement OK', { index, stmt: stmt.slice(0, 60) })
-		} catch (e) {
-			log.error('Schema statement failed', { index, stmt, error: String(e) })
-			throw e
+		const snippet = stmt.length > 160 ? `${stmt.slice(0, 160)}…` : stmt
+		let lastError: unknown
+		for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+			try {
+				log.debug('Executing schema statement', { index, attempt, snippet })
+				await db.query(stmt)
+				log.debug('Schema statement OK', { index, attempt, stmt: stmt.slice(0, 60) })
+				lastError = undefined
+				break
+			} catch (e) {
+				lastError = e
+				const retryable = isRetryableSchemaError(e)
+				const hasNextAttempt = attempt < MAX_RETRY_ATTEMPTS - 1
+				if (!retryable || !hasNextAttempt) {
+					log.error('Schema statement failed', {
+						index,
+						attempt,
+						retryable,
+						stmt,
+						error: String(e),
+					})
+					throw e
+				}
+				const delayMs = computeRetryDelayMs(attempt)
+				log.warning('Schema statement conflict; retrying', {
+					index,
+					attempt,
+					delayMs,
+					error: String(e),
+				})
+				await sleep(delayMs)
+			}
 		}
+		if (lastError) throw lastError
 	}
 	log.info('Schema ready')
 }

package/src/embedding/index.ts

@@ -16,7 +16,7 @@ export async function getEmbedding(
 	log.debug('getEmbedding()', { provider: config.provider, dimension: config.dimension })
 
 	switch (config.provider) {
-		case 'surreal':
+		case 'surrealml':
 			return { clause: 'fn::embed($content)' }
 
 		case 'openai-compatible': {
@@ -39,7 +39,7 @@ export async function getEmbedding(
 
 export function buildEmbeddingClause(config: EmbeddingProvider): string {
 	switch (config.provider) {
-		case 'surreal':
+		case 'surrealml':
 			return 'fn::embed($content)'
 		case 'openai-compatible':
 		case 'stub':

package/src/mcp/server.ts

@@ -149,7 +149,7 @@ export async function startMcpStdioServer(config: SuemoConfig): Promise<void> {
 	autoSync.start()
 	try {
 		const compat = await checkCompatibility(db, {
-			requireEmbedding: config.embedding.provider === 'surreal',
+			requireEmbedding: config.embedding.provider === 'surrealml',
 			context: 'mcp:stdio-startup',
 		})
 		if (!compat.ok) {

package/src/mcp/stdio.ts

@@ -4,6 +4,8 @@ import type { SuemoConfig } from '../config.ts'
 import { getLogger } from '../logger.ts'
 import { handleToolCall } from './dispatch.ts'
 
+import packageJson from '../../package.json' with { type: 'json' }
+
 const log = getLogger(['suemo', 'mcp', 'stdio'])
 
 interface JsonRpcRequest {
@@ -338,7 +340,7 @@ async function handleRpcMethod(
 			},
 			serverInfo: {
 				name: 'suemo',
-				version: '0.0.1',
+				version: packageJson.version ?? '0.0.0',
 			},
 		}
 	}
@@ -358,17 +360,33 @@ async function handleRpcMethod(
 	if (method === 'tools/call') {
 		const name = typeof params.name === 'string' ? params.name : null
 		if (!name) {
-			throw new Error('Invalid tools/call params: missing string field `name`')
+			return {
+				isError: true,
+				content: [{ type: 'text', text: 'Invalid tools/call params: missing string field `name`' }],
+				structuredContent: { error: 'Invalid tools/call params: missing string field `name`' },
+			}
 		}
 
 		const toolArgs = params.arguments && typeof params.arguments === 'object' && !Array.isArray(params.arguments)
 			? params.arguments as Record<string, unknown>
 			: {}
 
-		const toolResult = await handleToolCall(db, config, name, toolArgs, opts)
-		return {
-			content: [{ type: 'text', text: JSON.stringify(toolResult, null, 2) }],
-			structuredContent: toolResult,
+		try {
+			const toolResult = await handleToolCall(db, config, name, toolArgs, opts)
+			const structuredContent = toolResult && typeof toolResult === 'object' && !Array.isArray(toolResult)
+				? toolResult
+				: { result: toolResult }
+			return {
+				content: [{ type: 'text', text: JSON.stringify(toolResult, null, 2) }],
+				structuredContent,
+			}
+		} catch (error) {
+			const message = String(error)
+			return {
+				isError: true,
+				content: [{ type: 'text', text: message }],
+				structuredContent: { error: message },
+			}
 		}
 	}
 

package/src/memory/episode.ts

@@ -1,4 +1,5 @@
 import type { Surreal } from 'surrealdb'
+import { incrementWriteStats } from '../cognitive/health.ts'
 import { getLogger } from '../logger.ts'
 import type { Episode } from '../types.ts'
 
@@ -21,6 +22,7 @@ export async function episodeStart(
   `,
 		{ sessionId },
 	)
+	await incrementWriteStats(db)
 	return result[0]![0]!
 }
 
@@ -43,6 +45,7 @@ export async function episodeEnd(
 	)
 	const episode = result[0]?.[0]
 	if (!episode) throw new Error(`No open episode found for session: ${sessionId}`)
+	await incrementWriteStats(db)
 	return episode
 }
 
@@ -128,6 +131,7 @@ export async function setSessionContext(
 			{ sessionId, summary: patch.summary, context: patch.context },
 		)
 		if (!result[0]?.[0]) throw new Error(`No open episode found for session: ${sessionId}`)
+		await incrementWriteStats(db)
 		return
 	}
 
@@ -142,6 +146,7 @@ export async function setSessionContext(
 			{ sessionId, summary: patch.summary },
 		)
 		if (!result[0]?.[0]) throw new Error(`No open episode found for session: ${sessionId}`)
+		await incrementWriteStats(db)
 		return
 	}
 
@@ -155,4 +160,5 @@ export async function setSessionContext(
 		{ sessionId, context: patch.context },
 	)
 	if (!result[0]?.[0]) throw new Error(`No open episode found for session: ${sessionId}`)
+	await incrementWriteStats(db)
 }

package/src/memory/read.ts

@@ -24,11 +24,9 @@ export async function query(
 	const topK = input.topK ?? 5
 	const strategies = input.strategies ?? ['vector', 'bm25', 'graph']
 	const candidateK = topK * 4 // over-fetch before reranking
-	const vectorProbeK = Math.max(1, Math.min(200, candidateK))
-	const vectorProbeEF = Math.max(40, vectorProbeK * 2)
 	const activeFilter = input.activeOnly ? ACTIVE_FILTER : 'true'
-	const scopeFilter = '($scope = NONE OR scope = $scope)'
-	const kindFilter = '($kinds = NONE OR kind INSIDE $kinds)'
+	const scopeFilter = '(array::len($scopes) = 0 OR scope INSIDE $scopes)'
+	const kindFilter = '(array::len($kinds) = 0 OR kind INSIDE $kinds)'
 	const needsQueryEmbedding = strategies.includes('vector') || strategies.includes('bm25')
 		|| strategies.includes('graph')
 
@@ -50,42 +48,52 @@ export async function query(
 
 	const params = {
 		queryText: input.input,
-		scope: input.scope ?? null,
-		kinds: input.kind ?? null,
+		scopes: input.scope ? [input.scope] : [],
+		kinds: input.kind ?? [],
 		candidateK,
 		...(embeddingParam ? { embedding: embeddingParam } : {}),
 	}
 
 	const promises: Promise<MemoryNode[]>[] = []
 
-	// ── Strategy A: RRF — vector + BM25 combined (one SurrealDB round trip) ──
-	if (strategies.includes('vector') || strategies.includes('bm25')) {
-		log.debug('query vector/bm25 strategy enabled', {
-			vectorProbeK,
-			vectorProbeEF,
-			weights: { vector: weights.vector, bm25: weights.bm25 },
+	// ── Strategy A: vector similarity ──────────────────────────────────────────
+	if (strategies.includes('vector')) {
+		log.debug('query vector strategy enabled', {
+			weights: { vector: weights.vector },
 		})
 		promises.push(
-			db.query<[MemoryNode[]]>(
+			db.query<unknown[]>(
 				`
       LET $vec = ${vectorExpr};
-      LET $vecCand = (
-        SELECT id, embedding
-        FROM memory
-        WHERE ${activeFilter}
-          AND ${scopeFilter}
-          AND ${kindFilter}
-          AND embedding <|${vectorProbeK}, ${vectorProbeEF}|> $vec
-      );
+      SELECT *,
+        vector::similarity::cosine(embedding, $vec) * ${weights.vector} AS _score
+      FROM memory
+      WHERE ${activeFilter}
+        AND ${scopeFilter}
+        AND ${kindFilter}
+      ORDER BY _score DESC
+      LIMIT $candidateK
+				`,
+				params,
+			).then((r) => {
+				const rows = r.at(-1)
+				return Array.isArray(rows) ? rows as MemoryNode[] : []
+			}),
+		)
+	}
 
+	// ── Strategy B: BM25 lexical match ─────────────────────────────────────────
+	if (strategies.includes('bm25')) {
+		log.debug('query bm25 strategy enabled', {
+			weights: { bm25: weights.bm25 },
+		})
+		promises.push(
+			db.query<unknown[]>(
+				`
       SELECT *,
-        (
-          search::score(1) * ${weights.bm25} +
-          vector::similarity::cosine(embedding, $vec) * ${weights.vector}
-        ) AS _score
+        search::score(1) * ${weights.bm25} AS _score
       FROM memory
       WHERE content @1@ $queryText
-        AND id INSIDE $vecCand.id
         AND ${activeFilter}
         AND ${scopeFilter}
         AND ${kindFilter}
@@ -93,30 +101,29 @@ export async function query(
       LIMIT $candidateK
     `,
 				params,
-			).then((r) => r[0] ?? []),
+			).then((r) => {
+				const rows = r.at(-1)
+				return Array.isArray(rows) ? rows as MemoryNode[] : []
+			}),
 		)
 	}
 
-	// ── Strategy B: Graph spreading activation ───────────────────────────────
+	// ── Strategy C: Graph spreading activation ───────────────────────────────
 	if (strategies.includes('graph')) {
-		// First get anchor IDs from a quick vector probe, then fan out via graph
+		// First get anchor IDs from cosine similarity, then fan out via graph
 		log.debug('query graph strategy enabled', {
 			weights: { graph: weights.graph },
 		})
 		promises.push(
-			db.query<[MemoryNode[]]>(
+			db.query<unknown[]>(
 				`
       LET $vec = ${vectorExpr};
-      LET $anchor_cand = (
-        SELECT id, embedding
-        FROM memory
-        WHERE ${activeFilter}
-          AND embedding <|5, 20|> $vec
-      );
-
       LET $anchor_rows = (
         SELECT id, embedding, vector::similarity::cosine(embedding, $vec) AS _score
-        FROM $anchor_cand
+        FROM memory
+        WHERE ${activeFilter}
+          AND ${scopeFilter}
+          AND ${kindFilter}
         ORDER BY _score DESC
         LIMIT 5
       );
@@ -130,11 +137,15 @@ export async function query(
       )
       AND ${activeFilter}
       AND ${scopeFilter}
+      AND ${kindFilter}
       ORDER BY _score DESC
       LIMIT $candidateK
-    `,
+				`,
 				params,
-			).then((r) => r[0] ?? []),
+			).then((r) => {
+				const rows = r.at(-1)
+				return Array.isArray(rows) ? rows as MemoryNode[] : []
+			}),
 		)
 	}
 
@@ -209,6 +220,7 @@ export async function recall(
   `,
 		{ id: nodeId },
 	)
+	await incrementQueryStats(db)
 
 	return { node, neighbors: neighborResult[0] ?? [] }
 }
@@ -232,10 +244,13 @@ export async function wander(
 		{ scope: opts.scope ?? null },
 	).then((r) => r[0]?.[0]?.id)
 
-	if (!anchorId) return []
+	if (!anchorId) {
+		await incrementQueryStats(db)
+		return []
+	}
 
 	// Walk hops: follow relates_to edges, weight by strength
-	return db.query<[MemoryNode[]]>(
+	const result = await db.query<[MemoryNode[]]>(
 		`
     SELECT * FROM memory
     WHERE id INSIDE (
@@ -248,6 +263,8 @@ export async function wander(
   `,
 		{ anchor: anchorId },
 	).then((r) => r[0] ?? [])
+	await incrementQueryStats(db)
+	return result
 }
 
 // ── timeline() ───────────────────────────────────────────────────────────────
@@ -260,7 +277,7 @@ export async function timeline(
 	const untilIso = opts.until ? new Date(opts.until).toISOString() : null
 	const fromExpr = fromIso ? '<datetime>$from' : 'NONE'
 	const untilExpr = untilIso ? '<datetime>$until' : 'NONE'
-	return db.query<[MemoryNode[]]>(
+	const result = await db.query<[MemoryNode[]]>(
 		`
     SELECT * FROM memory
     WHERE (valid_until = NONE OR valid_until > time::now())
@@ -277,4 +294,6 @@ export async function timeline(
 			limit: opts.limit ?? 50,
 		},
 	).then((r) => r[0] ?? [])
+	await incrementQueryStats(db)
+	return result
 }

package/src/memory/write.ts

@@ -31,35 +31,30 @@ export async function observe(
 
 	// 2. Dedup probe: ANN search for cosine similarity > 0.97
 	// For non-surreal providers, we pass the pre-computed vector as $qvec.
-	if (config.embedding.provider !== 'surreal' && !embeddingParam) {
+	const usesSurrealEmbedding = config.embedding.provider === 'surrealml'
+	if (!usesSurrealEmbedding && !embeddingParam) {
 		throw new Error(`Missing embedding vector for provider: ${config.embedding.provider}`)
 	}
 
-	const dedupVecClause = config.embedding.provider === 'surreal'
+	const dedupVecClause = usesSurrealEmbedding
 		? 'fn::embed($content)'
 		: '$qvec'
-	const dedupParams = config.embedding.provider === 'surreal'
+	const dedupParams = usesSurrealEmbedding
 		? { content: input.content }
 		: { qvec: embeddingParam }
 	log.debug('observe dedup probe', {
 		provider: config.embedding.provider,
-		queryMode: config.embedding.provider === 'surreal' ? 'fn::embed($content)' : '$qvec',
+		queryMode: usesSurrealEmbedding ? 'fn::embed($content)' : '$qvec',
 	})
 
-	const dedupResult = await db.query<[{ id: string; score: number }[]]>(
+	const dedupResult = await db.query<unknown[]>(
 		`
     LET $vec = ${dedupVecClause};
-    LET $cand = (
-      SELECT id, embedding
-      FROM memory
-      WHERE (valid_until = NONE OR valid_until > time::now())
-        AND embedding <|1, 20|> $vec
-    );
-
     SELECT id, score
     FROM (
       SELECT id, vector::similarity::cosine(embedding, $vec) AS score
-      FROM $cand
+      FROM memory
+      WHERE (valid_until = NONE OR valid_until > time::now())
     )
     ORDER BY score DESC
     LIMIT 1
@@ -67,7 +62,10 @@ export async function observe(
 		dedupParams,
 	)
 
-	const topHit = dedupResult[0]?.[0]
+	const dedupRows = dedupResult.at(-1)
+	const topHit = Array.isArray(dedupRows)
+		? (dedupRows[0] as { id: string; score: number } | undefined)
+		: undefined
 	if (topHit && topHit.score > 0.97) {
 		log.debug('Near-duplicate detected — merging tags, updating updated_at', {
 			existingId: topHit.id,

package/src/types.ts

@@ -125,7 +125,7 @@ export const QueryInputSchema = z.object({
 	topK: z.number().int().min(1).max(50).default(5).optional(),
 	activeOnly: z.boolean().default(true).optional(),
 	strategies: z
-		.array(z.enum(['vector', 'bm25', 'graph', 'temporal']))
+		.array(z.enum(['vector', 'bm25', 'graph']))
 		.default(['vector', 'bm25', 'graph'])
 		.optional(),
 })