dsh-biocore 0.2.0 → 0.3.0

package/lib/modules/autonomy.js

@@ -0,0 +1,125 @@
+/** task-222: adapter side of autonomous actions -- execute + record only.
+ *
+ * The core (biocore_runtime.autonomy) decides WHAT and WHEN; this module just
+ * performs the returned action and appends the result to <dataDir>/actions.jsonl.
+ * No limit, drive or quiet-hour logic lives here.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+export const ACTIONS_FILE = 'actions.jsonl'
+export const ACTIONS_KEEP = 500
+
+export function actionsPath(dataDir) {
+  return join(String(dataDir || '').trim(), ACTIONS_FILE)
+}
+
+function appendAction(dataDir, row) {
+  const path = actionsPath(dataDir)
+  try {
+    mkdirSync(dirname(path), { recursive: true })
+    appendFileSync(path, JSON.stringify(row) + '\n', 'utf8')
+    const lines = readFileSync(path, 'utf8').split('\n').filter(Boolean)
+    if (lines.length > ACTIONS_KEEP) {
+      writeFileSync(path, lines.slice(-ACTIONS_KEEP).join('\n') + '\n', 'utf8')
+    }
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function deliverSend(ctx, action, log) {
+  try {
+    const controller = ctx && ctx.sessionController
+    if (!controller || typeof controller.resolveAgent !== 'function') {
+      return { delivered: false, reason: 'no_session_controller' }
+    }
+    const resolved = await controller.resolveAgent(String(action.session_id || ''))
+    const agent = resolved && resolved.agent
+    if (!agent || typeof agent.followup !== 'function') {
+      return { delivered: false, reason: 'no_agent' }
+    }
+    agent.followup({
+      id: 'bio-auto-' + Date.now(),
+      role: 'user',
+      content: [{ type: 'text', text: String(action.text || '') }],
+      source: { kind: 'biocore-autonomy' },
+    })
+    try { await ctx.sessions.flush(agent.session) } catch { /* best effort */ }
+    return { delivered: true }
+  } catch (error) {
+    try { log?.warn?.('[biocore] autonomy send failed: ' + String(error)) } catch { /* ignore */ }
+    return { delivered: false, reason: 'send_failed' }
+  }
+}
+
+/** Execute one core action; returns {ok, kind, result}. Never throws. */
+export async function executeAction(ctx, action, options) {
+  const opts = options || {}
+  const memory = typeof opts.memoryTool === 'function' ? opts.memoryTool : null
+  const log = opts.log
+  const kind = String((action && action.kind) || '')
+  const sessionId = String((action && action.session_id) || 'autonomy')
+  try {
+    if (kind === 'send') {
+      const result = await deliverSend(ctx, action, log)
+      return { ok: result.delivered === true, kind, result }
+    }
+    if (kind === 'write' && memory) {
+      const result = await memory(opts.store, sessionId, 'biocore_remember',
+        { text: String(action.text || '') }, opts.rerankConfig)
+      return { ok: Boolean(result && result.ok), kind, result: result || {} }
+    }
+    if (kind === 'retrieve' && memory) {
+      const result = await memory(opts.store, sessionId, 'biocore_recall',
+        { query: String(action.query || '最近'), limit: 3 }, opts.rerankConfig)
+      const count = result && Array.isArray(result.results) ? result.results.length : 0
+      return { ok: Boolean(result && result.ok), kind,
+               result: { count } }
+    }
+    return { ok: false, kind, result: { reason: 'unsupported_action' } }
+  } catch (error) {
+    return { ok: false, kind, result: { reason: 'execution_failed',
+      detail: String(error).slice(0, 120) } }
+  }
+}
+
+/** One tick: ask the core, execute its single action, record the outcome. */
+export async function runAutonomyTick(ctx, options) {
+  const opts = options || {}
+  const runAction = typeof opts.runAction === 'function' ? opts.runAction : null
+  if (!runAction) return { ok: false, reason: 'no_core' }
+  let decision = null
+  try {
+    decision = await runAction('autonomy_tick', {
+      store: opts.store,
+      data_dir: opts.dataDir,
+      session_id: opts.sessionId || 'autonomy',
+      last_human_ts: opts.lastHumanTs || 0,
+    })
+  } catch { decision = null }
+  if (!decision || decision.ok !== true) {
+    appendAction(opts.dataDir, { ts: Date.now(), kind: 'none',
+      reason: 'core_unavailable', result: { ok: false } })
+    return { ok: false, reason: 'core_unavailable' }
+  }
+  if (!decision.action) {
+    const reason = String(decision.reason || 'idle')
+    if (reason.indexOf('limit') >= 0 || reason.indexOf('decayed') >= 0
+      || reason === 'disabled') {
+      appendAction(opts.dataDir, { ts: Date.now(), kind: 'none',
+        reason, result: { ok: true, stopped: true } })
+    }
+    return { ok: true, action: null, reason }
+  }
+  const executed = await executeAction(ctx, decision.action, opts)
+  appendAction(opts.dataDir, {
+    ts: Date.now(),
+    kind: String(decision.action.kind || ''),
+    args: decision.action,
+    reason: String(decision.reason || ''),
+    result: executed.result,
+  })
+  return { ok: true, action: decision.action, executed }
+}

