suemo 0.0.4 → 0.0.6

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

@@ -1,12 +1,13 @@
 import { confirm } from '@crustjs/prompts'
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
 import { dirname, join, resolve as resolvePath } from 'node:path'
+import packageJson from '../../../package.json' with { type: 'json' }
 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 { 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 +16,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 +121,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 +140,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
@@ -158,13 +179,89 @@ const initSchemaCmd = init.sub('schema')
 		if (!ok) process.exitCode = 1
 	})
 
+const initOpenCodeCmd = init.sub('opencode')
+	.meta({ description: 'Print OpenCode MCP + AGENTS.md setup snippets' })
+	.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 }) => {
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('init opencode', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
+
+		const configPath = flags.config?.trim() || '~/.suemo/suemo.ts'
+		const npmVersion = packageJson.version ?? '0.0.0'
+
+		if (outputMode === 'json') {
+			console.log(JSON.stringify(
+				{
+					opencode: {
+						mcp: {
+							suemo: {
+								command: 'suemo',
+								args: ['serve', '--stdio', '--config', configPath],
+							},
+						},
+						agentsSnippetPath: 'data/AGENTS.md',
+					},
+					suemoVersion: npmVersion,
+				},
+				null,
+				2,
+			))
+			return
+		}
+
+		console.log('OpenCode MCP snippet (add to your OpenCode MCP config):')
+		console.log('{')
+		console.log('  "mcpServers": {')
+		console.log('    "suemo": {')
+		console.log('      "command": "suemo",')
+		console.log(`      "args": ["serve", "--stdio", "--config", "${configPath}"]`)
+		console.log('    }')
+		console.log('  }')
+		console.log('}')
+		console.log('\nMinimal AGENTS.md snippet:')
+		console.log('```md')
+		console.log('Before starting significant work:')
+		console.log('- query("what do I know about <topic>")')
+		console.log('- suemo skill (or suemo skill core-workflow) when you need latest workflow/docs')
+		console.log('During work:')
+		console.log('- observe("...") / believe("...")')
+		console.log('After completing work:')
+		console.log('- episode_end(session_id, summary="...")')
+		console.log('```')
+		console.log('\nAGENTS.md guidance source: data/AGENTS.md')
+		console.log(`Installed suemo version: ${npmVersion}`)
+	})
+
 export const initCmd = init
 	.command(initConfigCmd)
 	.command(initSchemaCmd)
+	.command(initOpenCodeCmd)
+	.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]')
+		console.log('  suemo init opencode')
+		console.log('  suemo skill [reference]')
 		console.log('\nRun `suemo init --help` for full details.')
 	})

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, resolveScopeLabel } 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) {
@@ -28,11 +36,14 @@ export const observeCmd = app.sub('observe')
 		}
 
 		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved observe scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		const db = await connect(config.surreal)
 		try {
 			log.debug('Running observe command', {
 				kind: kindParse.data,
-				hasScope: Boolean(flags.scope),
+				hasScope: Boolean(resolvedScope),
+				scope: resolvedScope,
 				tagCount: flags.tags ? flags.tags.split(',').filter(Boolean).length : 0,
 				confidence: flags.confidence,
 				contentLength: args.content.length,
@@ -41,12 +52,17 @@ export const observeCmd = app.sub('observe')
 				content: args.content,
 				kind: kindParse.data,
 				tags: flags.tags ? flags.tags.split(',').map((t) => t.trim()) : [],
-				scope: flags.scope,
+				scope: resolvedScope,
 				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))
+			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, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'query'])
 
@@ -13,30 +13,44 @@ 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,
+		})
+		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved query scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		log.debug('Running query command', {
-			hasScope: Boolean(flags.scope),
+			hasScope: Boolean(resolvedScope),
+			scope: resolvedScope,
 			top: flags.top,
-			json: Boolean(flags.json),
+			outputMode,
 			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)
+				return await query(db, { input: args.input, scope: resolvedScope, topK: flags.top }, config)
 			} finally {
 				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 { inferProjectScope, 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,15 +156,30 @@ 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()
 		}
 		const config = await loadConfig(process.cwd(), flags.config)
+		const inferredScope = inferProjectScope(process.cwd(), config)
+		log.info('Resolved default project scope', {
+			scope: inferredScope,
+			projectDir: config.main?.projectDir ?? '.ua',
+		})
 		const sync = resolveSyncConfig(config)
 		if (sync?.auto.enabled) {
 			log.info('Auto-sync enabled', {
@@ -89,12 +192,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
 	})