suemo 0.0.5 → 0.0.6

package/README.md

@@ -34,11 +34,14 @@ suemo gives AI agents a memory that survives across sessions, models, and runtim
 SurrealDB must be started with SurrealKV and a retention window:
 
 ```sh
-SURREAL_DATASTORE_RETENTION=90d surreal start \
+SURREAL_DATASTORE_VERSIONED=true SURREAL_DATASTORE_RETENTION=90d surreal start \
   --bind 0.0.0.0:8000 \
-  surrealkv:///path/to/data
+  --allow-funcs "fn::*" \
+  -- surrealkv:///path/to/data
 ```
 
+For suemo, the critical capability is allowing custom functions (`fn::embed`) via `--allow-funcs "fn::*"`.
+
 An embedding model must be configured in SurrealDB for `fn::embed()` to work.
 
 ---
@@ -64,6 +67,19 @@ bun run src/cli/index.ts init config
 
 This writes `~/.suemo/suemo.ts`. Edit it with your SurrealDB URL, credentials, and LLM endpoint.
 
+Set project scope discovery in config (recommended):
+
+```ts
+export default defineConfig({
+	main: {
+		projectDir: '.ua',
+	},
+	// ...
+})
+```
+
+With this, suemo resolves default scope from nearest `.ua/suemo.json` (auto-created if missing).
+
 **2. Apply schema**
 
 Apply schema after you set/edit namespace/database:
@@ -106,6 +122,30 @@ suemo serve --dev
 
 ---
 
