suemo 0.0.1 → 0.0.3

package/src/cli/commands/goal.ts

@@ -1,8 +1,11 @@
+import type { Surreal } from 'surrealdb'
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { goalList, goalResolve, goalSet } from '../../goal.ts'
-import { initLogger } from '../../logger.ts'
-import { app } from '../shared.ts'
+import { getLogger } from '../../logger.ts'
+import { app, initCliCommand } from '../shared.ts'
+
+const log = getLogger(['suemo', 'cli', 'goal'])
 
 const goal = app.sub('goal')
 	.meta({ description: 'Manage goal nodes' })
@@ -16,15 +19,24 @@ const setCmd = goal.sub('set')
 		tags: { type: 'string', short: 't', description: 'Comma-separated tags' },
 	})
 	.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 node = await goalSet(db, args.content, {
-			...(flags.scope ? { scope: flags.scope } : {}),
-			tags: flags.tags ? flags.tags.split(',').map((t) => t.trim()) : [],
+		await initCliCommand('goal set', { debug: flags.debug, config: flags.config })
+		log.debug('Running goal set command', {
+			hasScope: Boolean(flags.scope),
+			tagCount: flags.tags ? flags.tags.split(',').filter(Boolean).length : 0,
+			contentLength: args.content.length,
 		})
-		await disconnect()
-		console.log(JSON.stringify({ id: node.id, content: node.content }, null, 2))
+		const config = await loadConfig(process.cwd(), flags.config)
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			const node = await goalSet(db, args.content, config, {
+				...(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))
+		} finally {
+			if (db) await disconnect()
+		}
 	})
 
 // suemo goal list
@@ -35,19 +47,27 @@ const listCmd = goal.sub('list')
 		resolved: { type: 'boolean', description: 'Include resolved goals', default: false },
 	})
 	.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 goals = await goalList(db, {
-			...(flags.scope ? { scope: flags.scope } : {}),
-			includeResolved: flags.resolved,
+		await initCliCommand('goal list', { debug: flags.debug, config: flags.config })
+		log.debug('Running goal list command', {
+			hasScope: Boolean(flags.scope),
+			includeResolved: Boolean(flags.resolved),
 		})
-		await disconnect()
-		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()
+		const config = await loadConfig(process.cwd(), flags.config)
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			const goals = await goalList(db, {
+				...(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()
+			}
+		} finally {
+			if (db) await disconnect()
 		}
 	})
 
@@ -56,12 +76,17 @@ const resolveCmd = goal.sub('resolve')
 	.meta({ description: 'Mark a goal as resolved' })
 	.args([{ name: 'goalId', type: 'string', required: true }])
 	.run(async ({ args, flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('goal resolve', { debug: flags.debug, config: flags.config })
+		log.debug('Running goal resolve command', { goalId: args.goalId })
 		const config = await loadConfig(process.cwd(), flags.config)
-		const db = await connect(config.surreal)
-		await goalResolve(db, args.goalId)
-		await disconnect()
-		console.log(`✓ Goal ${args.goalId} resolved`)
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			await goalResolve(db, args.goalId)
+			console.log(`✓ Goal ${args.goalId} resolved`)
+		} finally {
+			if (db) await disconnect()
+		}
 	})
 
 // Export the container with its subcommands registered

package/src/cli/commands/health.ts

@@ -1,8 +1,11 @@
-import { healthReport, vitals } from '../../cognitive/health.ts'
+import type { Surreal } from 'surrealdb'
+import { healthReport, suemoStats, vitals } from '../../cognitive/health.ts'
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
-import { initLogger } from '../../logger.ts'
-import { app } from '../shared.ts'
+import { getLogger } from '../../logger.ts'
+import { app, initCliCommand } from '../shared.ts'
+
+const log = getLogger(['suemo', 'cli', 'health'])
 
 const health = app.sub('health')
 	.meta({ description: 'Memory health report and vitals' })
@@ -10,34 +13,66 @@ const health = app.sub('health')
 const reportCmd = health.sub('report')
 	.meta({ description: 'Full health report (default)' })
 	.run(async ({ flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('health report', { debug: flags.debug, config: flags.config })
+		log.debug('Running health report command')
 		const config = await loadConfig(process.cwd(), flags.config)
-		const db = await connect(config.surreal)
-		const report = await healthReport(db)
-		await disconnect()
-		console.log(JSON.stringify(report, null, 2))
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			const report = await healthReport(db)
+			console.log(JSON.stringify(report, null, 2))
+		} finally {
+			if (db) await disconnect()
+		}
 	})
 
 const vitalsCmd = health.sub('vitals')
 	.meta({ description: 'Last 10 consolidation runs + node counts' })
 	.run(async ({ flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('health vitals', { debug: flags.debug, config: flags.config })
+		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))
+		} finally {
+			if (db) await disconnect()
+		}
+	})
+
+const statsCmd = health.sub('stats')
+	.meta({ description: 'Lightweight usage stats' })
+	.run(async ({ flags }) => {
+		await initCliCommand('health stats', { debug: flags.debug, config: flags.config })
+		log.debug('Running health stats command')
 		const config = await loadConfig(process.cwd(), flags.config)
-		const db = await connect(config.surreal)
-		const v = await vitals(db)
-		await disconnect()
-		console.log(JSON.stringify(v, null, 2))
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			const s = await suemoStats(db)
+			console.log(JSON.stringify(s, null, 2))
+		} finally {
+			if (db) await disconnect()
+		}
 	})
 
 export const healthCmd = health
 	.command(reportCmd)
 	.command(vitalsCmd)
