mixdog 0.8.0 → 0.9.0

package/src/runtime/memory/lib/agent-ipc.mjs

@@ -1,9 +1,9 @@
 /**
- * agent-ipc.mjs — IPC client for bridge LLM calls from the memory worker.
+ * agent-ipc.mjs — IPC client for agent dispatch calls from the memory worker.
  *
- * The memory worker runs in its own fork, while the bridge / provider
+ * The memory worker runs in its own fork, while the agent runtime / provider
  * registry lives in-process in the parent server. cycle1 / cycle2 can't
- * call makeBridgeLlm() locally (provider map is empty here), so we route
+ * call makeAgentDispatch() locally (provider map is empty here), so we route
  * every LLM call over IPC:
  *
  *   memory → parent :  { type: 'agent_ipc_request',  callId, tool, params }
@@ -36,10 +36,10 @@ function nextCallId() {
 }
 
 /**
- * Send an agent-bridge LLM request to the parent. Throws if IPC is
+ * Send an agent-agent dispatch request to the parent. Throws if IPC is
  * unavailable (worker not forked) or the parent reports an error.
  *
- * @param {object} opts           bridge-llm construction options
+ * @param {object} opts           agent-dispatch construction options
  * @param {string} [opts.role]
  * @param {string} [opts.taskType]
  * @param {string} [opts.mode]
@@ -49,9 +49,9 @@ function nextCallId() {
  * @param {string} prompt          user message
  * @returns {Promise<string>}      raw assistant content
  */