+## OpenCode setup (only integration target)
+
+Print copy-paste setup snippets:
+
+```sh
+suemo init opencode
+```
+
+This prints:
+
+- MCP config snippet (`command: suemo`, `args: ["serve", "--stdio", ...]`)
+- minimal AGENTS.md guidance snippet
+
+To fetch the latest skill docs directly from your local checkout:
+
+```sh
+suemo skill
+suemo skill core-workflow
+```
+
+No files are auto-written by this command.
+
+---
+
 ## CLI Reference
 
 ```
@@ -119,6 +159,7 @@ Commands:
   init                  Show init subcommands and usage guidance
   init config           Create/update ~/.suemo/suemo.ts
   init schema           Apply DB schema from current config (with confirm)
+  skill                 Print suemo skill docs (or specific reference)
   serve                 Start the MCP server (HTTP or stdio)
   observe <content>     Store an observation
   believe <content>     Store a belief (triggers contradiction detection)
@@ -277,12 +318,16 @@ This prints your active target (`url`, `namespace`, `database`) and step-by-step
 | `recall`              | Fetch a node and its 1-hop neighbourhood; ticks FSRS                |
 | `wander`              | Spreading-activation walk through the graph                         |
 | `timeline`            | Chronological memory slice with optional date range                 |
+| `context`             | Recover recent session context for current/default scope            |
 | `episode_start`       | Begin a bounded session window                                      |
 | `episode_end`         | Close a session, optionally with a summary                          |
 | `goal_set`            | Create a goal node                                                  |
 | `goal_resolve`        | Mark a goal achieved                                                |
 | `goal_list`           | List active (or all) goals                                          |
 | `upsert_by_key`       | Upsert a memory node by stable topic key                            |
+| `update`              | Update an existing memory node by ID (re-embeds if content changed) |
+| `suggest_topic_key`   | Suggest deterministic canonical topic key from free text            |
+| `skill`               | Return current suemo skill docs or one named reference              |
 | `capture_prompt`      | Capture raw prompt and link derived observations                    |
 | `session_context_get` | Fetch open episode summary/context by session ID                    |
 | `session_context_set` | Update open episode summary/context by session ID                   |
@@ -293,6 +338,13 @@ This prints your active target (`url`, `namespace`, `database`) and step-by-step
 
 Agents never supply temporal fields (`valid_from`, `valid_until`). These are system-managed.
 
+### Scope and longevity notes
+
+- Default inferred project scope now uses nearest `<projectDir>/suemo.json` with `main.projectDir` defaulting to `.ua`.
+- Semantic operations are scope-aware (dedup, contradiction detection, upsert-by-key, consolidation).
+- Retention probe is fail-closed on unexpected probe errors.
+- Episode records are included in sync and export/import flows.
+
 ---
 
 ## Architecture

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suemo",
-	"version": "0.0.5",
+	"version": "0.0.6",
 	"description": "Persistent semantic memory for AI agents — backed by SurrealDB.",
 	"author": {
 		"name": "Umar Alfarouk",
@@ -37,7 +37,10 @@
 	"scripts": {
 		"dev": "bun run src/cli/index.ts",
 		"start": "bun run src/cli/index.ts",
-		"check": "bun tsc --noEmit"
+		"ssot:check": "bun run scripts/ssot.ts check",
+		"ssot:sync": "bun run scripts/ssot.ts sync",
+		"check": "bun tsc --noEmit && bun run ssot:check",
+		"sync": "bun run ssot:sync"
 	},
 	"dependencies": {
 		"@crustjs/core": "^0.0.15",

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'believe'])
 
@@ -24,16 +24,19 @@ export const believeCmd = app.sub('believe')
 			quiet: flags.quiet,
 		})
 		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved believe scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		const db = await connect(config.surreal)
 		try {
 			log.debug('Running believe command', {
-				hasScope: Boolean(flags.scope),
+				hasScope: Boolean(resolvedScope),
+				scope: resolvedScope,
 				confidence: flags.confidence,
 				contentLength: args.content.length,
 			})
 			const { node, contradicted } = await believe(db, {
 				content: args.content,
-				scope: flags.scope,
+				scope: resolvedScope,
 				confidence: flags.confidence,
 			}, config)
 			if (outputMode === 'json') {

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'consolidate'])
 
@@ -10,6 +10,7 @@ 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 },
+		scope: { type: 'string', short: 's', description: 'Scope label (defaults to inferred project scope)' },
 		json: { type: 'boolean', description: 'Output full JSON' },
 		pretty: { type: 'boolean', description: 'Human-readable output (default)' },
 	})
@@ -23,6 +24,7 @@ export const consolidateCmd = app.sub('consolidate')
 		})
 		log.debug('Running consolidate command', { nremOnly: flags['nrem-only'] })
 		const config = await loadConfig(process.cwd(), flags.config)
+		const scope = resolveScopeLabel(flags.scope, config)
 		const db = await connect(config.surreal)
 		try {
 			const run = await consolidate(db, {
@@ -31,6 +33,7 @@ export const consolidateCmd = app.sub('consolidate')
 				remRelationThreshold: config.consolidation.remRelationThreshold,
 				llm: config.consolidation.llm,
 				embedding: config.embedding,
+				...(scope ? { scope } : {}),
 			})
 			if (outputMode === 'json') {
 				printCliJson(run, flags)

package/src/cli/commands/doctor.ts

@@ -104,6 +104,8 @@ const doctorEmbedCmd = doctor.sub('embed')
 			console.log('\nHow to set up fn::embed() (step-by-step):')
 			console.log('\n1) Ensure SurrealDB CLI exposes ML commands:')
 			console.log('   surreal ml --help')
+			console.log('\n   and start SurrealDB with custom function capability:')
+			console.log('   surreal start --allow-funcs "fn::*" ...')
 			console.log('\n2) Import a .surml embedding model into this exact NS/DB:')
 			console.log(
 				`   surreal ml import --conn ${endpoint} --user <USER> --pass <PASS> --ns ${config.surreal.namespace} --db ${config.surreal.database} path/to/your-model.surml`,

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'export-import'])
 
@@ -30,19 +30,25 @@ export const exportCmd = app.sub('export')
 			includeInvalidated: Boolean(flags.all),
 		})
 		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved export scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		const db = await connect(config.surreal)
 		try {
 			const activeFilter = flags.all ? 'true' : '(valid_until = NONE OR valid_until > time::now())'
 			const scopeFilter = '($scope = NONE OR scope = $scope)'
 
-			const [nodesResult, relationsResult] = await Promise.all([
+			const [nodesResult, relationsResult, episodesResult] = await Promise.all([
 				db.query<[MemoryNode[]]>(
 					`
         SELECT * FROM memory WHERE ${activeFilter} AND ${scopeFilter} ORDER BY created_at ASC
       `,
-					{ scope: flags.scope ?? null },
+					{ scope: resolvedScope },
 				),
 				db.query<[Relation[]]>('SELECT * FROM relates_to ORDER BY created_at ASC'),
+				db.query<[Record<string, unknown>[]]>(
+					`SELECT * FROM episode WHERE ($scope = NONE OR session_id = $scope) ORDER BY started_at ASC`,
+					{ scope: resolvedScope },
+				),
 			])
 
 			for (const node of nodesResult[0] ?? []) {
@@ -51,6 +57,9 @@ export const exportCmd = app.sub('export')
 			for (const rel of relationsResult[0] ?? []) {
 				process.stdout.write(JSON.stringify({ _type: 'relation', ...rel }) + '\n')
 			}
+			for (const ep of episodesResult[0] ?? []) {
+				process.stdout.write(JSON.stringify({ _type: 'episode', ...ep }) + '\n')
+			}
 		} finally {
 			await disconnect()
 		}
@@ -79,6 +88,7 @@ export const importCmd = app.sub('import')
 		const rl = createInterface({ input: createReadStream(args.file) })
 		let lineNum = 0
 		let imported = 0
+		let importedEpisode = 0
 		let skipped = 0
 		let errors = 0
 
@@ -129,6 +139,13 @@ export const importCmd = app.sub('import')
 							},
 						)
 						imported++
+					} else if (type === 'episode') {
+						await db.query('UPSERT <record<episode>>$id CONTENT $row', {
+							id: row['id'],
+							row,
+						})
+						importedEpisode++
+						imported++
 					} else {
 						skipped++
 					}
@@ -142,8 +159,10 @@ export const importCmd = app.sub('import')
 			await disconnect()
 		}
 		if (outputMode === 'json') {
-			printCliJson({ imported, skipped, errors, lines: lineNum }, flags)
+			printCliJson({ imported, importedEpisode, skipped, errors, lines: lineNum }, flags)
 		} else {
-			console.log(`import done: imported=${imported} skipped=${skipped} errors=${errors} lines=${lineNum}`)
+			console.log(
+				`import done: imported=${imported} (episodes=${importedEpisode}) 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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'goal'])
 