+	.command(statsCmd)
 	// Default: run the report when just `suemo health` is called
 	.run(async ({ flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('health', { debug: flags.debug, config: flags.config })
+		log.debug('Running default health command')
 		const config = await loadConfig(process.cwd(), flags.config)
-		const db = await connect(config.surreal)
-		const report = await healthReport(db)
-		await disconnect()
-		console.log(JSON.stringify(report, null, 2))
+		let db: Surreal | undefined
+		try {
+			db = await connect(config.surreal)
+			const report = await healthReport(db)
+			console.log(JSON.stringify(report, null, 2))
+		} finally {
+			if (db) await disconnect()
+		}
 	})

package/src/cli/commands/init.ts

@@ -1,90 +1,170 @@
+import { confirm } from '@crustjs/prompts'
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { dirname, join, resolve as resolvePath } from 'node:path'
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
 import { checkCompatibility } from '../../db/preflight.ts'
 import { runSchema } from '../../db/schema.ts'
-import { initLogger } from '../../logger.ts'
-import { app } from '../shared.ts'
+import { getLogger } from '../../logger.ts'
+import { app, initCliCommand } from '../shared.ts'
 
-export const initCmd = app.sub('init')
-	.meta({ description: 'Initialize suemo: create config template and apply DB schema' })
+import template from '../../config.template.ts' with { type: 'text' }
+
+interface InitFlags {
+	debug?: boolean | undefined
+	config?: string | undefined
+	force?: boolean | undefined
+	yes?: boolean | undefined
+}
+
+const log = getLogger(['suemo', 'cli', 'init'])
+
+const init = app.sub('init')
+	.meta({ description: 'Initialize suemo config and/or database schema' })
+
+function homeConfigPath(): string {
+	const home = process.env.HOME ?? process.env.USERPROFILE
+	if (!home) throw new Error('HOME/USERPROFILE is not set; cannot resolve ~/.suemo path')
+	return join(home, '.suemo', 'suemo.ts')
+}
+
+function writeConfig(force: boolean, outputPath?: string): 'written' | 'skipped' {
+	const configPath = outputPath ? resolveConfigOutputPath(outputPath) : homeConfigPath()
+	log.debug('Preparing config template write', { configPath, force })
+	if (existsSync(configPath) && !force) {
+		console.log(`Config already exists at ${configPath}`)
+		console.log('Pass --force to overwrite.')
+		return 'skipped'
+	}
+
+	mkdirSync(dirname(configPath), { recursive: true })
+	writeFileSync(configPath, template as unknown as string, 'utf-8')
+	console.log(`✓ Config written to ${configPath}`)
+	return 'written'
+}
+
+function configOutputPath(flags: InitFlags): string | undefined {
+	const fromFlag = flags.config?.trim()
+	if (fromFlag) return fromFlag
+	const fromEnv = process.env.SUEMO_CONFIG_PATH?.trim()
+	return fromEnv || undefined
+}
+
+function resolveConfigOutputPath(configPath: string): string {
+	if (configPath.startsWith('~/')) {
+		const home = process.env.HOME ?? process.env.USERPROFILE
+		if (!home) throw new Error('HOME/USERPROFILE is not set; cannot expand ~ in config path')
+		return resolvePath(home, configPath.slice(2))
+	}
+	return resolvePath(configPath)
+}
+
+async function applySchema(configPath?: string): Promise<boolean> {
+	let connected = false
+	try {
+		log.debug('Loading config for schema apply', { cwd: process.cwd(), overridePath: configPath ?? null })
+		const config = await loadConfig(process.cwd(), configPath)
+		log.debug('Resolved schema apply target', {
+			namespace: config.surreal.namespace,
+			database: config.surreal.database,
+			url: config.surreal.url,
+		})
+		log.debug('Connecting for schema apply', {
+			url: config.surreal.url,
+			namespace: config.surreal.namespace,
+			database: config.surreal.database,
+		})
+		const db = await connect(config.surreal)
+		connected = true
+
+		const compat = await checkCompatibility(db, {
+			requireEmbedding: false,
+			context: 'cli:init-schema',
+		})
+		log.debug('Preflight result for init schema', {
+			ok: compat.ok,
+			surrealVersion: compat.surrealVersion,
+			surrealkv: compat.surrealkv,
+			retention_ok: compat.retention_ok,
+			embedding: compat.embedding,
+			errorCount: compat.errors.length,
+		})
+		if (!compat.ok) {
+			console.error('\n✗ Compatibility check failed:')
+			for (const e of compat.errors) console.error(`  • ${e}`)
+			return false
+		}
+
+		if (!compat.embedding) {
+			console.warn(
+				'\n⚠ fn::embed() is unavailable in this DB. Schema can still be applied, but observe/query/consolidate will fail until embedding model is configured.',
+			)
+		}
+
+		await runSchema(db)
+		console.log('✓ Schema applied to SurrealDB')
+		return true
+	} catch (e) {
+		console.error(`✗ Schema not applied: ${String(e)}`)
+		return false
+	} finally {
+		if (connected) {
+			await disconnect()
+		}
+	}
+}
+
+const initConfigCmd = init.sub('config')
+	.meta({ description: 'Create/update ~/.suemo/suemo.ts config template' })
 	.flags({
-		force: { type: 'boolean', description: 'Overwrite existing config without prompting' },
+		force: { type: 'boolean', description: 'Overwrite existing config file' },
 	})
 	.run(async ({ flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('init config', { debug: flags.debug, config: flags.config })
+		writeConfig(Boolean(flags.force), configOutputPath(flags))
+	})
 
-		const homeConfig = join(process.env.HOME ?? '~', '.suemo', 'suemo.ts')
-		const configExists = existsSync(homeConfig)
+const initSchemaCmd = init.sub('schema')
+	.meta({ description: 'Apply database schema using current config' })
+	.flags({
+		yes: { type: 'boolean', short: 'y', description: 'Skip schema confirmation prompt' },
+	})
+	.run(async ({ flags }) => {
+		await initCliCommand('init schema', { debug: flags.debug, config: flags.config })
 
-		if (configExists && !flags.force) {
-			console.log(`Config already exists at ${homeConfig}`)
-			console.log('Pass --force to overwrite.')
-			return
+		const confirmOptions: {
+			message: string
+			default: boolean
+			active: string
+			inactive: string
+			initial?: boolean
+		} = {
+			message: 'Apply schema to the configured SurrealDB now?',
+			default: false,
+			active: 'Apply',
+			inactive: 'Cancel',
 		}
+		if (flags.yes !== undefined) {
+			confirmOptions.initial = flags.yes
+		}
+		const proceed = await confirm(confirmOptions)
 
-		const template = `import { defineConfig } from "suemo";
-
-export default defineConfig({
-  surreal: {
-    url:       process.env.SURREAL_URL  ?? "ws://localhost:8000",
-    namespace: process.env.SURREAL_NS   ?? "myagents",
-    database:  process.env.SURREAL_DB   ?? "default",
-    auth: {
-      user: process.env.SURREAL_USER!,
-      pass: process.env.SURREAL_PASS!,
-    },
-  },
-  embedding: {
-    provider:  "surreal",
-    dimension: 1536,
-  },
-  consolidation: {
-    trigger:                 "timer",
-    intervalMinutes:         30,
-    reactiveThreshold:       50,
-    nremSimilarityThreshold: 0.85,
-    remRelationThreshold:    0.4,
-    llm: {
-      url:    process.env.LLM_URL!,
-      model:  process.env.LLM_MODEL ?? "gpt-4o",
-      apiKey: process.env.LLM_API_KEY!,
-    },
-  },
-  retrieval: {
-    weights: { vector: 0.5, bm25: 0.25, graph: 0.15, temporal: 0.1 },
-  },
-  mcp: {
-    port: Number(process.env.SUEMO_PORT) || 4242,
-    host: "127.0.0.1",
-  },
-});
-`
-
-		mkdirSync(join(process.env.HOME ?? '~', '.suemo'), { recursive: true })
-		writeFileSync(homeConfig, template, 'utf-8')
-		console.log(`✓ Config written to ${homeConfig}`)
-
-		// Apply schema if SURREAL_* env vars are present
-		if (process.env.SURREAL_URL && process.env.SURREAL_USER) {
-			try {
-				const config = await loadConfig(process.cwd(), flags.config)
-				const db = await connect(config.surreal)
-				const compat = await checkCompatibility(db)
-				if (!compat.ok) {
-					console.error('\n✗ Compatibility check failed:')
-					for (const e of compat.errors) console.error(`  • ${e}`)
-					await disconnect()
-					return
-				}
-				await runSchema(db)
-				await disconnect()
-				console.log('✓ Schema applied to SurrealDB')
-			} catch (e) {
-				console.warn(`  (Schema not applied — configure SURREAL_* env vars first: ${String(e)})`)
-			}
-		} else {
-			console.log('  Set SURREAL_URL, SURREAL_USER, SURREAL_PASS, then run `suemo init` again to apply schema.')
+		if (!proceed) {
+			console.log('Schema apply cancelled.')
+			return
 		}
+
+		const ok = await applySchema(flags.config)
+		if (!ok) process.exitCode = 1
+	})
+
+export const initCmd = init
+	.command(initConfigCmd)
+	.command(initSchemaCmd)
+	.run(async ({ flags }) => {
+		await initCliCommand('init', { debug: flags.debug, config: flags.config })
+		console.log('Use one of:')
+		console.log('  suemo init config [--force]')
+		console.log('  suemo init schema [--yes]')
+		console.log('\nRun `suemo init --help` for full details.')
 	})

package/src/cli/commands/observe.ts

@@ -1,9 +1,11 @@
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
-import { initLogger } from '../../logger.ts'
+import { getLogger } from '../../logger.ts'
 import { observe } from '../../memory/write.ts'
 import { MemoryKindSchema } from '../../types.ts'
-import { app } from '../shared.ts'
+import { app, initCliCommand } from '../shared.ts'
+
+const log = getLogger(['suemo', 'cli', 'observe'])
 
 export const observeCmd = app.sub('observe')
 	.meta({ description: 'Store a new observation in memory' })
@@ -17,7 +19,7 @@ export const observeCmd = app.sub('observe')
 		session: { type: 'string', description: 'Session ID (attach to open episode)' },
 	})
 	.run(async ({ args, flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('observe', { debug: flags.debug, config: flags.config })
 
 		const kindParse = MemoryKindSchema.safeParse(flags.kind)
 		if (!kindParse.success) {
@@ -27,14 +29,25 @@ export const observeCmd = app.sub('observe')
 
 		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))
+		try {
+			log.debug('Running observe command', {
+				kind: kindParse.data,
+				hasScope: Boolean(flags.scope),
+				tagCount: flags.tags ? flags.tags.split(',').filter(Boolean).length : 0,
+				confidence: flags.confidence,
+				contentLength: args.content.length,
+			})
+			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,
+				sessionId: flags.session,
+			}, config)
+			console.log(JSON.stringify({ id: node.id, kind: node.kind, valid_from: node.valid_from }, null, 2))
+		} finally {
+			await disconnect()
+		}
 	})

