suemo 0.0.4 → 0.0.5

package/package.json

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

package/src/cli/commands/believe.ts

@@ -2,7 +2,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { believe } from '../../memory/write.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'believe'])
 
@@ -12,9 +12,17 @@ export const believeCmd = app.sub('believe')
 	.flags({
 		scope: { type: 'string', short: 's', description: 'Scope label' },
 		confidence: { type: 'number', description: 'Confidence 0.0–1.0', default: 1.0 },
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('believe', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('believe', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
 		try {
@@ -28,9 +36,15 @@ export const believeCmd = app.sub('believe')
 				scope: flags.scope,
 				confidence: flags.confidence,
 			}, config)
-			const out: Record<string, unknown> = { id: node.id, valid_from: node.valid_from }
-			if (contradicted) out.contradicted = contradicted.id
-			console.log(JSON.stringify(out, null, 2))
+			if (outputMode === 'json') {
+				const out: Record<string, unknown> = { id: node.id, valid_from: node.valid_from }
+				if (contradicted) out.contradicted = contradicted.id
+				printCliJson(out, flags)
+			} else {
+				console.log(`Stored belief memory: ${node.id}`)
+				console.log(`  valid_from: ${node.valid_from}`)
+				if (contradicted) console.log(`  contradicted: ${contradicted.id}`)
+			}
 		} finally {
 			await disconnect()
 		}

package/src/cli/commands/consolidate.ts

@@ -2,7 +2,7 @@ import { consolidate } from '../../cognitive/consolidate.ts'
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'consolidate'])
 
