dsh-biocore 0.1.91 → 0.3.0

package/README.md

@@ -49,6 +49,17 @@ DSH `session/event` hook 每轮调用一次 `one_turn`，另有 `/bio sync <一
 2) **兜底命令 `/bio sync <一句话>`**：给没有 hook 的宿主/手动调试用，
    调同一个 bridge 更新当前会话，返回一行状态变化摘要（不产生模型消息）。
 
+## 子智能体（delegationDepth >= 1）
+
+core-turn 在组装 -190 注入前读取 session.header.delegationDepth（缺失按 0）：
+- depth = 0 / 缺失：保持现行为，注入人设、状态块与思考规则。
+- depth >= 1：仍调用 turn_start 维持状态/记忆/trace，但把本会话的 prompt_block
+  置空，跳过人设/状态/思考规则注入；turn_end 的 gate/trace 照常。
+
+persona preset 的常驻注入是宿主级（agent preset），插件无法按会话单独关掉；
+本插件只保证 turn 注入对子智能体跳过。若 preset 仍向子智能体注入，需要在
+宿主侧为 subagent 使用不含 persona 的 preset。
+
 ## 接口
 
 `GET /api/biocore/state?session=<id>`

package/lib/core-worker.js

@@ -0,0 +1,268 @@
+/** task-223: one persistent python core per DSH plugin lifetime.
+ *
+ * start(dataDir) spawns python/biocore_runtime/service.py; call(action, payload)
+ * correlates requests by id; a crash restarts at most 3 times (0.5s/1s/2s) and
+ * every failure is logged as '__bioWorker ...'. stop() sends SIGTERM and
+ * force-kills after 5s. When the worker is down, callers fall back to the old
+ * spawn-per-call bridge (handled in py-bridge.js).
+ */
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+import { embeddingEnv } from './modules/python-env.js'
+
+export const PACKAGE_ROOT = fileURLToPath(new URL('..', import.meta.url))
+export const PYTHON_DIR = join(PACKAGE_ROOT, 'python')
+export const SERVICE_SCRIPT = join(PYTHON_DIR, 'biocore_runtime', 'service.py')
+export const ADAPTER_DIR = join(PYTHON_DIR, 'dsh_adapter')
+export const WORKER_LOG_PREFIX = '__bioWorker'
+export const DEFAULT_TIMEOUT_MS = 10000
+export const MAX_RESTARTS = 3
+export const BACKOFF_MS = Object.freeze([500, 1000, 2000])
+export const STOP_GRACE_MS = 5000
+
+let worker = null
+let exitHookInstalled = false
+
+function log(message) {
+  try { console.error(WORKER_LOG_PREFIX + ' ' + message) } catch { /* ignore */ }
+}
+
+export class WorkerUnavailable extends Error {
+  constructor(reason, detail) {
+    super(String(reason || 'worker_unavailable'))
+    this.name = 'WorkerUnavailable'
+    this.reason = String(reason || 'worker_unavailable')
+    this.detail = detail ? String(detail) : ''
+  }
+}
+
+function pythonCommand() {
+  return process.env.BIOCORE_PYTHON || 'python'
+}
+
+function workerEnv(dataDir) {
+  let embedding = {}
+  try { embedding = dataDir ? embeddingEnv(dataDir) : {} } catch { embedding = {} }
+  return Object.assign({}, process.env, embedding, {
+    BIOCORE_PLUGIN_DIR: PYTHON_DIR,
+    BIOCORE_ADAPTER_DIR: ADAPTER_DIR,
+    PYTHONIOENCODING: 'utf-8',
+  })
+}
+
+function isAlive(handle) {
+  return Boolean(handle && handle.child && handle.child.exitCode === null
+    && handle.child.signalCode === null && !handle.stopping)
+}
+
+function rejectPending(handle, reason, detail) {
+  if (!handle || !handle.pending) return
+  for (const [id, entry] of handle.pending) {
+    clearTimeout(entry.timer)
+    entry.reject(new WorkerUnavailable(reason, detail))
+    handle.pending.delete(id)
+  }
+}
+
+function handleLine(handle, line) {
+  const text = String(line || '').trim()
+  if (!text) return
+  let message = null
+  try { message = JSON.parse(text) } catch {
+    log('bad-json ' + text.slice(0, 120))
+    return
+  }
+  if (!message || typeof message !== 'object') return
+  const id = message.id == null ? '' : String(message.id)
+  const entry = handle.pending.get(id)
+  if (!entry) return
+  handle.pending.delete(id)
+  clearTimeout(entry.timer)
+  if (message.ok === true) entry.resolve(message.result === undefined ? {} : message.result)
+  else entry.reject(new WorkerUnavailable(message.reason || 'service_error',
+    message.detail || ''))
+}
+
+function attach(handle) {
+  const child = handle.child
+  let buffer = ''
+  child.stdout.on('data', (chunk) => {
+    buffer += String(chunk)
+    let index = buffer.indexOf('\n')
+    while (index >= 0) {
+      const line = buffer.slice(0, index)
+      buffer = buffer.slice(index + 1)
+      handleLine(handle, line)
+      index = buffer.indexOf('\n')
+    }
+    if (buffer.length > 1024 * 1024) buffer = ''
+  })
+  child.stderr.on('data', (chunk) => {
+    const text = String(chunk).trim()
+    if (text) log('stderr ' + text.split('\n').slice(-3).join(' | ').slice(0, 500))
+  })
+  child.on('error', (error) => {
+    log('error ' + String(error && error.message || error).slice(0, 200))
+    onGone(handle, 'spawn_error', String(error && error.message || error))
+  })
+  // A sandbox may refuse piped stdio (EPIPE on write). Swallow the stream error
+  // so the host process survives; callers fall back to spawn-per-call.
+  try { child.stdin.on('error', (error) => onGone(handle, 'stdin_error', String(error && error.message || error))) } catch { /* noop */ }
+  try { child.stdout.on('error', (error) => onGone(handle, 'stdout_error', String(error && error.message || error))) } catch { /* noop */ }
+  child.on('exit', (code, signal) => {
+    onGone(handle, 'exit', 'code=' + code + ' signal=' + signal)
+  })
+}
+
+function onGone(handle, reason, detail) {
+  if (handle.gone) return
+  handle.gone = true
+  if (handle.stopping) {
+    rejectPending(handle, 'worker_stopped', '')
+    return
+  }
+  log('down reason=' + reason + ' ' + String(detail || '').slice(0, 160))
+  rejectPending(handle, 'worker_crashed', reason + ' ' + String(detail || ''))
+  if (handle.restarts >= MAX_RESTARTS) {
+    log('giving_up restarts=' + handle.restarts)
+    return
+  }
+  const delay = BACKOFF_MS[Math.min(handle.restarts, BACKOFF_MS.length - 1)]
+  handle.restarts += 1
+  log('restart=' + handle.restarts + ' delay_ms=' + delay)
+  handle.restartTimer = setTimeout(() => {
+    handle.restartTimer = null
+    if (handle.stopping || worker !== handle) return
+    spawnChild(handle)
+  }, delay)
+  if (typeof handle.restartTimer.unref === 'function') handle.restartTimer.unref()
+}
+
+function spawnChild(handle) {
+  handle.gone = false
+  let child = null
+  try {
+    child = spawn(pythonCommand(), [SERVICE_SCRIPT], {
+      cwd: ADAPTER_DIR,
+      env: workerEnv(handle.dataDir),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    })
+  } catch (error) {
+    log('spawn_failed ' + String(error && error.message || error))
+    handle.child = null
+    onGone(handle, 'spawn_failed', String(error && error.message || error))
+    return
+  }
+  handle.child = child
+  attach(handle)
+  log('started pid=' + (child.pid || '?') + ' dataDir=' + String(handle.dataDir || ''))
+}
+
+/** Start (or reuse) the singleton worker. Idempotent while it is alive. */
+export function startCoreWorker(dataDir) {
+  const dir = String(dataDir || '')
+  if (worker && isAlive(worker) && worker.dataDir === dir) return workerApi(worker)
+  if (worker) stopCoreWorker()
+  worker = {
+    dataDir: dir,
+    child: null,
+    pending: new Map(),
+    seq: 0,
+    restarts: 0,
+    stopping: false,
+    gone: false,
+    restartTimer: null,
+    startedAt: Date.now(),
+  }
+  spawnChild(worker)
+  if (!exitHookInstalled) {
+    exitHookInstalled = true
+    try {
+      process.once('exit', () => {
+        try { if (worker && worker.child) worker.child.kill() } catch { /* ignore */ }
+      })
+    } catch { /* ignore */ }
+  }
+  return workerApi(worker)
+}
+
+export function isWorkerRunning() {
+  return isAlive(worker)
+}
+
+export function workerPid() {
+  return worker && worker.child ? worker.child.pid : null
+}
+
+export function callCoreWorker(action, payload, options) {
+  const opts = options || {}
+  const timeoutMs = Number.isFinite(Number(opts.timeoutMs))
+    ? Math.max(1, Number(opts.timeoutMs)) : DEFAULT_TIMEOUT_MS
+  return new Promise((resolve, reject) => {
+    if (!isAlive(worker)) {
+      reject(new WorkerUnavailable('worker_down', ''))
+      return
+    }
+    const id = 'w' + (++worker.seq)
+    const entry = { resolve, reject, timer: null }
+    entry.timer = setTimeout(() => {
+      worker.pending.delete(id)
+      reject(new WorkerUnavailable('timeout', 'action=' + action))
+    }, timeoutMs)
+    if (typeof entry.timer.unref === 'function') entry.timer.unref()
+    worker.pending.set(id, entry)
+    const line = JSON.stringify({
+      id,
+      action: String(action || ''),
+      payload: payload && typeof payload === 'object' ? payload : {},
+    }) + '\n'
+    try {
+      worker.child.stdin.write(line)
+    } catch (error) {
+      worker.pending.delete(id)
+      clearTimeout(entry.timer)
+      reject(new WorkerUnavailable('write_failed', String(error && error.message || error)))
+    }
+  })
+}
+
+/** Stop the worker: SIGTERM, then force-kill after 5s. Never throws. */
+export function stopCoreWorker() {
+  const handle = worker
+  if (!handle) return
+  handle.stopping = true
+  if (handle.restartTimer) {
+    clearTimeout(handle.restartTimer)
+    handle.restartTimer = null
+  }
+  rejectPending(handle, 'worker_stopped', '')
+  const child = handle.child
+  worker = null
+  if (!child) return
+  try { child.kill('SIGTERM') } catch { /* ignore */ }
+  const timer = setTimeout(() => {
+    try { if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL') } catch { /* ignore */ }
+  }, STOP_GRACE_MS)
+  if (typeof timer.unref === 'function') timer.unref()
+  child.once('exit', () => clearTimeout(timer))
+}
+
+/** Test seam: kill the current process without marking it stopped (crash). */
+export function killWorkerForTest(signal) {
+  if (!isAlive(worker)) return false
+  try { worker.child.kill(signal || 'SIGKILL') } catch { return false }
+  return true
+}
+
+function workerApi(handle) {
+  return {
+    start: () => startCoreWorker(handle.dataDir),
+    call: (action, payload, options) => callCoreWorker(action, payload, options),
+    stop: () => stopCoreWorker(),
+    get pid() { return handle.child ? handle.child.pid : null },
+    get running() { return isAlive(handle) },
+    get restarts() { return handle.restarts },
+  }
+}

package/lib/index.js

@@ -17,22 +17,23 @@ import { dirname, join } from 'node:path'
 import {
   cleanSessionId,
   payloadWithinLimit,
-  projectState,
-  readStateFile,
   sessionStateFile,
   STATE_LIMIT,
 } from './modules/state.js'
-import { compilePersona, ensureState, runTurn, runtimeAction } from './py-bridge.js'
+import { compilePersona, configureBridge, configureCore, ensureState, memoryTool, runTurn, runtimeAction } from './py-bridge.js'
+import { rerankConfig } from './modules/python-env.js'
 import { SWITCH_ROUTE_PATH, handleSwitchRoute, readSwitches } from './modules/switch.js'
 import { TRACE_ROUTE_PATH, defaultStoreDir, handleTraceRoute } from './modules/trace.js'
+import { SERIES_ROUTE_PATH, handleSeriesRoute } from './modules/series.js'
+import { readCacheStats } from './modules/cache-stats.js'
+import { startCoreWorker, stopCoreWorker } from './core-worker.js'
+import { runAutonomyTick } from './modules/autonomy.js'
 import { queueSessionTurn } from './modules/turn-queue.js'
-import { anySwitchOn } from './modules/expression-inject.js'
 import { makeCoreSessionListener, registerCoreTurn } from './modules/core-turn.js'
 import { migrateLegacyPluginData, PLUGIN_DATA_DIR, resolveDataDir } from './modules/data-dir.js'
 import {
   PANEL_MOUNT_PATH,
   PANEL_ROUTE_PREFIX,
-  buildPanelExtras,
   servePanelPage,
 } from './modules/panel-data.js'
 import { resolveMemoryDir } from './modules/memory-store.js'
@@ -91,7 +92,7 @@ export function settingsPaths(dataDir) {
 export const EMBEDDING_MODES = Object.freeze(['auto', 'remote', 'local', 'off'])
 
 function emptyEmbedding() {
-  return { mode: 'auto', base_url: '', model: '', api_key: '', local_path: '' }
+  return { mode: 'auto', base_url: '', model: '', api_key: '' }
 }
 
 function normalizeEmbedding(value) {
@@ -102,11 +103,35 @@ function normalizeEmbedding(value) {
     base_url: String(source.base_url || '').trim().slice(0, 2000),
     model: String(source.model || '').trim().slice(0, 200),
     api_key: typeof source.api_key === 'string' ? source.api_key.trim().slice(0, 4000) : '',
-    local_path: String(source.local_path || '').trim().slice(0, 2000),
   }
 }
 
-export const RERANK_DEFAULTS = Object.freeze({
+export const AUTONOMY_DEFAULTS = Object.freeze({
+  max_actions_per_hour: 20,
+  max_sends_per_hour: 5,
+  max_sends_per_day: 30,
+  quiet_hours: [],
+  auto_decay_on_silence: true,
+})
+
+function normalizeAutonomy(value) {
+  const source = value && typeof value === 'object' && !Array.isArray(value)
+    ? value : {}
+  const int = (raw, fallback) => {
+    const number = Number(raw)
+    return Number.isFinite(number) ? Math.max(0, Math.round(number)) : fallback
+  }
+  return {
+    max_actions_per_hour: int(source.max_actions_per_hour, AUTONOMY_DEFAULTS.max_actions_per_hour),
+    max_sends_per_hour: int(source.max_sends_per_hour, AUTONOMY_DEFAULTS.max_sends_per_hour),
+    max_sends_per_day: int(source.max_sends_per_day, AUTONOMY_DEFAULTS.max_sends_per_day),
+    quiet_hours: Array.isArray(source.quiet_hours)
+      ? source.quiet_hours.map((item) => String(item).slice(0, 12)).slice(0, 12) : [],
+    auto_decay_on_silence: source.auto_decay_on_silence !== false,
+  }
+}
+
+const RERANK_DEFAULTS = Object.freeze({
   enabled: false,
   base_url: 'https://api.jina.ai/v1',
   model: 'jina-reranker-v2-base-multilingual',
@@ -167,6 +192,7 @@ export function readFullConfig(dataDir) {
     embedding: storedEmbedding(source),
     rerank: normalizeRerank(source.rerank),
     expression: normalizeExpression(source.expression),
+    autonomy: normalizeAutonomy(source.autonomy),
     sanitize_reply: source.sanitize_reply !== false,
   }
 }
@@ -177,6 +203,7 @@ function writeFullConfig(file, config) {
     embedding: config.embedding,
     rerank: config.rerank,
     expression: config.expression,
+    autonomy: config.autonomy,
     sanitize_reply: config.sanitize_reply !== false,
   }, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 })
   try { chmodSync(file, 0o600) } catch { /* Windows may ignore POSIX modes */ }
@@ -193,6 +220,7 @@ export async function handleSettings(req, res, dataDir) {
       embedding: maskedEmbedding(config.embedding),
       rerank: maskedRerank(config.rerank),
       expression: config.expression,
+      autonomy: config.autonomy,
       sanitize_reply: config.sanitize_reply !== false,
       restart_required: false,
     })
@@ -217,7 +245,9 @@ export async function handleSettings(req, res, dataDir) {
   const hasRerank = body.rerank && typeof body.rerank === 'object'
   const hasExpression = body.expression && typeof body.expression === 'object'
   const hasSanitize = typeof body.sanitize_reply === 'boolean'
-  if (!hasEmbedding && !hasRerank && !hasExpression && !hasSanitize) {
+  const hasAutonomy = body.autonomy && typeof body.autonomy === 'object'
+  if (!hasEmbedding && !hasRerank && !hasExpression && !hasSanitize
+    && !hasAutonomy) {
     return sendJson(res, 400, { ok: false, reason: 'no_settings' })
   }
   if (hasEmbedding) {
@@ -240,13 +270,16 @@ export async function handleSettings(req, res, dataDir) {
     config.rerank = rerank
   }
   if (hasExpression) config.expression = normalizeExpression(body.expression)
+  if (hasAutonomy) config.autonomy = normalizeAutonomy(body.autonomy)
   if (hasSanitize) config.sanitize_reply = body.sanitize_reply === true
   writeFullConfig(paths.file, config)
+  void configureCoreRuntime(paths.dir)
   return sendJson(res, 200, {
     ok: true,
     embedding: maskedEmbedding(config.embedding),
     rerank: maskedRerank(config.rerank),
     expression: config.expression,
+    autonomy: config.autonomy,
     sanitize_reply: config.sanitize_reply !== false,
     restart_required: true,
     hint: '重启 BioCore 生效',
@@ -342,6 +375,30 @@ export async function handleSettingsTest(req, res, options) {
   return sendJson(res, 200, result)
 }
 
+/** task-223: the adapter only ships the config; the core decides everything. */
+function coreConfigPayload(dataDir) {
+  const config = readFullConfig(dataDir)
+  let switches = {}
+  try { switches = readSwitches(dataDir).switches } catch { switches = {} }
+  let persona = ''
+  try { persona = readPersonaText(dataDir) } catch { persona = '' }
+  return {
+    data_dir: dataDir,
+    persona_text: persona,
+    embedding: config.embedding,
+    rerank: config.rerank,
+    expression: config.expression,
+    autonomy: config.autonomy,
+    sanitize_reply: config.sanitize_reply !== false,
+    switches,
+    recall_mode: 'query',
+  }
+}
+
+async function configureCoreRuntime(dataDir) {
+  try { await configureCore(coreConfigPayload(dataDir)) } catch { /* core decides defaults */ }
+}
+
 const PERSONA_PREVIEW_FIELDS = [
   ['E', '外向', 2],
   ['A', '宜人', 2],
@@ -686,32 +743,31 @@ export async function fetchCoreState(sessionId, options) {
   return value
 }
 
-/** Overlay the core state action's fields onto the /state projection. */
-export function mergeCoreState(body, reply) {
-  const base = body && typeof body === 'object' ? Object.assign({}, body) : { available: true }
-  if (!reply || reply.ok !== true || !reply.state || typeof reply.state !== 'object') return base
-  const core = reply.state
-  if (core.session_id != null) base.session_id = String(core.session_id)
-  const count = core.memory && Number(core.memory.count)
-  if (Number.isFinite(count)) base.memory_count = count
-  const intero = (core.intero && typeof core.intero === 'object')
-    ? core.intero
-    : ((core.core && core.core.intero && typeof core.core.intero === 'object') ? core.core.intero : null)
-  if (intero) base.intero = Object.assign({}, base.intero || {}, intero)
-  if (core.relationship && typeof core.relationship === 'object') {
-    const rel = core.relationship
-    const metrics = Object.assign({}, base.relationship_metrics || {})
-    for (const key of ['closeness', 'trust', 'conflict', 'bids']) {
-      const value = Number(rel[key])
-      if (Number.isFinite(value)) metrics[key] = Math.round(value * 100) / 100
-    }
-    base.relationship_metrics = metrics
-  }
-  for (const key of ['v', 'intero', 'tone', 'relation', 'autonomy', 'history',
-    'memory_recent', 'narrative', 'body_metrics', 'motivation']) {
-    if (core[key] !== undefined) base[key] = core[key]
+export const STATS_ROUTE_PATH = '/api/biocore/stats'
+
+/** task-223: /stats is a pure forward of the core reply (+ display-only cache). */
+export async function handleStats(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' })
   }
-  return base
+  let reply = null
+  try {
+    const runAction = typeof opts.runAction === 'function' ? opts.runAction : runtimeAction
+    const store = (() => {
+      try { return typeof opts.getStore === 'function' ? opts.getStore() : '' } catch { return '' }
+    })()
+    reply = await runAction('stats', { store })
+  } catch { reply = null }
+  const body = Object.assign({ ok: false, reason: 'core_unavailable' },
+    reply && typeof reply === 'object' ? reply : {})
+  try {
+    if (typeof opts.dataDir === 'string' && opts.dataDir) {
+      body.cache = readCacheStats(opts.dataDir)
+    }
+  } catch { /* display only */ }
+  return sendJson(res, 200, body)
 }
 
 export async function handleState(req, res, stateDir, options) {
@@ -725,43 +781,29 @@ export async function handleState(req, res, stateDir, options) {
   if (!rawSession) return sendJson(res, 200, unavailable('no_session'))
   const sessionId = cleanSessionId(rawSession)
   if (!sessionId) return sendJson(res, 200, unavailable('bad_session'))
-  const stateFile = sessionStateFile(stateDir, sessionId)
-  const read = readStateFile(stateFile)
-  let body = null
-  if (read.missing) {
-    // Fast path: never call Python when the session file exists. Only a
-    // missing file + an enabled switch may fall back to runtimeAction('state').
-    let core = null
-    try {
-      const getSwitches = typeof opts.getSwitches === 'function' ? opts.getSwitches : null
-      if (getSwitches && anySwitchOn(getSwitches())) {
-        core = await fetchCoreState(sessionId, {
-          runAction: opts.runAction,
-          store: opts.store,
-        })
-      }
-    } catch { core = null }
-    if (!core || core.ok !== true || !core.state || typeof core.state !== 'object') {
-      return sendJson(res, 200, unavailable('no_state_yet'))
-    }
-    body = projectState(core.state, { mtimeMs: 0, sessionId })
-    Object.assign(body, buildPanelExtras(core.state))
-    body.source = 'runtime'
-  } else if (read.error) {
-    return sendJson(res, 200, unavailable(read.error))
-  } else {
-    body = projectState(read.state, { mtimeMs: read.mtimeMs, sessionId })
-    Object.assign(body, buildPanelExtras(read.state))
-    body.source = 'file'
-  }
-  if (!payloadWithinLimit(body)) {
+  // task-223: pure forward -- the core owns the whole /state payload.
+  let reply = null
+  try {
+    const runAction = typeof opts.runAction === 'function' ? opts.runAction : runtimeAction
+    reply = await runAction('state', { session_id: sessionId, store: opts.store })
+  } catch { reply = null }
+  const state = reply && reply.ok === true && reply.state
+    && typeof reply.state === 'object' ? reply.state : null
+  if (!state) return sendJson(res, 200, unavailable('core_unavailable'))
+  if (!payloadWithinLimit(state)) {
     return sendJson(res, 200, unavailable('payload_too_large'))
   }
-  return sendJson(res, 200, body)
+  return sendJson(res, 200, state)
 }
 
 export function apply(ctx, config) {
   const dataDir = resolveDataDir(config)
+  configureBridge(dataDir)
+  // task-223: one persistent core process for this plugin lifetime.
+  try { startCoreWorker(dataDir) } catch (error) {
+    try { console.error('__bioWorker start_failed ' + String(error)) } catch { /* ignore */ }
+  }
+  void configureCoreRuntime(dataDir)
   try { migrateLegacyPluginData(dataDir) } catch { /* best-effort data migration */ }
   try { migratePersonaToShared(dataDir) } catch { /* best-effort migration */ }
   const disposers = []
@@ -799,14 +841,36 @@ export function apply(ctx, config) {
           path: STATE_ROUTE_PATH,
           handler: (req, res) => handleState(req, res, dataDir, { getSwitches, store: resolveMemoryDir(dataDir) }),
         }))
-        // task-196: four switches persist to <dataDir>/flags.json (atomic write).
+        // task-221: 24-point mood/channel series (global core_state history).
         keep(webServer.register({
           kind: 'exact',
-          path: SWITCH_ROUTE_PATH,
-          handler: (req, res) => handleSwitchRoute(req, res, {
+          path: SERIES_ROUTE_PATH,
+          handler: (req, res) => handleSeriesRoute(req, res, {
+            store: resolveMemoryDir(dataDir), dataDir,
+          }),
+        }))
+        // embedding cache stats (action=stats; zeros when unavailable).
+        keep(webServer.register({
+          kind: 'exact',
+          path: STATS_ROUTE_PATH,
+          handler: (req, res) => handleStats(req, res, {
+            getSwitches,
+            getStore: () => resolveMemoryDir(dataDir),
             dataDir,
           }),
         }))
+        // task-196: four switches persist to <dataDir>/flags.json (atomic write).
+        keep(webServer.register({
+          kind: 'exact',
+          path: SWITCH_ROUTE_PATH,
+          handler: async (req, res) => {
+            const out = await handleSwitchRoute(req, res, { dataDir })
+            if (String((req && req.method) || '').toUpperCase() === 'POST') {
+              void configureCoreRuntime(dataDir)
+            }
+            return out
+          },
+        }))
         // task-210: read-only "why this turn" traces written by python.
         keep(webServer.register({
           kind: 'exact',
@@ -879,11 +943,16 @@ export function apply(ctx, config) {
   } catch { /* memory capture unavailable */ }
   try {
     const injection = registerMemoryInjection(ctx, () => config, memoryDir,
-      injectionState)
+      injectionState, {
+        getRerankConfig: () => rerankConfig(dataDir),
+        getSwitches,
+      })
     if (injection) keep(injection)
   } catch { /* prompt service unavailable */ }
   try {
-    const tools = registerMemoryTools(ctx, () => config, memoryDir)
+    const tools = registerMemoryTools(ctx, () => config, memoryDir, {
+      getRerankConfig: () => rerankConfig(dataDir),
+    })
     if (tools) keep(tools.dispose)
   } catch { /* tool service unavailable */ }
 
@@ -903,10 +972,31 @@ export function apply(ctx, config) {
     }
   } catch { /* headless / no host services */ }
 
+  // task-222: autonomy tick -- the core decides, this loop only executes.
+  if (!config || config.autonomyEnabled !== false) {
+    let timer = null
+    const tick = async () => {
+      try {
+        await runAutonomyTick(ctx, {
+          runAction: runtimeAction,
+          store: resolveMemoryDir(dataDir),
+          dataDir,
+          sessionId: 'autonomy',
+          memoryTool,
+          rerankConfig: rerankConfig(dataDir),
+        })
+      } catch { /* an autonomy tick never disturbs a turn */ }
+    }
+    timer = setInterval(() => { void tick() }, 5 * 60 * 1000)
+    if (typeof timer.unref === 'function') timer.unref()
+    keep(() => { if (timer !== null) { clearInterval(timer); timer = null } })
+  }
+
   return () => {
     for (const dispose of disposers) {
       try { if (typeof dispose === 'function') dispose() } catch { /* ignore */ }
     }
+    try { stopCoreWorker() } catch { /* ignore */ }
   }
 }