package/src/cli/commands/query.ts

@@ -1,8 +1,11 @@
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
-import { initLogger } from '../../logger.ts'
+import { getLogger } from '../../logger.ts'
 import { query } from '../../memory/read.ts'
-import { app } from '../shared.ts'
+import type { MemoryNode } from '../../types.ts'
+import { app, initCliCommand } from '../shared.ts'
+
+const log = getLogger(['suemo', 'cli', 'query'])
 
 export const queryCmd = app.sub('query')
 	.meta({ description: 'Hybrid semantic search over memories' })
@@ -13,11 +16,24 @@ export const queryCmd = app.sub('query')
 		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()
+		await initCliCommand('query', { debug: flags.debug, config: flags.config })
+		log.debug('Running query command', {
+			hasScope: Boolean(flags.scope),
+			top: flags.top,
+			json: Boolean(flags.json),
+			inputLength: args.input.length,
+		})
+		const nodes: MemoryNode[] = await (async () => {
+			let connected = false
+			try {
+				const config = await loadConfig(process.cwd(), flags.config)
+				const db = await connect(config.surreal)
+				connected = true
+				return await query(db, { input: args.input, scope: flags.scope, topK: flags.top }, config)
+			} finally {
+				if (connected) await disconnect()
+			}
+		})()
 		if (flags.json) {
 			console.log(JSON.stringify(nodes, null, 2))
 		} else {

package/src/cli/commands/recall.ts

@@ -1,17 +1,23 @@
 import { loadConfig } from '../../config.ts'
 import { connect, disconnect } from '../../db/client.ts'
-import { initLogger } from '../../logger.ts'
+import { getLogger } from '../../logger.ts'
 import { recall } from '../../memory/read.ts'
-import { app } from '../shared.ts'
+import { app, initCliCommand } 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 }])
 	.run(async ({ args, flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('recall', { debug: flags.debug, config: flags.config })
+		log.debug('Running recall command', { nodeId: args.nodeId })
 		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))
+		try {
+			const result = await recall(db, args.nodeId)
+			console.log(JSON.stringify(result, null, 2))
+		} finally {
+			await disconnect()
+		}
 	})

