mixdog 0.9.3 → 0.9.5

package/src/runtime/memory/index.mjs

@@ -56,12 +56,11 @@ import {
 } from './lib/session-ingest.mjs'
 import { configureEmbedding, embedText, embedTexts, getEmbeddingDims, getEmbeddingDtype, getEmbeddingModelId, getKnownDimsForCurrentModel, isEmbeddingModelReady, primeEmbeddingDims, warmupEmbeddingProvider } from './lib/embedding-provider.mjs'
 import { startLlmWorker, stopLlmWorker } from './lib/llm-worker-host.mjs'
-import { runCycle1, runCycle2, runCycle3, runUnifiedGate, parseInterval, syncRootEmbedding, applySimpleStatus, applyUpdate, applyMerge, CYCLE2_ACTIVE_TARGET_CAP } from './lib/memory-cycle.mjs'
+import { runCycle1, runCycle2, runCycle3, runUnifiedGate, parseInterval, syncRootEmbedding, flushRawEmbeddings, applySimpleStatus, applyUpdate, applyMerge, CYCLE2_ACTIVE_TARGET_CAP } from './lib/memory-cycle.mjs'
 import { loadConfig as loadAgentConfig } from '../agent/orchestrator/config.mjs'
 import { initProviders } from '../agent/orchestrator/providers/registry.mjs'
 import { makeAgentDispatch } from '../agent/orchestrator/agent-runtime/agent-dispatch.mjs'
 import { getInFlightCycle1 } from './lib/memory-cycle1.mjs'