@@ -34,11 +34,13 @@ const setCmd = goal.sub('set')
 			contentLength: args.content.length,
 		})
 		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved goal set scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		let db: Surreal | undefined
 		try {
 			db = await connect(config.surreal)
 			const node = await goalSet(db, args.content, config, {
-				...(flags.scope ? { scope: flags.scope } : {}),
+				scope: resolvedScope,
 				tags: flags.tags ? flags.tags.split(',').map((t) => t.trim()) : [],
 			})
 			if (outputMode === 'json') {
@@ -69,16 +71,19 @@ const listCmd = goal.sub('list')
 			json: outputMode === 'json',
 			quiet: flags.quiet,
 		})
+		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved goal list scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		log.debug('Running goal list command', {
-			hasScope: Boolean(flags.scope),
+			hasScope: Boolean(resolvedScope),
+			scope: resolvedScope,
 			includeResolved: Boolean(flags.resolved),
 		})
-		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 } : {}),
+				scope: resolvedScope,
 				includeResolved: flags.resolved,
 			})
 			if (outputMode === 'json') {

package/src/cli/commands/init.ts

@@ -1,6 +1,7 @@
 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'
@@ -178,9 +179,72 @@ 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)' },
@@ -197,5 +261,7 @@ export const initCmd = init
 		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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'observe'])
 
@@ -36,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,
@@ -49,7 +52,7 @@ 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,

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'query'])
 
@@ -24,8 +24,12 @@ export const queryCmd = app.sub('query')
 			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,
 			outputMode,
 			inputLength: args.input.length,
@@ -33,10 +37,9 @@ export const queryCmd = app.sub('query')
 		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()
 			}

package/src/cli/commands/serve.ts

@@ -1,4 +1,4 @@
-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, resolveOutputModeOrExit } from '../shared.ts'
@@ -175,6 +175,11 @@ export const serveCmd = app.sub('serve')
 			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', {

package/src/cli/commands/skill.ts

