@onmars/lunar-core 0.1.0

package/src/lib/config-loader.ts

@@ -0,0 +1,1449 @@
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { ChannelPersona } from '../types/moon'
+import type { DedupConfig } from './dedup'
+import { log } from './logger'
+
+// Re-export for downstream consumers
+export type { DedupConfig } from './dedup'
+
+// ════════════════════════════════════════════════════════════
+// Types — Config Spec v3 (2026-03-01)
+// ════════════════════════════════════════════════════════════
+
+/**
+ * Security configuration from config.yaml.
+ * Controls what the agent subprocess can access.
+ */
+export interface SecurityConfig {
+  /** Isolation level */
+  isolation: 'process' | 'user' | 'container'
+  /** OS-level env vars that pass through. HOME and PATH always included. */
+  envDefaults: string[]
+  /** Additional user-specified env vars to pass through */
+  envPassthrough: string[]
+  /** Pass all env vars (dangerous, opt-in) */
+  envPassthroughAll: boolean
+  /** Regex patterns to redact from output */
+  outputRedactPatterns: string[]
+  /** OS user for agent subprocess (Level 2) */
+  agentUser?: string
+  /** Input sanitization configuration */
+  inputSanitization: InputSanitizationConfig
+}
+
+/**
+ * Input sanitization configuration — defense against prompt injection.
+ * Lives inside the security section of config.yaml.
+ *
+ * Default: enabled with all protections active. Zero config needed.
+ */
+export interface InputSanitizationConfig {
+  /** Master switch (default: true) */
+  enabled: boolean
+  /** Strip system-prompt-like markers from input (default: true) */
+  stripMarkers: boolean
+  /** Log suspicious patterns to pino logger (default: true) */
+  logSuspicious: boolean
+  /** Prepend sanitization note to system prompt so agent knows (default: true) */
+  notifyAgent: boolean
+  /** Additional user-defined strip patterns (regex strings) */
+  customPatterns: string[]
+}
+
+/**
+ * Moon entry — parsed from moons section.
+ * Value can be string shorthand (= path) or object with path + default.
+ */
+export interface MoonEntry {
+  /** Filesystem path (resolved relative to workspace) */
+  path: string
+  /** Whether this is the default moon */
+  isDefault: boolean
+  /** Model override for this moon (e.g., 'opus', 'sonnet', 'claude-opus-4-6') */
+  model?: string
+  /** Enable 1M context window for this moon's model */
+  context1m?: boolean
+}
+
+/**
+ * Recall configuration — controls what gets injected into the agent prompt.
+ * Merges the old autoRecall + recall sections into a single config.
+ */
+export interface RecallConfig {
+  /** Whether auto-recall is enabled (default: true if providers exist) */
+  enabled: boolean
+  /** Maximum number of results to inject (default: 5) */
+  limit: number
+  /** Minimum relevance score 0-1 (default: 0.3) */
+  minScore: number
+  /** Max token budget for memory context (default: 800) */
+  budget: number
+}
+
+/**
+ * Memory provider configuration — one entry per provider.
+ *
+ * Type detection:
+ *   - url present    → HTTP provider (Brain, custom REST)
+ *   - command present → MCP stdio provider (Engram, custom MCP server)
+ *   - module present  → Local JS/TS module (future)
+ *
+ * url and command are mutually exclusive.
+ */
+export interface ProviderConfig {
+  // ─── Connection (mutually exclusive) ───
+  /** HTTP endpoint URL → creates HTTP client adapter */
+  url?: string
+  /** Command to spawn MCP server via stdio → creates MCP adapter */
+  command?: string
+  /** Local module path (future) */
+  module?: string
+
+  // ─── MCP-specific ───
+  /** Command arguments */
+  args?: string[]
+  /** Environment variables for the MCP subprocess */
+  env?: Record<string, string>
+  /** Restart MCP server on crash (default: true) */
+  autoRestart?: boolean
+
+  // ─── HTTP-specific ───
+  /** Credential env var names — values are resolved from .env / process.env */
+  credentials?: Record<string, string>
+
+  // ─── Shared ───
+  /** Expose provider URL/info to agent subprocess env */
+  agentAccess?: boolean
+  /** Path to .md file with agent instructions (relative to workspace) */
+  instructions?: string
+  /** Adapter-specific configuration (project, limits, etc.) */
+  config?: Record<string, unknown>
+}
+
+/**
+ * Hook condition — guards that determine if a hook should execute.
+ */
+export interface HookCondition {
+  /** Only run if these providers are currently active and healthy */
+  providersAvailable?: string[]
+  /** Only run if the session had at least this many messages */
+  minMessages?: number
+}
+
+/**
+ * Hook definition — an action to execute at a lifecycle event.
+ */
+export interface HookEntry {
+  /** Built-in action name: promote, boost, context, summarize */
+  action: string
+  /** Provider to act on (action-specific) */
+  provider?: string
+  /** Source provider (for promote) */
+  from?: string
+  /** Target provider (for promote) */
+  to?: string
+  /** Promotion method (for promote, e.g., 'extraction') */
+  via?: string
+  /** Recency window (for boost, e.g., '24h') */
+  recencyWindow?: string
+  /** Boost factor (for boost, e.g., 1.3) */
+  factor?: number
+  /** Optional guard */
+  when?: HookCondition
+}
+
+/**
+ * Lifecycle event names for memory hooks.
+ */
+export type LifecycleEvent =
+  | 'sessionStart'
+  | 'beforeRecall'
+  | 'afterRecall'
+  | 'beforeSave'
+  | 'afterSave'
+  | 'sessionEnd'
+  | 'afterSessionEnd'
+  | 'compaction'
+
+/**
+ * Hooks configuration — keyed by lifecycle event name.
+ */
+export type HooksConfig = Partial<Record<LifecycleEvent, HookEntry[]>>
+
+/**
+ * Memory system configuration — providers + orchestration + hooks.
+ */
+export interface MemoryConfig {
+  /** Named providers — all are equal peers */
+  providers: Record<string, ProviderConfig>
+  /** Recall: how memory is injected into agent prompt */
+  recall: RecallConfig
+  /** Dedup: how results from multiple providers are merged */
+  dedup: DedupConfig
+  /** Lifecycle hooks for provider coordination (optional) */
+  hooks?: HooksConfig
+}
+
+/**
+ * TTS provider configuration from config.yaml voice.tts section.
+ */
+export interface VoiceTTSConfig {
+  /** Provider name: "elevenlabs" | "openai" */
+  provider: string
+  /** Voice ID or name (supports ${ENV_VAR} resolution) */
+  voice?: string
+  /** Model ID (e.g., "eleven_multilingual_v2") */
+  model?: string
+  /** Language code (e.g., "es", "en") */
+  language?: string
+  /** Speed multiplier (1.0 = normal) */
+  speed?: number
+  /** When to generate audio: auto (voice-in→voice-out), always, never */
+  mode: 'auto' | 'always' | 'never'
+  /** Credential env var names (values resolved from .env) */
+  credentials?: Record<string, string>
+}
+
+/**
+ * STT provider configuration from config.yaml voice.stt section.
+ */
+export interface VoiceSTTConfig {
+  /** Provider name: "whisper" */
+  provider: string
+  /** Model ID (e.g., "whisper-1") */
+  model?: string
+  /** Language hint for transcription */
+  language?: string
+  /** When to transcribe: auto (always transcribe audio), never */
+  mode: 'auto' | 'never'
+  /** Credential env var names */
+  credentials?: Record<string, string>
+}
+
+/**
+ * Voice configuration — TTS and/or STT.
+ * Both are optional — you can configure just one direction.
+ */
+export interface VoiceConfig {
+  tts?: VoiceTTSConfig
+  stt?: VoiceSTTConfig
+}
+
+/**
+ * Agent backend configuration.
+ */
+export interface AgentBackendConfig {
+  /** Model override (e.g., 'opus', 'sonnet', 'claude-opus-4-6') */
+  model?: string
+  /**
+   * Enable 1M context window. Appends [1m] to the model flag.
+   * Same pricing up to 200K tokens; 2x input / 1.5x output above 200K.
+   */
+  context1m?: boolean
+}
+
+/**
+ * Agent entry — parsed from the top-level `agents` section in config.yaml.
+ * Each entry declares an agent instance to register with the plugin registry.
+ */
+export interface AgentEntry {
+  /** Agent ID used for registration and channel routing */
+  id: string
+  /** Workspace path for this agent (used as cwd for Claude CLI) */
+  workspace?: string
+  /** Model override for this specific agent */
+  model?: string
+  /** Enable 1M context window */
+  context1m?: boolean
+  /** Claude CLI binary path (defaults to global setting) */
+  binary?: string
+  /** Whether to mark as default agent (first = default if not specified) */
+  default?: boolean
+}
+
+/**
+ * Platform configuration — one entry per messaging platform (Discord, Telegram, etc.).
+ * Contains credentials (resolved from env vars) and platform-specific settings.
+ *
+ * Credentials use ${ENV_VAR} syntax in config.yaml, resolved at load time.
+ */
+export interface PlatformConfig {
+  /** Bot/API token (resolved from ${ENV_VAR}) */
+  token: string
+  /** Platform-specific: Discord guild ID */
+  guild?: string
+  /** Allowed user IDs */
+  allowedUsers?: string[]
+  /** Allowed channel IDs (auto-populated from channels if not set) */
+  allowedChannels?: string[]
+  /** Channels within this platform */
+  channels: ChannelPersona[]
+}
+
+/**
+ * Full workspace config loaded from config.yaml (v2).
+ */
+export interface WorkspaceConfig {
+  /** Moon declarations — first entry (or default:true) is the default */
+  moons: Record<string, MoonEntry>
+  /** Platform configurations (discord, telegram, etc.) — v3 */
+  platforms: Record<string, PlatformConfig>
+  /** Channel → persona bindings (flattened from platforms for backward compat) */
+  channels: ChannelPersona[]
+  /** Security sandbox for agent subprocess */
+  security: SecurityConfig
+  /** Memory system configuration (optional — no memory if absent) */
+  memory?: MemoryConfig
+  /** Agent backend configuration (optional) */
+  agent?: AgentBackendConfig
+  /** Scheduler configuration (optional) */
+  scheduler?: SchedulerConfigParsed
+  /** Voice configuration (TTS + STT, optional) */
+  voice?: VoiceConfig
+  /** Agent instances to register — parsed from top-level `agents` section.
+   *  Defaults to a single `[{ id: 'claude', default: true }]` when absent. */
+  agents: AgentEntry[]
+}
+
+// ════════════════════════════════════════════════════════════
+// YAML Parser (unchanged — minimal custom parser, no deps)
+// ════════════════════════════════════════════════════════════
+
+/** Hardcoded minimum — these always pass through regardless of user config */
+const HARDCODED_ENV = ['HOME', 'PATH']
+
+/** Default env vars if user doesn't override envDefaults */
+const DEFAULT_ENV_DEFAULTS = ['HOME', 'PATH', 'USER', 'LANG', 'TERM', 'TZ', 'SHELL', 'TMPDIR']
+
+/** Valid lifecycle event names */
+const VALID_LIFECYCLE_EVENTS = new Set<string>([
+  'sessionStart',
+  'beforeRecall',
+  'afterRecall',
+  'beforeSave',
+  'afterSave',
+  'sessionEnd',
+  'afterSessionEnd',
+  'compaction',
+])
+
+/**
+ * Parse a simple YAML file into a nested object.
+ * Handles: scalars, lists (- item), nested objects via indentation.
+ * Does NOT handle: multi-line strings, anchors, flow style, complex keys.
+ */
+function parseSimpleYaml(text: string): Record<string, unknown> {
+  const lines = text.split('\n')
+  const root: Record<string, unknown> = {}
+  const stack: Array<{ obj: Record<string, unknown>; indent: number; key?: string }> = [
+    { obj: root, indent: -1 },
+  ]
+
+  // Array tracking — lazy: only activated when first '- ' is encountered
+  let currentArrayItems: unknown[] | null = null
+  let currentArrayKey: string | null = null
+  let currentArrayParent: Record<string, unknown> | null = null
+  let currentArrayIndent = -1
+  let currentObjItem: Record<string, unknown> | null = null
+  let currentObjItemIndent = -1
+
+  const flushObjItem = () => {
+    if (currentObjItem && currentArrayItems) {
+      currentArrayItems.push(currentObjItem)
+      currentObjItem = null
+      currentObjItemIndent = -1
+    }
+  }
+
+  const flushArray = () => {
+    flushObjItem()
+    if (currentArrayItems && currentArrayKey && currentArrayParent) {
+      if (currentArrayItems.length > 0) {
+        currentArrayParent[currentArrayKey] = currentArrayItems
+      }
+      currentArrayItems = null
+      currentArrayKey = null
+      currentArrayParent = null
+      currentArrayIndent = -1
+    }
+  }
+
+  const parseValue = (raw: string): unknown => {
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+      return raw.slice(1, -1)
+    }
+    if (raw === 'true') return true
+    if (raw === 'false') return false
+    if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw)
+    return raw
+  }
+
+  for (const rawLine of lines) {
+    const commentIdx = rawLine.indexOf('#')
+    const line = commentIdx >= 0 ? rawLine.slice(0, commentIdx) : rawLine
+    if (!line.trim()) continue
+
+    const indent = line.search(/\S/)
+    const trimmed = line.trim()
+
+    // Array item: "- value" or "- key: value"
+    if (trimmed.startsWith('- ')) {
+      const value = trimmed.slice(2).trim()
+
+      // Lazy array init: if no array is active, find the parent key from the stack
+      if (!currentArrayItems) {
+        // The parent should be the nearest stack entry whose indent < this indent
+        // and which created a child object for this indent level
+        let found = false
+        for (let i = stack.length - 1; i >= 0; i--) {
+          if (stack[i].indent < indent && stack[i].key) {
+            // Convert this key from an object to an array
+            currentArrayKey = stack[i].key!
+            currentArrayParent = i > 0 ? stack[i - 1].obj : root
+            currentArrayItems = []
+            currentArrayIndent = stack[i].indent
+            // Remove the empty object that was placed there
+            // (since this is actually an array, not an object)
+            delete currentArrayParent[currentArrayKey]
+            // Pop the stack entry since it's now an array, not an object
+            stack.splice(i, 1)
+            found = true
+            break
+          }
+        }
+        if (!found) {
+          log.warn({ line: trimmed }, 'Array item without preceding key')
+          continue
+        }
+      }
+
+      // Check if this is an object item (contains ':')
+      const colonIdx = value.indexOf(':')
+      if (colonIdx > 0) {
+        // Object array item: "- key: value"
+        flushObjItem()
+        const itemKey = value.slice(0, colonIdx).trim()
+        const itemRawVal = value.slice(colonIdx + 1).trim()
+        currentObjItem = { [itemKey]: parseValue(itemRawVal) }
+        currentObjItemIndent = indent
+      } else {
+        // Simple string array item: "- value"
+        flushObjItem()
+        currentArrayItems!.push(parseValue(value))
+      }
+      continue
+    }
+
+    // Continuation of object array item (indented key-value after "- key: val")
+    if (currentObjItem && indent > currentObjItemIndent) {
+      const colonIdx = trimmed.indexOf(':')
+      if (colonIdx > 0) {
+        const key = trimmed.slice(0, colonIdx).trim()
+        const rawValue = trimmed.slice(colonIdx + 1).trim()
+        currentObjItem[key] = parseValue(rawValue)
+        continue
+      }
+    }
+
+    // If we're in an array but hit a line at or before the array's indent level, flush
+    if (currentArrayItems && indent <= currentArrayIndent) {
+      flushArray()
+    }
+
+    // Non-array line: must be "key: value" or "key:"
+    const colonIdx = trimmed.indexOf(':')
+    if (colonIdx < 0) continue
+
+    const key = trimmed.slice(0, colonIdx).trim()
+    const rawValue = trimmed.slice(colonIdx + 1).trim()
+
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop()
+    }
+    const parent = stack[stack.length - 1].obj
+
+    if (rawValue === '' || rawValue === '[]') {
+      if (rawValue === '[]') {
+        parent[key] = []
+      } else {
+        // Create child object — DON'T set up array tracking (lazy init)
+        const child: Record<string, unknown> = {}
+        parent[key] = child
+        stack.push({ obj: child, indent, key })
+      }
+      continue
+    }
+
+    parent[key] = parseValue(rawValue)
+  }
+
+  flushArray()
+  return root
+}
+
+// ════════════════════════════════════════════════════════════
+// Environment Variable Resolution
+// ════════════════════════════════════════════════════════════
+
+/**
+ * Resolve ${ENV_VAR} references in a string value.
+ * Returns the resolved string, or undefined if the env var is not set.
+ *
+ * Examples:
+ *   resolveEnvVars("${DISCORD_TOKEN}") → "xyztoken123"
+ *   resolveEnvVars("prefix-${VAR}-suffix") → "prefix-value-suffix"
+ *   resolveEnvVars("no-vars-here") → "no-vars-here"
+ *   resolveEnvVars("${MISSING_VAR}") → undefined
+ */
+function resolveEnvVars(value: string): string | undefined {
+  const envPattern = /\$\{([^}]+)\}/g
+  let hasUnresolved = false
+
+  const resolved = value.replace(envPattern, (_match, varName: string) => {
+    const envValue = process.env[varName.trim()]
+    if (envValue === undefined || envValue === '') {
+      hasUnresolved = true
+      log.warn({ var: varName.trim() }, 'Unresolved env var in config.yaml')
+      return ''
+    }
+    return envValue
+  })
+
+  // If the entire value was a single ${VAR} that couldn't be resolved, return undefined
+  if (hasUnresolved && resolved.trim() === '') return undefined
+
+  return resolved
+}
+
+/**
+ * Check if a string contains ${...} env var references.
+ */
+function hasEnvVarRef(value: string): boolean {
+  return /\$\{[^}]+\}/.test(value)
+}
+
+// ════════════════════════════════════════════════════════════
+// Section Parsers
+// ════════════════════════════════════════════════════════════
+
+/**
+ * Parse moons section — unified format (replaces old moon + moons).
+ *
+ * Supports both shorthand (string = path) and full (object with path + default).
+ * First entry is default unless one has `default: true`.
+ */
+function parseMoons(raw: unknown): Record<string, MoonEntry> {
+  if (!raw || typeof raw !== 'object') return {}
+
+  const moons: Record<string, MoonEntry> = {}
+  let hasExplicitDefault = false
+  let isFirst = true
+
+  for (const [name, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (typeof value === 'string') {
+      // Shorthand: name: "path"
+      moons[name] = {
+        path: value,
+        isDefault: false, // set below
+      }
+    } else if (value && typeof value === 'object') {
+      const obj = value as Record<string, unknown>
+      const path = typeof obj.path === 'string' ? obj.path : `moons/${name}`
+      const isDefault = obj.default === true
+      const model = typeof obj.model === 'string' ? obj.model : undefined
+      const context1m = obj.context1m === true
+
+      if (isDefault) hasExplicitDefault = true
+
+      moons[name] = { path, isDefault, model, context1m: context1m || undefined }
+    } else {
+      log.warn({ moon: name }, 'Invalid moon config — skipping')
+      continue
+    }
+
+    // Mark first entry as default candidate
+    if (isFirst) {
+      isFirst = false
+      if (!hasExplicitDefault) {
+        moons[name].isDefault = true
+      }
+    }
+  }
+
+  // If an explicit default was found, ensure only it is marked
+  if (hasExplicitDefault) {
+    for (const [name, entry] of Object.entries(moons)) {
+      if (!entry.isDefault) continue
+      // Check if this one has explicit default
+      const rawObj = (raw as Record<string, unknown>)[name]
+      if (
+        rawObj &&
+        typeof rawObj === 'object' &&
+        (rawObj as Record<string, unknown>).default === true
+      ) {
+        // Keep it
+      } else {
+        entry.isDefault = false
+      }
+    }
+  }
+
+  return moons
+}
+
+/**
+ * Parse channel entries from a raw channels object into ChannelPersona[].
+ * Shared between single-account and multi-account platform parsing.
+ */
+function parsePlatformChannels(
+  channelsRaw: unknown,
+  adapterId: string,
+  channelNames: Set<string>,
+): ChannelPersona[] {
+  if (!channelsRaw || typeof channelsRaw !== 'object') return []
+
+  const channels: ChannelPersona[] = []
+
+  for (const [channelName, channelRaw] of Object.entries(channelsRaw as Record<string, unknown>)) {
+    if (!channelRaw || typeof channelRaw !== 'object') continue
+
+    // Check for globally unique channel names
+    if (channelNames.has(channelName)) {
+      log.warn(
+        { channel: channelName, platform: adapterId },
+        'Duplicate channel name across platforms — skipping',
+      )
+      continue
+    }
+    channelNames.add(channelName)
+
+    const ch = channelRaw as Record<string, unknown>
+    const id = ch.id
+
+    if (id === undefined || id === null || id === '') {
+      log.warn(
+        { platform: adapterId, channel: channelName },
+        'Channel missing "id" field — skipping',
+      )
+      continue
+    }
+
+    // Warn about numeric IDs losing precision (Discord IDs > 2^53)
+    if (typeof id === 'number' && id > Number.MAX_SAFE_INTEGER) {
+      log.warn(
+        { platform: adapterId, channel: channelName, id },
+        'Channel ID exceeds safe integer range — use quotes in YAML to prevent precision loss',
+      )
+    }
+
+    channels.push({
+      id: String(id),
+      name: channelName,
+      platform: adapterId,
+      moon: typeof ch.moon === 'string' ? ch.moon : undefined,
+      instructions: typeof ch.instructions === 'string' ? ch.instructions : undefined,
+      tone: typeof ch.tone === 'string' ? ch.tone : undefined,
+      focus: typeof ch.focus === 'string' ? ch.focus : undefined,
+      model: typeof ch.model === 'string' ? ch.model : undefined,
+      skills: Array.isArray(ch.skills) ? (ch.skills as unknown[]).map(String) : undefined,
+      agentId: typeof ch.agent === 'string' ? ch.agent : undefined,
+    })
+  }
+
+  return channels
+}
+
+/**
+ * Resolve token from a raw value (string with optional ${ENV_VAR} reference).
+ * Returns undefined if the value is not a string or the env var is unresolved.
+ */
+function resolveTokenValue(raw: unknown): string | undefined {
+  if (typeof raw !== 'string') return undefined
+  return hasEnvVarRef(raw) ? resolveEnvVars(raw) : raw
+}
+
+/**
+ * Resolve guild ID from a raw value (string with optional ${ENV_VAR}, or number).
+ */
+function resolveGuildValue(raw: unknown, context: string): string | undefined {
+  if (typeof raw === 'string') {
+    return hasEnvVarRef(raw) ? resolveEnvVars(raw) : raw
+  }
+  if (typeof raw === 'number') {
+    if (raw > Number.MAX_SAFE_INTEGER) {
+      log.warn(
+        { platform: context, guild: raw },
+        'Guild ID exceeds safe integer range — use quotes in YAML',
+      )
+    }
+    return String(raw)
+  }
+  return undefined
+}
+
+/**
+ * Parse a single platform account into a PlatformConfig entry.
+ * Used for both single-account and multi-account platform configs.
+ */
+function parseSingleAccount(
+  accountObj: Record<string, unknown>,
+  adapterId: string,
+  channelNames: Set<string>,
+): PlatformConfig | undefined {
+  const token = resolveTokenValue(accountObj.token)
+  if (!token) {
+    log.warn({ platform: adapterId }, 'Platform missing or unresolvable token — skipping')
+    return undefined
+  }
+
+  const guild = resolveGuildValue(accountObj.guild, adapterId)
+
+  let allowedUsers: string[] | undefined
+  if (Array.isArray(accountObj.allowedUsers)) {
+    allowedUsers = (accountObj.allowedUsers as unknown[]).map((u) => String(u)).filter(Boolean)
+  }
+
+  const channels = parsePlatformChannels(accountObj.channels, adapterId, channelNames)
+
+  return {
+    token,
+    guild,
+    allowedUsers,
+    allowedChannels: channels.map((c) => c.id),
+    channels,
+  }
+}
+
+/**
+ * Parse platforms section from config.yaml.
+ * Each platform entry contains credentials + platform-specific config + channels.
+ *
+ * Credentials use ${ENV_VAR} syntax, resolved from process.env at load time.
+ * Channel names must be globally unique across all platforms.
+ *
+ * Supports multi-account via `accounts` sub-section (Phase C):
+ *   platforms.discord.accounts.default  -> adapterId = 'discord'
+ *   platforms.discord.accounts.hermes   -> adapterId = 'discord:hermes'
+ *
+ * Returns: Record<adapterId, PlatformConfig> + flattened ChannelPersona[]
+ */
+function parsePlatforms(raw: unknown): {
+  platforms: Record<string, PlatformConfig>
+  channels: ChannelPersona[]
+} {
+  if (!raw || typeof raw !== 'object') return { platforms: {}, channels: [] }
+
+  const platforms: Record<string, PlatformConfig> = {}
+  const allChannels: ChannelPersona[] = []
+  const channelNames = new Set<string>()
+
+  for (const [platformName, platformRaw] of Object.entries(raw as Record<string, unknown>)) {
+    if (!platformRaw || typeof platformRaw !== 'object') continue
+
+    const platformObj = platformRaw as Record<string, unknown>
+
+    // ── Multi-account support (Phase C) ──
+    // If `accounts` sub-section exists, parse each account separately
+    if (platformObj.accounts && typeof platformObj.accounts === 'object') {
+      for (const [accountName, accountRaw] of Object.entries(
+        platformObj.accounts as Record<string, unknown>,
+      )) {
+        if (!accountRaw || typeof accountRaw !== 'object') continue
+
+        const adapterId =
+          accountName === 'default' ? platformName : `${platformName}:${accountName}`
+        const accountObj = accountRaw as Record<string, unknown>
+
+        const config = parseSingleAccount(accountObj, adapterId, channelNames)
+        if (config) {
+          platforms[adapterId] = config
+          allChannels.push(...config.channels)
+        }
+      }
+      continue
+    }
+
+    // ── Single-account (backward compat) ──
+    const config = parseSingleAccount(platformObj, platformName, channelNames)
+    if (config) {
+      platforms[platformName] = config
+      allChannels.push(...config.channels)
+    }
+  }
+
+  return { platforms, channels: allChannels }
+}
+
+/**
+ * Parse channels section from config.yaml into ChannelPersona array.
+ * Unchanged from v1.
+ */
+function parseChannels(raw: unknown): ChannelPersona[] {
+  if (!raw || typeof raw !== 'object') return []
+
+  const channels: ChannelPersona[] = []
+
+  for (const [platform, platformChannels] of Object.entries(raw as Record<string, unknown>)) {
+    if (!platformChannels || typeof platformChannels !== 'object') continue
+
+    for (const [name, value] of Object.entries(platformChannels as Record<string, unknown>)) {
+      if (!value || typeof value !== 'object') continue
+
+      const ch = value as Record<string, unknown>
+      const id = ch.id
+
+      if (id === undefined || id === null || id === '') {
+        log.warn({ platform, channel: name }, 'Channel missing "id" field — skipping')
+        continue
+      }
+
+      // Warn about numeric IDs losing precision (Discord IDs > 2^53)
+      if (typeof id === 'number' && id > Number.MAX_SAFE_INTEGER) {
+        log.warn(
+          { platform, channel: name, id },
+          'Channel ID exceeds safe integer range — use quotes in YAML to prevent precision loss',
+        )
+      }
+
+      channels.push({
+        id: String(id),
+        name,
+        platform,
+        moon: typeof ch.moon === 'string' ? ch.moon : undefined,
+        instructions: typeof ch.instructions === 'string' ? ch.instructions : undefined,
+        tone: typeof ch.tone === 'string' ? ch.tone : undefined,
+        focus: typeof ch.focus === 'string' ? ch.focus : undefined,
+        model: typeof ch.model === 'string' ? ch.model : undefined,
+        skills: Array.isArray(ch.skills) ? (ch.skills as unknown[]).map(String) : undefined,
+        agentId: typeof ch.agent === 'string' ? ch.agent : undefined,
+      })
+    }
+  }
+
+  return channels
+}
+
+/**
+ * Parse a single provider entry from memory.providers.<name>.
+ */
+function parseProvider(name: string, raw: unknown): ProviderConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  const entry = raw as Record<string, unknown>
+  const url = typeof entry.url === 'string' ? entry.url : undefined
+  const command = typeof entry.command === 'string' ? entry.command : undefined
+  const module = typeof entry.module === 'string' ? entry.module : undefined
+
+  // Validate: at least one connection method
+  if (!url && !command && !module) {
+    log.warn({ provider: name }, 'Provider needs url, command, or module — skipping')
+    return undefined
+  }
+
+  // Validate: mutually exclusive
+  const connectionCount = [url, command, module].filter(Boolean).length
+  if (connectionCount > 1) {
+    log.warn(
+      { provider: name },
+      'Provider has multiple connection types (url/command/module) — use only one. Skipping.',
+    )
+    return undefined
+  }
+
+  // Parse credentials
+  const credentials: Record<string, string> = {}
+  if (entry.credentials && typeof entry.credentials === 'object') {
+    for (const [key, value] of Object.entries(entry.credentials as Record<string, unknown>)) {
+      if (typeof value === 'string') credentials[key] = value
+    }
+  }
+
+  // Parse env
+  const env: Record<string, string> = {}
+  if (entry.env && typeof entry.env === 'object') {
+    for (const [key, value] of Object.entries(entry.env as Record<string, unknown>)) {
+      if (typeof value === 'string') env[key] = value
+    }
+  }
+
+  // Parse args
+  const args = Array.isArray(entry.args)
+    ? ((entry.args as unknown[]).filter((a) => typeof a === 'string') as string[])
+    : undefined
+
+  return {
+    url,
+    command,
+    module,
+    args: args?.length ? args : undefined,
+    env: Object.keys(env).length > 0 ? env : undefined,
+    autoRestart: entry.autoRestart !== false,
+    credentials: Object.keys(credentials).length > 0 ? credentials : undefined,
+    agentAccess: entry.agentAccess === true,
+    instructions: typeof entry.instructions === 'string' ? entry.instructions : undefined,
+    config:
+      entry.config && typeof entry.config === 'object'
+        ? (entry.config as Record<string, unknown>)
+        : undefined,
+  }
+}
+
+/**
+ * Parse hooks section from memory.hooks.
+ */
+function parseHooks(raw: unknown): HooksConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  const hooks: HooksConfig = {}
+  let hasAnyHook = false
+
+  for (const [eventName, entries] of Object.entries(raw as Record<string, unknown>)) {
+    if (!VALID_LIFECYCLE_EVENTS.has(eventName)) {
+      log.warn({ event: eventName }, 'Unknown lifecycle event in hooks — skipping')
+      continue
+    }
+
+    const event = eventName as LifecycleEvent
+
+    // entries can be an array of hook objects or a single object
+    // Our YAML parser creates objects for nested structures
+    if (!entries || typeof entries !== 'object') continue
+
+    // Handle array-like (our parser doesn't create arrays of objects,
+    // but if manually constructed it might)
+    const hookEntries: HookEntry[] = []
+
+    if (Array.isArray(entries)) {
+      for (const entry of entries) {
+        const hook = parseHookEntry(entry)
+        if (hook) hookEntries.push(hook)
+      }
+    } else {
+      // Single hook object under the event
+      const hook = parseHookEntry(entries)
+      if (hook) hookEntries.push(hook)
+    }
+
+    if (hookEntries.length > 0) {
+      hooks[event] = hookEntries
+      hasAnyHook = true
+    }
+  }
+
+  return hasAnyHook ? hooks : undefined
+}
+
+/**
+ * Parse a single hook entry.
+ */
+function parseHookEntry(raw: unknown): HookEntry | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  const entry = raw as Record<string, unknown>
+  const action = entry.action
+  if (typeof action !== 'string' || !action) {
+    log.warn('Hook entry missing "action" field — skipping')
+    return undefined
+  }
+
+  // Parse when condition
+  let when: HookCondition | undefined
+  if (entry.when && typeof entry.when === 'object') {
+    const w = entry.when as Record<string, unknown>
+    when = {}
+    if (Array.isArray(w.providersAvailable)) {
+      when.providersAvailable = w.providersAvailable.filter(
+        (v) => typeof v === 'string',
+      ) as string[]
+    }
+    if (typeof w.minMessages === 'number') {
+      when.minMessages = w.minMessages
+    }
+    // Only keep if there's at least one condition
+    if (!when.providersAvailable?.length && when.minMessages === undefined) {
+      when = undefined
+    }
+  }
+
+  return {
+    action,
+    provider: typeof entry.provider === 'string' ? entry.provider : undefined,
+    from: typeof entry.from === 'string' ? entry.from : undefined,
+    to: typeof entry.to === 'string' ? entry.to : undefined,
+    via: typeof entry.via === 'string' ? entry.via : undefined,
+    recencyWindow: typeof entry.recencyWindow === 'string' ? entry.recencyWindow : undefined,
+    factor: typeof entry.factor === 'number' ? entry.factor : undefined,
+    when,
+  }
+}
+
+/**
+ * Parse memory section — v2 format with providers map + orchestration.
+ */
+function parseMemory(raw: unknown): MemoryConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  const mem = raw as Record<string, unknown>
+
+  // Parse providers
+  const providersRaw = mem.providers
+  if (!providersRaw || typeof providersRaw !== 'object') {
+    log.warn('Memory section found but missing "providers" — skipping')
+    return undefined
+  }
+
+  const providers: Record<string, ProviderConfig> = {}
+  for (const [name, value] of Object.entries(providersRaw as Record<string, unknown>)) {
+    const provider = parseProvider(name, value)
+    if (provider) {
+      providers[name] = provider
+    }
+  }
+
+  if (Object.keys(providers).length === 0) {
+    log.warn('Memory providers configured but none are valid — skipping memory')
+    return undefined
+  }
+
+  // Parse recall config (merges old autoRecall + recall)
+  const recallRaw = (mem.recall ?? {}) as Record<string, unknown>
+  const recall: RecallConfig = {
+    enabled: recallRaw.enabled !== false,
+    limit: typeof recallRaw.limit === 'number' ? recallRaw.limit : 5,
+    minScore: typeof recallRaw.minScore === 'number' ? recallRaw.minScore : 0.3,
+    budget: typeof recallRaw.budget === 'number' ? recallRaw.budget : 800,
+  }
+
+  // Parse dedup config
+  const dedupRaw = (mem.dedup ?? {}) as Record<string, unknown>
+  const validStrategies = ['dice', 'minhash', 'adaptive']
+  const dedup: DedupConfig = {
+    strategy:
+      typeof dedupRaw.strategy === 'string' && validStrategies.includes(dedupRaw.strategy)
+        ? (dedupRaw.strategy as DedupConfig['strategy'])
+        : 'adaptive',
+    threshold: typeof dedupRaw.threshold === 'number' ? dedupRaw.threshold : 0.85,
+    numPermutations: typeof dedupRaw.numPermutations === 'number' ? dedupRaw.numPermutations : 128,
+    shingleSize: typeof dedupRaw.shingleSize === 'number' ? dedupRaw.shingleSize : 3,
+    crossoverLength: typeof dedupRaw.crossoverLength === 'number' ? dedupRaw.crossoverLength : 300,
+  }
+
+  // Parse hooks
+  const hooks = parseHooks(mem.hooks)
+
+  return { providers, recall, dedup, hooks }
+}
+
+/**
+ * Parse voice section from config.yaml.
+ * Supports ${ENV_VAR} resolution for voice ID and credentials.
+ */
+function parseVoice(raw: unknown): VoiceConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined
+
+  const voice = raw as Record<string, unknown>
+  const result: VoiceConfig = {}
+
+  // Parse TTS
+  if (voice.tts && typeof voice.tts === 'object') {
+    const tts = voice.tts as Record<string, unknown>
+    const provider = typeof tts.provider === 'string' ? tts.provider : undefined
+
+    if (!provider) {
+      log.warn('voice.tts missing "provider" field — skipping TTS')
+    } else {
+      // Resolve voice ID from ${ENV_VAR} if needed
+      let voiceId: string | undefined
+      if (typeof tts.voice === 'string') {
+        voiceId = hasEnvVarRef(tts.voice) ? resolveEnvVars(tts.voice) : tts.voice
+      }
+
+      // Parse credentials
+      const credentials: Record<string, string> = {}
+      if (tts.credentials && typeof tts.credentials === 'object') {
+        for (const [key, value] of Object.entries(tts.credentials as Record<string, unknown>)) {
+          if (typeof value === 'string') credentials[key] = value
+        }
+      }
+
+      // Validate mode
+      const validTTSModes = ['auto', 'always', 'never']
+      const mode =
+        typeof tts.mode === 'string' && validTTSModes.includes(tts.mode)
+          ? (tts.mode as VoiceTTSConfig['mode'])
+          : 'auto'
+
+      result.tts = {
+        provider,
+        voice: voiceId,
+        model: typeof tts.model === 'string' ? tts.model : undefined,
+        language: typeof tts.language === 'string' ? tts.language : undefined,
+        speed: typeof tts.speed === 'number' ? tts.speed : undefined,
+        mode,
+        credentials: Object.keys(credentials).length > 0 ? credentials : undefined,
+      }
+    }
+  }
+
+  // Parse STT
+  if (voice.stt && typeof voice.stt === 'object') {
+    const stt = voice.stt as Record<string, unknown>
+    const provider = typeof stt.provider === 'string' ? stt.provider : undefined
+
+    if (!provider) {
+      log.warn('voice.stt missing "provider" field — skipping STT')
+    } else {
+      const credentials: Record<string, string> = {}
+      if (stt.credentials && typeof stt.credentials === 'object') {
+        for (const [key, value] of Object.entries(stt.credentials as Record<string, unknown>)) {
+          if (typeof value === 'string') credentials[key] = value
+        }
+      }
+
+      const validSTTModes = ['auto', 'never']
+      const mode =
+        typeof stt.mode === 'string' && validSTTModes.includes(stt.mode)
+          ? (stt.mode as VoiceSTTConfig['mode'])
+          : 'auto'
+
+      result.stt = {
+        provider,
+        model: typeof stt.model === 'string' ? stt.model : undefined,
+        language: typeof stt.language === 'string' ? stt.language : undefined,
+        mode,
+        credentials: Object.keys(credentials).length > 0 ? credentials : undefined,
+      }
+    }
+  }
+
+  // Return undefined if neither TTS nor STT configured
+  if (!result.tts && !result.stt) return undefined
+
+  return result
+}
+
+/**
+ * Parse input sanitization config with safe defaults.
+ * Everything is enabled by default — user opts OUT, not in.
+ */
+function parseInputSanitization(raw: unknown): InputSanitizationConfig {
+  if (!raw || typeof raw !== 'object') {
+    // Default: everything enabled
+    return {
+      enabled: true,
+      stripMarkers: true,
+      logSuspicious: true,
+      notifyAgent: true,
+      customPatterns: [],
+    }
+  }
+
+  const obj = raw as Record<string, unknown>
+  return {
+    enabled: obj.enabled !== false,
+    stripMarkers: obj.stripMarkers !== false,
+    logSuspicious: obj.logSuspicious !== false,
+    notifyAgent: obj.notifyAgent !== false,
+    customPatterns: Array.isArray(obj.customPatterns)
+      ? ((obj.customPatterns as unknown[]).filter((p) => typeof p === 'string') as string[])
+      : [],
+  }
+}
+
+/**
+ * Parse the top-level `agents` section from config.yaml.
+ *
+ * YAML format:
+ *   agents:
+ *     deimos:
+ *       workspace: "."
+ *       model: sonnet
+ *       default: true
+ *     hermes:
+ *       workspace: "moons/hermes"
+ *       model: haiku
+ *
+ * Returns a single default entry `[{ id: 'claude', default: true }]`
+ * when the section is absent — backward compatible.
+ */
+function parseAgents(raw: unknown): AgentEntry[] {
+  const defaultEntry: AgentEntry[] = [{ id: 'claude', default: true }]
+
+  if (!raw || typeof raw !== 'object') return defaultEntry
+
+  const agents: AgentEntry[] = []
+  let hasExplicitDefault = false
+  let isFirst = true
+
+  for (const [id, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (!value || typeof value !== 'object') {
+      // Skip invalid entries
+      log.warn({ agent: id }, 'Invalid agent config — skipping')
+      continue
+    }
+
+    const obj = value as Record<string, unknown>
+    const isDefault = obj.default === true
+    if (isDefault) hasExplicitDefault = true
+
+    const entry: AgentEntry = {
+      id,
+      workspace: typeof obj.workspace === 'string' ? obj.workspace : undefined,
+      model: typeof obj.model === 'string' ? obj.model : undefined,
+      context1m: obj.context1m === true ? true : undefined,
+      binary: typeof obj.binary === 'string' ? obj.binary : undefined,
+      default: isFirst && !hasExplicitDefault ? true : isDefault,
+    }
+
+    agents.push(entry)
+    isFirst = false
+  }
+
+  // If an explicit default was found, clear auto-default from first entry
+  if (
+    hasExplicitDefault &&
+    agents.length > 0 &&
+    agents[0].default &&
+    !isExplicitDefault(raw, agents[0].id)
+  ) {
+    agents[0].default = false
+  }
+
+  return agents.length > 0 ? agents : defaultEntry
+}
+
+/** Check if an agent has explicit `default: true` in the raw config. */
+function isExplicitDefault(raw: unknown, id: string): boolean {
+  if (!raw || typeof raw !== 'object') return false
+  const entry = (raw as Record<string, unknown>)[id]
+  if (!entry || typeof entry !== 'object') return false
+  return (entry as Record<string, unknown>).default === true
+}
+
+// ════════════════════════════════════════════════════════════
+// Main Loader
+// ════════════════════════════════════════════════════════════
+
+/**
+ * Load workspace config from config.yaml (v2 format).
+ * Returns defaults if file doesn't exist.
+ */
+export function loadWorkspaceConfig(workspacePath: string): WorkspaceConfig {
+  const configPath = resolve(workspacePath, 'config.yaml')
+
+  const defaults: WorkspaceConfig = {
+    security: {
+      isolation: 'process',
+      envDefaults: DEFAULT_ENV_DEFAULTS,
+      envPassthrough: [],
+      envPassthroughAll: false,
+      outputRedactPatterns: [],
+      inputSanitization: {
+        enabled: true,
+        stripMarkers: true,
+        logSuspicious: true,
+        notifyAgent: true,
+        customPatterns: [],
+      },
+    },
+    platforms: {},
+    channels: [],
+    moons: {},
+    agents: [{ id: 'claude', default: true }],
+  }
+
+  if (!existsSync(configPath)) {
+    log.debug({ path: configPath }, 'No config.yaml found, using defaults')
+    return defaults
+  }
+
+  try {
+    const raw = require('node:fs').readFileSync(configPath, 'utf-8') as string
+    const parsed = parseSimpleYaml(raw)
+
+    // Security (unchanged from v1)
+    const secRaw = (parsed.security ?? {}) as Record<string, unknown>
+    const security: SecurityConfig = {
+      isolation: (['process', 'user', 'container'].includes(secRaw.isolation as string)
+        ? secRaw.isolation
+        : 'process') as SecurityConfig['isolation'],
+
+      envDefaults: Array.isArray(secRaw.envDefaults)
+        ? ensureHardcoded(secRaw.envDefaults as string[])
+        : DEFAULT_ENV_DEFAULTS,
+
+      envPassthrough: Array.isArray(secRaw.envPassthrough)
+        ? (secRaw.envPassthrough as string[])
+        : [],
+
+      envPassthroughAll: secRaw.envPassthroughAll === true,
+
+      outputRedactPatterns: Array.isArray(secRaw.outputRedactPatterns)
+        ? (secRaw.outputRedactPatterns as string[])
+        : [],
+
+      agentUser: typeof secRaw.agentUser === 'string' ? secRaw.agentUser : undefined,
+      inputSanitization: parseInputSanitization(secRaw.inputSanitization),
+    }
+
+    // Moons (v2 — unified)
+    const moons = parseMoons(parsed.moons)
+
+    // Platforms (v3 — credentials + channels unified)
+    const { platforms, channels: platformChannels } = parsePlatforms(parsed.platforms)
+
+    // Legacy fallback: if no platforms section, try old channels section
+    const channels = platformChannels.length > 0 ? platformChannels : parseChannels(parsed.channels)
+
+    // Memory (v2 — providers map + orchestration + hooks)
+    const memory = parseMemory(parsed.memory)
+
+    log.info(
+      {
+        isolation: security.isolation,
+        moons: Object.keys(moons).length,
+        defaultMoon: Object.entries(moons).find(([, m]) => m.isDefault)?.[0] ?? 'none',
+        platforms: Object.keys(platforms).length,
+        channels: channels.length,
+        memoryProviders: memory ? Object.keys(memory.providers).length : 0,
+        hooks: memory?.hooks ? Object.keys(memory.hooks).length : 0,
+      },
+      'Workspace config loaded (v3)',
+    )
+
+    // Agent backend config (optional)
+    let agent: AgentBackendConfig | undefined
+    if (parsed.agent && typeof parsed.agent === 'object') {
+      const raw = parsed.agent as Record<string, unknown>
+      agent = {
+        model: typeof raw.model === 'string' ? raw.model : undefined,
+        context1m: raw.context1m === true,
+      }
+    }
+
+    // Scheduler (v0.3)
+    const scheduler = parseSchedulerConfig(parsed.scheduler as Record<string, unknown> | undefined)
+    if (scheduler) {
+      log.info(
+        {
+          enabled: scheduler.enabled,
+          jobs: Object.keys(scheduler.jobs).length,
+          tz: scheduler.timezone,
+        },
+        'Scheduler config loaded',
+      )
+    }
+
+    // Voice (TTS + STT)
+    const voice = parseVoice(parsed.voice)
+    if (voice) {
+      log.info(
+        {
+          tts: voice.tts ? `${voice.tts.provider} (${voice.tts.mode})` : 'none',
+          stt: voice.stt ? `${voice.stt.provider} (${voice.stt.mode})` : 'none',
+        },
+        'Voice config loaded',
+      )
+    }
+
+    // Agents (Phase B — multi-agent routing)
+    const agents = parseAgents(parsed.agents)
+
+    return {
+      security,
+      moons,
+      platforms,
+      channels,
+      memory,
+      agent,
+      scheduler: scheduler ?? undefined,
+      voice,
+      agents,
+    }
+  } catch (error) {
+    log.error({ err: error, path: configPath }, 'Failed to parse config.yaml, using defaults')
+    return defaults
+  }
+}
+
+/** Ensure HOME and PATH are always in the list */
+function ensureHardcoded(vars: string[]): string[] {
+  const result = [...vars]
+  for (const required of HARDCODED_ENV) {
+    if (!result.includes(required)) {
+      result.unshift(required)
+    }
+  }
+  return result
+}
+
+// ════════════════════════════════════════════════════════════
+// Scheduler Config — v0.3
+// ════════════════════════════════════════════════════════════
+
+export interface SchedulerJobConfig {
+  schedule: { kind: string; expr?: string; at?: string; intervalMs?: number; tz?: string }
+  channel: string
+  payload: { kind: string; prompt?: string; text?: string }
+  moon?: string
+  enabled?: boolean
+  oneShot?: boolean
+}
+
+export interface SchedulerConfigParsed {
+  enabled: boolean
+  pollIntervalMs: number
+  timezone: string
+  jobs: Record<string, SchedulerJobConfig>
+}
+
+/**
+ * Parse the scheduler section from config.yaml.
+ * Returns null if no scheduler section exists.
+ */
+export function parseSchedulerConfig(
+  raw: Record<string, unknown> | undefined,
+): SchedulerConfigParsed | null {
+  if (!raw || typeof raw !== 'object') return null
+
+  const enabled = raw.enabled !== false
+  const pollIntervalMs = typeof raw.pollIntervalMs === 'number' ? raw.pollIntervalMs : 60000
+  const timezone = typeof raw.timezone === 'string' ? raw.timezone : 'UTC'
+
+  const jobs: Record<string, SchedulerJobConfig> = {}
+  const rawJobs = (raw.jobs ?? {}) as Record<string, Record<string, unknown>>
+
+  for (const [name, jobRaw] of Object.entries(rawJobs)) {
+    if (!jobRaw || typeof jobRaw !== 'object') continue
+
+    const schedRaw = jobRaw.schedule as Record<string, unknown> | undefined
+    const payloadRaw = jobRaw.payload as Record<string, unknown> | undefined
+
+    if (!schedRaw || !payloadRaw) {
+      log.warn({ job: name }, 'Scheduler job missing schedule or payload — skipping')
+      continue
+    }
+
+    jobs[name] = {
+      schedule: {
+        kind: String(schedRaw.kind ?? 'cron'),
+        expr: typeof schedRaw.expr === 'string' ? schedRaw.expr : undefined,
+        at: typeof schedRaw.at === 'string' ? schedRaw.at : undefined,
+        intervalMs: typeof schedRaw.intervalMs === 'number' ? schedRaw.intervalMs : undefined,
+        tz: typeof schedRaw.tz === 'string' ? schedRaw.tz : undefined,
+      },
+      channel: String(jobRaw.channel ?? ''),
+      payload: {
+        kind: String(payloadRaw.kind ?? 'message'),
+        prompt: typeof payloadRaw.prompt === 'string' ? payloadRaw.prompt : undefined,
+        text: typeof payloadRaw.text === 'string' ? payloadRaw.text : undefined,
+      },
+      moon: typeof jobRaw.moon === 'string' ? jobRaw.moon : undefined,
+      enabled: jobRaw.enabled !== false,
+      oneShot: jobRaw.oneShot === true,
+    }
+  }
+
+  return { enabled, pollIntervalMs, timezone, jobs }
+}