mixdog 0.8.1 → 0.9.1

package/src/runtime/memory/index.mjs

@@ -81,11 +81,22 @@ import {
   isBootstrapComplete,
   getMetaValue,
   setMetaValue,
+  mergeMetaValue,
   cleanMemoryText,
 } from './lib/memory.mjs'
-import { configureEmbedding, embedText, embedTexts, getEmbeddingDims, getEmbeddingModelId, getKnownDimsForCurrentModel, primeEmbeddingDims, warmupEmbeddingProvider } from './lib/embedding-provider.mjs'
+import {
+  normalizeIngestRole,
+  firstTextContent,
+  stableSessionSourceRef,
+  sessionMessageContent,
+  createIngestTurnAllocator,
+} 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 { 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 { claimAndMarkScheduledCycle, makeCycleRequestSignature, resolveCoalesceMaxRetries, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
 import { searchRelevantHybrid } from './lib/memory-recall-store.mjs'
@@ -96,10 +107,12 @@ import { computeEntryScore } from './lib/memory-score.mjs'
 import { runFullBackfill } from './lib/memory-ops-policy.mjs'
 import { listCore, addCore, editCore, deleteCore, compactCoreIds, CORE_SUMMARY_MAX } from './lib/core-memory-store.mjs'
 import { resolveProjectId, resolveProjectScope } from './lib/project-id-resolver.mjs'
-import { openTraceDatabase, insertTraceEvents, enqueueTraceEvents, insertBridgeCalls, registerTraceExitDrain } from './lib/trace-store.mjs'
+import { openTraceDatabase, closeTraceDatabase, insertTraceEvents, enqueueTraceEvents, insertAgentCalls, registerTraceExitDrain } from './lib/trace-store.mjs'
 import { updateJsonAtomicSync, writeJsonAtomicSync } from '../shared/atomic-file.mjs'
-import { resolvePluginData } from '../shared/plugin-paths.mjs'
-const DATA_DIR = process.argv[2] || resolvePluginData()
+import { resolvePluginData, mixdogHome } from '../shared/plugin-paths.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()
 if (!DATA_DIR) {
   __mixdogMemoryLog('[memory-service] memory data dir not set and no explicit data dir provided\n')
   process.exit(1)
@@ -113,6 +126,7 @@ const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
   : path.join(os.tmpdir(), 'mixdog')
 
 let _periodicAdvertiseInstalled = false
+let _periodicAdvertiseTimer = null
 // Track the most recently advertised port so the periodic tick re-reads it
 // every interval. Without this the setInterval closure binds the FIRST port
 // (the upstream we proxied to) and keeps re-advertising the dead upstream
@@ -124,7 +138,28 @@ function parsePositivePid(value) {
   return Number.isFinite(pid) && pid > 0 ? pid : null
 }
 
-const MEMORY_SERVER_PID = parsePositivePid(process.env.MIXDOG_SERVER_PID)
+const MEMORY_SERVER_PID = parsePositivePid(process.env.MIXDOG_SERVER_PID) ?? process.pid
+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
+
+function touchDaemonIdleTimer(reason = 'activity') {
+  if (!MEMORY_DAEMON_MODE || MEMORY_IDLE_TTL_MS <= 0) return
+  if (_idleShutdownTimer) {
+    try { clearTimeout(_idleShutdownTimer) } catch {}
+    _idleShutdownTimer = null
+  }
+  _idleShutdownTimer = setTimeout(() => {
+    __mixdogMemoryLog(`[memory-service] daemon idle TTL elapsed after ${reason}; shutting down\n`)
+    stop()
+      .then(() => process.exit(0))
+      .catch((e) => {
+        __mixdogMemoryLog(`[memory-service] daemon idle shutdown failed: ${e?.message || e}\n`)
+        process.exit(1)
+      })
+  }, MEMORY_IDLE_TTL_MS)
+  _idleShutdownTimer.unref?.()
+}
 
 function advertiseMemoryPort(boundPort, attempt = 0) {
   if (!Number.isFinite(boundPort) || boundPort <= 0) return
@@ -156,18 +191,20 @@ function advertiseMemoryPort(boundPort, attempt = 0) {
     }, { compact: true, fsyncDir: true })
     if (!_periodicAdvertiseInstalled) {
       _periodicAdvertiseInstalled = true
-      setInterval(() => {
+      _periodicAdvertiseTimer = setInterval(() => {
         try {
           if (_currentAdvertisedPort != null) {
             advertiseMemoryPort(_currentAdvertisedPort)
           }
         } catch {}
-      }, 30_000).unref()
+      }, 30_000)
+      _periodicAdvertiseTimer.unref?.()
     }
   } catch (e) {
     const transient = e?.code === 'EPERM' || e?.code === 'EBUSY' || e?.code === 'EACCES'
     if (transient && attempt < 3) {
-      setTimeout(() => advertiseMemoryPort(boundPort, attempt + 1), 50 * (attempt + 1))
+      const retryTimer = setTimeout(() => advertiseMemoryPort(boundPort, attempt + 1), 50 * (attempt + 1))
+      retryTimer.unref?.()
       return
     }
     __mixdogMemoryLog(`[memory-service] active-instance memory_port advertise failed: ${e?.message || e}\n`)
@@ -363,8 +400,12 @@ let _startupTimeout = null
 let _cycle1InFlight = null // shared cycle1 promise (outer coalesce layer)
 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()
 // 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 —
@@ -373,6 +414,7 @@ let _transcriptOffsets = new Map()
 // 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'
@@ -382,8 +424,50 @@ function embeddingWarmupEnabled() {
   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')
+}
+
+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
+  }
+}
+
+function assertSecondaryPgAttachable() {
+  if (!secondaryPgAdvertised()) {
+    throw new Error('memory-service: secondary mode requires an existing primary PG instance')
+  }
+}
+
 function scheduleBackgroundEmbeddingWarmup(metaPath, metaKey) {
-  if (!embeddingWarmupEnabled()) return
+  if (!embeddingWarmupCanStart()) return
   // Queue the warmup; _initRuntime fires it once boot completes.
   _pendingEmbeddingWarmup = () => {
     warmupEmbeddingProvider()
@@ -397,7 +481,6 @@ function scheduleBackgroundEmbeddingWarmup(metaPath, metaKey) {
       })
       .catch(err => {
         __mixdogMemoryLog(`[memory-service] background warmup failed: ${err?.message || err}\n`)
-        process.exit(1)
       })
   }
 }