package/lib/modules/cache-stats.js

@@ -0,0 +1,48 @@
+/** Display-only reader for <dataDir>/cache_stats.json.
+ *
+ * task-223: the adapter no longer computes usage-derived stats; the UI only
+ * reads whatever the file already contains. Missing/corrupt -> zeros.
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export const CACHE_STATS_FILE = 'cache_stats.json'
+export const CACHE_STATS_DEFAULTS = Object.freeze({
+  turns: 0,
+  prompt_tokens: 0,
+  output_tokens: 0,
+  cache_read: 0,
+  cache_write: 0,
+  hit_rate: 0,
+  updated_at: 0,
+})
+
+function num(value) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0
+}
+
+export function cacheStatsPath(dataDir) {
+  return join(String(dataDir || '').trim(), CACHE_STATS_FILE)
+}
+
+/** Read the file as-is (numbers default to 0); never throws. */
+export function readCacheStats(dataDir) {
+  try {
+    const doc = JSON.parse(readFileSync(cacheStatsPath(dataDir), 'utf8'))
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
+      return { ...CACHE_STATS_DEFAULTS }
+    }
+    return {
+      turns: Math.round(num(doc.turns)),
+      prompt_tokens: Math.round(num(doc.prompt_tokens)),
+      output_tokens: Math.round(num(doc.output_tokens)),
+      cache_read: Math.round(num(doc.cache_read)),
+      cache_write: Math.round(num(doc.cache_write)),
+      hit_rate: num(doc.hit_rate),
+      updated_at: Math.round(num(doc.updated_at)),
+    }
+  } catch {
+    return { ...CACHE_STATS_DEFAULTS }
+  }
+}

package/lib/modules/core-turn.js

