mixdog 0.9.95 → 0.9.97

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

@@ -1,49 +1,136 @@
 /**
- * agent-ipc.mjs — IPC client for agent dispatch calls from the memory worker.
+ * Agent-dispatch client for the memory process.
  *
- * 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 makeAgentDispatch() locally (provider map is empty here), so we route
- * every LLM call over IPC:
- *
- *   memory → parent :  { type: 'agent_ipc_request',  callId, tool, params }
- *   parent → memory :  { type: 'agent_ipc_response', callId, ok, result | error }
- *
- * Uses a module-level pending map keyed by callId. Parent-side handler
- * lives in server.mjs spawnWorker's message listener.
+ * PG/embedding/recall remain isolated in the memory process, while the heavy
+ * provider/session graph lives exactly once in the machine-global daemon.
+ * daemon. Calls use its authenticated loopback broker, so the memory process
+ * can outlive its original fork parent and reconnect after a daemon restart.
  */
-import { safeIpcSend } from '../../shared/safe-ipc-send.mjs'
+import http from 'node:http'
+import { readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
 
-const pending = new Map()
-let listenerInstalled = false
+const brokerAgent = new http.Agent({
+  keepAlive: true,
+  maxSockets: 64,
+  maxFreeSockets: 8,
+})
 let _idSeq = 0
 
-function installListener() {
-  if (listenerInstalled) return
-  listenerInstalled = true
-  process.on('message', (msg) => {
-    if (!msg || msg.type !== 'agent_ipc_response' || !msg.callId) return
-    const entry = pending.get(msg.callId)
-    if (!entry) return
-    pending.delete(msg.callId)
-    if (msg.ok) entry.resolve(msg.result)
-    else entry.reject(new Error(msg.error || 'agent_ipc_response error'))
-  })
-  process.once('disconnect', () => {
-    const error = new Error('agent-ipc: parent IPC disconnected')
-    for (const [, entry] of pending) entry.reject(error)
-    pending.clear()
-  })
-}
-
 function nextCallId() {
   _idSeq += 1
   return `mem-${process.pid}-${Date.now()}-${_idSeq}`
 }
 
+function runtimeRoot() {
+  return process.env.MIXDOG_RUNTIME_ROOT
+    ? resolve(process.env.MIXDOG_RUNTIME_ROOT)
+    : join(tmpdir(), 'mixdog')
+}
+
+function isPidAlive(value) {
+  const pid = Number(value)
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try { process.kill(pid, 0); return true } catch (error) { return error?.code === 'EPERM' }
+}
+
+function readBrokerDiscovery() {
+  try {
+    const raw = JSON.parse(readFileSync(join(runtimeRoot(), 'daemon.json'), 'utf8'))
+    const endpoint = raw?.endpoints?.channel
+    const port = Number(endpoint?.port)
+    if (!Number.isInteger(port) || port <= 0 || port >= 65536 || !endpoint?.token || !isPidAlive(raw?.pid)) {
+      return null
+    }
+    return { port, token: String(endpoint.token) }
+  } catch {
+    return null
+  }
+}
+
+function abortError(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new Error(String(signal?.reason || 'agent broker request canceled'))
+}
+
+function requestBroker(discovery, path, body, { timeoutMs, signal = null } = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const payload = JSON.stringify(body || {})
+    let settled = false
+    let req = null
+    const finish = (fn, value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(deadline)
+      try { signal?.removeEventListener?.('abort', onAbort) } catch {}
+      fn(value)
+    }
+    const reject = (error) => finish(
+      rejectPromise,
+      error instanceof Error ? error : new Error(String(error)),
+    )
+    const onAbort = () => {
+      const error = abortError(signal)
+      try { req?.destroy?.(error) } catch {}
+      reject(error)
+    }
+    const deadline = setTimeout(() => {
+      const error = new Error(`agent broker request timed out after ${timeoutMs}ms`)
+      try { req?.destroy?.(error) } catch {}
+      reject(error)
+    }, timeoutMs)
+    deadline.unref?.()
+    if (signal?.aborted) {
+      onAbort()
+      return
+    }
+    try { signal?.addEventListener?.('abort', onAbort, { once: true }) } catch {}
+    req = http.request({
+      hostname: '127.0.0.1',
+      port: discovery.port,
+      path,
+      method: 'POST',
+      agent: brokerAgent,
+      headers: {
+        'X-Mixdog-Daemon-Token': discovery.token,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+    }, (res) => {
+      let data = ''
+      res.setEncoding('utf8')
+      res.on('data', (chunk) => { data += chunk })
+      res.on('error', reject)
+      res.on('end', () => {
+        let parsed = null
+        try { parsed = data ? JSON.parse(data) : null } catch {}
+        if ((res.statusCode || 0) >= 400) {
+          reject(new Error(parsed?.error || data || `HTTP ${res.statusCode}`))
+          return
+        }
+        if (parsed?.ok === false) {
+          reject(new Error(parsed.error || 'agent broker dispatch failed'))
+          return
+        }
+        finish(resolvePromise, parsed)
+      })
+    })
+    req.on('error', reject)
+    req.write(payload)
+    req.end()
+  })
+}
+
+function cancelBrokerCall(discovery, callId, reason) {
+  return requestBroker(discovery, '/agent/cancel', { callId, reason }, {
+    timeoutMs: 1500,
+  }).catch(() => {})
+}
+
 /**
- * Send an agent-agent dispatch request to the parent. Throws if IPC is
- * unavailable (worker not forked) or the parent reports an error.
+ * Dispatch through the singleton daemon provider/session graph.
  *
  * @param {object} opts           agent-dispatch construction options
  * @param {string} [opts.agent]
@@ -55,55 +142,33 @@ function nextCallId() {
  * @param {string} prompt          user message
  * @returns {Promise<string>}      raw assistant content
  */