@@ -429,7 +512,7 @@ async function _initStore() {
   const metaKey = {
     provider: embeddingConfig?.provider ?? null,
     model: getEmbeddingModelId(),
-    dtype: embeddingConfig?.dtype ?? null,
+    dtype: getEmbeddingDtype(),
   }
   let dimsResolved = null
   try {
@@ -450,12 +533,17 @@ async function _initStore() {
 
   if (dimsResolved) {
     primeEmbeddingDims(dimsResolved)
+    assertSecondaryPgAttachable()
     db = await openDatabase(DATA_DIR, dimsResolved)
     scheduleBackgroundEmbeddingWarmup(EMBEDDING_META_PATH, metaKey)
   } else {
+    if (!embeddingWarmupCanStart()) {
+      throw new Error('memory-service: embedding dims unavailable while warmup is disabled')
+    }
     // Cold path: meta missed AND model not registered. Sequential.
     await warmupEmbeddingProvider()
     dimsResolved = Number(getEmbeddingDims())
+    assertSecondaryPgAttachable()
     db = await openDatabase(DATA_DIR, dimsResolved)
     try {
       writeJsonAtomicSync(EMBEDDING_META_PATH, { ...metaKey, dims: dimsResolved }, { lock: true })
@@ -467,7 +555,32 @@ async function _initStore() {
   if (!await isBootstrapComplete(db)) {
     throw new Error('memory-service: bootstrap not complete after openDatabase')
   }
-  startLlmWorker()
+  if (memoryLlmWorkerEnabled()) {
+    startLlmWorker()
+  } else {
+    __mixdogMemoryLog('[memory-service] secondary mode; skipping llm worker\n')
+  }
+  // Initialize the in-process provider registry so cycle1 can run the agent dispatch
+  // LLM locally (makeAgentDispatch → session manager → provider.send). In
+  // standalone the memory worker runs as a detached HTTP daemon whose parent
+  // has disconnected IPC, so the legacy callAgentDispatch() IPC path is dead on
+  // arrival. Mirror the channels worker boot (channels/index.mjs:
+  // loadAgentConfig() + initProviders) so the registry is populated before any
+  // cycle1 dispatch. The gate MUST match _startCycle1Run's makeAgentDispatch
+  // injection condition: cycle1 may dispatch in-process whenever cycles are
+  // enabled OR the llm worker is enabled (both exclude secondary mode), so
+  // registering only under the llm-worker gate would leave a hole where
+  // 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()) {
+    try {
+      const agentCfg = loadAgentConfig()
+      await initProviders(agentCfg.providers || {})
+    } catch (e) {
+      process.stderr.write(`[memory-service] initProviders failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`)
+    }
+  }
   _bootTimestamp = Date.now()
   await loadTranscriptOffsets()
 }
@@ -483,12 +596,16 @@ async function loadTranscriptOffsets() {
 }
 
 async function persistTranscriptOffsets() {
-  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`)
-  }
+  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() {
@@ -522,9 +639,7 @@ async function getCycleLastRun() {
 }
 
 async function setCycleLastRun(kind, ts) {
-  const cur = await getCycleLastRun()
-  cur[kind] = ts
-  await setMetaValue(db, CYCLE_LAST_RUN_KEY, JSON.stringify(cur))
+  await mergeMetaValue(db, CYCLE_LAST_RUN_KEY, { [kind]: ts })
 }
 
 // Raw-row priority lookup for narrow-window queries. Raw rows (is_root=0,
@@ -590,7 +705,7 @@ async function recallSessionRows(args = {}) {
     where.push(`(${clauses.join(' OR ')})`)
   }
   params.push(limit)
-  const rows = (await db.query(`
+  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
@@ -598,40 +713,132 @@ async function recallSessionRows(args = {}) {
     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 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 session_id = $1
+            AND id <> ALL($2::bigint[])
+          ORDER BY ts DESC, id DESC
+          LIMIT $3
+        `, [sessionId, [...seen], fillLimit])).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 : []
-  const limit = Math.max(1, Math.min(500, Number(args.limit) || 200))
+  // Recall fast-track hydrates the current session before compaction; allow
+  // callers to ingest the full in-memory transcript instead of silently
+  // clipping long sessions at 500 turns. Default remains conservative.
+  const limit = Math.max(1, Math.min(5000, Number(args.limit) || 200))
   const start = Math.max(0, messages.length - limit)
   const projectId = resolveProjectScope(typeof args.cwd === 'string' && args.cwd ? args.cwd : null)
   let considered = 0
   let inserted = 0
+  // Monotonic ingest order, independent of the current (post-compaction)
+  // array index. source_turn used to be `i+1`, but after compaction shrinks /
+  // reindexes session.messages a NEWLY appended turn gets a LOW i and thus a
+  // LOW source_turn — and since dump_session_roots / recall order by
+  // source_turn first, it would sort BEFORE older pre-compaction rows. Seed a
+  // running counter from the current max source_turn for this session so every
+  // new row is assigned a turn strictly greater than all previously-ingested
+  // ones (true continuation order). Re-ingested (ON CONFLICT) rows keep their
+  // original turn and do not consume a new one.
+  let prevMaxTurn = 0
+  try {
+    const maxRow = await db.query(
+      `SELECT COALESCE(MAX(source_turn), 0) AS max_turn FROM entries WHERE session_id = $1`,
+      [sessionId],
+    )
+    prevMaxTurn = Number(maxRow.rows?.[0]?.max_turn) || 0
+  } catch { prevMaxTurn = 0 }
+  const turnAllocator = createIngestTurnAllocator(prevMaxTurn)
   for (let i = start; i < messages.length; i += 1) {
     const m = messages[i]
-    if (!m || (m.role !== 'user' && m.role !== 'assistant')) continue
-    const content = cleanMemoryText(firstTextContent(m.content))
+    if (!m || typeof m !== 'object') continue
+    const role = normalizeIngestRole(m.role)
+    // ingest_session persists user/assistant only; system/developer/tool rows
+    // are dropped so recall-fasttrack summaries stay conversation-focused and
+    // do not re-inject content already in the protected system prefix.
+    if (!role) continue
+    const content = cleanMemoryText(sessionMessageContent(m))
     if (!content || !content.trim()) continue
     considered += 1
     const tsMs = parseTsToMs(m.ts ?? m.timestamp ?? (Date.now() - (messages.length - i)))
-    const sourceRef = `session:${sessionId}#${i + 1}`
+    // Stable per-message identity. The previous `session:${id}#${i+1}` key was
+    // positional, so after compaction shrinks/reindexes session.messages a
+    // later turn could reuse an old index and be silently skipped by
+    // ON CONFLICT DO NOTHING. stableSessionSourceRef hashes only durable
+    // fields (role, original ts if present, tool ids, content) — never the
+    // synthesized tsMs fallback or the loop index.
+    const sourceRef = stableSessionSourceRef(sessionId, m, role, content)
+    // Assign the next monotonic turn; only consume it when the row is actually
+    // inserted (a conflicting re-ingest keeps its original source_turn).
+    const assignedTurn = turnAllocator.peekNext()
     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, m.role, content, sourceRef, sessionId, i + 1, projectId])
-    inserted += Number(result.rowCount ?? result.affectedRows ?? 0) || 0
+    `, [tsMs, role, content, sourceRef, sessionId, assignedTurn, projectId])
+    const rowInserted = Number(result.rowCount ?? result.affectedRows ?? 0) || 0
+    if (rowInserted > 0) {
+      inserted += rowInserted
+      turnAllocator.next()
+    }
   }
   return { text: `ingest_session: considered=${considered} inserted=${inserted} session=${sessionId}` }
 }
 
-async function ingestTranscriptFile(transcriptPath, { cwd } = {}) {
+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 = _transcriptOffsets.get(transcriptPath) ?? { bytes: 0, lineIndex: 0 }
+  const prev = snapshotTranscriptOffset(transcriptPath)
   if (stat.size < prev.bytes) {
     prev.bytes = 0
     prev.lineIndex = 0
@@ -721,21 +928,16 @@ async function ingestTranscriptFile(transcriptPath, { cwd } = {}) {
       break
     }
   }
-  prev.bytes = lastGoodBytes
-  prev.lineIndex = lastGoodLineIndex
-  _transcriptOffsets.set(transcriptPath, prev)
+  _transcriptOffsets.set(transcriptPath, {
+    bytes: lastGoodBytes,
+    lineIndex: lastGoodLineIndex,
+  })
   await persistTranscriptOffsets()
   return count
 }
 
-function firstTextContent(content) {
-  if (typeof content === 'string') return content
-  if (!Array.isArray(content)) return ''
-  for (const item of content) {
-    if (typeof item === 'string') return item
-    if (item?.type === 'text' && typeof item.text === 'string') return item.text
-  }
-  return ''
+async function ingestTranscriptFile(transcriptPath, options = {}) {
+  return runTranscriptIngestSerialized(transcriptPath, () => ingestTranscriptFileImpl(transcriptPath, options))
 }
 
 function parseTsToMs(value) {
@@ -776,7 +978,7 @@ function cwdFromTranscriptPath(fp) {
 }
 
 function _initTranscriptWatcher() {
-  const projectsRoot = path.join(os.homedir(), '.mixdog', 'projects')
+  const projectsRoot = path.join(mixdogHome(), 'projects')
   const SAFETY_POLL_MS = 5 * 60_000
   const DEBOUNCE_MS = 500
   const watchedFiles = new Map()
@@ -963,6 +1165,83 @@ function _initTranscriptWatcher() {
 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({
+      role: '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({
+      role: '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({
+      role: 'cycle3-agent',
+      taskType: 'maintenance',
+      sourceType: 'memory-cycle',
+      brief: false,
+    })
+  }
+  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)
@@ -978,6 +1257,13 @@ async function recordCycle1Result(result) {
 }
 
 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() }
+  }
   _cycle1InFlight = (async () => {
     try {
       const result = await runCycle1(db, config, options, DATA_DIR)
@@ -1142,10 +1428,14 @@ function scheduleScheduledCycle2(config, signature, attempt = 0) {
     }
     _cycle2InFlight = true
     try {
-      const result = await runCycle2(db, config, {
+      let c2Options = {
         coalescedRetry: true,
         onCoalescedSuccess: _finalizeCycle2Run,
-      }, DATA_DIR)
+      }
+      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) {
@@ -1175,10 +1465,14 @@ function scheduleScheduledCycle3(config, signature, attempt = 0) {
     }
     _cycle3InFlight = true
     try {
-      const result = await runCycle3(db, config, DATA_DIR, {
+      let c3Options = {
         coalescedRetry: true,
         onCoalescedSuccess: () => setCycleLastRun('cycle3', Date.now()),
-      })
+      }
+      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) {
@@ -1335,8 +1629,12 @@ 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)
-  _transcriptWatcher = _initTranscriptWatcher()
-  _startCycles()
+  if (memoryCyclesEnabled()) {
+    _transcriptWatcher = _initTranscriptWatcher()
+    _startCycles()
+  } else {
+    __mixdogMemoryLog('[memory-service] secondary mode; skipping background cycles\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
@@ -1349,6 +1647,7 @@ function _beginRuntimeInit() {
   if (!_initPromise) {
     _initPromise = _initRuntime().catch((e) => {
       __mixdogMemoryLog(`[memory-service] runtime init failed: ${e?.stack || e?.message || e}\n`)
+      _initPromise = null
       throw e
     })
   }
@@ -1613,15 +1912,20 @@ async function handleSearch(args, signal) {
     })
     let settled
     try {
-      // Pre-warm the per-query embedding cache with one batched ONNX run so
-      // each sub-search lands an embedText cache hit (~0ms) instead of
-      // serially queueing through the worker's single-flight inference lock.
-      // Replaces N sequential ~130ms inferences with one ~150-200ms batch.
-      //
-      // 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])
+      // 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
@@ -1700,7 +2004,21 @@ async function handleSearch(args, signal) {
   if (query) {
     const _t0 = Date.now()
     if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-    const queryVector = await embedText(query)
+    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) {
@@ -1791,7 +2109,7 @@ async function handleSearch(args, signal) {
     // 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 bridge-side span id is only known after
+    // 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) {
@@ -1937,6 +2255,7 @@ async function dumpSessionRootChunks(args = {}) {
     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,
@@ -1954,7 +2273,7 @@ async function dumpSessionRootChunks(args = {}) {
     ? chunks.map((chunk, idx) => {
         const label = chunk.kind === 'root'
           ? `# chunk ${idx + 1} root=${chunk.id}${chunk.category ? ` category=${chunk.category}` : ''}`
-          : `# raw ${idx + 1} id=${chunk.id}`
+          : `${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')
@@ -1997,7 +2316,10 @@ async function _handleMemCycle1(args, config, signal) {
   const minBatchOverride = Number(args?.min_batch)
   const sessionCapOverride = Number(args?.session_cap)
   const batchSizeOverride = Number(args?.batch_size)
+  const windowSizeOverride = Number(args?.window_size ?? args?.windowSize)
+  const rowsPerSessionOverride = Number(args?.rows_per_session ?? args?.rowsPerSession ?? args?.max_rows_per_session ?? args?.maxRowsPerSession)
   const concurrencyOverride = Number(args?.concurrency)
+  const sessionIdOverride = String(args?.sessionId ?? args?.session_id ?? '').trim()
   const baseCycle1 = config?.cycle1 || {}
   let cycle1Config = baseCycle1
   // _runCycle1Impl reads `config?.min_batch ?? config?.cycle1?.min_batch ??
@@ -2011,12 +2333,24 @@ async function _handleMemCycle1(args, config, signal) {
   if (Number.isFinite(batchSizeOverride) && batchSizeOverride > 0) {
     cycle1Config = { ...cycle1Config, batch_size: batchSizeOverride }
   }
+  if (Number.isFinite(windowSizeOverride) && windowSizeOverride > 0) {
+    cycle1Config = { ...cycle1Config, window_size: windowSizeOverride }
+  }
+  if (Number.isFinite(rowsPerSessionOverride) && rowsPerSessionOverride > 0) {
+    cycle1Config = { ...cycle1Config, rows_per_session: rowsPerSessionOverride }
+  }
+  if (sessionIdOverride) {
+    cycle1Config = { ...cycle1Config, session_id: sessionIdOverride }
+  }
   if (Number.isFinite(concurrencyOverride) && concurrencyOverride > 0) {
     cycle1Config = { ...cycle1Config, concurrency: Math.min(8, Math.floor(concurrencyOverride)) }
   }
   const callerDeadlineMs = Number(args?._callerDeadlineMs) || 0
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
   const cycle1Options = callerDeadlineMs > 0 ? { callerDeadlineMs, signal } : { signal }
+  if (typeof args?._callLlm === 'function') {
+    cycle1Options.callLlm = args._callLlm
+  }
   const result = await _awaitCycle1Run(
     cycle1Config,
     cycle1Options,
@@ -2030,6 +2364,7 @@ async function _handleMemCycle1(args, config, signal) {
   const failedRows = Array.isArray(result?.failed_row_ids) ? result.failed_row_ids.length : Number(result?.quality?.failed_rows || 0)
   const invalidChunks = Array.isArray(result?.invalid_chunks) ? result.invalid_chunks.length : Number(result?.quality?.invalid_chunks || 0)
   return {
+    ...result,
     text: `cycle1: chunks=${result.chunks} processed=${result.processed} skipped_chunks=${result.skipped}` +
       ` omitted=${omitted} prefiltered=${prefiltered} failed_rows=${failedRows} invalid_chunks=${invalidChunks}` +
       ` pending=${pendingStr} inFlight=${inFlightStr}${timedOutPart}`,
@@ -2038,7 +2373,11 @@ async function _handleMemCycle1(args, config, signal) {
 
 async function _handleMemCycle2(args, config, signal) {
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-  const result = await runCycle2(db, config?.cycle2 || {}, { signal }, DATA_DIR)
+  let c2Options = { signal }
+  if (typeof c2Options?.callLlm !== 'function') {
+    c2Options = { ...c2Options, callLlm: getCycle2CallLlm() }
+  }
+  const result = await runCycle2(db, config?.cycle2 || {}, c2Options, DATA_DIR)
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
   await _finalizeCycle2Run(result)
   const counts = {
@@ -2075,7 +2414,11 @@ async function _handleMemCycle3(args, config, signal) {
     : (requestedMode === 'proposal' || requestedMode === 'dry-run' || requestedMode === 'dryrun')
       ? 'proposal'
       : 'conservative'
-  const result = await runCycle3(db, config || {}, DATA_DIR, { signal, apply: confirmed ? true : undefined, applyMode })
+  let c3Options = { signal, apply: confirmed ? true : undefined, applyMode }
+  if (typeof c3Options?.callLlm !== 'function') {
+    c3Options = { ...c3Options, callLlm: getCycle3CallLlm() }
+  }
+  const result = await runCycle3(db, config || {}, DATA_DIR, c3Options)
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
   const parts = ['reviewed', 'kept', 'updated', 'merged', 'deleted']
     .map(k => `${k}=${result?.[k] || 0}`)
@@ -2100,7 +2443,11 @@ async function _handleMemFlush(args, config, signal) {
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
   const r1 = await _awaitCycle1Run(config?.cycle1 || {}, { signal })
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-  const r2 = await runCycle2(db, config?.cycle2 || {}, { signal }, DATA_DIR)
+  let flushC2Options = { signal }
+  if (typeof flushC2Options?.callLlm !== 'function') {
+    flushC2Options = { ...flushC2Options, callLlm: getCycle2CallLlm() }
+  }
+  const r2 = await runCycle2(db, config?.cycle2 || {}, flushC2Options, DATA_DIR)
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
   await _finalizeCycle2Run(r2)
   return { text: `flush: cycle1 chunks=${r1.chunks} processed=${r1.processed}, cycle2 ${JSON.stringify(r2)}` }
@@ -2204,7 +2551,11 @@ async function _handleMemRebuild(args, config, signal) {
   // inside _awaitCycle1Run and guarantees the newly demoted rows are read.
   const r1 = await _startCycle1Run(config?.cycle1 || {}, { signal })
   if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-  const r2 = await runCycle2(db, config?.cycle2 || {}, { signal }, DATA_DIR)
+  let rebuildC2Options = { signal }
+  if (typeof rebuildC2Options?.callLlm !== 'function') {
+    rebuildC2Options = { ...rebuildC2Options, callLlm: getCycle2CallLlm() }
+  }
+  const r2 = await runCycle2(db, config?.cycle2 || {}, rebuildC2Options, DATA_DIR)
   await _finalizeCycle2Run(r2)
   return { text: `rebuild: cycle1 chunks=${r1.chunks} processed=${r1.processed}, cycle2 ${JSON.stringify(r2)}` }
 }
@@ -2254,7 +2605,11 @@ async function _handleMemBackfill(args, config, signal) {
     },
     runCycle2: async (dbArg, c2Config, c2Options, c2DataDir) => {
       if (signal?.aborted) throw signal.reason ?? new Error('aborted')
-      const r2 = await runCycle2(dbArg, c2Config, { ...c2Options, signal }, c2DataDir)
+      let backfillC2Options = { ...c2Options, signal }
+      if (typeof backfillC2Options?.callLlm !== 'function') {
+        backfillC2Options = { ...backfillC2Options, callLlm: getCycle2CallLlm() }
+      }
+      const r2 = await runCycle2(dbArg, c2Config, backfillC2Options, c2DataDir)
       _capturedCycle2 = r2
       return r2
     },
@@ -2676,7 +3031,7 @@ async function handleToolCall(name, args, signal) {
   try {
     if (name === 'search_memories') {
       const result = await handleSearch(args || {}, signal)
-      return { content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
     }
     if (name === 'recall') {
       // recall is aiWrapped in the unified build; in standalone mode map it to
@@ -2710,11 +3065,11 @@ async function handleToolCall(name, args, signal) {
         ...(a.currentSession !== undefined ? { currentSession: a.currentSession } : {}),
       }
       const result = await handleSearch(searchArgs, signal)
-      return { content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
     }
     if (name === 'memory') {
       const result = await handleMemoryAction(args || {}, signal)
-      return { content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
     }
     return { content: [{ type: 'text', text: `unknown tool: ${name}` }], isError: true }
   } catch (err) {
@@ -2854,6 +3209,7 @@ let _backfillInFlight = null
 const _ownerInFlightHttpCalls = new Map()
 
 const httpServer = http.createServer(async (req, res) => {
+  touchDaemonIdleTimer(`${req.method || 'HTTP'} ${req.url || '/'}`)
   if (req.method === 'POST' && req.url === '/session-reset') {
     _bootTimestamp = Date.now()
     sendJson(res, { ok: true, bootTimestamp: _bootTimestamp })
@@ -3075,9 +3431,9 @@ const httpServer = http.createServer(async (req, res) => {
       enqueueTraceEvents(_traceDb, body.events)
       // Use `queued` — events are async; `inserted` would imply durability.
       sendJson(res, { ok: true, queued: body.events.length })
-      // Fire-and-forget into focused bridge analytic tables.
-      insertBridgeCalls(_traceDb, body.events).catch(e =>
-        __mixdogMemoryLog(`[trace] insertBridgeCalls error: ${e?.message}\n`)
+      // Fire-and-forget into focused agent analytic tables.
+      insertAgentCalls(_traceDb, body.events).catch(e =>
+        __mixdogMemoryLog(`[trace] insertAgentCalls error: ${e?.message}\n`)
       )
     } catch (e) {
       sendJson(res, { ok: false, error: e.message }, 500)
@@ -3120,11 +3476,11 @@ const httpServer = http.createServer(async (req, res) => {
   // DEV-ONLY cycle1 chunking bench. Gated by env MIXDOG_DEV_BENCH=1 so
    // production is untouched (route returns 404 when unset). Mirrors cycle1's
    // exact fetch query + per-session windowing, then runs each window through
-   // buildCycle1ChunkPrompt + callBridgeLlm + parseCycle1LineFormat. STRICT
+   // buildCycle1ChunkPrompt + callAgentDispatch + parseCycle1LineFormat. STRICT
    // read-only — no UPDATE, no transaction, no commit.
   if (req.method === 'POST' && req.url === '/dev/cycle1-bench') {
     // Gate: env MIXDOG_DEV_BENCH=1 OR a runtime flag file, so it can be
-    // toggled without restarting Claude Code (env only reaches the worker
+    // toggled without restarting the host agent (env only reaches the worker
     // on a full CC restart, not via dev-sync full-restart).
     const _devBenchOn = process.env.MIXDOG_DEV_BENCH === '1'
       || (DATA_DIR && fs.existsSync(path.join(DATA_DIR, '.dev-bench-enabled')))
@@ -3150,11 +3506,14 @@ const httpServer = http.createServer(async (req, res) => {
         : null
 
       // Lazy-load LLM + chunking helpers so production boot pays nothing.
-      const [{ buildCycle1ChunkPrompt, parseCycle1LineFormat }, { callBridgeLlm }, { resolveMaintenancePreset }] = await Promise.all([
+      // Use the same in-process agent dispatch adapter as real cycle1 — the legacy
+      // agent-ipc callAgentDispatch() path is dead in the detached standalone
+      // memory daemon (no connected IPC), so the dev bench must mirror prod.
+      const [{ buildCycle1ChunkPrompt, parseCycle1LineFormat }, { resolveMaintenancePreset }] = await Promise.all([
         import('./lib/memory-cycle1.mjs'),
-        import('./lib/agent-ipc.mjs'),
         import('../shared/llm/index.mjs'),
       ])
+      const benchCallLlm = getCycle1CallLlm()
 
       const CYCLE1_MIN_BATCH = 3
       const CYCLE1_SESSION_CAP = 10
@@ -3225,13 +3584,9 @@ const httpServer = http.createServer(async (req, res) => {
         const t0 = Date.now()
         let raw, error
         try {
-          raw = await callBridgeLlm({
-            role: 'cycle1-agent',
-            taskType: 'maintenance',
-            mode: 'cycle1',
+          raw = await benchCallLlm({
             preset,
             timeout: TIMEOUT_MS,
-            cwd: null,
           }, userMessage)
         } catch (e) {
           error = e?.message ?? String(e)
@@ -3310,26 +3665,6 @@ const httpServer = http.createServer(async (req, res) => {
     return
   }
 
-  if (req.method === 'POST' && req.url === '/session-start/recap') {
-    try {
-      const body = await readBody(req)
-      const projectId = resolveProjectScope(typeof body.cwd === 'string' && body.cwd ? body.cwd : null)
-      const rows = projectId !== null
-        ? (await db.query(`
-            SELECT id, ts, summary FROM entries
-            WHERE is_root = 1 AND (project_id IS NULL OR project_id = $1)
-            ORDER BY ts DESC, id DESC LIMIT 20
-          `, [projectId])).rows
-        : (await db.query(`
-            SELECT id, ts, summary FROM entries
-            WHERE is_root = 1
-            ORDER BY ts DESC, id DESC LIMIT 20
-          `)).rows
-      sendJson(res, { ok: true, projectId, rows })
-    } catch (e) { sendError(res, e.message) }
-    return
-  }
-
   if (req.method === 'POST' && req.url === '/api/tool') {
     if (!isLocalOrigin(req)) {
       sendJson(res, { content: [{ type: 'text', text: 'forbidden: cross-origin' }], isError: true }, 403)
@@ -3530,34 +3865,94 @@ export async function init() {
     process.on('exit', releaseMemoryOwnerLock)
   }
   const runtimeReady = _beginRuntimeInit()
-  const boundPort = await _startHttpServer()
-  await runtimeReady
-  advertiseMemoryPort(boundPort)
+  let boundPort = null
+  if (!memorySecondaryMode()) {
+    boundPort = await _startHttpServer()
+    await runtimeReady
+    advertiseMemoryPort(boundPort)
+  } else {
+    await runtimeReady
+  }
   if (process.env.MIXDOG_WORKER_MODE === '1' && process.send) {
     __mixdogMemoryLog(`[boot-time] tag=memory-ready tMs=${Date.now()}\n`)
     process.send({ type: 'ready', port: boundPort })
   }
   __mixdogMemoryLog(`[memory-service] init() complete (entries unified mode, version=${PLUGIN_VERSION})\n`)
+  touchDaemonIdleTimer('init')
 }
 
 export async function stop() {
-  _stopCycles()
-  await stopLlmWorker()
-  if (httpServer) await new Promise(resolve => httpServer.close(resolve))
-  await closeDatabase(DATA_DIR)
-  // Stop the PG postmaster after the connection pool has been drained.
-  // closeDatabase() only ends the client pool; without this the child
-  // postmaster keeps running after the memory service exits.
-  try {
-    const { stopPgForShutdown } = await import('./lib/pg/supervisor.mjs')
-    await stopPgForShutdown()
-  } catch {}
-  releaseLock()
+  if (_stopPromise) return _stopPromise
+  _stopPromise = (async () => {
+    _stopCycles()
+    if (_periodicAdvertiseTimer) {
+      try { clearInterval(_periodicAdvertiseTimer) } catch {}
+      _periodicAdvertiseTimer = null
+    }
+    _periodicAdvertiseInstalled = false
+    _currentAdvertisedPort = null
+    _pendingEmbeddingWarmup = null
+    if (_idleShutdownTimer) {
+      try { clearTimeout(_idleShutdownTimer) } catch {}
+      _idleShutdownTimer = null
+    }
+    await stopLlmWorker()
+    resetHttpListenErrorHandler()
+    if (_httpBoundPort != null || _httpReadyPromise) {
+      await new Promise(resolve => {
+        try {
+          httpServer.close(() => resolve())
+        } catch {
+          resolve()
+        }
+      })
+    }
+    _httpReadyPromise = null
+    _httpBoundPort = null
+    activePort = BASE_PORT
+    if (_traceDb) {
+      try { await closeTraceDatabase(DATA_DIR) } catch {}
+      _traceDb = null
+    }
+    await closeDatabase(DATA_DIR)
+    // Stop the PG postmaster after the connection pools have been drained.
+    // closeDatabase() only ends the client pool; without this the child
+    // postmaster keeps running after the memory service exits.
+    if (!memorySecondaryMode()) {
+      try {
+        const { stopPgForShutdown } = await import('./lib/pg/supervisor.mjs')
+        await stopPgForShutdown()
+      } catch {}
+    } else {
+      __mixdogMemoryLog('[memory-service] secondary mode; leaving shared PG running\n')
+    }
+    db = null
+    mainConfig = null
+    _initialized = false
+    _initPromise = null
+    _bootTimestamp = null
+    _transcriptOffsets = new Map()
+    _cycle1InFlight = null
+    _cycle2InFlight = false
+    _cycle3InFlight = false
+    _checkCyclesInFlight = false
+    releaseLock()
+  })().finally(() => {
+    _stopPromise = null
+  })
+  return _stopPromise
 }
 
 let activePort = BASE_PORT
 let _httpReadyPromise = null
 let _httpBoundPort = null
+let _httpListenErrorHandler = null
+
+function resetHttpListenErrorHandler() {
+  if (!_httpListenErrorHandler) return
+  try { httpServer.off('error', _httpListenErrorHandler) } catch {}
+  _httpListenErrorHandler = null
+}
 
 function _startHttpServer() {
   if (_httpBoundPort != null) return Promise.resolve(_httpBoundPort)
@@ -3572,7 +3967,11 @@ function _startHttpServer() {
         resolve(boundPort)
       })
     }
-    httpServer.on('error', (err) => {
+    _httpListenErrorHandler = (err) => {
+      if (_httpBoundPort != null) {
+        __mixdogMemoryLog(`[memory-service] HTTP error: ${err?.message || err}\n`)
+        return
+      }
       if (err.code === 'EADDRINUSE' && activePort < MAX_PORT) {
         activePort++
         tryListen()
@@ -3582,9 +3981,11 @@ function _startHttpServer() {
         tryListen()
       } else {
         __mixdogMemoryLog(`[memory-service] HTTP fatal: ${err.message}\n`)
+        resetHttpListenErrorHandler()
         reject(err)
       }
-    })
+    }
+    httpServer.on('error', _httpListenErrorHandler)
     tryListen()
   })
   return _httpReadyPromise
@@ -3688,7 +4089,7 @@ if (process.env.MIXDOG_WORKER_MODE === '1' && process.send) {
 // server with acquireLock + StdioServerTransport. Server-main spawnWorker
 // also forks this file with MIXDOG_WORKER_MODE='1'; that path uses the IPC
 // handler block above and acquireLock/init() as the single memory owner.
-if (import.meta.url === pathToFileURL(process.argv[1] || '').href && process.env.MIXDOG_WORKER_MODE !== '1') {
+if (IS_MEMORY_ENTRY && process.env.MIXDOG_WORKER_MODE !== '1') {
   ;(async () => {
     acquireLock()
     process.on('exit', releaseLock)