-import { drainSessionCycle1 } from '../agent/orchestrator/session/compact.mjs'
 import { claimAndMarkScheduledCycle, resolveCoalesceMaxRetries, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
 import { searchRelevantHybrid } from './lib/memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './lib/memory-recall-id-patch.mjs'
@@ -74,9 +73,27 @@ import { resolveProjectId, resolveProjectScope } from './lib/project-id-resolver
 import { openTraceDatabase, closeTraceDatabase, insertTraceEvents, enqueueTraceEvents, insertAgentCalls, registerTraceExitDrain } from './lib/trace-store.mjs'
 import { updateJsonAtomicSync, writeJsonAtomicSync } from '../shared/atomic-file.mjs'
 import { resolvePluginData, mixdogHome } from '../shared/plugin-paths.mjs'
-import { parsePeriod, formatTs, coreRecallTerms, normalizeRecallProjectScope, sessionRecallTerms, interleaveRawRows, renderEntryLines } from './lib/recall-format.mjs'
+import { parsePeriod, formatTs, coreRecallTerms, normalizeRecallProjectScope, sessionRecallTerms, interleaveRawRows, renderEntryLines, renderSessionGroupedLines } from './lib/recall-format.mjs'
 import { readBody, sendJson, sendError, isLocalOrigin, normalizeCoreProjectId } from './lib/http-wire.mjs'
 import { scheduledCycle1Signature, scheduledCycle2Signature, scheduledCycle3Signature } from './lib/cycle-signatures.mjs'
+import { createTranscriptIngest } from './lib/transcript-ingest.mjs'
+import { createEmbeddingWarmup } from './lib/embedding-warmup.mjs'
+import { init as initKoMorph } from './lib/ko-morph.mjs'
+import { createCycleLlmAdapters } from './lib/cycle-llm-adapters.mjs'
+import { createCycleScheduler } from './lib/cycle-scheduler.mjs'
+import { createQueryHandlers } from './lib/query-handlers.mjs'
+import {
+  readMainConfig,
+  readRecapEnabled,
+  embeddingWarmupEnabled,
+  envFlagEnabled,
+  memorySecondaryMode,
+  embeddingWarmupCanStart,
+  memoryLlmWorkerEnabled,
+  memoryCyclesEnabled,
+  secondaryPgAdvertised as _secondaryPgAdvertised,
+  assertSecondaryPgAttachable as _assertSecondaryPgAttachable,
+} from './lib/memory-config-flags.mjs'
 const IS_MEMORY_ENTRY = !!process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href
 const USE_ARG_DATA_DIR = IS_MEMORY_ENTRY || process.env.MIXDOG_WORKER_MODE === '1'
 const DATA_DIR = process.env.MIXDOG_DATA_DIR || (USE_ARG_DATA_DIR ? process.argv[2] : '') || resolvePluginData()
@@ -86,7 +103,15 @@ if (!DATA_DIR) {
 }
 __mixdogMemoryLog(`[memory-service] DATA_DIR=${DATA_DIR}\n`)
 
-import { execFileSync } from 'child_process'
+import {
+  parsePositivePid,
+  isPidAliveLocal,
+  tryAcquireMemoryOwnerLock as _tryAcquireMemoryOwnerLock,
+  releaseMemoryOwnerLock as _releaseMemoryOwnerLock,
+  killPreviousServer as _killPreviousServer,
+  acquireLock as _acquireLock,
+  releaseLock as _releaseLock,
+} from './lib/memory-process-lock.mjs'
 
 const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
   ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
@@ -100,12 +125,8 @@ let _periodicAdvertiseTimer = null
 // port after fork-proxy promotion swaps in our own locally-bound port.
 let _currentAdvertisedPort = null
 
-function parsePositivePid(value) {
-  const pid = Number(value)
-  return Number.isFinite(pid) && pid > 0 ? pid : null
-}
-
 const MEMORY_SERVER_PID = parsePositivePid(process.env.MIXDOG_SERVER_PID) ?? process.pid
+const _isPidAliveLocal = isPidAliveLocal
 const MEMORY_DAEMON_MODE = process.env.MIXDOG_MEMORY_DAEMON === '1'
 const MEMORY_IDLE_TTL_MS = Math.max(0, Number(process.env.MIXDOG_MEMORY_IDLE_TTL_MS) || 10 * 60_000)
 let _idleShutdownTimer = null
@@ -155,7 +176,7 @@ function advertiseMemoryPort(boundPort, attempt = 0) {
         updatedAt: Date.now(),
       }
       return next
-    }, { compact: true, fsyncDir: true })
+    }, { compact: true, fsyncDir: true, renameFallback: 'truncate' })
     if (!_periodicAdvertiseInstalled) {
       _periodicAdvertiseInstalled = true
       _periodicAdvertiseTimer = setInterval(() => {
@@ -185,58 +206,12 @@ const LOCK_FILE = path.join(DATA_DIR, '.memory-service.lock')
 // EEXIST when another process won the race.
 const OWNER_LOCK_FILE = path.join(DATA_DIR, '.memory-owner.lock')
 
-function _isPidAliveLocal(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return false
-  try { process.kill(pid, 0); return true }
-  catch (e) { return e.code !== 'ESRCH' }
-}
-
 function tryAcquireMemoryOwnerLock() {
-  // Returns true on success (this process now owns memory worker for the data
-  // dir), false when a live peer holds the lock. Stale locks (dead PID) are
-  // unlinked and retried atomically. Throws on unexpected fs errors so callers
-  // surface lock-system corruption rather than silently downgrading.
-  //
-  // EPERM/EBUSY/EACCES at openSync are transient — AV scanners (SignKorea /
-  // SKCert / ezPDFWS etc) briefly lock newly-created files during inspection.
-  // The 0.1.x baseline threw immediately and the worker promoted to
-  // permanentlyDegraded, killing memory tools for the rest of the session.
-  // Treat the AV error codes as retryable with bounded backoff (~750ms total)
-  // before giving up and rethrowing.
-  for (let attempt = 0; attempt < 5; attempt++) {
-    try {
-      const fd = fs.openSync(OWNER_LOCK_FILE, 'wx')
-      fs.writeSync(fd, String(process.pid))
-      fs.closeSync(fd)
-      return true
-    } catch (e) {
-      if (e.code === 'EEXIST') {
-        let ownerPid = NaN
-        try { ownerPid = Number(fs.readFileSync(OWNER_LOCK_FILE, 'utf8').trim()) } catch {}
-        if (_isPidAliveLocal(ownerPid)) return false
-        // Stale lock: dead owner — unlink and retry exclusive create.
-        try { fs.unlinkSync(OWNER_LOCK_FILE) } catch {}
-        continue
-      }
-      const transient = e.code === 'EPERM' || e.code === 'EBUSY' || e.code === 'EACCES'
-      if (transient && attempt < 4) {
-        // Sync busy-wait acceptable here: this runs on memory worker boot
-        // path, once per process; the parent handler is not blocked.
-        const end = Date.now() + 50 * (attempt + 1)
-        while (Date.now() < end) {}
-        continue
-      }
-      throw e
-    }
-  }
-  return false
+  return _tryAcquireMemoryOwnerLock(OWNER_LOCK_FILE, __mixdogMemoryLog)
 }
 
 function releaseMemoryOwnerLock() {
-  try {
-    const ownerPid = Number(fs.readFileSync(OWNER_LOCK_FILE, 'utf8').trim())
-    if (ownerPid === process.pid) fs.unlinkSync(OWNER_LOCK_FILE)
-  } catch {}
+  return _releaseMemoryOwnerLock(OWNER_LOCK_FILE)
 }
 
 const BASE_PORT = 3350
@@ -247,139 +222,39 @@ let _traceDb = null
 const MEMORY_INSTRUCTIONS_TEXT = ''
 
 function killPreviousServer(pid) {
-  if (pid <= 0 || pid === process.pid) return false
-  if (process.platform === 'win32') {
-    try {
-      execFileSync('taskkill', ['/F', '/T', '/PID', String(pid)], { encoding: 'utf8', timeout: 5000, windowsHide: true })
-      __mixdogMemoryLog(`[memory-service] Killed previous server PID ${pid}\n`)
-      return true
-    } catch (e) {
-      // Exit code 128 = process not found; treat stale lock as already-dead = success.
-      // Status 128 reliably means "process not found" regardless of locale; no text match needed.
-      // Status 1 with English text match handles edge cases on some Windows versions.
-      const notFoundText = /not found|no running instance/i.test(e.stdout || '')
-        || /not found|no running instance/i.test(e.stderr || '')
-        || /not found|no running instance/i.test(e.message || '')
-      const alreadyDead = e.status === 128 || (e.status === 1 && notFoundText)
-      if (alreadyDead) {
-        __mixdogMemoryLog(`[memory-service] PID ${pid} already dead (stale lock), proceeding\n`)
-        return true
-      }
-      __mixdogMemoryLog(`[memory-service] taskkill failed for PID ${pid}: ${e.message}\n`)
-      return false
-    }
-  } else {
-    // Pre-flight: if the process is already gone, treat stale lock as success.
-    try {
-      process.kill(pid, 0)
-    } catch (e) {
-      if (e.code === 'ESRCH') {
-        __mixdogMemoryLog(`[memory-service] PID ${pid} already dead (stale lock), proceeding\n`)
-        return true
-      }
-    }
-    try { process.kill(pid, 'SIGTERM') } catch {}
-    try { process.kill(pid, 'SIGKILL') } catch {}
-    // Poll for death up to 2s
-    const deadline = Date.now() + 2000
-    while (Date.now() < deadline) {
-      try {
-        process.kill(pid, 0)
-      } catch (e) {
-        if (e.code === 'ESRCH') {
-          __mixdogMemoryLog(`[memory-service] Killed previous server PID ${pid}\n`)
-          return true
-        }
-      }
-      // Synchronous 50ms sleep via shared buffer spin
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50)
-    }
-    __mixdogMemoryLog(`[memory-service] PID ${pid} still alive after SIGKILL\n`)
-    return false
-  }
+  return _killPreviousServer(pid, __mixdogMemoryLog)
 }
 
 function acquireLock() {
-  // Multi-instance guard. In multi-terminal mode the lock owner is a *peer*
-  // memory worker serving recall for another CC session. killPreviousServer
-  // would taskkill /F that healthy peer mid-flight, then this fork-proxy
-  // mode wouldn't even need a lock anyway. Skip the entire kill-the-previous
-  // protocol; fork-proxy detection in init() takes priority. If neither
-  // proxy nor lock-owner path applies (race window during simultaneous
-  // boot), the worker simply continues without the lock — server-main /
-  // PG / port-listen handle the actual conflict cases.
-  if (process.env.MIXDOG_MULTI_INSTANCE === '1') return
-  try {
-    if (fs.existsSync(LOCK_FILE)) {
-      const lockedPid = Number(fs.readFileSync(LOCK_FILE, 'utf8').trim())
-      if (lockedPid > 0 && lockedPid !== process.pid) {
-        const killed = killPreviousServer(lockedPid)
-        if (!killed) {
-          __mixdogMemoryLog(`[memory-service] Could not kill previous server PID ${lockedPid}, aborting\n`)
-          process.exit(1)
-        }
-        try { fs.unlinkSync(LOCK_FILE) } catch {}
-      }
-    }
-    const fd = fs.openSync(LOCK_FILE, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600)
-    try {
-      fs.writeSync(fd, String(process.pid))
-    } finally {
-      fs.closeSync(fd)
-    }
-  } catch (e) {
-    if (e.code === 'EEXIST') {
-      __mixdogMemoryLog(`[memory-service] Lock file exists (EEXIST) — another instance is already running, exiting\n`)
-      process.exit(0)
-    }
-    __mixdogMemoryLog(`[memory-service] Lock acquisition failed: ${e.message}\n`)
-    process.exit(1)
-  }
+  return _acquireLock(LOCK_FILE, __mixdogMemoryLog)
 }
 
 function releaseLock() {
-  try {
-    const content = fs.readFileSync(LOCK_FILE, 'utf8').trim()
-    if (Number(content) === process.pid) fs.unlinkSync(LOCK_FILE)
-  } catch {}
-}
-
-import { readSection } from '../shared/config.mjs'
-
-function readMainConfig() {
-  return readSection('memory')
+  return _releaseLock(LOCK_FILE)
 }
 
 let db = null
 let mainConfig = null
-let _cycleInterval = null
-let _startupTimeout = null
-// Outer-layer cycle1 in-flight tracker (MCP-server scope).
-//
-// The AUTHORITATIVE guard lives in memory-cycle.mjs:runCycle1 itself — that
-// one catches every caller, including direct imports (setup-server backfill,
-// policy-layer backfill). This outer tracker is kept as a defense-in-depth
-// layer local to the MCP server process: it coalesces simultaneous
-// _awaitCycle1Run callers (MCP action, scheduler, flush) onto a shared
-// promise so they all observe the SAME result object rather than some
-// getting the real stats and others getting `skippedInFlight: true` from
-// the inner guard.
-let _cycle1InFlight = null // shared cycle1 promise (outer coalesce layer)
-// Per-session recall-drain in-flight map. Multiple terminals share one
-// memory daemon (active-instance.json memory_port); concurrent recall calls
-// for the SAME session must share one drain promise (dedup), while DIFFERENT
-// sessions drain in parallel (cycle1's own advisory-lock/coalesce guard in
-// memory-cycle1.mjs still serializes the actual DB work). A drain never
-// blocks recall for sessions other than its own.
-const _recallDrainInFlight = new Map() // sessionId -> Promise
+// NOTE: cycle tick timers + the cycle1 outer-coalesce in-flight tracker now
+// live inside the cycle scheduler factory (lib/cycle-scheduler.mjs). The
+// AUTHORITATIVE cycle1 guard is still memory-cycle.mjs:runCycle1; the
+// scheduler's outer layer coalesces simultaneous awaitCycle1Run callers.
 let _initialized = false
 let _initPromise = null
 let _stopPromise = null
 let _bootTimestamp = null
-let _transcriptOffsets = new Map()
-/** @type {Map<string, Promise<unknown>>} */
-const _ingestTranscriptTails = new Map()
-let _transcriptOffsetsPersistTail = Promise.resolve()
+// Post-ingest raw-embedding flush chain (facade-local). The checkCycles tick
+// keeps its OWN independent guard inside the scheduler; this chain serializes
+// flushes kicked from ingestSessionMessages so ingest bursts never stack
+// embedding work, while still guaranteeing every ingest's rows get their own
+// flush pass (the old boolean guard silently SKIPPED bursts, leaving rows
+// embedding-less until the ~60s tick — a recall (no results) window).
+let _rawEmbedFlushChain = Promise.resolve()
+// Ingest now WAITS for its embedding flush (bounded) so freshly ingested rows
+// are dense-searchable the moment ingest_session returns. On a cold ONNX
+// model the flush can stall on warmup; the race below caps the wait and lets
+// the flush finish in the background (tick fallback still sweeps stragglers).
+const INGEST_EMBED_WAIT_MS = 15_000
 // Boot-edge background warmup. ONNX session creation on the embedding worker
 // thread is CPU-heavy, so it must not overlap the worker's own init (DB open,
 // schema, cycle wiring). Previously this was gated behind a fixed setTimeout —
@@ -387,83 +262,47 @@ let _transcriptOffsetsPersistTail = Promise.resolve()
 // _initStore and fired at the _initRuntime completion edge (see _initRuntime),
 // so it starts the instant boot's CPU-heavy work is done — no magic-number
 // delay. MIXDOG_EMBED_WARMUP=0 disables it (model loads lazily on first use).
-let _pendingEmbeddingWarmup = null
-let _embeddingColdRecallLogAt = 0
 
 const TRANSCRIPT_OFFSETS_KEY = 'state.transcript_offsets'
 const CYCLE_LAST_RUN_KEY = 'state.cycle_last_run'
 
-function embeddingWarmupEnabled() {
-  const raw = String(process.env.MIXDOG_EMBED_WARMUP ?? '1').trim().toLowerCase()
-  return !(raw === '0' || raw === 'false' || raw === 'off' || raw === 'no')
-}
-
-function envFlagEnabled(name) {
-  const raw = String(process.env[name] ?? '').trim().toLowerCase()
-  return raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes'
-}
-
-function memorySecondaryMode() {
-  return envFlagEnabled('MIXDOG_MEMORY_SECONDARY')
-}
-
-function embeddingWarmupCanStart() {
-  return embeddingWarmupEnabled() && !memorySecondaryMode()
-}
-
-function memoryLlmWorkerEnabled() {
-  return !memorySecondaryMode() && !envFlagEnabled('MIXDOG_MEMORY_DISABLE_LLM_WORKER')
-}
-
-function memoryCyclesEnabled() {
-  return !memorySecondaryMode() && !envFlagEnabled('MIXDOG_MEMORY_DISABLE_CYCLES')
-}
+// Transcript ingest cluster (extracted to lib/transcript-ingest.mjs). Live
+// db/config coupling is injected so index.mjs keeps lifecycle ownership.
+const _transcriptIngest = createTranscriptIngest({
+  getDb: () => db,
+  loadMeta: () => getMetaValue(db, TRANSCRIPT_OFFSETS_KEY, '{}'),
+  persistMeta: (json) => setMetaValue(db, TRANSCRIPT_OFFSETS_KEY, json),
+  projectsRoot: () => path.join(mixdogHome(), 'projects'),
+  resolveProjectId,
+  firstTextContent,
+  cleanMemoryText,
+  log: __mixdogMemoryLog,
+})
+const {
+  loadTranscriptOffsets,
+  ingestTranscriptFile,
+  cwdFromTranscriptPath,
+  parseTsToMs,
+} = _transcriptIngest
+
+// Boot-edge embedding warmup queue (extracted to lib/embedding-warmup.mjs).
+const _embeddingWarmup = createEmbeddingWarmup({
+  canStart: embeddingWarmupCanStart,
+  warmup: warmupEmbeddingProvider,
+  getDims: getEmbeddingDims,
+  persistMeta: (metaPath, value) => writeJsonAtomicSync(metaPath, value, { lock: true }),
+  log: __mixdogMemoryLog,
+})
 
+// DATA_DIR-bound wrappers over the extracted pure flag helpers (see
+// ./lib/memory-config-flags.mjs). The pg-attach check needs DATA_DIR, which is
+// module-local here.
 function secondaryPgAdvertised() {
-  if (!memorySecondaryMode()) return true
-  const runtimeRoot = process.env.MIXDOG_RUNTIME_ROOT
-    ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
-    : path.join(os.tmpdir(), 'mixdog')
-  try {
-    const cur = JSON.parse(fs.readFileSync(path.join(runtimeRoot, 'active-instance.json'), 'utf8'))
-    const port = Number(cur?.pg_port)
-    const pgdata = cur?.pg_pgdata ? path.resolve(String(cur.pg_pgdata)) : ''
-    return Number.isInteger(port) && port > 0 && pgdata === path.resolve(path.join(DATA_DIR, 'pgdata'))
-  } catch {
-    return false
-  }
+  return _secondaryPgAdvertised(DATA_DIR)
 }
 
 function assertSecondaryPgAttachable() {
-  if (!secondaryPgAdvertised()) {
-    throw new Error('memory-service: secondary mode requires an existing primary PG instance')
-  }
-}
-
-function scheduleBackgroundEmbeddingWarmup(metaPath, metaKey) {
-  if (!embeddingWarmupCanStart()) return
-  // Queue the warmup; _initRuntime fires it once boot completes.
-  _pendingEmbeddingWarmup = () => {
-    warmupEmbeddingProvider()
-      .then(() => {
-        const measured = Number(getEmbeddingDims())
-        try {
-          writeJsonAtomicSync(metaPath, { ...metaKey, dims: measured }, { lock: true })
-        } catch (e) {
-          __mixdogMemoryLog(`[memory-service] could not persist embedding-meta: ${e?.message || e}\n`)
-        }
-      })
-      .catch(err => {
-        __mixdogMemoryLog(`[memory-service] background warmup failed: ${err?.message || err}\n`)
-      })
-  }
-}
-
-function fireDeferredEmbeddingWarmup() {
-  const fire = _pendingEmbeddingWarmup
-  if (!fire) return
-  _pendingEmbeddingWarmup = null
-  fire()
+  return _assertSecondaryPgAttachable(DATA_DIR)
 }
 
 async function _initStore() {
@@ -509,7 +348,7 @@ async function _initStore() {
     primeEmbeddingDims(dimsResolved)
     assertSecondaryPgAttachable()
     db = await openDatabase(DATA_DIR, dimsResolved)
-    scheduleBackgroundEmbeddingWarmup(EMBEDDING_META_PATH, metaKey)
+    _embeddingWarmup.schedule(EMBEDDING_META_PATH, metaKey)
   } else {
     if (!embeddingWarmupCanStart()) {
       throw new Error('memory-service: embedding dims unavailable while warmup is disabled')
@@ -547,7 +386,14 @@ async function _initStore() {
   // MIXDOG_MEMORY_DISABLE_LLM_WORKER=1 + cycles enabled hits an empty registry
   // and fails with "Provider not found". Non-fatal: a failure here is logged
   // and cycle1's own callLlm surfaces the unresolved-provider error per call.
-  if (memoryCyclesEnabled() || memoryLlmWorkerEnabled()) {
+  // Registry must be available whenever cycles COULD run in this process, not
+  // just when they are currently enabled: recap can be toggled on at runtime
+  // (memoryCyclesEnabled() now includes the recap flag), so gate registry init
+  // on the cycle-capable conditions (not secondary, env not hard-disabled) OR
+  // the llm worker gate — never on the runtime recap flag itself, or enabling
+  // recap later would hit an empty registry and fail with "Provider not found".
+  const cyclesCapable = !memorySecondaryMode() && !envFlagEnabled('MIXDOG_MEMORY_DISABLE_CYCLES')
+  if (cyclesCapable || memoryLlmWorkerEnabled()) {
     try {
       const agentCfg = loadAgentConfig()
       await initProviders(agentCfg.providers || {})
@@ -559,29 +405,6 @@ async function _initStore() {
   await loadTranscriptOffsets()
 }
 
-async function loadTranscriptOffsets() {
-  try {
-    const raw = await getMetaValue(db, TRANSCRIPT_OFFSETS_KEY, '{}')
-    const obj = JSON.parse(raw)
-    _transcriptOffsets = new Map(Object.entries(obj))
-  } catch {
-    _transcriptOffsets = new Map()
-  }
-}
-
-async function persistTranscriptOffsets() {
-  const run = _transcriptOffsetsPersistTail.catch(() => {}).then(async () => {
-    try {
-      const obj = Object.fromEntries(_transcriptOffsets)
-      await setMetaValue(db, TRANSCRIPT_OFFSETS_KEY, JSON.stringify(obj))
-    } catch (e) {
-      __mixdogMemoryLog(`[memory] persist transcript offsets failed: ${e.message}\n`)
-    }
-  })
-  _transcriptOffsetsPersistTail = run.catch(() => {})
-  return run
-}
-
 async function getCycleLastRun() {
   try {
     const raw = await getMetaValue(db, CYCLE_LAST_RUN_KEY, '{}')
@@ -616,146 +439,6 @@ async function setCycleLastRun(kind, ts) {
   await mergeMetaValue(db, CYCLE_LAST_RUN_KEY, { [kind]: ts })
 }
 
-// Raw-row priority lookup for narrow-window queries. Raw rows (is_root=0,
-// chunk_root IS NULL) are inserted immediately by ingestTranscriptFile before
-// cycle1 runs, so they always carry the freshest turns in the DB.
-async function readRawRowsInWindow(db, tsFromMs, tsToMs, hardLimit = 10, { projectScope, sessionId } = {}) {
-  try {
-    // Composable WHERE assembly (mirrors retrieveEntries' filter semantics so
-    // raw and chunked legs stay in filter parity: projectScope AND sessionId
-    // apply identically to both pools).
-    const where = ['chunk_root IS NULL', 'is_root = 0', 'ts >= $1', 'ts <= $2']
-    const params = [tsFromMs ?? 0, tsToMs ?? Date.now()]
-    if (projectScope === 'common') {
-      where.push('project_id IS NULL')
-    } else if (projectScope && projectScope !== 'all') {
-      params.push(projectScope)
-      where.push(`(project_id IS NULL OR project_id = $${params.length})`)
-    }
-    const sid = String(sessionId || '').trim()
-    if (sid) {
-      params.push(sid)
-      where.push(`session_id = $${params.length}`)
-    }
-    params.push(hardLimit)
-    const sql = `SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
-              element, category, summary, status, score, last_seen_at, project_id
-       FROM entries
-       WHERE ${where.join(' AND ')}
-       ORDER BY ts DESC
-       LIMIT $${params.length}`
-    const rows = (await db.query(sql, params)).rows
-    return rows.map(r => ({ ...r, retrievalScore: 0, rrf: 0 }))
-  } catch { return [] }
-}
-
-async function recallSessionRows(args = {}) {
-  const sessionId = String(args.sessionId || args.session_id || '').trim()
-  if (!sessionId) return { text: '(no current session)' }
-  const limit = Math.max(1, Math.min(100, Number(args.limit) || 20))
-  const terms = sessionRecallTerms(args.query)
-  const params = [sessionId]
-  // Roots + not-yet-chunked leaves only. Once cycle1 turns raw leaves into
-  // (root, members) pairs, selecting every row unfiltered emitted the root's
-  // summary AND its own member rows in the same browse — duplicate content.
-  // A committed member (is_root=0 with a chunk_root) is always reachable via
-  // its root's `members` expansion below, so it never needs to be selected
-  // directly here.
-  const where = ['session_id = $1', '(is_root = 1 OR chunk_root IS NULL OR chunk_root = id)']
-  // Current-turn cutoff: the newest unchunked row is very often the calling
-  // turn's OWN recall request/tool-args, still being written when this query
-  // runs. Exclude it from a bare (no-query) browse so the in-flight turn
-  // doesn't self-echo; a query browse (explicit search intent) keeps it.
-  // Only treat the newest unchunked turn as "in-flight" when its latest row
-  // is fresh (within FRESHNESS_MS of now) — an older newest-unchunked-turn
-  // is completed history (cycle1 just hasn't gotten to it, or drain timed
-  // out) and must stay visible, not be silently hidden every browse.
-  const IN_FLIGHT_TURN_FRESHNESS_MS = 5 * 60 * 1000
-  let excludeSourceTurnId = null
-  if (terms.length === 0) {
-    try {
-      const r = await db.query(
-        `SELECT source_turn t, MAX(ts) last_ts FROM entries
-         WHERE session_id = $1 AND chunk_root IS NULL
-         GROUP BY source_turn ORDER BY source_turn DESC LIMIT 1`,
-        [sessionId],
-      )
-      const t = r.rows?.[0]?.t
-      const lastTs = Number(r.rows?.[0]?.last_ts)
-      if (t != null && Number.isFinite(lastTs) && (Date.now() - lastTs) <= IN_FLIGHT_TURN_FRESHNESS_MS) {
-        excludeSourceTurnId = Number(t)
-      }
-    } catch {}
-  }
-  if (Number.isFinite(excludeSourceTurnId)) {
-    params.push(excludeSourceTurnId)
-    where.push(`NOT (chunk_root IS NULL AND source_turn = $${params.length})`)
-  }
-  if (terms.length > 0) {
-    const textExpr = `lower(coalesce(content, '') || ' ' || coalesce(element, '') || ' ' || coalesce(summary, ''))`
-    const clauses = terms.map((term) => {
-      params.push(`%${term}%`)
-      return `${textExpr} LIKE $${params.length}`
-    })
-    where.push(`(${clauses.join(' OR ')})`)
-  }
-  params.push(limit)
-  let rows = (await db.query(`
-    SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
-           element, category, summary, status, score, last_seen_at, project_id
-    FROM entries
-    WHERE ${where.join(' AND ')}
-    ORDER BY ts DESC, id DESC
-    LIMIT $${params.length}
-  `, params)).rows
-  if (rows.length < limit) {
-    const seen = new Set(rows.map((row) => Number(row.id)).filter((id) => Number.isFinite(id)))
-    const fillLimit = Math.max(0, limit - rows.length)
-    const fillWhere = ['session_id = $1', 'id <> ALL($2::bigint[])', '(is_root = 1 OR chunk_root IS NULL OR chunk_root = id)']
-    const fillParams = [sessionId, [...seen]]
-    if (Number.isFinite(excludeSourceTurnId)) {
-      fillParams.push(excludeSourceTurnId)
-      fillWhere.push(`NOT (chunk_root IS NULL AND source_turn = $${fillParams.length})`)
-    }
-    fillParams.push(fillLimit)
-    const fillRows = fillLimit > 0
-      ? (await db.query(`
-          SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
-                 element, category, summary, status, score, last_seen_at, project_id
-          FROM entries
-          WHERE ${fillWhere.join(' AND ')}
-          ORDER BY ts DESC, id DESC
-          LIMIT $${fillParams.length}
-        `, fillParams)).rows
-      : []
-    if (fillRows.length > 0) rows = [...rows, ...fillRows]
-  }
-  if (args.includeMembers === true) {
-    const rootIds = rows
-      .filter((row) => Number(row.is_root) === 1)
-      .map((row) => Number(row.id))
-      .filter((id) => Number.isFinite(id))
-    if (rootIds.length > 0) {
-      const members = (await db.query(`
-        SELECT id, ts, role, content, session_id, source_turn, project_id, chunk_root
-        FROM entries
-        WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
-        ORDER BY chunk_root ASC, COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-      `, [rootIds])).rows
-      const byRoot = new Map(rootIds.map((id) => [id, []]))
-      for (const member of members) {
-        const root = Number(member.chunk_root)
-        if (byRoot.has(root)) byRoot.get(root).push(member)
-      }
-      for (const row of rows) {
-        const id = Number(row.id)
-        if (byRoot.has(id)) row.members = byRoot.get(id)
-      }
-    }
-  }
-  return { text: renderEntryLines(rows) }
-}
-
 async function ingestSessionMessages(args = {}) {
   const sessionId = String(args.sessionId || args.session_id || `session-${Date.now()}`).trim()
   const messages = Array.isArray(args.messages) ? args.messages : []
@@ -828,886 +511,85 @@ async function ingestSessionMessages(args = {}) {
       turnAllocator.next()
     }
   }
-  return { text: `ingest_session: considered=${considered} inserted=${inserted} session=${sessionId}` }
-}
-
-function runTranscriptIngestSerialized(transcriptPath, fn) {
-  const key = path.resolve(transcriptPath)
-  const prev = _ingestTranscriptTails.get(key) ?? Promise.resolve()
-  const run = prev.catch(() => {}).then(fn)
-  _ingestTranscriptTails.set(key, run.catch(() => {}))
-  return run
-}
-
-function snapshotTranscriptOffset(transcriptPath) {
-  const stored = _transcriptOffsets.get(transcriptPath)
-  if (!stored) return { bytes: 0, lineIndex: 0 }
-  return { bytes: Number(stored.bytes) || 0, lineIndex: Number(stored.lineIndex) || 0 }
-}
-
-async function ingestTranscriptFileImpl(transcriptPath, { cwd } = {}) {
-  let stat
-  try { stat = await fs.promises.stat(transcriptPath) } catch { return 0 }
-  const sessionUuid = path.basename(transcriptPath, '.jsonl')
-  const prev = snapshotTranscriptOffset(transcriptPath)
-  if (stat.size < prev.bytes) {
-    prev.bytes = 0
-    prev.lineIndex = 0
-  }
-  if (stat.size <= prev.bytes) return 0
-
-  const fh = await fs.promises.open(transcriptPath, 'r')
-  const buf = Buffer.alloc(stat.size - prev.bytes)
-  try {
-    await fh.read(buf, 0, buf.length, prev.bytes)
-  } finally {
-    await fh.close()
-  }
-  const text = buf.toString('utf8')
-
-  const resolvedCwd = typeof cwd === 'string' && cwd ? cwd : cwdFromTranscriptPath(transcriptPath)
-  // No cwd resolved -> classify as COMMON (project_id NULL). Falling back to
-  // process.cwd() would misclassify rows under the service/plugin cwd.
-  const projectId = resolvedCwd ? resolveProjectId(resolvedCwd) : null
-
-  let count = 0
-  let index = prev.lineIndex
-  // Track the byte boundary of the LAST line we fully consumed (parsed +
-  // either inserted or intentionally skipped). On parse failure or
-  // transient insert error we stop and leave the boundary untouched so the
-  // next sweep retries from the same position. This prevents malformed
-  // trailing JSONL (mid-write partial lines) and DB hiccups from being
-  // silently consumed forever.
-  let lastGoodBytes = prev.bytes
-  let lastGoodLineIndex = prev.lineIndex
-  let cursor = 0
-  while (cursor < text.length) {
-    const nl = text.indexOf('\n', cursor)
-    // No trailing newline -> partial line still being written; stop here
-    // without advancing so the rest is re-read once the writer flushes.
-    if (nl === -1) break
-    const rawLine = text.slice(cursor, nl)
-    const consumedBytes = Buffer.byteLength(rawLine, 'utf8') + 1
-    cursor = nl + 1
-    const line = rawLine.replace(/\r$/, '')
-    if (!line) {
-      lastGoodBytes += consumedBytes
-      continue
-    }
-    index += 1
-    let parsed
-    try { parsed = JSON.parse(line) } catch {
-      // Malformed line: do not advance past it; retry on next sweep.
-      index -= 1
-      break
-    }
-    const role = parsed.message?.role
-    if (role !== 'user' && role !== 'assistant') {
-      lastGoodBytes += consumedBytes
-      lastGoodLineIndex = index
-      continue
-    }
-    const content = firstTextContent(parsed.message?.content)
-    if (!content || !content.trim()) {
-      lastGoodBytes += consumedBytes
-      lastGoodLineIndex = index
-      continue
-    }
-    const cleaned = cleanMemoryText(content)
-    if (!cleaned) {
-      lastGoodBytes += consumedBytes
-      lastGoodLineIndex = index
-      continue
-    }
-    const tsMs = parseTsToMs(parsed.timestamp ?? parsed.ts ?? Date.now())
-    const sourceRef = `transcript:${sessionUuid}#${index}`
-    try {
-      const result = await db.query(
-        `INSERT INTO entries(ts, role, content, source_ref, session_id, source_turn, project_id)
-         VALUES ($1, $2, $3, $4, $5, $6, $7)
-         ON CONFLICT DO NOTHING`,
-        [tsMs, role, cleaned, sourceRef, sessionUuid, index, projectId]
-      )
-      if (Number(result.rowCount ?? result.affectedRows ?? 0) > 0) count += 1
-      lastGoodBytes += consumedBytes
-      lastGoodLineIndex = index
-    } catch (e) {
-      __mixdogMemoryLog(`[transcript-watch] insert error (${sourceRef}): ${e.message}\n`)
-      // Transient insert failure: leave the boundary before this line so
-      // the next sweep retries it. Roll back the line counter too.
-      index -= 1
-      break
-    }
-  }
-  _transcriptOffsets.set(transcriptPath, {
-    bytes: lastGoodBytes,
-    lineIndex: lastGoodLineIndex,
-  })
-  await persistTranscriptOffsets()
-  return count
-}
-
-async function ingestTranscriptFile(transcriptPath, options = {}) {
-  return runTranscriptIngestSerialized(transcriptPath, () => ingestTranscriptFileImpl(transcriptPath, options))
-}
-
-function parseTsToMs(value) {
-  if (typeof value === 'number' && Number.isFinite(value)) return value < 1e12 ? value * 1000 : value
-  const parsed = Date.parse(String(value))
-  return Number.isFinite(parsed) ? parsed : Date.now()
-}
-
-// Extract cwd from the transcript file's JSONL rows. Mixdog embeds
-// the session cwd as a top-level `cwd` field on every message row, so
-// scanning the first few lines is reliable on all platforms (Windows/Linux)
-// without slug-decoding ambiguity. Returns undefined when no cwd is found
-// or the extracted path does not exist on disk (falls back to COMMON).
-function cwdFromTranscriptPath(fp) {
-  let fd
-  try {
-    fd = fs.openSync(fp, 'r')
-    const buf = Buffer.alloc(Math.min(fs.fstatSync(fd).size, 100 * 1024))
-    fs.readSync(fd, buf, 0, buf.length, 0)
-    fs.closeSync(fd)
-    fd = undefined
-    const lines = buf.toString('utf8').split('\n')
-    for (let i = 0; i < Math.min(lines.length, 5); i++) {
-      const line = lines[i].trim()
-      if (!line) continue
-      try {
-        const obj = JSON.parse(line)
-        if (typeof obj.cwd === 'string' && obj.cwd) {
-          const candidate = obj.cwd
-          try { if (fs.statSync(candidate).isDirectory()) return candidate } catch {}
-        }
-      } catch {}
-    }
-  } catch {} finally {
-    if (fd != null) { try { fs.closeSync(fd) } catch {} }
-  }
-  return undefined
-}
-
-function _initTranscriptWatcher() {
-  const projectsRoot = path.join(mixdogHome(), 'projects')
-  const SAFETY_POLL_MS = 5 * 60_000
-  const DEBOUNCE_MS = 500
-  const watchedFiles = new Map()
-  const pendingByFile = new Map()
-  const watchers = []
-  const intervals = []
-  const polledFiles = new Set()
-  let safetySweepTimeout = null
-
-  function isWatchable(relOrBase) {
-    const base = path.basename(relOrBase)
-    if (!base.endsWith('.jsonl') || base.startsWith('agent-')) return false
-    if (relOrBase.includes('tmp') || relOrBase.includes('cache') || relOrBase.includes('plugins')) return false
-    return true
-  }
-
-  async function ingestOne(fp) {
-    try {
-      if (!fs.existsSync(fp)) return
-      const stat = fs.statSync(fp)
-      const mtime = stat.mtimeMs
-      const prev = watchedFiles.get(fp)
-      if (prev && prev >= mtime) return
-      const n = await ingestTranscriptFile(fp, { cwd: cwdFromTranscriptPath(fp) })
-      // Only mark this mtime as 'consumed' once the persisted offset has
-      // fully advanced past the observed file size. On a transient insert
-      // error (or a malformed trailing line) ingestTranscriptFile leaves
-      // the persisted offset before the failed line for retry; caching
-      // the new mtime unconditionally would suppress the next sweep until
-      // the file mutated again, losing the retry. Leave the cache
-      // untouched on partial advance so the next sweep re-ingests.
-      const off = _transcriptOffsets.get(fp)
-      if (off && off.bytes >= stat.size) {
-        watchedFiles.set(fp, mtime)
-      }
-      if (n > 0) {
-        __mixdogMemoryLog(`[transcript-watch] ingested ${n} entries from ${path.basename(fp)}\n`)
-      }
-    } catch (e) {
-      __mixdogMemoryLog(`[transcript-watch] ingest error: ${e.message}\n`)
-    }
-  }
-
-  function scheduleIngest(fp) {
-    const existing = pendingByFile.get(fp)
-    if (existing) clearTimeout(existing)
-    const timer = setTimeout(() => {
-      pendingByFile.delete(fp)
-      ingestOne(fp)
-    }, DEBOUNCE_MS)
-    pendingByFile.set(fp, timer)
-  }
-
-  async function discoverActiveTranscripts() {
-    let topLevel
-    try { topLevel = await fs.promises.readdir(projectsRoot) }
-    catch { return [] }
-    const files = []
-    for (const d of topLevel) {
-      if (d.includes('tmp') || d.includes('cache') || d.includes('plugins')) continue
-      const full = path.join(projectsRoot, d)
-      let inner
-      try { inner = await fs.promises.readdir(full) } catch { continue }
-      for (const f of inner) {
-        if (!f.endsWith('.jsonl') || f.startsWith('agent-')) continue
-        const fp = path.join(full, f)
-        try {
-          const stat = await fs.promises.stat(fp)
-          files.push({ path: fp, mtime: stat.mtimeMs })
-        } catch {}
-      }
-    }
-    const cutoff = Date.now() - 30 * 60_000
-    return files.filter(f => f.mtime > cutoff)
-  }
-
-  async function safetySweep() {
-    try {
-      const active = await discoverActiveTranscripts()
-      for (const { path: fp } of active) ingestOne(fp)
-    } catch (e) {
-      __mixdogMemoryLog(`[transcript-watch] safety sweep error: ${e.message}\n`)
-    }
-  }
-
-  safetySweepTimeout = setTimeout(safetySweep, 3_000)
-
-  // fs.watch({recursive}) is only reliable on win32.
-  // darwin: recursive option unreliable — use flat watch per-entry (glob dirs at start).
-  // linux/WSL: recursive not supported — use fs.watchFile polling per file found via
-  //   the safety sweep, or fall back entirely to safety sweep.
-  if (process.platform === 'win32') {
-    try {
-      const watcher = fs.watch(projectsRoot, { recursive: true, persistent: true }, (_event, filename) => {
-        if (!filename) return
-        if (!isWatchable(filename)) return
-        const fp = path.join(projectsRoot, filename)
-        scheduleIngest(fp)
-      })
-      watcher.on('error', (err) => {
-        __mixdogMemoryLog(`[transcript-watch] fs.watch error: ${err.message}\n`)
+  // Always-on post-ingest raw embedding: freshly ingested rows become
+  // dense-searchable immediately (autoclear/recall-fasttrack hydration,
+  // recall empty-fallback), without waiting for cycle1 chunking or the
+  // ~60s background tick. Local ONNX only — no LLM cost, so it runs
+  // regardless of the recap toggle. SYNCHRONOUS (bounded): ingest_session
+  // resolves only after this session's rows are embedded, so an immediately
+  // following recall sees them in the dense leg. Bursts serialize on
+  // _rawEmbedFlushChain instead of being skipped; a 15s cap keeps a cold
+  // ONNX warmup from wedging ingest (tick fallback sweeps what's left).
+  if (inserted > 0) {
+    const run = _rawEmbedFlushChain
+      .catch(() => {}) // never let a previous flush failure poison the chain
+      .then(() => flushRawEmbeddings(db, { limit: 200 }))
+      .then((r) => {
+        if (r.attempted > 0) __mixdogMemoryLog(`[embed] post-ingest raw flush attempted=${r.attempted} embedded=${r.embedded}\n`)
+        return r
       })
-      watchers.push(watcher)
-      __mixdogMemoryLog(`[transcript-watch] fs.watch(recursive) active on ${projectsRoot}\n`)
-    } catch (e) {
-      __mixdogMemoryLog(`[transcript-watch] fs.watch setup failed: ${e.message} — relying on safety sweep only\n`)
-    }
-    intervals.push(setInterval(safetySweep, SAFETY_POLL_MS))
-  } else if (process.platform === 'darwin') {
-    // Flat watch: register a non-recursive watcher on each immediate subdirectory.
-    // New subdirs are picked up on the next safety sweep cycle.
-    try {
-      const registerFlat = (dir) => {
-        try {
-          const w = fs.watch(dir, { persistent: true }, (_event, filename) => {
-            if (!filename) return
-            const fp = path.join(dir, filename)
-            if (!isWatchable(fp)) return
-            scheduleIngest(fp)
-          })
-          w.on('error', () => { /* ignore individual dir errors */ })
-          watchers.push(w)
-        } catch { /* dir may not exist yet */ }
-      }
-      registerFlat(projectsRoot)
-      try {
-        for (const entry of fs.readdirSync(projectsRoot, { withFileTypes: true })) {
-          if (entry.isDirectory()) registerFlat(path.join(projectsRoot, entry.name))
-        }
-      } catch { /* best effort */ }
-      __mixdogMemoryLog(`[transcript-watch] flat fs.watch active on ${projectsRoot} (darwin)\n`)
-    } catch (e) {
-      __mixdogMemoryLog(`[transcript-watch] flat watch setup failed: ${e.message} — relying on safety sweep only\n`)
-    }
-    intervals.push(setInterval(safetySweep, SAFETY_POLL_MS))
-  } else {
-    // linux/WSL: fs.watch recursive is unsupported. Use fs.watchFile polling for
-    // individual files surfaced by the safety sweep, in addition to the sweep itself.
-    __mixdogMemoryLog(`[transcript-watch] linux/WSL — using safety sweep + fs.watchFile polling (no recursive watch)\n`)
-    // Wrap by reassigning the closure-captured reference is not possible here;
-    // instead, register watchFile inside the safety sweep callback by intercepting
-    // active file list after each sweep.  The interval already calls safetySweep
-    // which calls ingestOne; watchFile additions happen as a side-effect of the sweep.
-    const _patchedSweep = async () => {
-      try {
-        const active = await discoverActiveTranscripts()
-        for (const { path: fp } of active) {
-          if (!polledFiles.has(fp)) {
-            polledFiles.add(fp)
-            fs.watchFile(fp, { persistent: false, interval: 2000 }, () => {
-              if (isWatchable(fp)) scheduleIngest(fp)
-            })
-          }
-          ingestOne(fp)
-        }
-      } catch (e) {
-        __mixdogMemoryLog(`[transcript-watch] linux sweep error: ${e.message}\n`)
-      }
-    }
-    // Replace the safety sweep interval with the patched version.
-    intervals.push(setInterval(_patchedSweep, SAFETY_POLL_MS))
-  }
-
-  return {
-    stop() {
-      if (safetySweepTimeout) { clearTimeout(safetySweepTimeout); safetySweepTimeout = null }
-      for (const t of pendingByFile.values()) { try { clearTimeout(t) } catch {} }
-      pendingByFile.clear()
-      for (const i of intervals) { try { clearInterval(i) } catch {} }
-      intervals.length = 0
-      for (const w of watchers) { try { w.close() } catch {} }
-      watchers.length = 0
-      for (const fp of polledFiles) { try { fs.unwatchFile(fp) } catch {} }
-      polledFiles.clear()
-    },
-  }
-}
-
-// Phase B §2.4 — cache-keeper health thresholds.
-// warning fires when cycle1 is overdue past HEALTH_OVERDUE_MS; an auto-
-// restart attempt fires when the warning has been emitted AND the most
-// recent unscheduled restart was more than AUTO_RESTART_COOLDOWN_MS ago.
-// Both default to 5 min per spec; caller overrides are not exposed yet.
-const CYCLE1_HEALTH_OVERDUE_MS = 5 * 60_000
-const CYCLE1_AUTO_RESTART_COOLDOWN_MS = 5 * 60_000
-
-// In-process cycle1 LLM adapter. The memory daemon runs makeAgentDispatch()
-// locally (provider registry is initialized in _initStore), so cycle1 never
-// has to route over the dead IPC agent path (agent-ipc.mjs callAgentDispatch). The
-// factory is built once (role/taskType are fixed) and the returned function
-// is reshaped to cycle1's call signature: cycle1 invokes
-// `callLlm({ role, taskType, mode, preset, timeout, cwd }, userMessage)` and
-// expects a raw string, while makeAgentDispatch's function takes a single
-// `{ prompt }` object. The adapter maps the two — preset/cwd resolution is
-// handled inside makeAgentDispatch via role (cycle1-agent → maint.memory slot).
-let _cycle1AgentDispatch = null
-function getCycle1CallLlm() {
-  if (!_cycle1AgentDispatch) {
-    _cycle1AgentDispatch = makeAgentDispatch({
-      agent: 'cycle1-agent',
-      taskType: 'maintenance',
-      sourceType: 'memory-cycle',
-      // cycle1 parses the full raw line-format response; the agent brief cap
-      // (12KB) would truncate a large valid response and append prose, causing
-      // partial parsing / omitted / invalid chunks. Opt out so the cycle1
-      // no-truncation contract is preserved through makeAgentDispatch.
-      brief: false,
-    })
-  }
-  return async (opts = {}, userMessage) => {
-    // Preserve cycle1's timeout contract: cycle1 derives `opts.timeout` from
-    // config / caller deadline and expects it to bound the call. makeAgentDispatch
-    // takes it as a per-call `idleTimeoutMs` (stale watchdog). Map it through;
-    // omit when absent/0 so agent defaults apply.
-    const callTimeout = Number(opts?.timeout)
-    return _cycle1AgentDispatch({
-      prompt: String(userMessage ?? ''),
-      preset: opts?.preset || undefined,
-      ...(Number.isFinite(callTimeout) && callTimeout > 0 ? { idleTimeoutMs: callTimeout } : {}),
-    })
-  }
-}
-
-let _cycle2AgentDispatch = null
-function getCycle2CallLlm() {
-  if (!_cycle2AgentDispatch) {
-    _cycle2AgentDispatch = makeAgentDispatch({
-      agent: 'cycle2-agent',
-      taskType: 'maintenance',
-      sourceType: 'memory-cycle',
-      brief: false,
-    })
-  }
-  return async (opts = {}, userMessage) => {
-    const callTimeout = Number(opts?.timeout)
-    return _cycle2AgentDispatch({
-      prompt: String(userMessage ?? ''),
-      preset: opts?.preset || undefined,
-      ...(Number.isFinite(callTimeout) && callTimeout > 0 ? { idleTimeoutMs: callTimeout } : {}),
-    })
-  }
-}
-
-let _cycle3AgentDispatch = null
-function getCycle3CallLlm() {
-  if (!_cycle3AgentDispatch) {
-    _cycle3AgentDispatch = makeAgentDispatch({
-      agent: 'cycle3-agent',
-      taskType: 'maintenance',
-      sourceType: 'memory-cycle',
-      brief: false,
-    })
+      .catch((err) => __mixdogMemoryLog(`[embed] post-ingest raw flush failed: ${err?.message || err}\n`))
+    _rawEmbedFlushChain = run
+    let timer
+    await Promise.race([
+      run,
+      new Promise((resolve) => { timer = setTimeout(resolve, INGEST_EMBED_WAIT_MS) }),
+    ]).finally(() => clearTimeout(timer))
   }
-  return async (opts = {}, userMessage) => {
-    const callTimeout = Number(opts?.timeout)
-    return _cycle3AgentDispatch({
-      prompt: String(userMessage ?? ''),
-      preset: opts?.preset || undefined,
-      ...(Number.isFinite(callTimeout) && callTimeout > 0 ? { idleTimeoutMs: callTimeout } : {}),
-    })
-  }
-}
-
-async function recordCycle1Result(result) {
-  const now = Date.now()
-  await setCycleLastRun('cycle1_heartbeat', now)
-  const skipped = result?.skippedInFlight === true
-  const coalescedNoop = result?.coalescedRetryNoop === true
-  const allFailed = !skipped
-    && Number(result?.chunks ?? 0) === 0
-    && Number(result?.processed ?? 0) === 0
-    && Number(result?.skipped ?? 0) > 0
-  if (!skipped && !coalescedNoop && !allFailed) {
-    await setCycleLastRun('cycle1', now)
-  }
-  if (!skipped && !coalescedNoop) markCycleDone('cycle1', !allFailed, allFailed ? 'all rows skipped' : null)
+  return { text: `ingest_session: considered=${considered} inserted=${inserted} session=${sessionId}` }
 }
 
-// ── Cycle health state (no new commands; consumed by /health + statusline) ──
-// In-memory per-cycle run ledger + a small state file the TUI statusline can
-// read without HTTP. "Silently stalled cycles" (2026-07: cycle2 poison
-// rotation sat unnoticed for months) become visible three ways: /health
-// fields, a WARN log with cooldown, and the L2 "Memory" segment.
+// ── Cycle scheduling cluster (extracted to lib/cycle-scheduler.mjs) ────────
+// The mutually-referential cycle machinery (health ledger, cycle1 outer
+// coalesce layer, scheduled enqueue/retry paths, checkCycles, tick loop) lives
+// in the factory below. index.mjs keeps lifecycle ownership by injecting live
+// getters (getDb/getConfig/setConfig) plus runners and LLM adapters.
 const CYCLE_STATE_FILE = path.join(DATA_DIR, 'memory-cycle-state.json')
-const _cycleHealth = {
-  cycle1: { last_success_at: 0, last_error_at: 0, last_error: null, consecutive_failures: 0 },
-  cycle2: { last_success_at: 0, last_error_at: 0, last_error: null, consecutive_failures: 0 },
-  cycle3: { last_success_at: 0, last_error_at: 0, last_error: null, consecutive_failures: 0 },
-}
-let _cycleRunning = null // { cycle, started_at }
-let _cycleBacklogSnapshot = { unchunked: 0, cycle2_pending: 0, at: 0 }
-let _lastBacklogWarnAt = 0
-const BACKLOG_WARN_COOLDOWN_MS = 10 * 60_000
-const BACKLOG_WARN_PENDING = 500
-const BACKLOG_WARN_FAILURES = 5
-
-function _writeCycleStateFile() {
-  try {
-    fs.writeFileSync(CYCLE_STATE_FILE, JSON.stringify({
-      running: _cycleRunning,
-      backlog: _cycleBacklogSnapshot,
-      cycles: _cycleHealth,
-      updatedAt: Date.now(),
-    }))
-  } catch { /* best-effort; statusline just shows nothing */ }
-}
-
-function markCycleRunning(cycle) {
-  _cycleRunning = { cycle, started_at: Date.now() }
-  _writeCycleStateFile()
-}
-
-function markCycleDone(cycle, ok, err = null) {
-  const h = _cycleHealth[cycle]
-  if (h) {
-    const now = Date.now()
-    if (ok) { h.last_success_at = now; h.consecutive_failures = 0; h.last_error = null }
-    else { h.last_error_at = now; h.consecutive_failures += 1; h.last_error = String(err || 'unknown').slice(0, 200) }
-    if (!ok && h.consecutive_failures >= BACKLOG_WARN_FAILURES) {
-      _warnCycleHealth(`${cycle} failing repeatedly (consecutive=${h.consecutive_failures}, last="${h.last_error}")`)
-    }
-  }
-  if (_cycleRunning?.cycle === cycle) _cycleRunning = null
-  _writeCycleStateFile()
-}
-
-function _warnCycleHealth(msg) {
-  const now = Date.now()
-  if (now - _lastBacklogWarnAt < BACKLOG_WARN_COOLDOWN_MS) return
-  _lastBacklogWarnAt = now
-  __mixdogMemoryLog(`[cycle-health] WARN ${msg}\n`)
-}
-
-function _startCycle1Run(config = {}, options = {}) {
-  // Default to the in-process agent dispatch so every cycle1 path — scheduled,
-  // auto-restart, periodic, manual (action:cycle1), backfill drain, rebuild —
-  // dispatches locally and the dead IPC fallback in memory-cycle1.mjs is never
-  // reached. Explicit options.callLlm (if a caller ever passes one) wins.
-  if (typeof options?.callLlm !== 'function') {
-    options = { ...options, callLlm: getCycle1CallLlm() }
-  }
-  markCycleRunning('cycle1')
-  _cycle1InFlight = (async () => {
-    try {
-      const result = await runCycle1(db, config, options, DATA_DIR)
-      // #13: heartbeat (attempt) is always recorded so the overdue check
-      // can tell the keeper is alive; success timestamp only advances when
-      // the run actually did work. Skipped/in-flight runs do NOT count as
-      // success because the next overdue check would otherwise see a fake
-      // green and stop forcing auto-restarts.
-      if (typeof options?.onCoalescedSuccess !== 'function') {
-        await recordCycle1Result(result)
-      }
-      return result
-    } catch (err) {
-      markCycleDone('cycle1', false, err?.message || err)
-      throw err
-    } finally {
-      if (_cycleRunning?.cycle === 'cycle1') { _cycleRunning = null; _writeCycleStateFile() }
-      if (_cycle1InFlight === promise) _cycle1InFlight = null
-    }
-  })()
-  const promise = _cycle1InFlight
-  return _cycle1InFlight
-}
-
-async function _awaitCycle1Run(config = {}, options = {}) {
-  const target = _cycle1InFlight || _startCycle1Run(config, options)
-  const callerDeadlineMs = Number(options.callerDeadlineMs) || 0
-  if (callerDeadlineMs <= 0) return await target
-  // Caller-deadline race. When the channels-side timeout fires, we
-  // (a) graceful-return a skippedInFlight envelope so the calling
-  // SessionStart slot stops blocking with a 200 OK + flags instead of a
-  // 503-class throw, and (b) release the outer in-flight handle. The
-  // underlying LLM run keeps progressing in the background — it still
-  // owns the inner dedup guard (memory-cycle.mjs _runCycle1InFlight).
-  // Releasing the outer handle is what breaks the cascade: any later
-  // _awaitCycle1Run call now re-enters _startCycle1Run, whose inner
-  // runCycle1 short-circuits with skippedInFlight:true the moment it
-  // sees the same db still busy. Returning a graceful object (vs the
-  // pre-0.1.198 throw) keeps the channel route response shape stable
-  // and lets pollers read inFlight=true rather than parse an error.
-  let timer
-  const deadlinePromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      // Do NOT clear _cycle1InFlight here — the underlying runCycle1 is still
-      // running in the background and owns that slot; its own `finally`
-      // (_startCycle1Run above) clears it when the real work settles. Clearing
-      // it early made a later unbounded drain (deadlineMs:0, e.g. the query
-      // recall path) re-enter _startCycle1Run and spawn a SECOND concurrent
-      // cycle1 run instead of awaiting the one already in flight, defeating
-      // drain-to-zero silently. The caller here just stops WAITING at the
-      // deadline; state ownership stays with the promise itself.
-      resolve({
-        processed: 0,
-        chunks: 0,
-        skipped: 0,
-        sessions: 0,
-        skippedInFlight: true,
-        timedOutWaiting: true,
-        callerDeadlineMs,
-      })
-    }, callerDeadlineMs)
-  })
-  try {
-    return await Promise.race([target, deadlinePromise])
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-// Periodic cycle1 sizing: only enter when ≥ 20 pending rows have built up,
-// then process up to 2 sessions × 50 rows per tick. cycle1 itself keeps each
-// classifier window session-isolated. The on-demand path used by SessionStart
-// hooks runs with a 1-row threshold and 5×20 windows instead — see
-// hooks/session-start.cjs ON_DEMAND_CYCLE1_ARGS.
-// mainConfig.cycle1 values still win, so users can override any of these in
-// config.json.
-function periodicCycle1Config() {
-  return {
-    min_batch: 20,
-    session_cap: 2,
-    batch_size: 50,
-    concurrency: 2,
-    ...(mainConfig?.cycle1 || {}),
-  }
-}
-
-async function enqueueScheduledCycle(kind, intervalMs, signature) {
-  const claim = await claimAndMarkScheduledCycle(db, kind, intervalMs, signature, { reason: 'scheduled' })
-  return claim.claimed === true
-}
 
-async function enqueueScheduledCycle1(intervalMs, _reason = 'scheduled') {
-  const config = periodicCycle1Config()
-  const signature = scheduledCycle1Signature(config)
-  if (await enqueueScheduledCycle('cycle1', intervalMs, signature)) {
-    scheduleScheduledCycle1(config, signature)
-  }
-}
-
-async function enqueueScheduledCycle2(intervalMs, _reason = 'scheduled') {
-  const config = mainConfig?.cycle2 || {}
-  const signature = scheduledCycle2Signature(config)
-  if (await enqueueScheduledCycle('cycle2', intervalMs, signature)) {
-    scheduleScheduledCycle2(config, signature)
-  }
-}
-
-async function enqueueScheduledCycle3(intervalMs, _reason = 'scheduled') {
-  const config = mainConfig || {}
-  const signature = scheduledCycle3Signature(config)
-  if (await enqueueScheduledCycle('cycle3', intervalMs, signature)) {
-    scheduleScheduledCycle3(config, signature)
-  }
-}
-
-function scheduleScheduledCycle1(config, signature, attempt = 0) {
-  const maxRetries = resolveCoalesceMaxRetries(config, 3)
-  if (attempt > maxRetries) {
-    __mixdogMemoryLog('[cycle1] scheduled queue retry cap reached\n')
-    return
-  }
-  scheduleCoalescedCycleRetry(db, 'cycle1', async () => {
-    if (_cycle1InFlight) {
-      scheduleScheduledCycle1(config, signature, attempt + 1)
-      return
-    }
-    const result = await _awaitCycle1Run(config, {
-      coalescedRetry: true,
-      onCoalescedSuccess: recordCycle1Result,
-    })
-    if (result?.skippedInFlight) scheduleScheduledCycle1(config, signature, attempt + 1)
-  }, config, signature)
-}
-
-function scheduleScheduledCycle2(config, signature, attempt = 0) {
-  const maxRetries = resolveCoalesceMaxRetries(config, 3)
-  if (attempt > maxRetries) {
-    __mixdogMemoryLog('[cycle2] scheduled queue retry cap reached\n')
-    return
-  }
-  scheduleCoalescedCycleRetry(db, 'cycle2', async () => {
-    if (_cycle2InFlight) {
-      scheduleScheduledCycle2(config, signature, attempt + 1)
-      return
-    }
-    _cycle2InFlight = true
-    markCycleRunning('cycle2')
-    try {
-      let c2Options = {
-        coalescedRetry: true,
-        onCoalescedSuccess: _finalizeCycle2Run,
-      }
-      if (typeof c2Options?.callLlm !== 'function') {
-        c2Options = { ...c2Options, callLlm: getCycle2CallLlm() }
-      }
-      const result = await runCycle2(db, config, c2Options, DATA_DIR)
-      if (result?.skippedInFlight) {
-        scheduleScheduledCycle2(config, signature, attempt + 1)
-      } else if (result?.coalescedRetryNoop) {
-        __mixdogMemoryLog('[cycle2] scheduled queue noop\n')
-      } else if (result?.ok === false) {
-        await _finalizeCycle2Run(result)
-      }
-    } catch (err) {
-      __mixdogMemoryLog(`[cycle2] scheduled queue failed: ${err?.message || err}\n`)
-      markCycleDone('cycle2', false, err?.message || err)
-    } finally {
-      _cycle2InFlight = false
-      if (_cycleRunning?.cycle === 'cycle2') { _cycleRunning = null; _writeCycleStateFile() }
-    }
-  }, config, signature)
-}
-
-function scheduleScheduledCycle3(config, signature, attempt = 0) {
-  const retryConfig = config?.cycle3 || config
-  const maxRetries = resolveCoalesceMaxRetries(retryConfig, 3)
-  if (attempt > maxRetries) {
-    __mixdogMemoryLog('[cycle3] scheduled queue retry cap reached\n')
-    return
-  }
-  scheduleCoalescedCycleRetry(db, 'cycle3', async () => {
-    if (_cycle3InFlight) {
-      scheduleScheduledCycle3(config, signature, attempt + 1)
-      return
-    }
-    _cycle3InFlight = true
-    markCycleRunning('cycle3')
-    try {
-      let c3Options = {
-        coalescedRetry: true,
-        onCoalescedSuccess: async () => { await setCycleLastRun('cycle3', Date.now()); markCycleDone('cycle3', true) },
-      }
-      if (typeof c3Options?.callLlm !== 'function') {
-        c3Options = { ...c3Options, callLlm: getCycle3CallLlm() }
-      }
-      const result = await runCycle3(db, config, DATA_DIR, c3Options)
-      if (result?.skippedInFlight) {
-        scheduleScheduledCycle3(config, signature, attempt + 1)
-      } else if (result?.coalescedRetryNoop) {
-        __mixdogMemoryLog('[cycle3] scheduled queue noop\n')
-      }
-    } catch (err) {
-      __mixdogMemoryLog(`[cycle3] scheduled queue failed: ${err?.message || err}\n`)
-      markCycleDone('cycle3', false, err?.message || err)
-    } finally {
-      _cycle3InFlight = false
-      if (_cycleRunning?.cycle === 'cycle3') { _cycleRunning = null; _writeCycleStateFile() }
-    }
-  }, retryConfig, signature)
-}
-
-async function _finalizeCycle2Run(result) {
-  if (result?.skippedInFlight) {
-    __mixdogMemoryLog('[cycle2] skipped: in flight\n')
-    return
-  }
-  if (result.ok) {
-    await setCycleLastRun('cycle2', Date.now())
-    await setCycleLastRun('cycle2_last_error', '')
-    __mixdogMemoryLog('[cycle2] completed\n')
-    markCycleDone('cycle2', true)
-  } else {
-    await setCycleLastRun('cycle2_last_error', result.error || 'unknown error')
-    __mixdogMemoryLog(`[cycle2] failed: ${result.error}\n`)
-    markCycleDone('cycle2', false, result.error || 'unknown error')
-  }
-}
-
-async function checkCycles() {
-  // Poll-on-use: re-read memory config each tick so changed enabled/interval
-  // values apply without a restart (mirrors search/cwd poll-on-use). The fixed
-  // 60s poll bounds latency; manual `memory` tool calls already re-read per-call.
-  mainConfig = readMainConfig();
-  if (mainConfig?.enabled === false) return
-
-  const cycle1Ms = parseInterval(mainConfig?.cycle1?.interval || '10m')
-  const cycle2Ms = parseInterval(mainConfig?.cycle2?.interval || '1h')
-  const cycle3Ms = parseInterval(mainConfig?.cycle3?.interval || '24h')
-
-  const now = Date.now()
-  const last = await getCycleLastRun()
-
-  // Phase B §2.4 — cache-keeper health check + auto-restart.
-  //
-  // `last.cycle1 + cycle1Ms` is the next scheduled run time; anything beyond
-  // that by > HEALTH_OVERDUE_MS means the keeper missed its window and the
-  // Anthropic shard is drifting cold. Emit a warning, and — if we haven't
-  // retried in the last cooldown window — force an unscheduled run so the
-  // shard gets re-touched before the next Worker / Sub call pays the 2×
-  // write premium. Cooldown prevents a tight retry loop when the underlying
-  // cause (network, provider outage) is still broken.
-  //
-  // Cold-start guard: a fresh DB has last.cycle1 = 0, which would make
-  // (now - 0 - cycle1Ms) blow past HEALTH_OVERDUE_MS on every first boot
-  // and force-trigger the auto-restart branch even though the shard never
-  // existed in the first place. The "drifting cold" concept doesn't apply
-  // until at least one successful run has anchored a baseline.
-  const cycle1OverdueMs = last.cycle1 > 0
-    ? Math.max(0, now - last.cycle1 - cycle1Ms)
-    : 0
-  if (cycle1OverdueMs > CYCLE1_HEALTH_OVERDUE_MS) {
-    const lastSeen = last.cycle1 ? new Date(last.cycle1).toISOString() : 'never'
-    __mixdogMemoryLog(
-      `[cycle1] overdue by ${Math.floor(cycle1OverdueMs / 60_000)}min `
-      + `(last=${lastSeen}). Pool B Anthropic shard may be cold.\n`
-    )
-    const lastAutoRestart = last.cycle1_autoRestart || 0
-    if (now - lastAutoRestart >= CYCLE1_AUTO_RESTART_COOLDOWN_MS) {
-      // #14: record the attempt timestamp BEFORE the call (so a hung run
-      // cannot tight-loop) and the result timestamp only on success. On
-      // failure we return immediately instead of falling through into the
-      // due branch — falling through would silently re-enter the same
-      // failing path within the same tick.
-      await setCycleLastRun('cycle1_autoRestart_attempt', now)
-      try {
-        const result = await _awaitCycle1Run(periodicCycle1Config())
-        await setCycleLastRun('cycle1_autoRestart', Date.now())
-        __mixdogMemoryLog(
-          `[cycle1] auto-restart completed chunks=${result?.chunks ?? 0} processed=${result?.processed ?? 0}\n`
-        )
-        return
-      } catch (e) {
-        __mixdogMemoryLog(`[cycle1] auto-restart error: ${e.message}\n`)
-        // Cooldown attempt timestamp is committed; do NOT fall through
-        // to the due branch — next tick will retry after cooldown.
-        return
-      }
-    }
-  }
-
-  if (now - last.cycle1 >= cycle1Ms) {
-    await enqueueScheduledCycle1(cycle1Ms, 'scheduled')
-  }
-
-  if (now - last.cycle2 >= cycle2Ms) {
-    await enqueueScheduledCycle2(cycle2Ms, 'scheduled')
-  }
-
-  if (now - last.cycle3 >= cycle3Ms) {
-    await enqueueScheduledCycle3(cycle3Ms, 'scheduled')
-  }
+const _cycleLlmAdapters = createCycleLlmAdapters({ makeAgentDispatch })
+const { getCycle1CallLlm, getCycle2CallLlm, getCycle3CallLlm } = _cycleLlmAdapters
+
+const _cycleScheduler = createCycleScheduler({
+  getDb: () => db,
+  getConfig: () => mainConfig,
+  setConfig: (cfg) => { mainConfig = cfg },
+  dataDir: DATA_DIR,
+  log: __mixdogMemoryLog,
+  getCycleLastRun,
+  setCycleLastRun,
+  readMainConfig,
+  memoryCyclesEnabled,
+  getCycle1CallLlm,
+  getCycle2CallLlm,
+  getCycle3CallLlm,
+  runCycle1,
+  runCycle2,
+  runCycle3,
+  parseInterval,
+  flushRawEmbeddings,
+  getInFlightCycle1,
+  claimAndMarkScheduledCycle,
+  resolveCoalesceMaxRetries,
+  scheduleCoalescedCycleRetry,
+  scheduledCycle1Signature,
+  scheduledCycle2Signature,
+  scheduledCycle3Signature,
+  cycleStateFile: CYCLE_STATE_FILE,
+})
+// Cycle1 run primitives + cycle2 finalize used by MCP action handlers below.
+const _startCycle1Run = _cycleScheduler.startCycle1Run
+const _awaitCycle1Run = _cycleScheduler.awaitCycle1Run
+const _finalizeCycle2Run = _cycleScheduler.finalizeCycle2Run
 
-  // ── Backlog watch + self-kick (cycle-health) ─────────────────────────────
-  // Cheap counts each tick (60s): surface a WARN when the pipeline is
-  // building a backlog, and if a cycle has not SUCCEEDED for 2h+ while its
-  // backlog is over threshold, kick one unscheduled run now instead of
-  // waiting for the interval — a stalled cycle otherwise hides behind
-  // "the schedule ran it" (attempt != success; see 2026-07 cycle2 stall).
-  try {
-    const unchunked = Number((await db.query(
-      `SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL AND NULLIF(btrim(session_id), '') IS NOT NULL`,
-    )).rows[0]?.c ?? 0)
-    const cycle2Pending = Number((await db.query(
-      `SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'pending'`,
-    )).rows[0]?.c ?? 0)
-    _cycleBacklogSnapshot = { unchunked, cycle2_pending: cycle2Pending, at: now }
-    _writeCycleStateFile()
-    if (unchunked > BACKLOG_WARN_PENDING || cycle2Pending > BACKLOG_WARN_PENDING) {
-      _warnCycleHealth(`backlog unchunked=${unchunked} cycle2_pending=${cycle2Pending}`)
-    }
-    const SELF_KICK_STALE_MS = 2 * 3600_000
-    const c1Stale = (_cycleHealth.cycle1.last_success_at || last.cycle1 || 0) < now - SELF_KICK_STALE_MS
-    const c2Stale = (_cycleHealth.cycle2.last_success_at || last.cycle2 || 0) < now - SELF_KICK_STALE_MS
-    if (c1Stale && unchunked > BACKLOG_WARN_PENDING) {
-      _warnCycleHealth(`cycle1 self-kick: no success 2h+, unchunked=${unchunked}`)
-      await enqueueScheduledCycle1(0, 'self-kick')
-    } else if (c2Stale && cycle2Pending > BACKLOG_WARN_PENDING) {
-      _warnCycleHealth(`cycle2 self-kick: no success 2h+, pending=${cycle2Pending}`)
-      await enqueueScheduledCycle2(0, 'self-kick')
-    }
-  } catch { /* counts are best-effort; never fail the tick */ }
-}
-let _cycle2InFlight = false
-let _cycle3InFlight = false
-
-// #12: self-rescheduling timer. setInterval would fire ticks regardless of
-// whether the previous checkCycles() call had finished; with cycle1/cycle2
-// each potentially taking minutes, that races. Use setTimeout that re-arms
-// itself only after the prior tick resolves, plus an in-flight guard so a
-// stray manual call cannot stack ticks.
-let _checkCyclesInFlight = false
-async function _runCheckCyclesGuarded() {
-  if (_checkCyclesInFlight) return
-  _checkCyclesInFlight = true
-  try { await checkCycles() }
-  catch (e) { __mixdogMemoryLog(`[cycle-tick] error: ${e.message}\n`) }
-  finally { _checkCyclesInFlight = false }
-}
-function _scheduleNextCheck() {
-  _cycleInterval = setTimeout(async () => {
-    _cycleInterval = null
-    try {
-      await _runCheckCyclesGuarded()
-    } catch (e) {
-      __mixdogMemoryLog(`[cycle-tick] re-arm guard caught: ${e?.message || e}\n`)
-    } finally {
-      // Re-arm regardless of inner outcome — _runCheckCyclesGuarded already
-      // swallows its own errors, but defensive try/finally guarantees the
-      // periodic tick continues even if a synchronous throw escapes.
-      if (_cyclesActive) _scheduleNextCheck()
-    }
-  }, 60_000)
-}
-let _cyclesActive = false
+// Transcript watcher lifecycle stays in the facade (owns _transcriptIngest);
+// the cycle tick loop start/stop is delegated to the scheduler.
 let _transcriptWatcher = null
 function _startCycles() {
-  if (_cyclesActive) return
-  _cyclesActive = true
-  _scheduleNextCheck()
-  _startupTimeout = setTimeout(() => { void _runCheckCyclesGuarded() }, 30_000)
+  _cycleScheduler.startCycles()
 }
 
 function _stopCycles() {
-  _cyclesActive = false
-  if (_cycleInterval) { clearTimeout(_cycleInterval); _cycleInterval = null }
-  if (_startupTimeout) { clearTimeout(_startupTimeout); _startupTimeout = null }
+  _cycleScheduler.stopCycles()
   if (_transcriptWatcher) { try { _transcriptWatcher.stop() } catch {} _transcriptWatcher = null }
 }
 
@@ -1718,17 +600,36 @@ async function _initRuntime() {
   // increments, so deleted rows leave permanent gaps. Fast no-op when already
   // contiguous (or empty). Runs only here — never in cycle2/addCore/deleteCore.
   await compactCoreIds(DATA_DIR)
-  if (memoryCyclesEnabled()) {
-    _transcriptWatcher = _initTranscriptWatcher()
+  // Memory module is always-on: the transcript watcher/ingest runs
+  // unconditionally except in secondary mode (secondary attaches to a primary's
+  // PG and must not double-ingest). The recap toggle only gates whether the
+  // background cycles actually schedule work — but we still start the tick loop
+  // so recap can be toggled ON at runtime (checkCycles polls recap each tick and
+  // no-ops while recap is off). The env hard-override / secondary mode skip the
+  // tick loop entirely.
+  if (!memorySecondaryMode()) {
+    _transcriptWatcher = _transcriptIngest.initTranscriptWatcher()
+  } else {
+    __mixdogMemoryLog('[memory-service] secondary mode; skipping transcript watcher\n')
+  }
+  if (!memorySecondaryMode() && !envFlagEnabled('MIXDOG_MEMORY_DISABLE_CYCLES')) {
     _startCycles()
   } else {
-    __mixdogMemoryLog('[memory-service] secondary mode; skipping background cycles\n')
+    __mixdogMemoryLog('[memory-service] background cycle tick loop not started (secondary/env-disabled)\n')
   }
   _initialized = true
   // Boot complete — continue straight into the deferred embedding warmup.
   // Fire-and-forget on the embedding worker thread; never awaited so it does
   // not delay init() returning or the memory-ready signal.
-  fireDeferredEmbeddingWarmup()
+  _embeddingWarmup.fireDeferred()
+  // Boot-edge Korean morph warmup. Same fire-and-forget style: lazy async init
+  // downloads+caches the Kiwi model once under DATA_DIR/kiwi-model/<version>,
+  // then builds the WASM analyzer. On any failure ko-morph stays null and
+  // buildFtsQuery keeps the websearch_to_tsquery fallback (never throws here).
+  // Skipped in secondary mode (query path lives on the primary).
+  if (!memorySecondaryMode()) {
+    initKoMorph(DATA_DIR, __mixdogMemoryLog).catch(() => {})
+  }
 }
 
 function _beginRuntimeInit() {
@@ -1743,661 +644,22 @@ function _beginRuntimeInit() {
   return _initPromise
 }
 
-async function recallCoreRows(query, { projectScope, category, limit } = {}) {
-  const terms = coreRecallTerms(query)
-  if (terms.length === 0) return []
-
-  const params = []
-  const where = []
-  const scope = normalizeRecallProjectScope(projectScope)
-  if (scope === null) {
-    where.push('project_id IS NULL')
-  } else if (scope !== '*') {
-    params.push(scope)
-    where.push(`(project_id IS NULL OR project_id = $${params.length})`)
-  }
-  if (category != null) {
-    const cats = (Array.isArray(category) ? category : [category])
-      .map((value) => String(value || '').trim().toLowerCase())
-      .filter(Boolean)
-    if (cats.length > 0) {
-      const placeholders = cats.map((cat) => {
-        params.push(cat)
-        return `$${params.length}`
-      })
-      where.push(`category IN (${placeholders.join(', ')})`)
-    }
-  }
-
-  const textExpr = `lower(coalesce(element, '') || ' ' || coalesce(summary, ''))`
-  const termClauses = terms.map((term) => {
-    params.push(`%${term}%`)
-    return `${textExpr} LIKE $${params.length}`
-  })
-  where.push(`(${termClauses.join(' OR ')})`)
-  const hitExpr = termClauses.map((clause) => `CASE WHEN ${clause} THEN 1 ELSE 0 END`).join(' + ')
-  const rowLimit = Math.max(1, Math.min(10, Number(limit) || 5))
-  params.push(rowLimit)
-
-  const rows = (await db.query(`
-    SELECT id, element, summary, category, project_id, created_at, updated_at,
-           (${hitExpr}) AS hit_count
-    FROM core_entries
-    WHERE ${where.join(' AND ')}
-    ORDER BY hit_count DESC, updated_at DESC, id ASC
-    LIMIT $${params.length}
-  `, params)).rows
-
-  return rows.map((row) => ({
-    ...row,
-    id: `core:${row.id}`,
-    ts: row.updated_at || row.created_at || Date.now(),
-    is_root: 1,
-  }))
-}
-
-// Session-scoped full drain before a recall(query) search. Chunking is
-// partitioned by session_id (memory-cycle1.mjs:409-431 selected_sessions
-// GROUP BY session_id + ROW_NUMBER PARTITION BY session_id), so this drains
-// ONLY the calling session's backlog via the same session_id override
-// (memory-cycle1.mjs:394) — other sessions' pending rows are left for the
-// periodic cycle1 sweep. Reuses recall-fasttrack's drainSessionCycle1
-// (session/compact.mjs:504) which loops cycle1 until raw rows hit 0 or a
-// no-progress pass. Safety limits: a 500-row hard cap (both in the pending
-// pre-check and as the per-call cycle1 batch ceiling) and cooperative
-// abort-signal propagation through handleMemoryAction — no time budget.
-// Window 20 rows per classifier prompt × concurrency 5 (haiku — cost is
-// negligible; 500 rows ≈ 25 prompts ≈ 5 waves).
-//
-// Multi-terminal safety: the memory daemon is one shared instance across
-// terminals (active-instance.json memory_port). Concurrent recall(query)
-// calls for the SAME session share one in-flight drain promise (dedup);
-// different sessions drain independently in parallel (cycle1's own
-// advisory-lock/coalesce guard in memory-cycle1.mjs still serializes actual
-// DB writes). A drain only gates recall for its OWN session — every other
-// terminal's recall (different session, or no session) proceeds unblocked.
-const RECALL_DRAIN_HARD_CAP_ROWS = 500
-async function _drainSessionForRecallQuery(sessionId, signal, deadlineMs = 0) {
-  if (!sessionId || signal?.aborted) return
-  const existing = _recallDrainInFlight.get(sessionId)
-  if (existing) { try { await existing } catch {} return }
-  let pendingCount = 0
-  try {
-    const r = await db.query(
-      `SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL AND session_id = $1`,
-      [sessionId],
-    )
-    pendingCount = Number(r.rows?.[0]?.c ?? 0)
-  } catch { return }
-  if (pendingCount <= 0) return
-  const runTool = async (_name, toolArgs) => {
-    const result = await handleMemoryAction(toolArgs, signal)
-    return result?.text ?? ''
-  }
-  const dumpArgs = {
-    action: 'dump_session_roots',
-    sessionId,
-    includeRaw: true,
-    limit: Math.min(RECALL_DRAIN_HARD_CAP_ROWS, Math.max(1, pendingCount)),
-  }
-  const drainPromise = (async () => {
-    try {
-      return await drainSessionCycle1(runTool, {
-        sessionId,
-        dumpArgs,
-        deadlineMs, // 0 = no time budget (query path); bare browse passes a
-        // short bound so a browse call never blocks minutes on LLM chunking.
-        maxPasses: 20, // safety stopper; drainSessionCycle1 also self-stops on no-progress
-        cycleArgs: {
-          min_batch: 1,
-          session_cap: 1,
-          batch_size: RECALL_DRAIN_HARD_CAP_ROWS,
-          rows_per_session: RECALL_DRAIN_HARD_CAP_ROWS,
-          window_size: 20,
-          concurrency: 5,
-        },
-      })
-    } catch (err) {
-      __mixdogMemoryLog(`[recall] session drain aborted/failed (sess=${sessionId}): ${err?.message || err}\n`)
-      return null
-    }
-  })()
-  _recallDrainInFlight.set(sessionId, drainPromise)
-  try {
-    await drainPromise
-  } finally {
-    if (_recallDrainInFlight.get(sessionId) === drainPromise) _recallDrainInFlight.delete(sessionId)
-  }
-}
-
-// Bare-browse drain deadline: best-effort only. A browse call ("show me
-// recent context") must never block on LLM chunking for minutes the way a
-// query recall is allowed to — the raw-row merge already covers unchunked
-// content, so the drain here is a nice-to-have upgrade to chunked/scored
-// rows, not a correctness requirement. Failures/timeouts are silently
-// tolerated; the raw fallback in the caller applies regardless.
-const RECALL_BROWSE_DRAIN_DEADLINE_MS = 1800
-
-async function handleSearch(args, signal) {
-  // Cooperative abort check: throw early if the caller already aborted
-  // (IPC cancel handler signals the AbortController before re-entry).
-  if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-  // Drain this session's unchunked backlog to zero BEFORE searching, so a
-  // recall never returns raw/unclassified transcript tail instead of the
-  // chunked summary. Runs whenever a session is scoped, query or not — a
-  // bare "show recent" browse hits raw unchunked rows just as often as a
-  // query recall does. Query path keeps the unbounded (deadlineMs:0) drain
-  // since chunked accuracy matters more than latency there; bare browse
-  // gets a short best-effort deadline — it must never block on LLM
-  // chunking for minutes, the raw-row merge covers the fallback either way.
-  {
-    const _drainSessionId = String(args?.sessionId || args?.session_id || '').trim()
-    const _drainHasQuery = Array.isArray(args?.query)
-      ? args.query.some((v) => String(v || '').trim())
-      : String(args?.query ?? '').trim() !== ''
-    if (_drainSessionId) {
-      await _drainSessionForRecallQuery(
-        _drainSessionId,
-        signal,
-        _drainHasQuery ? 0 : RECALL_BROWSE_DRAIN_DEADLINE_MS,
-      )
-    }
-  }
-  // #id lookup normalization: search_memories and memory action:'search'
-  // callers pass a single `id` (or an id array under that same key), not
-  // the `ids` array below. Normalize once here so every dispatch path gets
-  // exact-id lookup, not just callers who already knew to use `ids`.
-  if (!Array.isArray(args.ids) && args.id != null) {
-    args = { ...args, ids: Array.isArray(args.id) ? args.id : [args.id] }
-  }
-  if (args?.currentSession === true || args?.sessionId || args?.session_id) {
-    return await recallSessionRows(args)
-  }
-  // id mode (follow-up lookup): caller passed `#N` markers from a prior
-  // recall result. Fetch those rows directly + their chunk members,
-  // bypassing hybrid search entirely. Output reuses renderEntryLines so
-  // the shape stays identical to the search path (chunk members first,
-  // root summary fallback).
-  if (Array.isArray(args.ids) && args.ids.length > 0) {
-    const ids = args.ids
-      .map(v => Number(v))
-      .filter(v => Number.isInteger(v) && v > 0)
-    if (ids.length === 0) return { text: '(no valid ids)' }
-    const includeArchived = args.includeArchived !== false
-    const category = args.category
-    const period = String(args.period ?? '').trim() || undefined
-    const temporal = parsePeriod(period, false)
-    let projectScope
-    if (typeof args.projectScope === 'string' && args.projectScope) {
-      projectScope = args.projectScope
-    } else {
-      const projectId = resolveProjectScope(typeof args.cwd === 'string' && args.cwd ? args.cwd : null)
-      projectScope = projectId !== null ? projectId : 'common'
-    }
-    const excludeStatuses = includeArchived ? [] : ['archived']
-    const rows = await fetchEntriesByIdsScoped(db, ids, {
-      ts_from: temporal?.startMs,
-      ts_to: temporal?.endMs,
-      excludeStatuses,
-      category,
-      projectScope,
-    })
-    if (rows.length === 0) return { text: '(no results)' }
-    // Members for any root rows in the result set.
-    const rootIds = rows.filter(r => r.is_root === 1).map(r => Number(r.id))
-    const memberLeafIds = new Set()
-    if (rootIds.length > 0) {
-      const { rows: memberRows } = await db.query(
-        `SELECT id, ts, role, content, chunk_root
-         FROM entries WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
-         ORDER BY ts ASC, id ASC`,
-        [rootIds],
-      )
-      const membersByRoot = new Map()
-      for (const m of memberRows) {
-        const k = Number(m.chunk_root)
-        if (!membersByRoot.has(k)) membersByRoot.set(k, [])
-        membersByRoot.get(k).push(m)
-        memberLeafIds.add(Number(m.id))
-      }
-      for (const r of rows) {
-        if (r.is_root === 1) r.members = membersByRoot.get(Number(r.id)) ?? []
-      }
-    }
-    // Preserve caller-supplied id order; drop leaves already inlined as a
-    // root's chunk member to prevent double emission when the caller names
-    // a root and one of its leaves in the same batch.
-    const byId = new Map(rows.map(r => [Number(r.id), r]))
-    const ordered = ids
-      .map(id => byId.get(id))
-      .filter(Boolean)
-      .filter(r => !(r.is_root === 0 && memberLeafIds.has(Number(r.id))))
-    return { text: renderEntryLines(ordered) }
-  }
-  // Array query — fan out in parallel, each query runs its own hybrid search
-  // path, and results are grouped in the response so the caller sees one
-  // ranked list per angle. Collapses what would otherwise be N sequential
-  // tool calls into a single invocation.
-  if (Array.isArray(args.query)) {
-    // Dedup + fan-out cap. The cap protects the result envelope from
-    // over-eager callers (20+ near-duplicate queries N× the IO) without
-    // silently swallowing the caller's intent: when the input exceeds
-    // QUERIES_CAP, prepend a one-line note so the caller can see the
-    // truncation and re-shape their query list.
-    const QUERIES_CAP = 5
-    const dedup = [...new Set(args.query.map(q => String(q || '').trim()).filter(Boolean))]
-    if (dedup.length === 0) return { text: '' }
-    const queries = dedup.slice(0, QUERIES_CAP)
-    const dropped = dedup.length - queries.length
-    const rest = { ...args }
-    delete rest.query
-    const deadlineSec = Math.max(1, Number(process.env.MEMORY_FANOUT_DEADLINE_S) || 180)
-    const deadlineMs = deadlineSec * 1000
-    const fanOutAbort = new AbortController()
-    let deadlineTimer
-    const deadlineRace = new Promise((_res, rej) => {
-      deadlineTimer = setTimeout(() => {
-        fanOutAbort.abort(new Error(`memory fan-out deadline exceeded (${deadlineSec}s)`))
-        rej(Object.assign(new Error(`memory fan-out deadline exceeded (${deadlineSec}s)`), { _deadline: true }))
-      }, deadlineMs)
-    })
-    let settled
-    try {
-      // Pre-warm only when the embedding model is already resident. If the
-      // process is still cold, keep recall responsive and let the background
-      // warmup finish independently instead of making the first query pay the
-      // ONNX session-create cost.
-      if (isEmbeddingModelReady()) {
-        // Race against the same deadline as the fan-out itself: a stuck
-        // embedding worker would previously park here indefinitely because
-        // the timer hadn't been started yet from the fan-out's perspective.
-        await Promise.race([embedTexts(queries), deadlineRace])
-      } else if (embeddingWarmupCanStart()) {
-        void warmupEmbeddingProvider().catch((err) => {
-          __mixdogMemoryLog(`[memory-service] embedding warmup after cold fan-out skipped dense search: ${err?.message || err}\n`)
-        })
-      }
-      settled = await Promise.race([
-        Promise.all(queries.map(async (q) => {
-          if (fanOutAbort.signal.aborted) throw fanOutAbort.signal.reason
-          if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-          const sub = await handleSearch({ ...rest, query: q }, signal)
-          return `[${q}]\n${sub.text || '(no results)'}`
-        })),
-        deadlineRace,
-      ])
-    } finally {
-      clearTimeout(deadlineTimer)
-    }
-    const parts = settled
-    const header = dropped > 0
-      ? `note: ${dedup.length} queries received, ${queries.length} processed, ${dropped} dropped (cap ${QUERIES_CAP})\n\n`
-      : ''
-    return { text: header + parts.join('\n\n') }
-  }
-  const query = String(args.query ?? '').trim()
-  let period = String(args.period ?? '').trim() || undefined
-  // Period and sort are caller-supplied only. Lead is responsible for
-  // mapping vague time phrases / chronological intent into the period
-  // argument before calling; the engine does not infer them from query
-  // text.
-  const RECALL_LIMIT_CAP = 100
-  const RECALL_OFFSET_CAP = 500
-  const requestedLimit = Number(args.limit)
-  const requestedOffset = Number(args.offset)
-  let limit = Math.max(1, Number.isFinite(requestedLimit) ? requestedLimit : 10)
-  let offset = Math.max(0, Number.isFinite(requestedOffset) ? requestedOffset : 0)
-  const recallCapNotes = []
-  if (Number.isFinite(requestedLimit) && requestedLimit > RECALL_LIMIT_CAP) {
-    limit = RECALL_LIMIT_CAP
-    recallCapNotes.push(`limit capped to ${RECALL_LIMIT_CAP} (requested ${requestedLimit})`)
-  } else {
-    limit = Math.min(RECALL_LIMIT_CAP, limit)
-  }
-  if (Number.isFinite(requestedOffset) && requestedOffset > RECALL_OFFSET_CAP) {
-    offset = RECALL_OFFSET_CAP
-    recallCapNotes.push(`offset capped to ${RECALL_OFFSET_CAP} (requested ${requestedOffset})`)
-  } else {
-    offset = Math.min(RECALL_OFFSET_CAP, offset)
-  }
-  const recallCapPrefix = recallCapNotes.length ? `${recallCapNotes.join('; ')}\n` : ''
-  // Recent-browsing default: a query-less recall is a "show me the latest
-  // messages" browse, not a relevance search — chronological order is the
-  // only ordering that makes sense there, so sort defaults to 'date' when
-  // no query is present (explicit args.sort still wins). Query recalls keep
-  // the importance default.
-  const hasQueryForSort = Array.isArray(args.query)
-    ? args.query.some((v) => String(v || '').trim())
-    : String(args.query ?? '').trim() !== ''
-  const sort = args.sort != null ? String(args.sort) : (hasQueryForSort ? 'importance' : 'date')
-  // Chunk content is the primary recall output. Members default to true so
-  // callers receive the raw chunk leaves (the cycle1-produced semantic
-  // chunks) rather than just the root's cycle2-compressed summary line.
-  // Explicit `includeMembers:false` keeps the legacy summary-only mode.
-  const includeMembers = args.includeMembers !== false
-  const includeRaw = Boolean(args.includeRaw)
-  const includeArchived = args.includeArchived !== false
-  const category = args.category
-  const temporal = parsePeriod(period, Boolean(query))
-
-  // Derive projectScope from caller cwd (falls back to process.cwd()).
-  // Explicit args.projectScope (string) takes priority so callers can
-  // override to 'all', 'common', or a specific slug.
-  let projectScope
-  if (typeof args.projectScope === 'string' && args.projectScope) {
-    projectScope = args.projectScope
-  } else {
-    const projectId = resolveProjectScope(typeof args.cwd === 'string' && args.cwd ? args.cwd : null)
-    projectScope = projectId !== null ? projectId : 'common'
-  }
-
-  // R11 reviewer M4: calendar-bounded periods disable freshness decay
-  // so within-period ranking doesn't downgrade Mon entries vs Sun.
-  const CALENDAR_PERIODS = new Set(['yesterday', 'today', 'this_week', 'last_week'])
-  const isCalendarPeriod = period != null
-    && (CALENDAR_PERIODS.has(period) || /^\d{4}-\d{2}-\d{2}/.test(period))
-  const applyFreshness = !isCalendarPeriod
-
-  if (query) {
-    const _t0 = Date.now()
-    if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-    let queryVector = null
-    if (isEmbeddingModelReady()) {
-      queryVector = await embedText(query)
-    } else {
-      const now = Date.now()
-      if (now - _embeddingColdRecallLogAt > 10_000) {
-        _embeddingColdRecallLogAt = now
-        __mixdogMemoryLog('[recall] embedding model cold; returning lexical results while background warmup continues\n')
-      }
-      if (embeddingWarmupCanStart()) {
-        void warmupEmbeddingProvider().catch((err) => {
-          __mixdogMemoryLog(`[memory-service] embedding warmup after cold recall failed: ${err?.message || err}\n`)
-        })
-      }
-    }
-    if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-    const _t1 = Date.now()
-    if (process.env.MIXDOG_DEBUG_MEMORY) {
-      __mixdogMemoryLog(`[search-time] embed=${_t1 - _t0}ms query="${query.slice(0, 60)}"\n`)
-    }
-    // Push ts and status filters into the hybrid candidate query so FTS / vec
-    // rank inside the requested window, not the whole tree. The previous post-
-    // filter approach silently emptied results when relevant matches sat
-    // outside `period` (default 30d) and could not bubble through.
-    // Recall is history-first: archived roots hold most prior work. Callers
-    // that need only live invariants can pass includeArchived:false.
-    const excludeStatuses = includeArchived ? [] : ['archived']
-    const results = await searchRelevantHybrid(db, query, {
-      limit: limit + offset,
-      queryVector: Array.isArray(queryVector) ? queryVector : null,
-      includeMembers,
-      ts_from: temporal?.startMs,
-      ts_to: temporal?.endMs,
-      applyFreshness,
-      projectScope,
-      category,
-      excludeStatuses,
-      // useHotActive was set to true here so default (no-period) calls
-      // routed through the mv_hot_active materialized view — a narrow
-      // active-roots-only pool. Live usage is dominated by vague-time
-      // queries ("recent / lately") where Lead callers omit the period
-      // filter, leaving the MV as the sole source. That hid every
-      // orphan leaf and every pending root — fresh work from the last 1-60
-      // minutes never surfaced. Now that the entries-table CTE legs run
-      // against broaden HNSW + GIN trgm partial indexes (the
-      // is_root=1 predicate was dropped in the same revision), the
-      // entries path is fast enough (1-2 ms ANN on ~10K rows, O(log N)
-      // through 1M+) to be the single source of truth. The MV is left in
-      // place for now but no longer routed to from search; cycle2 may stop
-      // refreshing it in a follow-up commit once nothing else reads it.
-      useHotActive: false,
-    })
-    let filtered = results
-    if (sort === 'date') {
-      // R11 reviewer L5: NaN guard — entries with null/undefined ts default
-      // to 0 so the comparator stays numeric and stable.
-      filtered.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0))
-    } else {
-      filtered.sort((a, b) => {
-        const sa = (v) => { const n = Number(v); return Number.isFinite(n) ? n : 0 }
-        return (sa(b.retrievalScore ?? b.rrf ?? 0) - sa(a.retrievalScore ?? a.rrf ?? 0))
-          || (sa(b.score ?? 0) - sa(a.score ?? 0))
-          || (sa(b.ts ?? 0) - sa(a.ts ?? 0))
-          || (Number(a.id ?? 0) - Number(b.id ?? 0))
-      })
-    }
-    if (includeRaw) {
-      // Raw rows (chunk_root IS NULL) carry no retrievalScore, so a naive
-      // append-after-hybrid under sort=importance always lands them past
-      // slice(offset, offset+limit) once the hybrid pool exceeds one page —
-      // every page beyond the first silently drops them. Fetch a wider raw
-      // window (bounded like the hybrid candidate pool) and spread the
-      // fetched raw rows evenly across the WHOLE hybrid list before slicing,
-      // so every offset page gets its proportional share instead of only
-      // page 0. Same projectScope/ts window as the hybrid leg — filter
-      // parity (item 3) is deliberate, not accidental.
-      const RAW_FETCH = Math.min(500, Math.max(20, limit + offset))
-      const rawRows = await readRawRowsInWindow(
-        db,
-        temporal?.startMs ?? null,
-        temporal?.endMs ?? Date.now(),
-        RAW_FETCH,
-        { projectScope },
-      )
-      const seenIds = new Set(filtered.map(r => r.id))
-      const newRaw = rawRows.filter(r => !seenIds.has(r.id))
-      if (sort === 'date') {
-        for (const r of newRaw) filtered.push(r)
-        filtered.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0))
-      } else {
-        // sort=importance: interleave raw rows at a fixed stride through the
-        // full (pre-slice) hybrid list instead of appending at the tail, so
-        // offset > 0 pages also draw from the raw pool proportionally.
-        filtered = interleaveRawRows(filtered, newRaw)
-      }
-    }
-    const coreRows = await recallCoreRows(query, { projectScope, category, limit })
-    if (coreRows.length > 0) {
-      filtered = [...coreRows, ...filtered]
-    }
-    const sliced = filtered.slice(offset, offset + limit)
-    const _t2 = Date.now()
-    if (process.env.MIXDOG_DEBUG_MEMORY) {
-      __mixdogMemoryLog(`[search-time] hybrid+sort+raw=${_t2 - _t1}ms rows=${filtered.length} sliced=${sliced.length}\n`)
-    }
-    // Emit a recall trace event so getTraceWithEntries() can correlate
-    // this search with the top-ranked memory entry.  One event per
-    // handleSearch call (not per returned row) — cheapest meaningful link.
-    // parent_span_id left null: the agent-side span id is only known after
-    // the DB insert of the loop/tool events, which happens async on the
-    // client side and is not available here.
-    if (_traceDb && filtered.length > 0) {
-      const topHit = filtered[0]
-      const topId = topHit?.id != null ? Number(topHit.id) : null
-      if (topId !== null && Number.isFinite(topId)) {
-        insertTraceEvents(_traceDb, [{
-          ts: Date.now(),
-          kind: 'recall',
-          entry_id: topId,
-          payload: { query: query.slice(0, 200), hit_count: filtered.length },
-        }]).catch(e => __mixdogMemoryLog(`[trace] insertTraceEvents error: ${e?.message}\n`))
-      }
-    }
-    const out = { text: recallCapPrefix + renderEntryLines(sliced) }
-    if (process.env.MIXDOG_DEBUG_MEMORY) {
-      __mixdogMemoryLog(`[search-time] render+trace=${Date.now() - _t2}ms total=${Date.now() - _t0}ms textLen=${out.text.length}\n`)
-    }
-    return out
-  }
-
-  const filters = { limit: limit + offset }
-  if (temporal?.startMs != null) { filters.ts_from = temporal.startMs; filters.ts_to = temporal.endMs }
-  // period='last' used to hard-cap ts_to at _bootTimestamp-1 unconditionally,
-  // which silently hid the CURRENT session's own content from a query-less
-  // recent browse (the whole point of "what did we just talk about"). Keep
-  // the boot cap only for session-less global browsing, where 'last' means
-  // "the previously completed session" and there's no session-scoped drain
-  // above to have already surfaced the in-flight rows. When a sessionId is
-  // present the drain above already pulled that session's raw backlog to
-  // zero, so the current session's rows are safe (and wanted) to include.
-  const _hasScopedSession = Boolean(String(args?.sessionId || args?.session_id || '').trim())
-  if (temporal?.mode === 'last' && _bootTimestamp && !_hasScopedSession) {
-    filters.ts_to = _bootTimestamp - 1
-  }
-  filters.projectScope = projectScope
-  if (category != null) filters.category = category
-  filters.sort = sort
-  if (!includeArchived) filters.excludeStatuses = ['archived']
-  if (includeMembers) filters.includeMembers = true
-  const rows = await retrieveEntries(db, filters)
-  // Recent-browsing raw merge: a query-less recall must show the freshest
-  // turns even when cycle1 hasn't chunked them yet. Roots lag ingest by up
-  // to a cycle interval, so on sort=date pull the raw (unchunked) window
-  // too and merge chronologically — original text first, no summaries.
-  // Query-less + includeRaw:false callers keep the roots-only view.
-  let merged = rows
-  if (sort === 'date' && args.includeRaw !== false) {
-    const rawRows = await readRawRowsInWindow(
-      db,
-      temporal?.startMs ?? null,
-      temporal?.endMs ?? (filters.ts_to ?? Date.now()),
-      Math.min(500, Math.max(20, limit + offset)),
-      { projectScope },
-    )
-    const seenIds = new Set(rows.map(r => Number(r.id)))
-    // Drop raw leaves already inlined as some returned root's member.
-    for (const r of rows) {
-      if (Array.isArray(r.members)) for (const m of r.members) seenIds.add(Number(m.id))
-    }
-    const newRaw = rawRows.filter(r => !seenIds.has(Number(r.id)))
-    if (newRaw.length > 0) {
-      merged = [...rows, ...newRaw]
-      merged.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
-    }
-  }
-  const sliced = merged.slice(offset, offset + limit)
-  return { text: recallCapPrefix + renderEntryLines(sliced) }
-}
-
-async function dumpSessionRootChunks(args = {}) {
-  const sessionId = String(args.sessionId || args.session_id || '').trim()
-  if (!sessionId) return { text: '(no current session)', rows: [], chunks: [], isError: true }
-  const includeRaw = args.includeRaw !== false
-  const limit = Math.max(1, Math.min(1000, Number(args.limit) || 1000))
-  const rootRows = (await db.query(`
-    SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
-           element, category, summary, status, score, last_seen_at, project_id
-    FROM entries
-    WHERE session_id = $1 AND is_root = 1
-    ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-    LIMIT $2
-  `, [sessionId, limit])).rows
-  const roots = rootRows.map((r) => ({ ...r, members: [] }))
-  const rootIds = roots.map((r) => Number(r.id)).filter((id) => Number.isFinite(id))
-  const memberRows = rootIds.length > 0
-    ? (await db.query(`
-        SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
-        FROM entries
-        WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
-        ORDER BY chunk_root ASC, COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-      `, [rootIds])).rows
-    : []
-  const byRoot = new Map(roots.map((r) => [Number(r.id), r]))
-  for (const m of memberRows) {
-    const root = byRoot.get(Number(m.chunk_root))
-    if (root) root.members.push(m)
-  }
-  let rawRows = []
-  if (includeRaw) {
-    rawRows = (await db.query(`
-      SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
-      FROM entries
-      WHERE session_id = $1
-        AND is_root = 0
-        AND (chunk_root IS NULL OR chunk_root = id)
-      ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-      LIMIT $2
-    `, [sessionId, limit])).rows
-  }
-  const chunks = []
-  for (const root of roots) {
-    const memberText = root.members
-      .map((m) => `${m.role === 'assistant' ? 'assistant' : m.role === 'user' ? 'user' : m.role}: ${cleanMemoryText(String(m.content ?? ''))}`)
-      .filter(Boolean)
-      .join('\n')
-    const summary = [root.element, root.summary].map((v) => String(v || '').trim()).filter(Boolean).join(' — ')
-    chunks.push({
-      id: Number(root.id),
-      kind: 'root',
-      ts: Number(root.ts) || 0,
-      sourceTurn: root.source_turn ?? null,
-      category: root.category || null,
-      summary,
-      text: memberText || cleanMemoryText(String(root.content ?? '')),
-      members: root.members,
-    })
-  }
-  for (const raw of rawRows) {
-    chunks.push({
-      id: Number(raw.id),
-      kind: 'raw',
-      chunkRoot: raw.chunk_root ?? null,
-      ts: Number(raw.ts) || 0,
-      sourceTurn: raw.source_turn ?? null,
-      category: null,
-      summary: '',
-      text: `${raw.role === 'assistant' ? 'assistant' : raw.role === 'user' ? 'user' : raw.role}: ${cleanMemoryText(String(raw.content ?? ''))}`,
-      members: [],
-    })
-  }
-  chunks.sort((a, b) => {
-    const at = Number.isFinite(Number(a.sourceTurn)) ? Number(a.sourceTurn) : 2147483647
-    const bt = Number.isFinite(Number(b.sourceTurn)) ? Number(b.sourceTurn) : 2147483647
-    return (at - bt) || ((a.ts || 0) - (b.ts || 0)) || ((a.id || 0) - (b.id || 0))
-  })
-  const text = chunks.length
-    ? chunks.map((chunk, idx) => {
-        const label = chunk.kind === 'root'
-          ? `# chunk ${idx + 1} root=${chunk.id}${chunk.category ? ` category=${chunk.category}` : ''}`
-          : `${chunk.chunkRoot == null ? '# raw_pending' : '# raw_terminal'} ${idx + 1} id=${chunk.id}`
-        const summary = chunk.summary ? `summary: ${chunk.summary}\n` : ''
-        return `${label}\n${summary}${chunk.text}`.trim()
-      }).join('\n\n')
-    : '(no results)'
-  return { text, rows: [...roots, ...rawRows], chunks }
-}
-
-async function entryStats() {
-  return await db.transaction(async (tx) => {
-    const total               = (await tx.query(`SELECT COUNT(*) c FROM entries`)).rows[0].c
-    const roots               = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1`)).rows[0].c
-    const active_roots        = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active'`)).rows[0].c
-    const archived_roots      = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'archived'`)).rows[0].c
-    const unchunked_leaves    = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL`)).rows[0].c
-    const cycle2_pending_roots = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'pending'`)).rows[0].c
-    const core_entries        = (await tx.query(`SELECT COUNT(*) c FROM core_entries`)).rows[0].c
-    const core_embed_null     = (await tx.query(`SELECT COUNT(*) c FROM core_entries WHERE embedding IS NULL`)).rows[0].c
-    const active_core_summaries = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' AND core_summary IS NOT NULL`)).rows[0].c
-    const active_core_summary_missing = (await tx.query(`
-      SELECT COUNT(*) c
-      FROM entries
-      WHERE is_root = 1
-        AND status = 'active'
-        AND (core_summary IS NULL OR btrim(core_summary) = '')
-    `)).rows[0].c
-    const byStatus            = (await tx.query(`SELECT status, COUNT(*) c FROM entries WHERE is_root = 1 GROUP BY status`)).rows
-    const byCategory          = (await tx.query(`SELECT category, COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' GROUP BY category ORDER BY c DESC`)).rows
-    const mvRows              = (await tx.query(`SELECT relispopulated FROM pg_class WHERE relname = 'mv_hot_active' LIMIT 1`)).rows
-    const mv_hot_active_populated = mvRows.length ? Boolean(mvRows[0].relispopulated) : null
-    return {
-      total, roots, active_roots, archived_roots, unchunked_leaves, cycle2_pending_roots,
-      core_entries, core_embed_null, active_core_summaries, active_core_summary_missing,
-      mv_hot_active_populated,
-      byStatus, byCategory,
-    }
-  })
-}
+const __queryHandlers = createQueryHandlers({
+  getDb: () => db,
+  log: __mixdogMemoryLog,
+  resolveProjectScope,
+  embeddingWarmupCanStart,
+  getBootTimestamp: () => _bootTimestamp,
+  getTraceDb: () => _traceDb,
+})
+const {
+  readRawRowsInWindow,
+  recallSessionRows,
+  recallCoreRows,
+  handleSearch,
+  dumpSessionRootChunks,
+  entryStats,
+} = __queryHandlers
 
 async function _handleMemCycle1(args, config, signal) {
   const minBatchOverride = Number(args?.min_batch)
@@ -2591,7 +853,7 @@ async function _handleMemRebuild(args, config, signal) {
   // then loop once more if one layer exposed another promise while awaiting.
   const drainedCycle1Promises = new Set()
   for (;;) {
-    const pendingCycle1Promises = [_cycle1InFlight, getInFlightCycle1(db)]
+    const pendingCycle1Promises = [_cycleScheduler.getCycle1InFlight(), getInFlightCycle1(db)]
       .filter(p => p && !drainedCycle1Promises.has(p))
     if (pendingCycle1Promises.length === 0) break
     for (const pendingCycle1 of pendingCycle1Promises) {
@@ -3196,6 +1458,9 @@ async function handleToolCall(name, args, signal) {
         ...(a.sessionId ? { sessionId: a.sessionId } : {}),
         ...(a.session_id ? { session_id: a.session_id } : {}),
         ...(a.currentSession !== undefined ? { currentSession: a.currentSession } : {}),
+        // Hint only — never a filter. Marks the caller's own session as
+        // "(current)" in the multi-session grouped browse output.
+        ...(a.currentSessionId ? { currentSessionId: a.currentSessionId } : {}),
       }
       const result = await handleSearch(searchArgs, signal)
       return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
@@ -3325,9 +1590,9 @@ const httpServer = http.createServer(async (req, res) => {
         active_core_summaries: stats.active_core_summaries,
         active_core_summary_missing: stats.active_core_summary_missing,
         mv_hot_active_populated: stats.mv_hot_active_populated,
-        cycle_running: _cycleRunning,
-        cycle_health: _cycleHealth,
-        cycle_backlog: _cycleBacklogSnapshot,
+        cycle_running: _cycleScheduler.getCycleRunning(),
+        cycle_health: _cycleScheduler.getCycleHealth(),
+        cycle_backlog: _cycleScheduler.getCycleBacklogSnapshot(),
       })
     } catch (e) { sendError(res, e.message) }
     return
@@ -3911,7 +2176,7 @@ const httpServer = http.createServer(async (req, res) => {
         }
         const fileSize = stat.size
         await ingestTranscriptFile(filePath, { cwd: body.cwd })
-        const off = _transcriptOffsets.get(filePath)
+        const off = _transcriptIngest.getOffset(filePath)
         const offsetBytes = off && Number.isFinite(off.bytes) ? off.bytes : 0
         const complete = offsetBytes >= fileSize
         sendJson(res, { ok: true, offsetBytes, fileSize, complete })
@@ -3973,7 +2238,7 @@ export async function stop() {
     }
     _periodicAdvertiseInstalled = false
     _currentAdvertisedPort = null
-    _pendingEmbeddingWarmup = null
+    _embeddingWarmup.reset()
     if (_idleShutdownTimer) {
       try { clearTimeout(_idleShutdownTimer) } catch {}
       _idleShutdownTimer = null
@@ -4051,11 +2316,8 @@ export async function stop() {
     _initialized = false
     _initPromise = null
     _bootTimestamp = null
-    _transcriptOffsets = new Map()
-    _cycle1InFlight = null
-    _cycle2InFlight = false
-    _cycle3InFlight = false
-    _checkCyclesInFlight = false
+    _transcriptIngest.resetOffsets()
+    _cycleScheduler.resetInFlight()
     releaseLock()
   })().finally(() => {
     _stopPromise = null