suemo 0.0.4 → 0.0.6

package/src/db/preflight.ts

@@ -109,9 +109,12 @@ export async function checkCompatibility(
 						+ 'Start SurrealDB with: SURREAL_DATASTORE_RETENTION=90d surreal start surrealkv://path/to/data',
 				)
 			} else {
-				// Unexpected error — still flag but don't assume retention is wrong
-				retention_ok = true
-				log.debug('Retention probe returned unexpected error (may be fine)', { error: String(e) })
+				retention_ok = false
+				errors.push(
+					`Retention probe failed unexpectedly: ${String(e)}. `
+						+ 'Verify server capabilities and retention env (SURREAL_DATASTORE_VERSIONED=true and SURREAL_DATASTORE_RETENTION=90d).',
+				)
+				log.debug('Retention probe returned unexpected error', { error: String(e) })
 			}
 		} finally {
 			try {
@@ -172,11 +175,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/db/schema.surql

@@ -70,6 +70,9 @@ DEFINE INDEX OVERWRITE idx_memory_salience
 DEFINE INDEX OVERWRITE idx_memory_topic_key
   ON memory FIELDS topic_key;
 
+DEFINE INDEX OVERWRITE idx_memory_updated_at
+  ON memory FIELDS updated_at;
+
 -- ── relates_to ───────────────────────────────────────────────────────────────
 DEFINE TABLE OVERWRITE relates_to SCHEMAFULL
   TYPE RELATION IN memory OUT memory;
@@ -83,14 +86,28 @@ DEFINE FIELD OVERWRITE valid_until ON relates_to TYPE option<datetime> DEFAULT N
 DEFINE FIELD OVERWRITE created_at ON relates_to TYPE datetime DEFAULT time::now();
 DEFINE FIELD OVERWRITE updated_at ON relates_to TYPE datetime DEFAULT time::now();
 
+DEFINE INDEX OVERWRITE idx_relates_to_updated_at
+  ON relates_to FIELDS updated_at;
+
 -- ── episode ───────────────────────────────────────────────────────────────────
 DEFINE TABLE OVERWRITE episode SCHEMAFULL;
 
 DEFINE FIELD OVERWRITE session_id  ON episode TYPE string;
 DEFINE FIELD OVERWRITE started_at  ON episode TYPE datetime DEFAULT time::now();
 DEFINE FIELD OVERWRITE ended_at    ON episode TYPE option<datetime> DEFAULT NONE;
+DEFINE FIELD OVERWRITE updated_at  ON episode TYPE datetime DEFAULT time::now();
 DEFINE FIELD OVERWRITE summary     ON episode TYPE option<string>;
 DEFINE FIELD OVERWRITE context     ON episode TYPE option<object> FLEXIBLE DEFAULT NONE;
+DEFINE FIELD OVERWRITE goal        ON episode TYPE option<string> DEFAULT NONE;
+DEFINE FIELD OVERWRITE discoveries ON episode TYPE option<array<string>> DEFAULT NONE;
+DEFINE FIELD OVERWRITE accomplished ON episode TYPE option<array<string>> DEFAULT NONE;
+DEFINE FIELD OVERWRITE files_changed ON episode TYPE option<array<string>> DEFAULT NONE;
+
+DEFINE INDEX OVERWRITE idx_episode_session_time
+  ON episode FIELDS session_id, ended_at, started_at;
+
+DEFINE INDEX OVERWRITE idx_episode_updated_at
+  ON episode FIELDS updated_at;
 
 -- REFERENCES: bidirectional array of memory links
 DEFINE FIELD OVERWRITE memory_ids  ON episode

package/src/index.ts

@@ -1,11 +1,13 @@
 // src/index.ts — public API surface
-export { defineConfig, loadConfig, resolveSyncConfig } from './config.ts'
+export { defineConfig, inferProjectIdentity, inferProjectScope, loadConfig, resolveSyncConfig } from './config.ts'
 export type {
 	AuthConfig,
 	ConsolidationConfig,
 	EmbeddingProvider,
 	LLMConfig,
+	MainConfig,
 	McpConfig,
+	ProjectIdentity,
 	ResolvedSyncAutoConfig,
 	ResolvedSyncConfig,
 	RetrievalConfig,

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/dispatch.ts

@@ -2,12 +2,22 @@ import type { Surreal } from 'surrealdb'
 import { z } from 'zod'
 import { consolidate } from '../cognitive/consolidate.ts'
 import { healthReport, suemoStats, vitals } from '../cognitive/health.ts'
+import { inferProjectScope } from '../config.ts'
 import type { SuemoConfig } from '../config.ts'
 import { goalList, goalResolve, goalSet } from '../goal.ts'
 import { getLogger } from '../logger.ts'
 import { episodeEnd, episodeStart, getSessionContext, setSessionContext } from '../memory/episode.ts'
-import { query, recall, timeline, wander } from '../memory/read.ts'
-import { believe, capturePrompt, invalidate, observe, upsertByKey } from '../memory/write.ts'
+import { context, query, recall, timeline, wander } from '../memory/read.ts'
+import {
+	believe,
+	capturePrompt,
+	invalidate,
+	observe,
+	suggestTopicKey,
+	updateMemoryById,
+	upsertByKey,
+} from '../memory/write.ts'
+import { listSkillReferences, readSkillDoc, readSkillReference } from '../skill/catalog.ts'
 import { ObserveInputSchema, QueryInputSchema } from '../types.ts'
 
 const log = getLogger(['suemo', 'mcp', 'dispatch'])
@@ -20,7 +30,10 @@ const MUTATING_TOOLS = new Set([
 	'goal_resolve',
 	'upsert_by_key',
 	'capture_prompt',
+	'episode_start',
+	'episode_end',
 	'session_context_set',
+	'update',
 ])
 
 interface DispatchOptions {
@@ -35,6 +48,7 @@ export async function handleToolCall(
 	opts: DispatchOptions = {},
 ): Promise<unknown> {
 	log.debug('Dispatching MCP tool call', { method, paramKeys: Object.keys(params) })
+	const inferredScope = inferProjectScope(process.cwd(), config)
 
 	const maybeTriggerMutationSync = (): void => {
 		if (!MUTATING_TOOLS.has(method) || !opts.onMutation) return
@@ -45,7 +59,11 @@ export async function handleToolCall(
 
 	switch (method) {
 		case 'observe': {
-			const result = await observe(db, ObserveInputSchema.parse(params), config)
+			const parsed = ObserveInputSchema.parse(params)
+			const result = await observe(db, {
+				...parsed,
+				scope: parsed.scope?.trim() || inferredScope,
+			}, config)
 			maybeTriggerMutationSync()
 			return result
 		}
@@ -58,7 +76,10 @@ export async function handleToolCall(
 					confidence: z.number().optional(),
 				})
 				.parse(params)
-			const result = await believe(db, parsed, config)
+			const result = await believe(db, {
+				...parsed,
+				scope: parsed.scope?.trim() || inferredScope,
+			}, config)
 			maybeTriggerMutationSync()
 			return result
 		}
@@ -70,8 +91,13 @@ export async function handleToolCall(
 			return { ok: true }
 		}
 
-		case 'query':
-			return query(db, QueryInputSchema.parse(params), config)
+		case 'query': {
+			const parsed = QueryInputSchema.parse(params)
+			return query(db, {
+				...parsed,
+				scope: parsed.scope?.trim() || inferredScope,
+			}, config)
+		}
 
 		case 'recall': {
 			const parsed = z.object({ nodeId: z.string() }).parse(params)
@@ -85,7 +111,7 @@ export async function handleToolCall(
 			return wander(db, {
 				...(parsed.anchor ? { anchor: parsed.anchor } : {}),
 				...(parsed.hops ? { hops: parsed.hops } : {}),
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 			})
 		}
 
@@ -99,21 +125,46 @@ export async function handleToolCall(
 				})
 				.parse(params)
 			return timeline(db, {
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 				...(parsed.from ? { from: parsed.from } : {}),
 				...(parsed.until ? { until: parsed.until } : {}),
 				...(parsed.limit ? { limit: parsed.limit } : {}),
 			})
 		}
 
+		case 'context': {
+			const parsed = z.object({ scope: z.string().optional(), limit: z.number().optional() }).parse(params)
+			return context(db, {
+				scope: parsed.scope?.trim() || inferredScope,
+				...(parsed.limit !== undefined ? { limit: parsed.limit } : {}),
+			})
+		}
+
 		case 'episode_start': {
 			const parsed = z.object({ sessionId: z.string() }).parse(params)
-			return episodeStart(db, parsed.sessionId)
+			const result = await episodeStart(db, parsed.sessionId)
+			maybeTriggerMutationSync()
+			return result
 		}
 
 		case 'episode_end': {
-			const parsed = z.object({ sessionId: z.string(), summary: z.string().optional() }).parse(params)
-			return episodeEnd(db, parsed.sessionId, parsed.summary)
+			const parsed = z.object({
+				sessionId: z.string(),
+				summary: z.string().optional(),
+				goal: z.string().optional(),
+				discoveries: z.array(z.string()).optional(),
+				accomplished: z.array(z.string()).optional(),
+				files_changed: z.array(z.string()).optional(),
+			}).parse(params)
+			const result = await episodeEnd(db, parsed.sessionId, parsed.summary, {
+				...(parsed.summary !== undefined ? { summary: parsed.summary } : {}),
+				...(parsed.goal !== undefined ? { goal: parsed.goal } : {}),
+				...(parsed.discoveries !== undefined ? { discoveries: parsed.discoveries } : {}),
+				...(parsed.accomplished !== undefined ? { accomplished: parsed.accomplished } : {}),
+				...(parsed.files_changed !== undefined ? { files_changed: parsed.files_changed } : {}),
+			})
+			maybeTriggerMutationSync()
+			return result
 		}
 
 		case 'goal_set': {
@@ -121,7 +172,7 @@ export async function handleToolCall(
 				.object({ content: z.string(), scope: z.string().optional(), tags: z.array(z.string()).optional() })
 				.parse(params)
 			const result = await goalSet(db, parsed.content, config, {
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 				tags: parsed.tags ?? [],
 			})
 			maybeTriggerMutationSync()
@@ -138,7 +189,7 @@ export async function handleToolCall(
 		case 'goal_list': {
 			const parsed = z.object({ scope: z.string().optional(), includeResolved: z.boolean().optional() }).parse(params)
 			return goalList(db, {
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 				includeResolved: parsed.includeResolved ?? false,
 			})
 		}
@@ -153,13 +204,14 @@ export async function handleToolCall(
 			return vitals(db)
 
 		case 'consolidate': {
-			const parsed = z.object({ nremOnly: z.boolean().optional() }).parse(params)
+			const parsed = z.object({ nremOnly: z.boolean().optional(), scope: z.string().optional() }).parse(params)
 			return consolidate(db, {
 				nremOnly: parsed.nremOnly ?? false,
 				nremSimilarityThreshold: config.consolidation.nremSimilarityThreshold,
 				remRelationThreshold: config.consolidation.remRelationThreshold,
 				llm: config.consolidation.llm,
 				embedding: config.embedding,
+				scope: parsed.scope?.trim() || inferredScope,
 			})
 		}
 
@@ -177,7 +229,7 @@ export async function handleToolCall(
 				})
 				.parse(params)
 			const result = await upsertByKey(db, config, parsed.topicKey, parsed.content, {
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 				tags: parsed.tags ?? [],
 				...(parsed.source ? { source: parsed.source } : {}),
 				...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
@@ -198,13 +250,61 @@ export async function handleToolCall(
 				})
 				.parse(params)
 			const result = await capturePrompt(db, config, parsed.prompt, parsed.derivedIds ?? [], {
-				...(parsed.scope ? { scope: parsed.scope } : {}),
+				scope: parsed.scope?.trim() || inferredScope,
 				...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
 			})
 			maybeTriggerMutationSync()
 			return result
 		}
 
+		case 'update': {
+			const parsed = z
+				.object({
+					nodeId: z.string(),
+					content: z.string().optional(),
+					kind: z.enum(['observation', 'belief', 'question', 'hypothesis', 'goal']).optional(),
+					tags: z.array(z.string()).optional(),
+					scope: z.string().nullable().optional(),
+					source: z.string().nullable().optional(),
+					confidence: z.number().optional(),
+				})
+				.parse(params)
+
+			const result = await updateMemoryById(db, config, parsed.nodeId, {
+				...(parsed.content !== undefined ? { content: parsed.content } : {}),
+				...(parsed.kind !== undefined ? { kind: parsed.kind } : {}),
+				...(parsed.tags !== undefined ? { tags: parsed.tags } : {}),
+				...(parsed.scope !== undefined ? { scope: parsed.scope ?? null } : {}),
+				...(parsed.source !== undefined ? { source: parsed.source ?? null } : {}),
+				...(parsed.confidence !== undefined ? { confidence: parsed.confidence } : {}),
+			})
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'suggest_topic_key': {
+			const parsed = z.object({ input: z.string() }).parse(params)
+			return { topicKey: suggestTopicKey(parsed.input) }
+		}
+
+		case 'skill': {
+			const parsed = z.object({ reference: z.string().optional() }).parse(params)
+			const reference = parsed.reference?.trim()
+			if (!reference) {
+				const references = listSkillReferences()
+				return {
+					name: 'suemo',
+					content: readSkillDoc(),
+					references,
+				}
+			}
+			const resolved = readSkillReference(reference)
+			if (!resolved) {
+				throw new Error(`Unknown skill reference: ${reference}`)
+			}
+			return { name: resolved.name, content: resolved.content }
+		}
+
 		case 'session_context_get': {
 			const parsed = z.object({ sessionId: z.string() }).parse(params)
 			return getSessionContext(db, parsed.sessionId)

package/src/mcp/server.ts

@@ -1,6 +1,6 @@
 // src/mcp/server.ts
 import { Elysia } from 'elysia'
-import { resolveSyncConfig, type SuemoConfig } from '../config.ts'
+import { inferProjectScope, resolveSyncConfig, type SuemoConfig } from '../config.ts'
 import { connect, disconnect } from '../db/client.ts'
 import { checkCompatibility, requireCompatibility } from '../db/preflight.ts'
 import { runSchema } from '../db/schema.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)
 			}
 		}
 	}
@@ -116,6 +121,11 @@ function createAutoSyncRunner(
 }
 
 export async function startMcpServer(config: SuemoConfig): Promise<void> {
+	const inferredScope = inferProjectScope(process.cwd(), config)
+	log.info('Resolved default project scope', {
+		scope: inferredScope,
+		projectDir: config.main?.projectDir ?? '.ua',
+	})
 	const db = await connect(config.surreal)
 	await requireCompatibility(db)
 	await runSchema(db)
@@ -144,6 +154,11 @@ export async function startMcpServer(config: SuemoConfig): Promise<void> {
 }
 
 export async function startMcpStdioServer(config: SuemoConfig): Promise<void> {
+	const inferredScope = inferProjectScope(process.cwd(), config)
+	log.info('Resolved default project scope', {
+		scope: inferredScope,
+		projectDir: config.main?.projectDir ?? '.ua',
+	})
 	const db = await connect(config.surreal)
 	const autoSync = createAutoSyncRunner(db, config)
 	autoSync.start()
@@ -153,12 +168,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 })

package/src/mcp/stdio.ts

@@ -121,6 +121,17 @@ const MCP_TOOLS: McpToolDefinition[] = [
 			},
 		},
 	},
+	{
+		name: 'context',
+		description: 'Recover recent session context by scope',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				scope: { type: 'string' },
+				limit: { type: 'number' },
+			},
+		},
+	},
 	{
 		name: 'episode_start',
 		description: 'Start an episode for a session ID',
@@ -138,6 +149,10 @@ const MCP_TOOLS: McpToolDefinition[] = [
 			properties: {
 				sessionId: { type: 'string' },
 				summary: { type: 'string' },
+				goal: { type: 'string' },
+				discoveries: { type: 'array', items: { type: 'string' } },
+				accomplished: { type: 'array', items: { type: 'string' } },
+				files_changed: { type: 'array', items: { type: 'string' } },
 			},
 			required: ['sessionId'],
 		},
@@ -195,7 +210,10 @@ const MCP_TOOLS: McpToolDefinition[] = [
 		description: 'Trigger memory consolidation',
 		inputSchema: {
 			type: 'object',
-			properties: { nremOnly: { type: 'boolean' } },
+			properties: {
+				nremOnly: { type: 'boolean' },
+				scope: { type: 'string' },
+			},
 		},
 	},
 	{
@@ -216,6 +234,44 @@ const MCP_TOOLS: McpToolDefinition[] = [
 			required: ['topicKey', 'content'],
 		},
 	},
+	{
+		name: 'update',
+		description: 'Update an existing memory node by ID',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				nodeId: { type: 'string' },
+				content: { type: 'string' },
+				kind: { type: 'string', enum: ['observation', 'belief', 'question', 'hypothesis', 'goal'] },
+				tags: { type: 'array', items: { type: 'string' } },
+				scope: { type: ['string', 'null'] },
+				source: { type: ['string', 'null'] },
+				confidence: { type: 'number' },
+			},
+			required: ['nodeId'],
+		},
+	},
+	{
+		name: 'suggest_topic_key',
+		description: 'Suggest a deterministic canonical topic key from free text',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				input: { type: 'string' },
+			},
+			required: ['input'],
+		},
+	},
+	{
+		name: 'skill',
+		description: 'Get suemo skill doc or a specific versioned reference',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				reference: { type: 'string' },
+			},
+		},
+	},
 	{
 		name: 'capture_prompt',
 		description: 'Capture a raw prompt and link derived observations',

package/src/memory/episode.ts

@@ -1,7 +1,7 @@
 import type { Surreal } from 'surrealdb'
 import { incrementWriteStats } from '../cognitive/health.ts'
 import { getLogger } from '../logger.ts'
-import type { Episode } from '../types.ts'
+import { type Episode, type EpisodeSummaryFields, EpisodeSummaryFieldsSchema } from '../types.ts'
 
 const log = getLogger(['suemo', 'memory', 'episode'])
 
@@ -17,6 +17,10 @@ export async function episodeStart(
       ended_at:   NONE,
       summary:    NONE,
       context:    NONE,
+      goal:       NONE,
+      discoveries: NONE,
+      accomplished: NONE,
+      files_changed: NONE,
       memory_ids: []
     }
   `,
@@ -30,18 +34,42 @@ export async function episodeEnd(
 	db: Surreal,
 	sessionId: string,
 	summary?: string,
+	structured?: EpisodeSummaryFields,
 ): Promise<Episode> {
 	log.info('episodeEnd()', { sessionId })
+	const fields = structured ? EpisodeSummaryFieldsSchema.parse(structured) : undefined
+	const summaryText = summary ?? fields?.summary
 	const result = await db.query<[Episode[]]>(
 		`
     UPDATE episode
     SET ended_at = time::now(),
-        summary  = $summary
+        updated_at = time::now(),
+        summary  = $summary,
+        goal = $goal,
+        discoveries = $discoveries,
+        accomplished = $accomplished,
+        files_changed = $filesChanged,
+        context = $context
     WHERE session_id = $sessionId
       AND ended_at   = NONE
     RETURN AFTER
   `,
-		{ sessionId, summary: summary ?? null },
+		{
+			sessionId,
+			summary: summaryText ?? null,
+			goal: fields?.goal ?? null,
+			discoveries: fields?.discoveries ?? null,
+			accomplished: fields?.accomplished ?? null,
+			filesChanged: fields?.files_changed ?? null,
+			context: fields
+				? {
+					...(fields.goal !== undefined ? { goal: fields.goal } : {}),
+					...(fields.discoveries !== undefined ? { discoveries: fields.discoveries } : {}),
+					...(fields.accomplished !== undefined ? { accomplished: fields.accomplished } : {}),
+					...(fields.files_changed !== undefined ? { files_changed: fields.files_changed } : {}),
+				}
+				: null,
+		},
 	)
 	const episode = result[0]?.[0]
 	if (!episode) throw new Error(`No open episode found for session: ${sessionId}`)
@@ -63,6 +91,7 @@ export async function attachToEpisode(
 		`
     UPDATE episode
     SET memory_ids += [$memoryId]
+      , updated_at = time::now()
     WHERE session_id = $sessionId AND ended_at = NONE
   `,
 		{ sessionId, memoryId },
@@ -124,7 +153,8 @@ export async function setSessionContext(
 			`
       UPDATE episode
       SET summary = $summary,
-          context = $context
+          context = $context,
+          updated_at = time::now()
       WHERE session_id = $sessionId AND ended_at = NONE
       RETURN AFTER
     `,
@@ -139,7 +169,8 @@ export async function setSessionContext(
 		const result = await db.query<[Episode[]]>(
 			`
       UPDATE episode
-      SET summary = $summary
+      SET summary = $summary,
+          updated_at = time::now()
       WHERE session_id = $sessionId AND ended_at = NONE
       RETURN AFTER
     `,
@@ -153,7 +184,8 @@ export async function setSessionContext(
 	const result = await db.query<[Episode[]]>(
 		`
     UPDATE episode
-    SET context = $context
+    SET context = $context,
+        updated_at = time::now()
     WHERE session_id = $sessionId AND ended_at = NONE
     RETURN AFTER
   `,