-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)'))
+export async function callAgentDispatch(opts = {}, prompt) {
+  const discovery = readBrokerDiscovery()
+  if (!discovery) {
+    throw new Error('agent-broker: daemon unavailable')
   }
-  installListener()
   const callId = nextCallId()
   const timeoutMs = Math.max(1000, Number(opts.timeout ?? 600000))
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      if (!pending.has(callId)) return
-      pending.delete(callId)
-      if (process.connected) {
-        safeIpcSend(process, { type: 'agent_ipc_cancel', callId })
-      }
-      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) },
+  try {
+    const response = await requestBroker(discovery, '/agent/dispatch', {
+      callId,
+      params: {
+        agent: opts.agent || null,
+        taskType: opts.taskType || null,
+        mode: opts.mode || null,
+        preset: opts.preset || null,
+        cwd: opts.cwd || null,
+        prompt: String(prompt ?? ''),
+        timeout: timeoutMs,
+      },
+    }, {
+      // Small transport grace after the dispatch's own timeout/watchdog.
+      timeoutMs: timeoutMs + 5000,
+      signal: opts.signal || null,
     })
-    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.
-    safeIpcSend(process, {
-        type: 'agent_ipc_request',
-        callId,
-        tool: 'agent_dispatch',
-        params: {
-          agent: opts.agent || null,
-          taskType: opts.taskType || null,
-          mode: opts.mode || null,
-          preset: opts.preset || null,
-          cwd: opts.cwd || null,
-          prompt: String(prompt ?? ''),
-          timeout: timeoutMs,
-        },
-      }, {
-        onError: (err) => {
-        if (!pending.has(callId)) return
-        pending.delete(callId)
-        clearTimeout(timer)
-        reject(err)
-        },
-      })
-  })
+    return String(response?.result ?? '')
+  } catch (error) {
+    await cancelBrokerCall(discovery, callId, error?.message || 'agent broker request failed')
+    throw error
+  }
 }

package/src/runtime/memory/lib/compact-vector-cache.mjs