@@ -10,9 +10,17 @@ export const consolidateCmd = app.sub('consolidate')
 	.meta({ description: 'Manually trigger memory consolidation (NREM + REM)' })
 	.flags({
 		'nrem-only': { type: 'boolean', description: 'Run only NREM (compression) phase', default: false },
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('consolidate', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('consolidate', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running consolidate command', { nremOnly: flags['nrem-only'] })
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
@@ -24,7 +32,14 @@ export const consolidateCmd = app.sub('consolidate')
 				llm: config.consolidation.llm,
 				embedding: config.embedding,
 			})
-			console.log(JSON.stringify(run, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(run, flags)
+			} else {
+				console.log(
+					`Consolidation ${run.status}: phase=${run.phase} nodes_in=${run.nodes_in} nodes_out=${run.nodes_out}`,
+				)
+				if (run.error) console.log(`  error: ${run.error}`)
+			}
 		} finally {
 			await disconnect()
 		}

package/src/cli/commands/doctor.ts

@@ -3,7 +3,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { checkCompatibility } from '../../db/preflight.ts'
 import { getLogger } from '../../logger.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'doctor'])
 
@@ -50,8 +50,19 @@ async function detectModelNames(db: Surreal): Promise<string[]> {
 
 const doctorEmbedCmd = doctor.sub('embed')
 	.meta({ description: 'Diagnose fn::embed() and show setup steps' })
+	.flags({
+		json: { type: 'boolean', description: 'Machine-readable output mode' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('doctor embed', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('doctor embed', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 
 		const config = await loadConfig(process.cwd(), flags.config)
 		const endpoint = toCliEndpoint(config.surreal.url)
@@ -115,8 +126,19 @@ const doctorEmbedCmd = doctor.sub('embed')
 
 export const doctorCmd = doctor
 	.command(doctorEmbedCmd)
+	.flags({
+		json: { type: 'boolean', description: 'Machine-readable output mode' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('doctor', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('doctor', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		console.log('Use one of:')
 		console.log('  suemo doctor embed')
 		console.log('\nRun `suemo doctor --help` for full details.')

package/src/cli/commands/export-import.ts

@@ -4,7 +4,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import type { MemoryNode, Relation } from '../../types.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'export-import'])
 
@@ -14,9 +14,17 @@ export const exportCmd = app.sub('export')
 	.flags({
 		scope: { type: 'string', short: 's', description: 'Filter by scope' },
 		all: { type: 'boolean', description: 'Include invalidated nodes' },
+		json: { type: 'boolean', description: 'Force JSONL-safe mode (stderr logs only)' },
+		pretty: { type: 'boolean', description: 'Human-readable output mode (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('export', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('export', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running export command', {
 			hasScope: Boolean(flags.scope),
 			includeInvalidated: Boolean(flags.all),
@@ -52,8 +60,18 @@ export const exportCmd = app.sub('export')
 export const importCmd = app.sub('import')
 	.meta({ description: 'Import memories from a JSONL file' })
 	.args([{ name: 'file', type: 'string', required: true }])
+	.flags({
+		json: { type: 'boolean', description: 'Output JSON summary' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('import', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('import', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running import command', { file: args.file })
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
@@ -123,5 +141,9 @@ export const importCmd = app.sub('import')
 			rl.close()
 			await disconnect()
 		}
-		console.log(JSON.stringify({ imported, skipped, errors, lines: lineNum }, null, 2))
+		if (outputMode === 'json') {
+			printCliJson({ imported, skipped, errors, lines: lineNum }, flags)
+		} else {
+			console.log(`import done: imported=${imported} skipped=${skipped} errors=${errors} lines=${lineNum}`)
+		}
 	})

package/src/cli/commands/goal.ts

@@ -3,7 +3,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { goalList, goalResolve, goalSet } from '../../goal.ts'
 import { getLogger } from '../../logger.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'goal'])
 
@@ -17,9 +17,17 @@ const setCmd = goal.sub('set')
 	.flags({
 		scope: { type: 'string', short: 's', description: 'Scope label' },
 		tags: { type: 'string', short: 't', description: 'Comma-separated tags' },
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('goal set', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('goal set', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running goal set command', {
 			hasScope: Boolean(flags.scope),
 			tagCount: flags.tags ? flags.tags.split(',').filter(Boolean).length : 0,
@@ -33,7 +41,12 @@ const setCmd = goal.sub('set')
 				...(flags.scope ? { scope: flags.scope } : {}),
 				tags: flags.tags ? flags.tags.split(',').map((t) => t.trim()) : [],
 			})
-			console.log(JSON.stringify({ id: node.id, content: node.content }, null, 2))
+			if (outputMode === 'json') {
+				printCliJson({ id: node.id, content: node.content }, flags)
+			} else {
+				console.log(`Created goal: ${node.id}`)
+				console.log(`  ${node.content}`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}
@@ -45,9 +58,17 @@ const listCmd = goal.sub('list')
 	.flags({
 		scope: { type: 'string', short: 's', description: 'Filter by scope' },
 		resolved: { type: 'boolean', description: 'Include resolved goals', default: false },
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('goal list', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('goal list', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running goal list command', {
 			hasScope: Boolean(flags.scope),
 			includeResolved: Boolean(flags.resolved),
@@ -60,11 +81,19 @@ const listCmd = goal.sub('list')
 				...(flags.scope ? { scope: flags.scope } : {}),
 				includeResolved: flags.resolved,
 			})
-			for (const g of goals) {
-				const status = g.valid_until ? `resolved ${g.valid_until}` : 'active'
-				console.log(`[${status}] ${g.id}`)
-				console.log(`  ${g.content}`)
-				console.log()
+			if (outputMode === 'json') {
+				printCliJson(goals, flags)
+			} else {
+				if (goals.length === 0) {
+					console.log('No goals found.')
+					return
+				}
+				for (const g of goals) {
+					const status = g.valid_until ? `resolved ${g.valid_until}` : 'active'
+					console.log(`[${status}] ${g.id}`)
+					console.log(`  ${g.content}`)
+					console.log()
+				}
 			}
 		} finally {
 			if (db) await disconnect()
@@ -75,15 +104,29 @@ const listCmd = goal.sub('list')
 const resolveCmd = goal.sub('resolve')
 	.meta({ description: 'Mark a goal as resolved' })
 	.args([{ name: 'goalId', type: 'string', required: true }])
+	.flags({
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('goal resolve', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('goal resolve', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running goal resolve command', { goalId: args.goalId })
 		const config = await loadConfig(process.cwd(), flags.config)
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			await goalResolve(db, args.goalId)
-			console.log(`✓ Goal ${args.goalId} resolved`)
+			if (outputMode === 'json') {
+				printCliJson({ ok: true, goalId: args.goalId }, flags)
+			} else {
+				console.log(`✓ Goal ${args.goalId} resolved`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}

package/src/cli/commands/health.ts

@@ -3,7 +3,7 @@ import { healthReport, suemoStats, vitals } from '../../cognitive/health.ts'
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'health'])
 
@@ -12,15 +12,34 @@ const health = app.sub('health')
 
 const reportCmd = health.sub('report')
 	.meta({ description: 'Full health report (default)' })
+	.flags({
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('health report', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('health report', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running health report command')
 		const config = await loadConfig(process.cwd(), flags.config)
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			const report = await healthReport(db)
-			console.log(JSON.stringify(report, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(report, flags)
+			} else {
+				console.log(
+					`nodes: total=${report.nodes.total} active=${report.nodes.active} consolidated=${report.nodes.consolidated}`,
+				)
+				console.log(`relations: ${report.relations}`)
+				console.log(`goals_active: ${report.goals_active}  fsrs_due: ${report.fsrs_due}`)
+				console.log(`surreal: ${report.version_check.surreal_version}  surrealkv=${report.version_check.surrealkv}`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}
@@ -28,15 +47,30 @@ const reportCmd = health.sub('report')
 
 const vitalsCmd = health.sub('vitals')
 	.meta({ description: 'Last 10 consolidation runs + node counts' })
+	.flags({
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('health vitals', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('health vitals', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running health vitals command')
 		const config = await loadConfig(process.cwd(), flags.config)
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			const v = await vitals(db)
-			console.log(JSON.stringify(v, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(v, flags)
+			} else {
+				console.log(`last10Runs: ${v.last10Runs.length}`)
+				console.log(`kinds: ${Object.keys(v.nodesByKind).length}  scopes: ${Object.keys(v.nodesByScope).length}`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}
@@ -44,15 +78,30 @@ const vitalsCmd = health.sub('vitals')
 
 const statsCmd = health.sub('stats')
 	.meta({ description: 'Lightweight usage stats' })
+	.flags({
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('health stats', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('health stats', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running health stats command')
 		const config = await loadConfig(process.cwd(), flags.config)
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			const s = await suemoStats(db)
-			console.log(JSON.stringify(s, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(s, flags)
+			} else {
+				console.log(`nodes: total=${s.totalNodes} active=${s.activeNodes} relations=${s.relations}`)
+				console.log(`writes=${s.totalWrites} queries=${s.totalQueries}`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}
@@ -63,15 +112,34 @@ export const healthCmd = health
 	.command(vitalsCmd)
 	.command(statsCmd)
 	// Default: run the report when just `suemo health` is called
+	.flags({
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('health', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('health', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running default health command')
 		const config = await loadConfig(process.cwd(), flags.config)
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			const report = await healthReport(db)
-			console.log(JSON.stringify(report, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(report, flags)
+			} else {
+				console.log(
+					`nodes: total=${report.nodes.total} active=${report.nodes.active} consolidated=${report.nodes.consolidated}`,
+				)
+				console.log(`relations: ${report.relations}`)
+				console.log(`goals_active: ${report.goals_active}  fsrs_due: ${report.fsrs_due}`)
+				console.log(`surreal: ${report.version_check.surreal_version}  surrealkv=${report.version_check.surrealkv}`)
+			}
 		} finally {
 			if (db) await disconnect()
 		}

package/src/cli/commands/init.ts

@@ -6,7 +6,7 @@ import { connect, disconnect } from '../../db/client.ts'
 import { checkCompatibility } from '../../db/preflight.ts'
 import { runSchema } from '../../db/schema.ts'
 import { getLogger } from '../../logger.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, resolveOutputModeOrExit } from '../shared.ts'
 
 import template from '../../config.template.ts' with { type: 'text' }
 
@@ -15,6 +15,8 @@ interface InitFlags {
 	config?: string | undefined
 	force?: boolean | undefined
 	yes?: boolean | undefined
+	json?: boolean | undefined
+	quiet?: boolean | undefined
 }
 
 const log = getLogger(['suemo', 'cli', 'init'])
@@ -118,9 +120,18 @@ const initConfigCmd = init.sub('config')
 	.meta({ description: 'Create/update ~/.suemo/suemo.ts config template' })
 	.flags({
 		force: { type: 'boolean', description: 'Overwrite existing config file' },
+		json: { type: 'boolean', description: 'Machine-readable output mode' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('init config', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('init config', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		writeConfig(Boolean(flags.force), configOutputPath(flags))
 	})
 
@@ -128,9 +139,18 @@ const initSchemaCmd = init.sub('schema')
 	.meta({ description: 'Apply database schema using current config' })
 	.flags({
 		yes: { type: 'boolean', short: 'y', description: 'Skip schema confirmation prompt' },
+		json: { type: 'boolean', description: 'Machine-readable output mode' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('init schema', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('init schema', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 
 		const confirmOptions: {
 			message: string
@@ -161,8 +181,19 @@ const initSchemaCmd = init.sub('schema')
 export const initCmd = init
 	.command(initConfigCmd)
 	.command(initSchemaCmd)
+	.flags({
+		json: { type: 'boolean', description: 'Machine-readable output mode' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ flags }) => {
-		await initCliCommand('init', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('init', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		console.log('Use one of:')
 		console.log('  suemo init config [--force]')
 		console.log('  suemo init schema [--yes]')

package/src/cli/commands/observe.ts

@@ -3,7 +3,7 @@ import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { observe } from '../../memory/write.ts'
 import { MemoryKindSchema } from '../../types.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'observe'])
 
@@ -17,9 +17,17 @@ export const observeCmd = app.sub('observe')
 		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)' },
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('observe', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('observe', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 
 		const kindParse = MemoryKindSchema.safeParse(flags.kind)
 		if (!kindParse.success) {
@@ -46,7 +54,12 @@ export const observeCmd = app.sub('observe')
 				source: flags.source,
 				sessionId: flags.session,
 			}, config)
-			console.log(JSON.stringify({ id: node.id, kind: node.kind, valid_from: node.valid_from }, null, 2))
+			if (outputMode === 'json') {
+				printCliJson({ id: node.id, kind: node.kind, valid_from: node.valid_from }, flags)
+			} else {
+				console.log(`Stored ${node.kind} memory: ${node.id}`)
+				console.log(`  valid_from: ${node.valid_from}`)
+			}
 		} finally {
 			await disconnect()
 		}

package/src/cli/commands/query.ts

@@ -3,7 +3,7 @@ import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { query } from '../../memory/read.ts'
 import type { MemoryNode } from '../../types.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'query'])
 
@@ -13,14 +13,21 @@ export const queryCmd = app.sub('query')
 	.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' },
+		json: { type: 'boolean', description: 'Output full JSON nodes' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('query', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('query', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running query command', {
 			hasScope: Boolean(flags.scope),
 			top: flags.top,
-			json: Boolean(flags.json),
+			outputMode,
 			inputLength: args.input.length,
 		})
 		const nodes: MemoryNode[] = await (async () => {
@@ -34,9 +41,13 @@ export const queryCmd = app.sub('query')
 				if (connected) await disconnect()
 			}
 		})()
-		if (flags.json) {
-			console.log(JSON.stringify(nodes, null, 2))
+		if (outputMode === 'json') {
+			printCliJson(nodes, flags)
 		} else {
+			if (nodes.length === 0) {
+				console.log('No memories matched this query.')
+				return
+			}
 			for (const n of nodes) {
 				console.log(`[${n.kind}] ${n.id}`)
 				console.log(`  ${n.content.slice(0, 120)}`)

package/src/cli/commands/recall.ts

@@ -2,21 +2,37 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { recall } from '../../memory/read.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'recall'])
 
 export const recallCmd = app.sub('recall')
 	.meta({ description: 'Fetch a single node + its neighbours (ticks FSRS)' })
 	.args([{ name: 'nodeId', type: 'string', required: true }])
+	.flags({
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
+	})
 	.run(async ({ args, flags }) => {
-		await initCliCommand('recall', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('recall', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running recall command', { nodeId: args.nodeId })
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
 		try {
 			const result = await recall(db, args.nodeId)
-			console.log(JSON.stringify(result, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(result, flags)
+			} else {
+				console.log(`[${result.node.kind}] ${result.node.id}`)
+				console.log(`  ${result.node.content.slice(0, 120)}`)
+				console.log(`  neighbors: ${result.neighbors.length}`)
+			}
 		} finally {
 			await disconnect()
 		}

package/src/cli/commands/serve.ts

@@ -1,14 +1,45 @@
 import { loadConfig, resolveSyncConfig } from '../../config.ts'
 import { getLogger } from '../../logger.ts'
 import { startMcpServer, startMcpStdioServer } from '../../mcp/server.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, resolveOutputModeOrExit } 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`)
+	console.error(`\n[suemo:dev] MCP restarted (${now})\n`)
+}
+
+function isProcessAlive(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 1) return false
+	try {
+		process.kill(pid, 0)
+		return true
+	} catch {
+		return false
+	}
+}
+
+function startParentWatchdog(stdioMode: boolean): void {
+	const explicitParentPid = Number(process.env.SUEMO_PARENT_PID ?? process.env.SUEMO_DEV_PARENT_PID)
+	const inferredParentPid = process.ppid
+	const parentPid = Number.isInteger(explicitParentPid) && explicitParentPid > 1
+		? explicitParentPid
+		: (stdioMode ? inferredParentPid : NaN)
+
+	if (!Number.isInteger(parentPid) || parentPid <= 1 || parentPid === process.pid) return
+
+	const rawInterval = Number(process.env.SUEMO_PARENT_WATCH_INTERVAL_MS ?? '2000')
+	const intervalMs = Number.isFinite(rawInterval) && rawInterval >= 500 ? rawInterval : 2000
+
+	const timer = setInterval(() => {
+		if (!isProcessAlive(parentPid)) {
+			log.warning('Parent process not found; shutting down stdio server', { parentPid })
+			process.exit(0)
+		}
+	}, intervalMs)
+	timer.unref()
 }
 
 async function runServeDevMode(): Promise<never> {
@@ -24,7 +55,12 @@ async function runServeDevMode(): Promise<never> {
 
 	const child = Bun.spawn({
 		cmd,
-		env: { ...process.env, SUEMO_DEV_WATCH: '1' },
+		env: {
+			...process.env,
+			SUEMO_DEV_WATCH: '1',
+			SUEMO_PARENT_PID: String(process.pid),
+			SUEMO_DEV_PARENT_PID: String(process.pid),
+		},
 		stdin: 'inherit',
 		stdout: 'inherit',
 		stderr: 'inherit',
@@ -45,6 +81,9 @@ async function runServeDevMode(): Promise<never> {
 	process.once('SIGTERM', () => {
 		shutdown('SIGTERM')
 	})
+	process.once('SIGHUP', () => {
+		shutdown('SIGHUP')
+	})
 
 	const exitCode = await child.exited
 	process.exit(exitCode)
@@ -61,6 +100,55 @@ async function maybeDelayDevStartup(): Promise<void> {
 	}
 }
 
+function parseDevRetryDelayMs(attempt: number): number {
+	const base = Number(process.env.SUEMO_DEV_RETRY_BASE_MS ?? '1000')
+	const cap = Number(process.env.SUEMO_DEV_RETRY_MAX_MS ?? '30000')
+	const safeBase = Number.isFinite(base) && base > 0 ? base : 1000
+	const safeCap = Number.isFinite(cap) && cap > 0 ? cap : 30000
+	return Math.min(safeCap, safeBase * (2 ** attempt))
+}
+
+async function runServerWithDevRetry(opts: {
+	stdio: boolean
+	config: Awaited<ReturnType<typeof loadConfig>>
+}): Promise<void> {
+	const isDevChild = process.env.SUEMO_DEV_WATCH === '1'
+	if (!isDevChild) {
+		if (opts.stdio) {
+			await startMcpStdioServer(opts.config)
+			return
+		}
+		await startMcpServer(opts.config)
+		return
+	}
+
+	let attempt = 0
+	while (true) {
+		try {
+			if (opts.stdio) {
+				await startMcpStdioServer(opts.config)
+				return
+			}
+			await startMcpServer(opts.config)
+			return
+		} catch (error) {
+			if (error instanceof Error && /compatibility check failed/i.test(error.message)) {
+				console.error(error.message)
+			} else {
+				console.error(String(error))
+			}
+			const delayMs = parseDevRetryDelayMs(attempt)
+			attempt += 1
+			log.warning('Dev server start failed; retrying with backoff', {
+				attempt,
+				delayMs,
+				error: String(error),
+			})
+			await Bun.sleep(delayMs)
+		}
+	}
+}
+
 export const serveCmd = app.sub('serve')
 	.meta({ description: 'Start the MCP server (HTTP or stdio)' })
 	.flags({
@@ -68,11 +156,21 @@ export const serveCmd = app.sub('serve')
 		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)' },
+		json: { type: 'boolean', description: 'Machine-readable startup logs only' },
+		'verbose-json': { type: 'boolean', description: 'Include embeddings in JSON output (implies --json)' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
+		const outputMode = resolveOutputModeOrExit(flags)
+		startParentWatchdog(Boolean(flags.stdio))
 		printDevRestartBanner()
 		await maybeDelayDevStartup()
-		await initCliCommand('serve', { debug: flags.debug, config: flags.config })
+		await initCliCommand('serve', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		if (flags.dev) {
 			await runServeDevMode()
 		}
@@ -89,12 +187,12 @@ export const serveCmd = app.sub('serve')
 		}
 		if (flags.stdio) {
 			log.debug('Starting MCP stdio transport')
-			await startMcpStdioServer(config)
+			await runServerWithDevRetry({ stdio: true, config })
 			return
 		}
 		if (flags.port) config.mcp.port = flags.port
 		if (flags.host) config.mcp.host = flags.host
 		log.debug('Starting MCP HTTP transport', { host: config.mcp.host, port: config.mcp.port })
-		await startMcpServer(config)
+		await runServerWithDevRetry({ stdio: false, config })
 		// Server runs indefinitely — no disconnect
 	})

package/src/cli/commands/sync.ts

@@ -2,7 +2,7 @@ import { loadConfig, resolveSyncConfig, type SurrealTarget } from '../../config.
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { syncTo } from '../../sync.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'sync'])
 
@@ -12,9 +12,17 @@ export const syncCmd = app.sub('sync')
 		'dry-run': { type: 'boolean', description: 'Show what would be pushed without writing', default: false },
 		direction: { type: 'string', description: 'Sync direction: push | pull | both', default: 'push' },
 		remote: { type: 'string', description: 'Named remote from sync.remotes (defaults to sync.defaultRemote)' },
+		json: { type: 'boolean', description: 'Output JSON result' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('sync', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('sync', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		const config = await loadConfig(process.cwd(), flags.config)
 		const sync = resolveSyncConfig(config)
 		if (!sync) {
@@ -50,7 +58,18 @@ export const syncCmd = app.sub('sync')
 				dryRun: flags['dry-run'],
 				direction,
 			})
-			console.log(JSON.stringify(result, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(result, flags)
+			} else {
+				const pushed = result.pushed ?? 0
+				const skipped = result.skipped ?? 0
+				const errors = result.errors ?? 0
+				console.log(
+					`sync ${
+						errors > 0 ? 'failed' : 'ok'
+					}: pushed=${pushed} skipped=${skipped} errors=${errors} cursor=${result.cursor}`,
+				)
+			}
 		} finally {
 			await disconnect()
 		}

package/src/cli/commands/timeline.ts

@@ -2,7 +2,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { timeline } from '../../memory/read.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'timeline'])
 
@@ -13,16 +13,23 @@ export const timelineCmd = app.sub('timeline')
 		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' },
+		json: { type: 'boolean', description: 'Output full JSON' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('timeline', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('timeline', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running timeline command', {
 			hasScope: Boolean(flags.scope),
 			from: flags.from ?? null,
 			until: flags.until ?? null,
 			limit: flags.limit,
-			json: Boolean(flags.json),
+			outputMode,
 		})
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
@@ -33,9 +40,13 @@ export const timelineCmd = app.sub('timeline')
 				...(flags.until ? { until: flags.until } : {}),
 				...(flags.limit ? { limit: flags.limit } : {}),
 			})
-			if (flags.json) {
-				console.log(JSON.stringify(nodes, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(nodes, flags)
 			} else {
+				if (nodes.length === 0) {
+					console.log('No timeline entries found for this filter.')
+					return
+				}
 				for (const n of nodes) {
 					const ts = new Date(n.created_at).toLocaleString()
 					console.log(`${ts}  [${n.kind}] ${n.id}`)

package/src/cli/commands/wander.ts

@@ -2,7 +2,7 @@ import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { getLogger } from '../../logger.ts'
 import { wander } from '../../memory/read.ts'
-import { app, initCliCommand } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'wander'])
 
@@ -12,15 +12,22 @@ export const wanderCmd = app.sub('wander')
 		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' },
+		json: { type: 'boolean', description: 'Output full JSON nodes' },
+		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
 	.run(async ({ flags }) => {
-		await initCliCommand('wander', { debug: flags.debug, config: flags.config })
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('wander', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
 		log.debug('Running wander command', {
 			hasAnchor: Boolean(flags.from),
 			hops: flags.hops,
 			hasScope: Boolean(flags.scope),
-			json: Boolean(flags.json),
+			outputMode,
 		})
 		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
@@ -30,8 +37,8 @@ export const wanderCmd = app.sub('wander')
 				...(flags.hops ? { hops: flags.hops } : {}),
 				...(flags.scope ? { scope: flags.scope } : {}),
 			})
-			if (flags.json) {
-				console.log(JSON.stringify(nodes, null, 2))
+			if (outputMode === 'json') {
+				printCliJson(nodes, flags)
 			} else {
 				if (nodes.length === 0) {
 					console.log('No memories found for this wander query.')

package/src/cli/shared.ts

@@ -6,6 +6,13 @@ const cliLog = getLogger(['suemo', 'cli'])
 
 const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'off'])
 
+export type OutputMode = 'pretty' | 'json'
+export interface OutputModeFlags {
+	json?: boolean | undefined
+	pretty?: boolean | undefined
+	['verbose-json']?: boolean | undefined
+}
+
 function isTruthyEnv(name: string): boolean {
 	const raw = process.env[name]
 	if (raw === undefined) return false
@@ -18,18 +25,79 @@ export function isDebugEnabled(debugFlag?: boolean): boolean {
 	return Boolean(debugFlag) || isTruthyEnv('SUEMO_DEBUG')
 }
 
+export function isQuietEnabled(quietFlag?: boolean): boolean {
+	const envQuiet = isTruthyEnv('SUEMO_QUIET')
+	const envLogLevel = (process.env.SUEMO_LOG_LEVEL ?? '').trim().toLowerCase()
+	const envLogOff = envLogLevel === 'off' || envLogLevel === 'silent' || envLogLevel === 'none'
+	return Boolean(quietFlag) || envQuiet || envLogOff
+}
+
+export function isVerboseJsonEnabled(flags: OutputModeFlags): boolean {
+	return Boolean(flags['verbose-json'])
+}
+
+export function resolveOutputMode(flags: OutputModeFlags): OutputMode {
+	const verboseJson = isVerboseJsonEnabled(flags)
+	const jsonMode = Boolean(flags.json) || verboseJson
+	if (jsonMode && flags.pretty) {
+		throw new Error('Cannot use --json and --pretty together')
+	}
+	return jsonMode ? 'json' : 'pretty'
+}
+
+export function resolveOutputModeOrExit(
+	flags: OutputModeFlags,
+): OutputMode {
+	try {
+		return resolveOutputMode(flags)
+	} catch (error) {
+		console.error(String(error))
+		process.exit(1)
+	}
+}
+
+function redactEmbeddings(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map((entry) => redactEmbeddings(entry))
+	if (!value || typeof value !== 'object') return value
+	const src = value as Record<string, unknown>
+	const out: Record<string, unknown> = {}
+	for (const [key, val] of Object.entries(src)) {
+		if (key === 'embedding') continue
+		out[key] = redactEmbeddings(val)
+	}
+	return out
+}
+
+export function printCliJson(payload: unknown, flags: OutputModeFlags): void {
+	const verboseJson = isVerboseJsonEnabled(flags)
+	const output = verboseJson ? payload : redactEmbeddings(payload)
+	console.log(JSON.stringify(output, null, 2))
+}
+
 export async function initCliCommand(
 	command: string,
-	flags: { debug?: boolean | undefined; config?: string | undefined },
+	flags: {
+		debug?: boolean | undefined
+		config?: string | undefined
+		json?: boolean | undefined
+		quiet?: boolean | undefined
+	},
 ): Promise<void> {
 	const debug = isDebugEnabled(flags.debug)
-	await initLogger({ level: debug ? 'debug' : 'info' })
+	const quiet = isQuietEnabled(flags.quiet)
+	const level = quiet ? 'fatal' : (debug ? 'debug' : (flags.json ? 'warning' : 'info'))
+	await initLogger({ level, quiet })
 	cliLog.debug('CLI command invocation', {
 		command,
 		cwd: process.cwd(),
 		debugFlag: flags.debug ?? false,
 		envDebug: process.env.SUEMO_DEBUG ?? null,
+		quietFlag: flags.quiet ?? false,
+		envQuiet: process.env.SUEMO_QUIET ?? null,
+		envLogLevel: process.env.SUEMO_LOG_LEVEL ?? null,
 		debugEnabled: debug,
+		quietEnabled: quiet,
+		jsonOutput: flags.json ?? false,
 		configFlag: flags.config ?? null,
 		envConfigPath: process.env.SUEMO_CONFIG_PATH ?? null,
 	})
@@ -40,4 +108,12 @@ export const app = new Crust('suemo')
 	.flags({
 		config: { type: 'string', short: 'c', description: 'Path to config file', inherit: true },
 		debug: { type: 'boolean', short: 'd', description: 'Verbose debug logging', inherit: true },
+		json: { type: 'boolean', short: 'j', description: 'Machine-readable JSON output', inherit: true },
+		'verbose-json': {
+			type: 'boolean',
+			description: 'Include embeddings in JSON output (implies --json)',
+			inherit: true,
+		},
+		pretty: { type: 'boolean', description: 'Human-readable output (default)', inherit: true },
+		quiet: { type: 'boolean', short: 'q', description: 'Suppress non-fatal logs', inherit: true },
 	})

package/src/cognitive/health.ts

@@ -6,7 +6,7 @@ import type { ConsolidationRun, HealthReport, SuemoStats } from '../types.ts'
 const log = getLogger(['suemo', 'cognitive', 'health'])
 
 export async function healthReport(db: Surreal): Promise<HealthReport> {
-	log.info('healthReport()')
+	log.debug('healthReport()')
 
 	const [
 		totalResult,
@@ -97,7 +97,7 @@ export async function vitals(db: Surreal): Promise<{
 	nodesByKind: Record<string, number>
 	nodesByScope: Record<string, number>
 }> {
-	log.info('vitals()')
+	log.debug('vitals()')
 	const [runsResult, byKindResult, byScopeResult] = await Promise.all([
 		db.query<[ConsolidationRun[]]>(
 			'SELECT * FROM consolidation_run ORDER BY started_at DESC LIMIT 10',
@@ -123,7 +123,7 @@ export async function vitals(db: Surreal): Promise<{
 }
 
 export async function suemoStats(db: Surreal): Promise<SuemoStats> {
-	log.info('suemoStats()')
+	log.debug('suemoStats()')
 
 	const [totalR, activeR, kindR, relR, runR, statsR] = await Promise.all([
 		db.query<[{ count: number }[]]>('SELECT count() AS count FROM memory GROUP ALL'),

package/src/db/client.ts

@@ -13,7 +13,7 @@ let _db: Surreal | null = null
 export async function connect(target: SurrealTarget): Promise<Surreal> {
 	if (_db) return _db
 
-	log.info('Connecting to SurrealDB', {
+	log.debug('Connecting to SurrealDB', {
 		url: target.url,
 		ns: target.namespace,
 		db: target.database,
@@ -41,7 +41,7 @@ export async function connect(target: SurrealTarget): Promise<Surreal> {
 	})
 
 	_db = db
-	log.info('Connected')
+	log.debug('Connected')
 	return db
 }
 
@@ -54,6 +54,6 @@ export async function disconnect(): Promise<void> {
 	if (_db) {
 		await _db.close()
 		_db = null
-		log.info('Disconnected')
+		log.debug('Disconnected')
 	}
 }

package/src/db/preflight.ts

@@ -172,11 +172,7 @@ export async function checkCompatibility(
 export async function requireCompatibility(db: Surreal): Promise<void> {
 	const result = await checkCompatibility(db)
 	if (!result.ok) {
-		console.error('\n[suemo] Compatibility check failed:\n')
-		for (const err of result.errors) {
-			console.error(`  ✗ ${err}`)
-		}
-		console.error('\nFix the issues above and retry.\n')
-		process.exit(1)
+		const details = result.errors.map((err) => `  ✗ ${err}`).join('\n')
+		throw new Error(`\n[suemo] Compatibility check failed:\n\n${details}\n\nFix the issues above and retry.\n`)
 	}
 }

package/src/logger.ts

@@ -10,10 +10,26 @@ export type LogLevel = 'debug' | 'info' | 'warning' | 'error' | 'fatal'
 
 // Different formatters for different purposes
 const prettySink: Sink = getConsoleSink({
+	console: {
+		debug: console.error,
+		info: console.error,
+		log: console.error,
+		warn: console.error,
+		error: console.error,
+		trace: console.error,
+	} as Console,
 	formatter: record => `${record.level}: ${String(record.message)}\n`,
 })
 
 const jsonSink: Sink = getConsoleSink({
+	console: {
+		debug: console.error,
+		info: console.error,
+		log: console.error,
+		warn: console.error,
+		error: console.error,
+		trace: console.error,
+	} as Console,
 	formatter: record =>
 		JSON.stringify({
 			level: record.level,
@@ -26,12 +42,16 @@ const jsonSink: Sink = getConsoleSink({
 export async function initLogger(options: {
 	level: LogLevel
 	logFile?: string // if set, also write to file
+	quiet?: boolean
 }): Promise<void> {
 	const sinks: Record<string, ReturnType<typeof getConsoleSink>> = {
 		pretty: prettySink,
 		json: jsonSink,
 	}
 
+	const noopSink: Sink = () => {}
+	sinks['noop'] = noopSink as ReturnType<typeof getConsoleSink>
+
 	if (options.logFile) {
 		sinks['file'] = getFileSink(options.logFile)
 	}
@@ -48,7 +68,9 @@ export async function initLogger(options: {
 			{
 				category: ['suemo'],
 				lowestLevel: options.level,
-				sinks: Object.keys(sinks).filter(item => item !== 'json'),
+				sinks: options.quiet
+					? ['noop']
+					: Object.keys(sinks).filter(item => item !== 'json' && item !== 'noop'),
 			},
 		],
 	})

package/src/mcp/server.ts

@@ -37,6 +37,7 @@ function createAutoSyncRunner(
 	let running = false
 	let queued = false
 	let lastRunAt = 0
+	let lastAttemptAt = 0
 
 	const runAutoSync = async ({ reason, force = false }: AutoSyncOptions): Promise<void> => {
 		if (!resolvedSync.auto.enabled) return
@@ -44,7 +45,8 @@ function createAutoSyncRunner(
 
 		const now = Date.now()
 		const minIntervalMs = resolvedSync.auto.minWriteIntervalSeconds * 1000
-		if (!force && reason === 'write' && lastRunAt > 0 && now - lastRunAt < minIntervalMs) {
+		const throttleFrom = Math.max(lastRunAt, lastAttemptAt)
+		if (!force && reason === 'write' && throttleFrom > 0 && now - throttleFrom < minIntervalMs) {
 			return
 		}
 
@@ -60,6 +62,7 @@ function createAutoSyncRunner(
 		}
 
 		running = true
+		lastAttemptAt = Date.now()
 		try {
 			const result = await syncTo(db, target, {
 				direction: resolvedSync.auto.direction,
@@ -78,9 +81,11 @@ function createAutoSyncRunner(
 			running = false
 			if (queued) {
 				queued = false
-				queueMicrotask(() => {
-					void runAutoSync({ reason: 'write', force: true })
-				})
+				const nowAfterRun = Date.now()
+				const minDelay = Math.max(0, minIntervalMs - (nowAfterRun - Math.max(lastRunAt, lastAttemptAt)))
+				setTimeout(() => {
+					void runAutoSync({ reason: 'write' })
+				}, minDelay)
 			}
 		}
 	}
@@ -153,12 +158,8 @@ export async function startMcpStdioServer(config: SuemoConfig): Promise<void> {
 			context: 'mcp:stdio-startup',
 		})
 		if (!compat.ok) {
-			console.error('\n[suemo] Compatibility check failed:\n')
-			for (const err of compat.errors) {
-				console.error(`  ✗ ${err}`)
-			}
-			console.error('\nFix the issues above and retry.\n')
-			process.exit(1)
+			const details = compat.errors.map((err) => `  ✗ ${err}`).join('\n')
+			throw new Error(`\n[suemo] Compatibility check failed:\n\n${details}\n\nFix the issues above and retry.\n`)
 		}
 		await runSchema(db)
 		await runStdioServer(db, config, { onMutation: autoSync.onWrite })