package/src/cli/commands/serve.ts

@@ -1,19 +1,38 @@
-import { loadConfig } from '../../config.ts'
-import { initLogger } from '../../logger.ts'
-import { startMcpServer } from '../../mcp/server.ts'
-import { app } from '../shared.ts'
+import { loadConfig, resolveSyncConfig } from '../../config.ts'
+import { getLogger } from '../../logger.ts'
+import { startMcpServer, startMcpStdioServer } from '../../mcp/server.ts'
+import { app, initCliCommand } from '../shared.ts'
+
+const log = getLogger(['suemo', 'cli', 'serve'])
 
 export const serveCmd = app.sub('serve')
-	.meta({ description: 'Start the MCP server' })
+	.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' },
 	})
 	.run(async ({ flags }) => {
-		await initLogger({ level: flags.debug ? 'debug' : 'info' })
+		await initCliCommand('serve', { debug: flags.debug, config: flags.config })
 		const config = await loadConfig(process.cwd(), flags.config)
+		const sync = resolveSyncConfig(config)
+		if (sync?.auto.enabled) {
+			log.info('Auto-sync enabled', {
+				remote: sync.auto.remote,
+				direction: sync.auto.direction,
+				intervalSeconds: sync.auto.intervalSeconds,
+				onWrite: sync.auto.onWrite,
+				minWriteIntervalSeconds: sync.auto.minWriteIntervalSeconds,
+			})
+		}
+		if (flags.stdio) {
+			log.debug('Starting MCP stdio transport')
+			await startMcpStdioServer(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)
 		// Server runs indefinitely — no disconnect
 	})