-export function callBridgeLlm(opts = {}, prompt) {
-  if (!process.send) {
-    return Promise.reject(new Error('agent-ipc: process.send unavailable (not running as worker)'))
+export function callAgentDispatch(opts = {}, prompt) {
+  if (!process.send || !process.connected) {
+    return Promise.reject(new Error('agent-ipc: IPC channel unavailable (no process.send / not connected)'))
   }
   installListener()
   const callId = nextCallId()
@@ -60,20 +60,31 @@ export function callBridgeLlm(opts = {}, prompt) {
     const timer = setTimeout(() => {
       if (!pending.has(callId)) return
       pending.delete(callId)
-      try {
-        process.send({ type: 'agent_ipc_cancel', callId })
-      } catch {}
+      if (process.connected) {
+        try {
+          process.send({ type: 'agent_ipc_cancel', callId }, undefined, {}, () => {})
+        } catch {}
+      }
       reject(new Error(`agent-ipc: timed out after ${timeoutMs}ms`))
     }, timeoutMs)
     pending.set(callId, {
       resolve: (v) => { clearTimeout(timer); resolve(v) },
       reject: (e) => { clearTimeout(timer); reject(e) },
     })
+    if (!process.connected) {
+      pending.delete(callId)
+      clearTimeout(timer)
+      reject(new Error('agent-ipc: IPC channel not connected'))
+      return
+    }
+    // Pass a write callback so a closed-channel write surfaces as an async
+    // error here (rejecting this Promise) instead of bubbling to the process
+    // 'error' event and crashing the daemon with ERR_IPC_CHANNEL_CLOSED.
     try {
       process.send({
         type: 'agent_ipc_request',
         callId,
-        tool: 'bridge_llm',
+        tool: 'agent_dispatch',
         params: {
           role: opts.role || null,
           taskType: opts.taskType || null,
@@ -83,6 +94,12 @@ export function callBridgeLlm(opts = {}, prompt) {
           prompt: String(prompt ?? ''),
           timeout: timeoutMs,
         },
+      }, undefined, {}, (err) => {
+        if (!err) return
+        if (!pending.has(callId)) return
+        pending.delete(callId)
+        clearTimeout(timer)
+        reject(err)
       })
     } catch (e) {
       pending.delete(callId)

package/src/runtime/memory/lib/core-memory-store.mjs

@@ -16,7 +16,7 @@ function __mixdogMemoryLog(...args) {
 
 import { getDatabase, embeddingToSql } from './memory.mjs'
 import { cachedEmbedTextBatch } from './memory-embed.mjs'
-import { callBridgeLlm } from './agent-ipc.mjs'
+import { callAgentDispatch } from './agent-ipc.mjs'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
 import { checkedConnect } from './pg/adapter.mjs'
 
@@ -169,7 +169,7 @@ async function _llmJudgeMerge(existing, incoming) {
     `EXISTING: ${existing.element} — ${String(existing.summary || '')}\n` +
     `INCOMING: ${incoming.element} — ${String(incoming.summary || '')}`
   try {
-    const raw = await callBridgeLlm({
+    const raw = await callAgentDispatch({
       role: 'cycle2-agent',
       taskType: 'maintenance',
       mode: 'core-merge-judge',

package/src/runtime/memory/lib/embedding-model-config.mjs

@@ -0,0 +1,55 @@
+const DEFAULT_MODEL_ID = 'ibm-granite/granite-embedding-97m-multilingual-r2'
+
+const MODEL_PROFILES = Object.freeze({
+  [DEFAULT_MODEL_ID]: Object.freeze({
+    dims: 384,
+    defaultDtype: 'fp32',
+    defaultDevice: 'cpu',
+    modelFileName: 'model_quint8_avx2',
+    supportedDtypes: Object.freeze(['fp32']),
+  }),
+  'Xenova/bge-m3': Object.freeze({
+    dims: 1024,
+    defaultDtype: 'q4',
+    defaultDevice: 'auto',
+    supportedDtypes: Object.freeze(['fp32', 'fp16', 'q8', 'q4']),
+  }),
+})
+
+function clean(value) {
+  return String(value ?? '').trim()
+}
+
+export function getConfiguredEmbeddingModelId() {
+  return clean(process.env.MIXDOG_EMBED_MODEL) || DEFAULT_MODEL_ID
+}
+
+export function getEmbeddingModelProfile(modelId = getConfiguredEmbeddingModelId()) {
+  return MODEL_PROFILES[clean(modelId)] || null
+}
+
+export function getKnownEmbeddingDims(modelId = getConfiguredEmbeddingModelId()) {
+  return getEmbeddingModelProfile(modelId)?.dims ?? null
+}
+
+export function normalizeEmbeddingDtype(modelId, dtype) {
+  const profile = getEmbeddingModelProfile(modelId)
+  const fallback = profile?.defaultDtype || 'fp32'
+  const requested = clean(dtype).toLowerCase()
+  if (!requested) return fallback
+  const supported = new Set(profile?.supportedDtypes || ['fp32', 'fp16', 'q8', 'q4'])
+  return supported.has(requested) ? requested : fallback
+}
+
+export function getDefaultEmbeddingDtype(modelId = getConfiguredEmbeddingModelId()) {
+  return normalizeEmbeddingDtype(modelId, process.env.MIXDOG_EMBED_DTYPE)
+}
+
+export function getDefaultEmbeddingDevice(modelId = getConfiguredEmbeddingModelId()) {
+  return getEmbeddingModelProfile(modelId)?.defaultDevice || 'auto'
+}
+
+export function getEmbeddingModelLoadOptions(modelId = getConfiguredEmbeddingModelId()) {
+  const profile = getEmbeddingModelProfile(modelId)
+  return profile?.modelFileName ? { model_file_name: profile.modelFileName } : {}
+}

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -12,12 +12,18 @@ import { Worker } from 'worker_threads'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { writeProfilePoint } from './model-profile.mjs'
+import {
+  getConfiguredEmbeddingModelId,
+  getDefaultEmbeddingDtype,
+  getKnownEmbeddingDims,
+  normalizeEmbeddingDtype,
+} from './embedding-model-config.mjs'
 
-const MODEL_ID = 'Xenova/bge-m3'
+const MODEL_ID = getConfiguredEmbeddingModelId()
 
 // Static dims registry — bypasses first-boot measurement for registered models.
 // Validated against measured dims inside warmupEmbeddingProvider; mismatch throws.
-const KNOWN_MODEL_DIMS = { 'Xenova/bge-m3': 1024 }
+const KNOWN_MODEL_DIMS = { [MODEL_ID]: getKnownEmbeddingDims(MODEL_ID) }
 
 let worker = null
 let _restartCount = 0
@@ -26,6 +32,8 @@ const MAX_RESTART_BACKOFF_MS = 30_000
 let cachedDims = null
 let _modelReady = false
 let _device = 'cpu'
+let _configuredDtype = getDefaultEmbeddingDtype(MODEL_ID)
+let _warmupPromise = null
 let _embedCallCount = 0
 let _msgId = 0
 const _pending = new Map()
@@ -145,9 +153,10 @@ export function configureEmbedding(config = {}) {
   cachedDims = null
   _modelReady = false
   _device = 'cpu'
+  _configuredDtype = normalizeEmbeddingDtype(MODEL_ID, config.dtype ?? process.env.MIXDOG_EMBED_DTYPE)
   queryEmbeddingCache.clear()
   if (worker) {
-    sendToWorker('configure', { dtype: config.dtype }).catch((err) => {
+    sendToWorker('configure', { dtype: _configuredDtype }).catch((err) => {
       // Silent .catch hid worker reconfigure failures (dtype mismatch,
       // worker crash, IPC closed). At least one log line so cycle1 /
       // cycle2 root-cause investigation can see the upstream failure
@@ -166,16 +175,24 @@ export function getEmbeddingModelId() {
   return MODEL_ID
 }
 
+export function getEmbeddingDtype() {
+  return _configuredDtype
+}
+
 export function getKnownDimsForCurrentModel() {
   return KNOWN_MODEL_DIMS[MODEL_ID] ?? null
 }
 
+export function isEmbeddingModelReady() {
+  return _modelReady && Boolean(cachedDims)
+}
+
 export function getEmbeddingDims() {
   if (!cachedDims) throw new Error('embedding dims not yet measured — warmup required')
   return cachedDims
 }
 
-export async function warmupEmbeddingProvider() {
+async function runEmbeddingWarmup() {
   if (_modelReady && cachedDims) return true
   const result = await sendToWorker('warmup')
   if (!result.dims) throw new Error('warmup returned no dims — model output missing')
@@ -191,6 +208,16 @@ export async function warmupEmbeddingProvider() {
   return true
 }
 
+export function warmupEmbeddingProvider() {
+  if (_modelReady && cachedDims) return Promise.resolve(true)
+  if (!_warmupPromise) {
+    _warmupPromise = runEmbeddingWarmup().finally(() => {
+      _warmupPromise = null
+    })
+  }
+  return _warmupPromise
+}
+
 export async function embedText(text) {
   const clean = String(text ?? '').trim()
   if (!clean) return []

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -7,14 +7,23 @@ function __mixdogMemoryLog(...args) {
 import { parentPort } from 'worker_threads'
 import { createRequire } from 'module'
 import { join } from 'path'
-import { pathToFileURL } from 'url'
 import { mkdirSync } from 'fs'
 import os from 'os'
 import { execFile } from 'child_process'
 import { promisify } from 'util'
+import { resolvePluginData } from '../../shared/plugin-paths.mjs'
+import {
+  getConfiguredEmbeddingModelId,
+  getDefaultEmbeddingDevice,
+  getDefaultEmbeddingDtype,
+  getEmbeddingModelLoadOptions,
+  normalizeEmbeddingDtype,
+} from './embedding-model-config.mjs'
 
-const MODEL_ID = 'Xenova/bge-m3'
-const DEFAULT_DTYPE = 'q4'
+const MODEL_ID = getConfiguredEmbeddingModelId()
+const DEFAULT_DEVICE = getDefaultEmbeddingDevice(MODEL_ID)
+const DEFAULT_DTYPE = getDefaultEmbeddingDtype(MODEL_ID)
+const MODEL_LOAD_OPTIONS = getEmbeddingModelLoadOptions(MODEL_ID)
 const INTRA_OP_THREADS = 1
 const INTER_OP_THREADS = 1
 // Session-create graph optimization. ORT defaults to 'all' (full node fusion),
@@ -31,7 +40,7 @@ const execFileAsync = promisify(execFile)
 // MIXDOG_EMBED_LOAD_CORES overrides (default 1 = single core).
 const _envLoadCores = Number(process.env.MIXDOG_EMBED_LOAD_CORES)
 const LOAD_AFFINITY_CORES = Number.isInteger(_envLoadCores) && _envLoadCores >= 1 ? _envLoadCores : 1
-const MODEL_CACHE_DIR = join(process.env.HOME || process.env.USERPROFILE, '.cache', 'mixdog-memory', 'models')
+const MODEL_CACHE_DIR = join(resolvePluginData(), 'memory-models')
 // Idle dispose was previously 15 min. Production profiling showed the model
 // re-load cost (~3 s DirectML cold start) repeating ~880×/4 h because cycle1
 // gaps exceed 15 min in normal use. Default to keep-alive (0) so the model
@@ -92,8 +101,8 @@ function patchOrtThreads() {
     const require = createRequire(import.meta.url)
     let ort = null
     try {
-      const transformersPkg = require.resolve('@huggingface/transformers/package.json')
-      const transformersRequire = createRequire(pathToFileURL(transformersPkg))
+      const transformersEntry = require.resolve('@huggingface/transformers')
+      const transformersRequire = createRequire(transformersEntry)
       ort = transformersRequire('onnxruntime-node')
     } catch {
       ort = require('onnxruntime-node')
@@ -129,12 +138,13 @@ async function loadExtractor() {
       env.cacheDir = MODEL_CACHE_DIR
       try { env.backends.onnx.wasm.numThreads = INTRA_OP_THREADS } catch {}
       const opts = {}
-      if (configuredDtype && configuredDtype !== 'fp32') {
+      Object.assign(opts, MODEL_LOAD_OPTIONS)
+      if (configuredDtype) {
         opts.dtype = configuredDtype
       }
       const startMs = Date.now()
       let extractor
-      const requestedDevice = String(process.env.MIXDOG_MEMORY_EMBED_DEVICE || 'auto').trim().toLowerCase()
+      const requestedDevice = String(process.env.MIXDOG_MEMORY_EMBED_DEVICE || DEFAULT_DEVICE).trim().toLowerCase()
       const preferGpu = requestedDevice === 'dml'
         || requestedDevice === 'gpu'
         || (requestedDevice === 'auto' && process.platform === 'win32')
@@ -268,8 +278,7 @@ async function processMessage(msg) {
         _embedInFlight = true
         if (_idleTimer) { clearTimeout(_idleTimer); _idleTimer = null }
         if (msg.dtype != null) {
-          const dt = String(msg.dtype).trim().toLowerCase()
-          configuredDtype = ['fp32', 'fp16', 'q8', 'q4'].includes(dt) ? dt : DEFAULT_DTYPE
+          configuredDtype = normalizeEmbeddingDtype(MODEL_ID, msg.dtype)
         }
         if (extractorPromise) {
           try {

package/src/runtime/memory/lib/memory-cycle1.mjs

@@ -6,9 +6,9 @@ function __mixdogMemoryLog(...args) {
 
 import { cleanMemoryText } from './memory.mjs'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
-import { callBridgeLlm } from './agent-ipc.mjs'
+import { callAgentDispatch } from './agent-ipc.mjs'
 import {
-  flushEmbeddingDirty, inferChunkProjectId,
+  flushEmbeddingDirty, inferChunkProjectId, syncRootEmbedding,
 } from './memory-embed.mjs'
 import { markCycleRequest, consumeCycleRequests, resolveCoalesceMaxDrains, scheduleCoalescedCycleRetry, makeCycleRequestSignature, resolveCoalesceMaxRetries } from './memory-cycle-requests.mjs'
 
@@ -277,7 +277,7 @@ export async function runCycle1(db, config = {}, options = {}, dataDir = null) {
   )
   if (_runCycle1InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle1', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     logCycle1Throttled('in-flight', '[cycle1] skipped: already in flight for this db\n')
     return {
       processed: 0, chunks: 0, skipped: 0, sessions: 0,
@@ -301,7 +301,7 @@ export async function runCycle1(db, config = {}, options = {}, dataDir = null) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle1', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     logCycle1Throttled('advisory-lock', '[cycle1] skipped: advisory lock held by another worker\n')
     return { processed: 0, chunks: 0, skipped: 0, sessions: 0, skippedInFlight: true, pendingRows: await countPendingRows(db) }
   }
@@ -380,9 +380,21 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
   const pendingRowsAtStart = await countPendingRows(db)
   throwIfAborted(signal)
   const batchSize = Math.max(1, Number(config.batch_size ?? 100))
+  const windowSize = Math.max(1, Number(config.window_size ?? config.windowSize ?? batchSize))
+  const rowsPerSession = Math.max(windowSize, Number(
+    config.rows_per_session
+      ?? config.rowsPerSession
+      ?? config.max_rows_per_session
+      ?? config.maxRowsPerSession
+      ?? batchSize,
+  ) || batchSize)
   // Fallback chain handles flat config + nested cycle1 wrap shapes.
   const minBatch = Math.max(1, Number(config?.min_batch ?? config?.cycle1?.min_batch ?? CYCLE1_MIN_BATCH))
   const sessionCap = Math.max(1, Number(config?.session_cap ?? config?.cycle1?.session_cap ?? CYCLE1_SESSION_CAP))
+  const onlySessionId = String(config.session_id ?? config.sessionId ?? '').trim()
+  const sessionFilterSql = onlySessionId ? 'AND session_id = $4' : ''
+  const queryParams = [sessionCap, Date.now() - CYCLE1_OMITTED_COOLDOWN_MS, rowsPerSession]
+  if (onlySessionId) queryParams.push(onlySessionId)
   const preset = options.preset || resolveMaintenancePreset('memory')
   // Inner LLM timeout aligns to caller deadline -1s so the channel side can ack gracefully.
   const callerDeadlineMs = Number(options.callerDeadlineMs ?? 0)
@@ -390,23 +402,24 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
   const timeout = callerDeadlineMs > 0
     ? Math.min(baseTimeout, Math.max(5000, callerDeadlineMs - 1000))
     : baseTimeout
-  // Select oldest-pending sessions first, then fetch oldest rows per selected
-  // session. This keeps classifier windows session-isolated and prevents hot
-  // sessions/new rows from starving older pending work.
+  // Select closest/recent sessions first, then fetch closest/recent rows per
+  // selected session. Memory fill is recency-first; session isolation below
+  // keeps unrelated episodes out of the same classifier prompt.
   const fetchResult = await db.query(
     `WITH selected_sessions AS (
-       SELECT session_id, MIN(ts) AS oldest_ts, MIN(id) AS oldest_id
+       SELECT session_id, MAX(ts) AS latest_ts, MAX(id) AS latest_id
        FROM entries
        WHERE chunk_root IS NULL
          AND NULLIF(btrim(session_id), '') IS NOT NULL
          AND (reviewed_at IS NULL OR reviewed_at < $2)
+         ${sessionFilterSql}
        GROUP BY session_id
-       ORDER BY oldest_ts ASC, oldest_id ASC
+       ORDER BY latest_ts DESC, latest_id DESC
        LIMIT $1
      ), ranked AS (
        SELECT e.id, e.ts, e.role, e.content, e.session_id, e.source_ref, e.project_id,
-              s.oldest_ts, s.oldest_id,
-              ROW_NUMBER() OVER (PARTITION BY e.session_id ORDER BY e.ts ASC, e.id ASC) AS rn
+              s.latest_ts, s.latest_id,
+              ROW_NUMBER() OVER (PARTITION BY e.session_id ORDER BY e.ts DESC, e.id DESC) AS rn
        FROM entries e
        JOIN selected_sessions s ON s.session_id = e.session_id
        WHERE e.chunk_root IS NULL
@@ -415,8 +428,8 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
      SELECT id, ts, role, content, session_id, source_ref, project_id
      FROM ranked
      WHERE rn <= $3
-     ORDER BY oldest_ts ASC, oldest_id ASC, session_id, ts DESC, id DESC`,
-    [sessionCap, Date.now() - CYCLE1_OMITTED_COOLDOWN_MS, batchSize],
+     ORDER BY latest_ts DESC, latest_id DESC, session_id, ts DESC, id DESC`,
+    queryParams,
   )
   throwIfAborted(signal)
   const rowsDesc = fetchResult.rows
@@ -463,9 +476,9 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
   const windows = []
   for (const sessionRowsDesc of rowsBySession.values()) {
     const rowsAsc = sessionRowsDesc.slice().reverse()
-    for (let offset = 0; offset < rowsAsc.length; offset += batchSize) {
+    for (let offset = 0; offset < rowsAsc.length; offset += windowSize) {
       throwIfAborted(signal)
-      windows.push(rowsAsc.slice(offset, offset + batchSize))
+      windows.push(rowsAsc.slice(offset, offset + windowSize))
     }
   }
 
@@ -501,7 +514,7 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
     }
 
     const userMessage = buildCycle1ChunkPrompt(rows)
-    const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callBridgeLlm
+    const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callAgentDispatch
 
     let raw
     const _tLlm = Date.now()
@@ -512,7 +525,7 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
         mode: 'cycle1',
         preset,
         timeout,
-        // Pin cwd to null so every memory cycle call hits the same bridge cache shard.
+        // Pin cwd to null so every memory cycle call hits the same agent cache shard.
         cwd: null,
       }, userMessage)
     } catch (err) {
@@ -646,6 +659,14 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
           usedIds.add(mid)
           committedRowIds.add(mid)
         }
+        // Real-time embedding: embed this episode the moment it is committed so
+        // dense recall sees fresh roots without waiting for the end-of-cycle flush.
+        // Fire-and-forget on a separate pool connection (independent of the
+        // just-finished chunk transaction); never await — the chunk loop must
+        // not block. The end-of-cycle flushEmbeddingDirty remains as a safety
+        // net that sweeps any NULL embeddings this per-root path raced/missed.
+        syncRootEmbedding(db, rootId, { signal })
+          .catch((err) => __mixdogMemoryLog(`[cycle1] realtime embed failed (root=${rootId}): ${err.message}\n`))
       } catch (err) {
         __mixdogMemoryLog(`[cycle1] chunk commit failed (root=${rootId}): ${err.message}\n`)
         skippedChunks += 1

package/src/runtime/memory/lib/memory-cycle2.mjs

@@ -8,7 +8,7 @@ import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
-import { callBridgeLlm } from './agent-ipc.mjs'
+import { callAgentDispatch } from './agent-ipc.mjs'
 import {
   syncRootEmbedding, deleteRootEmbedding, flushEmbeddingDirty,
 } from './memory-embed.mjs'
@@ -45,7 +45,7 @@ function resourceDir() {
   return process.env.MIXDOG_ROOT || fileURLToPath(new URL('../../../..', import.meta.url))
 }
 
-async function invokeLlm(prompt, mode, preset, timeout, llmCall = callBridgeLlm) {
+async function invokeLlm(prompt, mode, preset, timeout, llmCall = callAgentDispatch) {
   return await llmCall({
     role: 'cycle2-agent',
     taskType: 'maintenance',
@@ -339,7 +339,7 @@ function _pickKeeper(a, b) {
 async function _llmJudgePair(summaryA, summaryB, siblingContext = [], options = {}) {
   const signal = options?.signal
   throwIfAborted(signal)
-  const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callBridgeLlm
+  const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callAgentDispatch
   const siblings = Array.isArray(siblingContext) && siblingContext.length > 0
     ? `\n\nSibling near-matches (recall context only — do not absorb these into the verdict):\n${siblingContext.slice(0, 5).map((p, i) => `${i + 1}. ${String(p.a?.summary ?? '')} ↔ ${String(p.b?.summary ?? '')}`).join('\n')}`
     : ''
@@ -521,7 +521,6 @@ export function loadCurrentRulesDigest() {
   const now = Date.now()
   if (_currentRulesDigest && now - _currentRulesDigestTs < 60_000) return _currentRulesDigest
   const sources = [
-    join(resourceDir(), 'rules', 'shared', '00-language.md'),
     join(resourceDir(), 'rules', 'shared', '01-general.md'),
     join(resourceDir(), 'rules', 'shared', '01-tool.md'),
     join(resourceDir(), 'rules', 'shared', '04-memory.md'),
@@ -805,7 +804,7 @@ async function sonnetCascade(candidates, rulesDigest, options = {}) {
   // when no binding exists, which would defeat the cascade. SONNET HIGH
   // matches the worker pool's default preset id from agent-config.
   const preset = options.cascadePreset || 'SONNET HIGH'
-  const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callBridgeLlm
+  const llmCall = typeof options?.callLlm === 'function' ? options.callLlm : callAgentDispatch
   let raw
   try {
     raw = await llmCall({
@@ -901,7 +900,7 @@ export async function runCycle2(db, config = {}, options = {}, dataDir = null) {
   }
   if (_runCycle2InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle2', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle2] skipped: already in flight for this db\n')
     return { ok: true, ...partial, skippedInFlight: true }
   }
@@ -921,7 +920,7 @@ export async function runCycle2(db, config = {}, options = {}, dataDir = null) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle2', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle2] skipped: advisory lock held by another worker\n')
     return { ok: true, ...partial, skippedInFlight: true }
   }

package/src/runtime/memory/lib/memory-cycle3.mjs

@@ -23,7 +23,7 @@ import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
-import { callBridgeLlm } from './agent-ipc.mjs'
+import { callAgentDispatch } from './agent-ipc.mjs'
 import { listCore, editCore, deleteCore, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
 import { loadCurrentRulesDigest } from './memory-cycle2.mjs'
 import { embedText } from './embedding-provider.mjs'
@@ -34,7 +34,7 @@ function resourceDir() {
   return process.env.MIXDOG_ROOT || fileURLToPath(new URL('../../../..', import.meta.url))
 }
 
-async function invokeLlm(prompt, mode, preset, timeout, llmCall = callBridgeLlm) {
+async function invokeLlm(prompt, mode, preset, timeout, llmCall = callAgentDispatch) {
   return await llmCall({
     role: 'cycle3-agent',
     taskType: 'maintenance',
@@ -272,7 +272,7 @@ export async function runCycle3(db, config, dataDir, options = {}) {
   }
   if (_runCycle3InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle3', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle3] skipped: already in flight for this db\n')
     return { ...partial, skippedInFlight: true }
   }
@@ -291,7 +291,7 @@ export async function runCycle3(db, config, dataDir, options = {}) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle3', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle3] skipped: advisory lock held by another worker\n')
     return { ...partial, skippedInFlight: true }
   }

package/src/runtime/memory/lib/memory-ops-policy.mjs

@@ -7,6 +7,7 @@ function __mixdogMemoryLog(...args) {
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { mixdogHome } from '../../shared/plugin-paths.mjs'
 
 function normalizeBackfillWindow(value) {
   const normalized = String(value ?? 'all').trim().toLowerCase()
@@ -44,7 +45,7 @@ export async function countUnclassified(db) {
 }
 
 export function selectBackfillTranscripts({ sinceMs = null, limit = null, projectsRoot = null } = {}) {
-  const root = projectsRoot || path.join(os.homedir(), '.mixdog', 'projects')
+  const root = projectsRoot || path.join(mixdogHome(), 'projects')
   if (!fs.existsSync(root)) return []
   const files = []
   for (const d of fs.readdirSync(root)) {

package/src/runtime/memory/lib/memory-session-merge.mjs

@@ -0,0 +1,38 @@
+// Pure, DB-free merge of session-fallback recall rows into the already-ranked
+// global hybrid rows. Extracted into its own module so the starve-prevention +
+// dedupe contract can be unit-tested without booting the memory worker (which
+// has heavy top-level side effects: http server, pg, onnx embedding).
+//
+// Contract:
+//   - APPEND session rows, never prepend. Blind prepend lets session rows
+//     (limit+) starve the global first page and distorts sort/offset/limit.
+//   - Re-apply the SAME sort policy as the global path so global hybrid hits
+//     (carrying a real retrievalScore) keep their rank; session rows
+//     (retrievalScore 0 under importance, ts-ordered under date) only fill
+//     genuinely open slots.
+//   - Dedupe drops any session row whose id already appears as a global row OR
+//     as a global root's inlined chunk member (prevents member/leaf double
+//     output).
+export function mergeSessionRowsIntoGlobal(globalRows, sessionRows, { sort = 'importance' } = {}) {
+  const filtered = Array.isArray(globalRows) ? [...globalRows] : []
+  if (!Array.isArray(sessionRows) || sessionRows.length === 0) return filtered
+  const seen = new Set(filtered.map(r => Number(r.id)))
+  for (const r of filtered) {
+    if (Array.isArray(r.members)) {
+      for (const m of r.members) seen.add(Number(m.id))
+    }
+  }
+  const merged = sessionRows.filter(r => !seen.has(Number(r.id)))
+  if (merged.length === 0) return filtered
+  const out = [...filtered, ...merged]
+  const sa = (v) => { const n = Number(v); return Number.isFinite(n) ? n : 0 }
+  if (sort === 'date') {
+    out.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0))
+  } else {
+    out.sort((a, b) => (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)))
+  }
+  return out
+}