@@ -19,7 +19,6 @@ import { join } from 'node:path'
 import { readStateFile, sessionStateFile } from './state.js'
 import { pendingSessionTurn, queueSessionTurn } from './turn-queue.js'
 import {
-  anySwitchOn,
   promptTextFor,
   rememberPromptText,
   sessionIdOf,
@@ -35,7 +34,7 @@ import {
 } from './sanitize-reply.js'
 
 export const TURN_CONTEXT_NAME = 'biocore-expression-turn'
-export const TURN_CONTEXT_ORDER = -190
+export const TURN_CONTEXT_ORDER = 9500
 export const CORE_WARN_PREFIX = '__bioCoreWarn'
 export const CORE_GATE_PREFIX = '__bioGate'
 export const CORE_TRACE_PREFIX = '__bioTrace'
@@ -107,6 +106,21 @@ export function chooseCleanReply(original, coreCleanText, options) {
   return String(sanitize(source))
 }
 
+/** Delegation depth from the DSH session header; missing -> 0 (main). */
+export function delegationDepthOf(session) {
+  const header = session && session.header && typeof session.header === 'object'
+    ? session.header : {}
+  const fromHeader = Number(header.delegationDepth)
+  if (Number.isFinite(fromHeader)) return Math.max(0, Math.trunc(fromHeader))
+  const direct = Number(session && session.delegationDepth)
+  if (Number.isFinite(direct)) return Math.max(0, Math.trunc(direct))
+  return 0
+}
+
+export function isSubagentSession(session) {
+  return delegationDepthOf(session) >= 1
+}
+
 export function personaApplied(dataDir) {
   try {
     const status = JSON.parse(readFileSync(join(String(dataDir || '').trim(), 'persona_preset.json'), 'utf8'))
@@ -186,8 +200,8 @@ export function makeCoreSessionListener(options) {
       if (type !== 'user/message' && type !== 'assistant/message') return
       const sessionId = session && session.id != null ? stringId(session.id) : ''
       if (!sessionId) return
+      const subagent = isSubagentSession(session)
       const switches = getSwitches()
-      if (!anySwitchOn(switches)) return
       if (type === 'user/message') {
         const data = event.data || {}
         const source = data.source || {}
@@ -207,9 +221,15 @@ export function makeCoreSessionListener(options) {
             core = { ok: false, reason: 'core_exception' }
           }
           if (core && core.ok === true && typeof core.prompt_block === 'string') {
-            rememberPromptText(sessionId, 'turn', core.prompt_block)
+            // Subagent sessions must not receive persona/state/thinking rules:
+            // keep turn_start for state capture, but blank the -190 prompt.
+            rememberPromptText(sessionId, 'turn', subagent ? '' : core.prompt_block)
             return core
           }
+          if (subagent) {
+            rememberPromptText(sessionId, 'turn', '')
+            return null
+          }
           warnOnce((core && (core.reason || core.detail)) || 'turn_start_failed')
           try {
             const stateFile = sessionStateFile(stateDir, sessionId)
@@ -293,7 +313,6 @@ export function registerCoreTurn(ctx, options) {
             order: TURN_CONTEXT_ORDER,
             text: (context) => {
               try {
-                if (!anySwitchOn(getSwitches())) return ''
                 const sessionId = sessionIdOf(context)
                 return sessionId ? sanitizeTemplateVars(promptTextFor(sessionId, 'turn')) : ''
               } catch { return '' }
@@ -310,7 +329,6 @@ export function registerCoreTurn(ctx, options) {
         let result = await next()
         if (!result || typeof result !== 'object') result = assembly
         try {
-          if (!anySwitchOn(getSwitches())) return result
           const sessionId = sessionIdOf(context)
           if (!sessionId) return result
           // turn_start was queued by session/event; wait for it, then patch the

package/lib/modules/expression-inject.js

@@ -32,15 +32,6 @@ export function sessionIdOf(context) {
   } catch { return '' }
 }
 
-/** True when any of the four flags.json switches is on. */
-export function anySwitchOn(switches) {
-  try {
-    const value = switches && typeof switches === 'object' ? switches : {}
-    return value.safety_enabled === true || value.boundary_enabled === true
-      || value.crisis_safety_enabled === true || value.proactive_send === true
-  } catch { return false }
-}
-
 /** Cache one python-produced prompt text ('' clears it). */
 export function rememberPromptText(sessionId, phase, text) {
   try {
@@ -98,7 +89,6 @@ export function registerExpressionInjections(ctx, options) {
             order,
             text: (context) => {
               try {
-                if (!anySwitchOn(getSwitches())) return ''
                 const sessionId = sessionIdOf(context)
                 if (!sessionId) return ''
                 return String(getText(phase, sessionId) || '')

package/lib/modules/expression-refresh.js

@@ -9,7 +9,6 @@ import { readStateFile, sessionStateFile, projectState } from './state.js'
 import {
   BOOT_CONTEXT_NAME,
   TURN_CONTEXT_NAME,
-  anySwitchOn,
   promptTextFor,
   rememberPromptText,
   clearPromptText,
@@ -39,10 +38,6 @@ export async function refreshPromptCache(options) {
   const callInject = typeof opts.callInject === 'function' ? opts.callInject : null
   if (!sessionId || !callInject) return { refreshed: false, reason: 'unavailable' }
   const switches = getSwitches()
-  if (!anySwitchOn(switches)) {
-    clearPromptText(sessionId)
-    return { refreshed: false, reason: 'switches_off' }
-  }
   const userText = lastUserFor(sessionId)
   const state = statePayloadFor(dataDir, sessionId)
   const phases = []
@@ -106,10 +101,6 @@ export function registerContextRefresh(ctx, options) {
         const switches = getSwitches()
         const sessionId = sessionIdOf(context)
         if (!sessionId) return result
-        if (!anySwitchOn(switches)) {
-          clearPromptText(sessionId)
-          return result
-        }
         // One turn may still be writing the state file; wait for it so python
         // sees the state the user message just produced.
         await pendingSessionTurn(sessionId)

package/lib/modules/memory-capture.js

@@ -57,7 +57,8 @@ export function registerMemoryCapture(ctx, getConfig, storeDir, options = {}) {
           min_chars: config.memoryMinChars,
         })
         if (result && result.ok === true && result.captured === true && injectionState) {
-          await refreshInjection(storeDir, sessionId, config, injectionState)
+          const rerank = typeof options.getRerankConfig === 'function' ? options.getRerankConfig() : null
+      await refreshInjection(storeDir, sessionId, config, injectionState, rerank)
         }
       }).catch(() => { /* capture never disturbs a turn */ })
     } catch { /* contained */ }

package/lib/modules/memory-inject.js

@@ -3,11 +3,16 @@
  * DSH asks for prompt context synchronously, so this module only caches the
  * text returned by the python bridge per session; formatting and truncation
  * never happen in Node.
+ *
+ * task-221: refresh uses the user's own words (mode=query) so retrieval is a
+ * query recall, not "newest N"; python falls back to the recent ordering when
+ * the engine/embedding/rerank chain is unavailable.
  */
 import { memoryInject } from '../py-bridge.js'
 
 export const CONTEXT_NAME = 'biocore-memory'
-export const CONTEXT_ORDER = -190
+export const CONTEXT_ORDER = 9510
+export const DEFAULT_TOP_K = 5
 
 export function createInjectionState() {
   return new Map()
@@ -29,22 +34,41 @@ export function sessionIdOf(context) {
   } catch { return '' }
 }
 
+function textOfMessage(message) {
+  try {
+    const blocks = message && Array.isArray(message.content) ? message.content : []
+    const parts = []
+    for (const block of blocks) {
+      if (block && block.type === 'text' && typeof block.text === 'string') parts.push(block.text)
+    }
+    return parts.join('\n').replace(/\s+/g, ' ').trim().slice(0, 2000)
+  } catch { return '' }
+}
+
+function topKOf(config) {
+  const raw = Number(config && config.injectTopK)
+  if (!Number.isFinite(raw)) return DEFAULT_TOP_K
+  return Math.max(1, Math.min(10, Math.round(raw)))
+}
+
 /** Reload one session summary from the python pipeline and cache it. */
-export async function refreshInjection(storeDir, sessionId, config, state) {
+export async function refreshInjection(storeDir, sessionId, config, state, rerankConfig,
+  query) {
   if (!state || typeof state.set !== 'function') return ''
   if (config && config.memoryEnabled === false) {
     state.set(String(sessionId), '')
     return ''
   }
   const result = await memoryInject(storeDir, sessionId,
-    config && config.injectMaxChars, 5)
+    config && config.injectMaxChars, topKOf(config), rerankConfig, query)
   const text = result && result.ok === true ? String(result.text || '') : ''
   state.set(String(sessionId), text)
   return text
 }
 
-/** Register the per-session cached text as a dynamic system prompt context. */
-export function registerMemoryInjection(ctx, getConfig, storeDir, state) {
+/** Register the per-session cached text + the user-message refresh listener. */
+export function registerMemoryInjection(ctx, getConfig, storeDir, state, options) {
+  const opts = options || {}
   if (!ctx || typeof ctx.inject !== 'function') return null
   const cfg = () => {
     try { return (typeof getConfig === 'function' ? getConfig() : getConfig) || {} } catch { return {} }
@@ -70,5 +94,26 @@ export function registerMemoryInjection(ctx, getConfig, storeDir, state) {
       } catch { /* prompt context rejected */ }
     })
   } catch { /* cordis inject unavailable */ }
+  try {
+    if (typeof ctx.on === 'function') {
+      const dispose = ctx.on('session/event', (session, event) => {
+        try {
+          if (!event || event.type !== 'user/message') return
+          const data = event.data || {}
+          const source = data.source || {}
+          if (source.kind !== 'user') return
+          const sessionId = String((session && session.id) || '')
+          const text = textOfMessage(data)
+          const config = cfg()
+          if (!sessionId || !text || config.memoryEnabled === false) return
+          const rerank = typeof opts.getRerankConfig === 'function'
+            ? opts.getRerankConfig() : null
+          void refreshInjection(storeDir, sessionId, config, state, rerank,
+            text, 'query')
+        } catch { /* a refresh never disturbs a turn */ }
+      })
+      if (typeof dispose === 'function') disposers.push(dispose)
+    }
+  } catch { /* session/event unavailable */ }
   return () => { for (const dispose of disposers) { try { dispose() } catch { /* ignore */ } } }
 }

package/lib/modules/memory-tools.js

@@ -25,13 +25,14 @@ export function sessionIdFromExec(exec) {
   } catch { return 'global' }
 }
 
-export function buildMemoryToolDefinitions(storeDir, getConfig) {
+export function buildMemoryToolDefinitions(storeDir, getConfig, getRerankConfig) {
   const cfg = () => {
     try { return (typeof getConfig === 'function' ? getConfig() : getConfig) || {} } catch { return {} }
   }
   const run = async (name, args, exec) => {
     if (cfg().memoryEnabled === false) return { ok: false, reason: 'memory_disabled' }
-    const response = await memoryTool(storeDir, sessionIdFromExec(exec), name, args || {})
+    const rerank = typeof getRerankConfig === 'function' ? getRerankConfig() : null
+    const response = await memoryTool(storeDir, sessionIdFromExec(exec), name, args || {}, rerank)
     const flat = response && response.result && typeof response.result === 'object'
       ? response.result : {}
     if (response && response.ok === true) return { ok: true, ...flat }
@@ -83,9 +84,11 @@ export function buildMemoryToolDefinitions(storeDir, getConfig) {
   ]
 }
 
-export function registerMemoryTools(ctx, getConfig, storeDir) {
+export function registerMemoryTools(ctx, getConfig, storeDir, options) {
   if (!ctx || typeof ctx.inject !== 'function') return null
-  const definitions = buildMemoryToolDefinitions(storeDir, getConfig)
+  const opts = options || {}
+  const getRerankConfig = typeof opts.getRerankConfig === 'function' ? opts.getRerankConfig : null
+  const definitions = buildMemoryToolDefinitions(storeDir, getConfig, getRerankConfig)
   const disposers = []
   const registered = []
   try {

package/lib/modules/python-env.js

@@ -0,0 +1,46 @@
+/** config.json -> Python env / rerank payload (read-only, fail-silent). */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+function readConfig(dataDir) {
+  try {
+    const doc = JSON.parse(readFileSync(join(String(dataDir || '').trim(), 'config.json'), 'utf8'))
+    return doc && typeof doc === 'object' && !Array.isArray(doc) ? doc : {}
+  } catch { return {} }
+}
+
+const MODES = new Set(['auto', 'remote', 'local', 'off'])
+
+/** Env for embedding; local_path is intentionally not exported. */
+export function embeddingEnv(dataDir) {
+  const doc = readConfig(dataDir)
+  const embedding = doc.embedding && typeof doc.embedding === 'object' ? doc.embedding : {}
+  const mode = String(embedding.mode || 'auto').trim()
+  const env = {
+    BIOCORE_EMBEDDING_MODE: MODES.has(mode) ? mode : 'auto',
+    BIOCORE_EMBEDDING_BASE_URL: String(embedding.base_url || '').trim(),
+    BIOCORE_EMBEDDING_MODEL: String(embedding.model || '').trim(),
+    BIOCORE_EMBEDDING_KEY: typeof embedding.api_key === 'string' ? embedding.api_key : '',
+    // Cross-process disk cache so spawn-per-call still hits (task-221).
+    BIOCORE_EMBEDDING_CACHE_FILE: dataDir ? join(String(dataDir).trim(), 'cache') : '',
+    // Counters survive the spawn-per-call bridge; /stats reads this file.
+    BIOCORE_EMBED_STATS_FILE: dataDir ? join(String(dataDir).trim(), 'embed_stats.json') : '',
+  }
+  for (const key of Object.keys(env)) if (!env[key]) delete env[key]
+  return env
+}
+
+/** rerank_config for memory_inject / recall payloads. */
+export function rerankConfig(dataDir) {
+  const doc = readConfig(dataDir)
+  const rerank = doc.rerank && typeof doc.rerank === 'object' ? doc.rerank : {}
+  const top = Number(rerank.top_n)
+  return {
+    rerank_enabled: rerank.enabled === true,
+    rerank_base_url: String(rerank.base_url || '').trim(),
+    rerank_model: String(rerank.model || '').trim(),
+    rerank_api_key: typeof rerank.api_key === 'string' ? rerank.api_key : '',
+    rerank_top_n: Number.isFinite(top) ? Math.max(1, Math.min(100, Math.round(top))) : 20,
+    rerank_timeout: 8,
+  }
+}

package/lib/modules/safety-gate.js

@@ -8,8 +8,6 @@
  *
  * All four flags off -> no call, no log, no mutation (old behaviour).
  */
-import { anySwitchOn } from './expression-inject.js'
-
 export const GATE_LOG_PREFIX = '__bioGate'
 export const ASSISTANT_EVENT = 'assistant/message'
 export const USER_EVENT = 'user/message'
@@ -112,7 +110,6 @@ export function registerSafetyGate(ctx, options) {
         }
         if (kind !== ASSISTANT_EVENT) return
         const switches = getSwitches()
-        if (!anySwitchOn(switches)) return
         const reply = assistantTextOf(event)
         if (!reply) return
         const decision = await runGate({

package/lib/modules/series.js

@@ -0,0 +1,54 @@
+/** task-223: GET /api/biocore/series -- pure forward to the core.
+ *
+ * The core assembles the points (global history + growth history). This file
+ * only forwards the request and returns the reply unchanged; when the core is
+ * unreachable it answers an empty series so the panel never sees a 404.
+ */
+import { runtimeAction } from '../py-bridge.js'
+
+export const SERIES_ROUTE_PATH = '/api/biocore/series'
+export const SERIES_DEFAULT_LIMIT = 24
+export const SERIES_MAX_LIMIT = 288
+
+function sendJson(res, code, payload) {
+  try {
+    res.writeHead(code, {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'no-store',
+    })
+    res.end(JSON.stringify(payload))
+  } catch { /* client gone */ }
+  return payload
+}
+
+export async function handleSeriesRoute(req, res, options) {
+  const opts = options || {}
+  const method = String((req && req.method) || 'GET').toUpperCase()
+  if (method !== 'GET' && method !== 'HEAD') {
+    return sendJson(res, 405, { ok: false, reason: 'method_not_allowed' })
+  }
+  let limit = SERIES_DEFAULT_LIMIT
+  try {
+    const url = new URL(String(req.url || ''), 'http://local')
+    const raw = Number(url.searchParams.get('limit'))
+    if (Number.isFinite(raw)) {
+      limit = Math.max(1, Math.min(SERIES_MAX_LIMIT, Math.round(raw)))
+    }
+  } catch { /* default limit */ }
+  let reply = null
+  try {
+    const runAction = typeof opts.runAction === 'function' ? opts.runAction : runtimeAction
+    reply = await runAction('series', {
+      store: opts.store,
+      data_dir: opts.dataDir,
+      limit,
+    })
+  } catch { reply = null }
+  if (reply && typeof reply === 'object') return sendJson(res, 200, reply)
+  return sendJson(res, 200, {
+    ok: true,
+    series: { ts: [], v: [], tension: [], warmth: [], heaviness: [], clarity: [] },
+    points: [],
+    source: 'unavailable',
+  })
+}

package/lib/modules/switch.js

@@ -27,24 +27,40 @@ export const FLAGS_FILE_NAME = 'flags.json'
 export const BODY_LIMIT = 4096
 
 export const SWITCH_KEYS = Object.freeze([
+  'core_enabled',
   'safety_enabled',
   'boundary_enabled',
   'crisis_safety_enabled',
   'proactive_send',
+  // learning switches (task-221): flags only, never safety semantics
+  'mood_recall',
+  'affect_encoding',
+  'memory_feedback',
+  'preference_drift',
 ])
 
 export const SWITCH_LABELS = Object.freeze({
+  core_enabled: '核心',
   safety_enabled: '安全闸',
   boundary_enabled: '底线',
   crisis_safety_enabled: '危机兜底',
   proactive_send: '主动回复',
+  mood_recall: '情绪匹配召回',
+  affect_encoding: '编码带情绪',
+  memory_feedback: '回忆回灌情绪',
+  preference_drift: '主题偏好漂移',
 })
 
 export const DEFAULT_SWITCHES = Object.freeze({
+  core_enabled: true,
   safety_enabled: false,
   boundary_enabled: false,
   crisis_safety_enabled: false,
   proactive_send: false,
+  mood_recall: true,
+  affect_encoding: true,
+  memory_feedback: true,
+  preference_drift: true,
 })
 
 /** Read-side aliases for renamed switches (writes always use the canonical key). */