@@ -0,0 +1,88 @@
+const DEFAULT_MAX_ENTRIES = 1000
+const DEFAULT_MAX_BYTES = 8 * 1024 * 1024
+
+function entryBytes(key, vector) {
+  // Vector storage is exact (Float32Array.byteLength). UTF-16 key bytes plus a
+  // small fixed allowance bound Map/string/object overhead conservatively.
+  return vector.byteLength + String(key).length * 2 + 64
+}
+
+/**
+ * LRU cache specialized for embedding vectors.
+ *
+ * Worker results are semantically float32 but arrive over structured clone as
+ * JS number[]. Keeping 1,000 such arrays stores every component as a wider JS
+ * Number. Compact once on insertion; callers still receive normal arrays, so
+ * the embedding provider's public contract and PG serialization stay intact.
+ */
+export function createCompactVectorCache({
+  maxEntries = DEFAULT_MAX_ENTRIES,
+  maxBytes = DEFAULT_MAX_BYTES,
+} = {}) {
+  const entryLimit = Math.max(1, Math.floor(Number(maxEntries) || DEFAULT_MAX_ENTRIES))
+  const byteLimit = Math.max(1024, Math.floor(Number(maxBytes) || DEFAULT_MAX_BYTES))
+  const entries = new Map()
+  let bytes = 0
+
+  function remove(key) {
+    const current = entries.get(key)
+    if (!current) return false
+    entries.delete(key)
+    bytes = Math.max(0, bytes - current.bytes)
+    return true
+  }
+
+  function trim() {
+    while (entries.size > entryLimit || bytes > byteLimit) {
+      const oldest = entries.keys().next().value
+      if (oldest === undefined) break
+      remove(oldest)
+    }
+  }
+
+  function set(key, input) {
+    if (!Array.isArray(input) && !ArrayBuffer.isView(input)) {
+      throw new TypeError('embedding cache vector must be an array or typed array')
+    }
+    const vector = input instanceof Float32Array ? input.slice() : Float32Array.from(input)
+    remove(key)
+    const size = entryBytes(key, vector)
+    // A single vector larger than the whole budget is useful to its caller but
+    // must not permanently violate the cache bound.
+    if (size > byteLimit) return false
+    entries.set(key, { vector, bytes: size })
+    bytes += size
+    trim()
+    return true
+  }
+
+  function get(key) {
+    const current = entries.get(key)
+    if (!current) return null
+    entries.delete(key)
+    entries.set(key, current)
+    return current.vector
+  }
+
+  function clear() {
+    entries.clear()
+    bytes = 0
+  }
+
+  function snapshot() {
+    return {
+      entries: entries.size,
+      bytes,
+      maxEntries: entryLimit,
+      maxBytes: byteLimit,
+    }
+  }
+
+  return {
+    get,
+    set,
+    has: (key) => entries.has(key),
+    clear,
+    snapshot,
+  }
+}

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

@@ -29,6 +29,20 @@ export const CORE_DEDUP_TOP_K = 5
 
 const CORE_ELEMENT_DERIVE_LENGTH = 40
 