@@ -0,0 +1,56 @@
+import packageJson from '../../../package.json' with { type: 'json' }
+import { listSkillReferences, readSkillDoc, readSkillReference, skillFilePath } from '../../skill/catalog.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+
+export const skillCmd = app.sub('skill')
+	.meta({ description: 'Print latest suemo skill or a specific reference file' })
+	.args([{ name: 'reference', type: 'string' }])
+	.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 ({ args, flags }) => {
+		const outputMode = resolveOutputModeOrExit(flags)
+		await initCliCommand('skill', {
+			debug: flags.debug,
+			config: flags.config,
+			json: outputMode === 'json',
+			quiet: flags.quiet,
+		})
+
+		const reference = (args as { reference?: string }).reference?.trim()
+		if (!reference) {
+			const content = readSkillDoc()
+			const references = listSkillReferences()
+			if (outputMode === 'json') {
+				printCliJson({
+					name: 'suemo',
+					version: packageJson.version ?? '0.0.0',
+					description: 'Suemo persistent memory usage skill',
+					path: skillFilePath(),
+					content,
+					references,
+				}, flags)
+				return
+			}
+			console.log(content)
+			return
+		}
+
+		const resolved = readSkillReference(reference)
+		if (!resolved) {
+			throw new Error(`Unknown reference "${reference}". Available: ${listSkillReferences().join(', ')}`)
+		}
+
+		if (outputMode === 'json') {
+			printCliJson({
+				name: resolved.name,
+				version: packageJson.version ?? '0.0.0',
+				path: resolved.path,
+				content: resolved.content,
+			}, flags)
+			return
+		}
+		console.log(resolved.content)
+	})

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'timeline'])
 
@@ -24,18 +24,21 @@ export const timelineCmd = app.sub('timeline')
 			json: outputMode === 'json',
 			quiet: flags.quiet,
 		})
+		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved timeline scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		log.debug('Running timeline command', {
-			hasScope: Boolean(flags.scope),
+			hasScope: Boolean(resolvedScope),
+			scope: resolvedScope,
 			from: flags.from ?? null,
 			until: flags.until ?? null,
 			limit: flags.limit,
 			outputMode,
 		})
-		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
 		try {
 			const nodes = await timeline(db, {
-				...(flags.scope ? { scope: flags.scope } : {}),
+				scope: resolvedScope,
 				...(flags.from ? { from: flags.from } : {}),
 				...(flags.until ? { until: flags.until } : {}),
 				...(flags.limit ? { limit: flags.limit } : {}),

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, printCliJson, resolveOutputModeOrExit } from '../shared.ts'
+import { app, initCliCommand, printCliJson, resolveOutputModeOrExit, resolveScopeLabel } from '../shared.ts'
 
 const log = getLogger(['suemo', 'cli', 'wander'])
 
@@ -23,19 +23,22 @@ export const wanderCmd = app.sub('wander')
 			json: outputMode === 'json',
 			quiet: flags.quiet,
 		})
+		const config = await loadConfig(process.cwd(), flags.config)
+		const resolvedScope = resolveScopeLabel(flags.scope, config)
+		log.debug('Resolved wander scope', { scope: resolvedScope, explicit: flags.scope ?? null })
 		log.debug('Running wander command', {
 			hasAnchor: Boolean(flags.from),
 			hops: flags.hops,
-			hasScope: Boolean(flags.scope),
+			hasScope: Boolean(resolvedScope),
+			scope: resolvedScope,
 			outputMode,
 		})
-		const config = await loadConfig(process.cwd(), flags.config)
 		const db = await connect(config.surreal)
 		try {
 			const nodes = await wander(db, {
 				...(flags.from ? { anchor: flags.from } : {}),
 				...(flags.hops ? { hops: flags.hops } : {}),
-				...(flags.scope ? { scope: flags.scope } : {}),
+				scope: resolvedScope,
 			})
 			if (outputMode === 'json') {
 				printCliJson(nodes, flags)

package/src/cli/index.ts

@@ -12,6 +12,7 @@ import { observeCmd } from './commands/observe.ts'
 import { queryCmd } from './commands/query.ts'
 import { recallCmd } from './commands/recall.ts'
 import { serveCmd } from './commands/serve.ts'
+import { skillCmd } from './commands/skill.ts'
 import { syncCmd } from './commands/sync.ts'
 import { timelineCmd } from './commands/timeline.ts'
 import { wanderCmd } from './commands/wander.ts'
@@ -24,6 +25,7 @@ await app
 	.use(helpPlugin())
 	.command(initCmd)
 	.command(serveCmd)
+	.command(skillCmd)
 	.command(observeCmd)
 	.command(believeCmd)
 	.command(queryCmd)