+// Op aliases: the surface verbs are add/edit/delete/list/…, and a caller
+// naming the same intent differently ("update", "remove") used to get a hard
+// rejection. Only unambiguous synonyms map through.
+const CORE_OP_ALIASES = {
+  update: 'edit', modify: 'edit', change: 'edit', set: 'edit',
+  create: 'add', new: 'add', insert: 'add', store: 'add', save: 'add',
+  remove: 'delete', rm: 'delete', del: 'delete', forget: 'delete',
+  show: 'list', get: 'list', read: 'list',
+}
+export function normalizeCoreOp(op) {
+  const raw = String(op ?? '').trim().toLowerCase()
+  return CORE_OP_ALIASES[raw] ?? raw
+}
+
 function trimOrNull(v) {
   if (v == null) return null
   const s = String(v).trim()
@@ -36,7 +50,10 @@ function trimOrNull(v) {
 }
 
 export function normalizeCoreInput(input = {}, options = {}) {
-  const summary = trimOrNull(input.summary ?? input.content)
+  // Summary aliases: the field is `summary`, but callers routinely send the
+  // synonym they'd use in prose. Accepting them costs nothing and removes a
+  // measured class of bounced calls.
+  const summary = trimOrNull(input.summary ?? input.content ?? input.text ?? input.value ?? input.note)
   const element = trimOrNull(input.element) ?? (summary ? summary.slice(0, CORE_ELEMENT_DERIVE_LENGTH) : null)
   const suppliedCategory = trimOrNull(input.category)
   const category = (suppliedCategory ?? 'fact').toLowerCase()

package/src/runtime/memory/lib/cycle-llm-adapters.mjs

@@ -1,43 +1,22 @@
 // Cycle LLM dispatch adapters, extracted from index.mjs (pass 3).
 //
-// Each cycleN scheduler/handler routes its LLM work through an in-process
-// makeAgentDispatch() adapter (the memory daemon runs the provider registry
-// locally, so the dead IPC agent path is never used). The factory built per
-// cycle is fixed (role/taskType), so it is memoized in a single-slot closure
-// and reshaped to the cycle call signature:
+// Each cycleN scheduler/handler routes its LLM work through the provider's
+// process-singleton agent broker. The memory process owns PG/embeddings only;
+// provider/session modules are not duplicated here. The factory fixes the
+// cycle role/taskType and reshapes to the cycle call signature:
 //   callLlm({ role, taskType, mode, preset, timeout, cwd }, userMessage) -> string
-// while makeAgentDispatch's function takes a single { prompt } object. The
-// adapter maps the two — preset/cwd resolution is handled inside
-// makeAgentDispatch via role.
+// while callAgentDispatch takes (opts, prompt).
 //
-// Pure factory: index.mjs injects makeAgentDispatch. No import-time side
+// Pure factory: index.mjs injects callAgentDispatch. No import-time side
 // effects, no db/config coupling.
-export function createCycleLlmAdapters({ makeAgentDispatch }) {
+export function createCycleLlmAdapters({ callAgentDispatch }) {
   function buildAdapter(agent) {
-    let dispatch = null
     return async (opts = {}, userMessage) => {
-      if (!dispatch) {
-        dispatch = makeAgentDispatch({
-          agent,
-          taskType: 'maintenance',
-          sourceType: 'memory-cycle',
-          // The cycle agents parse 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 no-truncation contract is preserved.
-          brief: false,
-        })
-      }
-      // Preserve the cycle timeout contract: the caller 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 dispatch({
-        prompt: String(userMessage ?? ''),
-        preset: opts?.preset || undefined,
-        ...(Number.isFinite(callTimeout) && callTimeout > 0 ? { idleTimeoutMs: callTimeout } : {}),
-      })
+      return callAgentDispatch({
+        ...opts,
+        agent,
+        taskType: 'maintenance',
+      }, String(userMessage ?? ''))
     }
   }
 
@@ -45,7 +24,7 @@ export function createCycleLlmAdapters({ makeAgentDispatch }) {
   // treat these as FACTORIES: call once to obtain the callLlm adapter.
   // Returning the adapter directly here made `getCycle1CallLlm()` execute an
   // LLM dispatch with no arguments — empty prompt → agent-dispatch throw →
-  // unhandled rejection that killed the memory daemon. Keep the factory
+  // unhandled rejection that killed the memory runtime. Keep the factory
   // contract: each getter returns the (memoized) adapter function.
   const cycle1 = buildAdapter('cycle1-agent')
   const cycle2 = buildAdapter('cycle2-agent')

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

@@ -8,6 +8,7 @@ import { Worker } from 'worker_threads'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 import { writeProfilePoint } from './model-profile.mjs'
+import { createCompactVectorCache } from './compact-vector-cache.mjs'
 import {
   getConfiguredEmbeddingModelId,
   getDefaultEmbeddingDtype,
@@ -33,27 +34,21 @@ let _warmupPromise = null
 let _embedCallCount = 0
 let _msgId = 0
 const _pending = new Map()
+const retiringWorkers = new WeakSet()
 const EMBED_STEADY_SAMPLE_EVERY = 20
-const queryEmbeddingCache = new Map()
-const QUERY_EMBEDDING_CACHE_LIMIT = 1000
+const queryEmbeddingCache = createCompactVectorCache({
+  maxEntries: 1000,
+  maxBytes: 8 * 1024 * 1024,
+})
 
 const WORKER_PATH = join(fileURLToPath(import.meta.url), '..', 'embedding-worker.mjs')
 
 function cacheEmbedding(key, vector) {
-  if (queryEmbeddingCache.has(key)) queryEmbeddingCache.delete(key)
   queryEmbeddingCache.set(key, vector)
-  if (queryEmbeddingCache.size > QUERY_EMBEDDING_CACHE_LIMIT) {
-    const oldestKey = queryEmbeddingCache.keys().next().value
-    if (oldestKey) queryEmbeddingCache.delete(oldestKey)
-  }
 }
 
 function getCachedEmbedding(key) {
-  if (!queryEmbeddingCache.has(key)) return null
-  const value = queryEmbeddingCache.get(key)
-  queryEmbeddingCache.delete(key)
-  queryEmbeddingCache.set(key, value)
-  return value
+  return queryEmbeddingCache.get(key)
 }
 
 function ensureWorker() {
@@ -68,8 +63,16 @@ function ensureWorker() {
   }
   _lastRestartMs = now
   const execArgv = process.execArgv.filter((arg) => !String(arg).startsWith('--input-type'))
-  worker = new Worker(WORKER_PATH, { env: { ...process.env }, execArgv })
-  worker.on('message', (msg) => {
+  const created = new Worker(WORKER_PATH, { env: { ...process.env }, execArgv })
+  worker = created
+  const rejectWorkerPending = (error) => {
+    for (const [id, pending] of _pending) {
+      if (pending.worker !== created) continue
+      _pending.delete(id)
+      pending.reject(error)
+    }
+  }
+  created.on('message', (msg) => {
     if (msg.type === 'log') {
       // Worker-thread stdio forwarded via IPC (see embedding-worker.mjs
       // header): route through the parent's guardable stderr so TUI runs
@@ -85,8 +88,25 @@ function ensureWorker() {
       _modelReady = false
       _device = 'cpu'
       const reason = String(msg.reason || 'idle timeout')
-      __mixdogMemoryLog(`[embed] ${reason} — model disposed\n`)
+      __mixdogMemoryLog(`[embed] ${reason} — model disposed; retiring worker thread\n`)
       writeProfilePoint({ phase: 'post-idle', model: MODEL_ID, device: msg.device, dtype: msg.dtype, note: reason })
+      // A request can be posted after the worker's idle timer starts disposal
+      // but before this notification reaches the parent. Do not terminate that
+      // worker out from under the accepted request; its next idle cycle will
+      // retire it after the request finishes.
+      const hasAcceptedRequest = [..._pending.values()]
+        .some((pending) => pending.worker === created)
+      if (hasAcceptedRequest) {
+        __mixdogMemoryLog(`[embed] ${reason} — worker retirement deferred for accepted request\n`)
+        return
+      }
+      // ORT's native allocator does not reliably return model pages when only
+      // InferenceSession.dispose() runs on Windows. Ending the worker thread is
+      // the actual native-memory boundary; the next recall lazily creates a
+      // fresh worker while cached dimensions remain available.
+      if (worker === created) worker = null
+      retiringWorkers.add(created)
+      void created.terminate().catch(() => {})
       return
     }
     const pending = _pending.get(msg.id)
@@ -98,28 +118,28 @@ function ensureWorker() {
       pending.resolve(msg)
     }
   })
-  worker.on('error', (err) => {
+  created.on('error', (err) => {
     __mixdogMemoryLog(`[embed] worker error: ${err?.message || err}\n`)
-    for (const [, p] of _pending) p.reject(err)
-    _pending.clear()
-    worker = null
+    rejectWorkerPending(err)
+    if (worker === created) worker = null
     _modelReady = false
     _restartCount++
   })
-  worker.on('exit', (code) => {
+  created.on('exit', (code) => {
+    const retired = retiringWorkers.has(created)
+    retiringWorkers.delete(created)
     const exitError = new Error(`Worker exited with code ${code}`)
-    if (code !== 0) {
+    if (!retired && code !== 0) {
       __mixdogMemoryLog(`[embed] worker exited with code ${code}\n`)
       _restartCount++
-    } else {
+    } else if (!retired) {
       _restartCount = 0
     }
-    for (const [, p] of _pending) p.reject(exitError)
-    _pending.clear()
-    worker = null
+    rejectWorkerPending(exitError)
+    if (worker === created) worker = null
     _modelReady = false
   })
-  return worker
+  return created
 }
 
 const EMBED_WORKER_TIMEOUT_MS = 60_000
@@ -140,6 +160,7 @@ function sendToWorker(action, extra = {}, timeoutMs = EMBED_WORKER_TIMEOUT_MS) {
       reject(new Error(`embed worker ${action} timed out after ${timeoutMs}ms`))
     }, timeoutMs)
     _pending.set(id, {
+      worker: w,
       resolve: (v) => { clearTimeout(timer); resolve(v) },
       reject: (e) => { clearTimeout(timer); reject(e) },
     })