mixdog 0.9.96 → 0.9.97

package/src/runtime/memory/index.mjs

@@ -1,13 +1,8 @@
 #!/usr/bin/env bun
 import { __mixdogMemoryLog } from './lib/memory-log.mjs';
 
-process.removeAllListeners('warning')
-process.on('warning', () => {})
-
-// V8 compile cache: the memory runtime is its own long-lived child process
-// (spawned by the channel daemon / standalone proxy) and never passes through
-// cli.mjs, so it pays full ESM parse cost on every boot without this. Same
-// best-effort guard as cli.mjs.
+// V8 compile cache: the memory runtime is a separate long-lived child in
+// product mode. The standalone MCP entry uses the same module directly.
 try {
   const { enableCompileCache } = await import('node:module')
   enableCompileCache?.()
@@ -26,8 +21,6 @@ import { readPluginVersion, readPromotionCodeFingerprint } from './lib/promotion
 const PLUGIN_VERSION = readPluginVersion(PLUGIN_ROOT)
 const BOOT_PROMOTION_CODE_FINGERPRINT = readPromotionCodeFingerprint(PLUGIN_ROOT)
 
-try { os.setPriority(os.constants.priority.PRIORITY_BELOW_NORMAL) } catch {}
-
 import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
@@ -104,8 +97,14 @@ import {
   assertSecondaryPgAttachable as _assertSecondaryPgAttachable,
 } from './lib/memory-config-flags.mjs'
 const IS_MEMORY_ENTRY = !!process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href
-const USE_ARG_DATA_DIR = IS_MEMORY_ENTRY || process.env.MIXDOG_WORKER_MODE === '1'
+if (IS_MEMORY_ENTRY) {
+  process.removeAllListeners('warning')
+  process.on('warning', () => {})
+  try { os.setPriority(os.constants.priority.PRIORITY_BELOW_NORMAL) } catch {}
+}
+const USE_ARG_DATA_DIR = IS_MEMORY_ENTRY
 const DATA_DIR = process.env.MIXDOG_DATA_DIR || (USE_ARG_DATA_DIR ? process.argv[2] : '') || resolvePluginData()
+const INTEGRATED_DAEMON_HOST = process.env.MIXDOG_DAEMON_HOST === '1' && !IS_MEMORY_ENTRY
 if (!DATA_DIR) {
   __mixdogMemoryLog('[memory-service] memory data dir not set and no explicit data dir provided\n')
   process.exit(1)
@@ -126,9 +125,6 @@ function memoryProfile(event, fields = {}) {
 import {
   parsePositivePid,
   isPidAliveLocal,
-  tryAcquireMemoryOwnerLock as _tryAcquireMemoryOwnerLock,
-  releaseMemoryOwnerLock as _releaseMemoryOwnerLock,
-  killPreviousServer as _killPreviousServer,
   acquireLock as _acquireLock,
   releaseLock as _releaseLock,
 } from './lib/memory-process-lock.mjs'
@@ -169,19 +165,6 @@ const _daemonLifecycle = createMemoryDaemonLifecycle({
 const { touchDaemonIdleTimer, registerClient, deregisterClient } = _daemonLifecycle
 
 const LOCK_FILE = path.join(DATA_DIR, '.memory-service.lock')
-// Owner-election lock. Separate from LOCK_FILE so single-instance mode keeps
-// its kill-the-previous protocol while multi-instance fork-proxy workers use
-// atomic CAS for takeover. Created via fs.openSync(path,'wx') — node guarantees
-// EEXIST when another process won the race.
-const OWNER_LOCK_FILE = path.join(DATA_DIR, '.memory-owner.lock')
-
-function tryAcquireMemoryOwnerLock() {
-  return _tryAcquireMemoryOwnerLock(OWNER_LOCK_FILE, __mixdogMemoryLog)
-}
-
-function releaseMemoryOwnerLock() {
-  return _releaseMemoryOwnerLock(OWNER_LOCK_FILE)
-}
 
 const BASE_PORT = 3350
 const MAX_PORT = 3357
@@ -190,10 +173,6 @@ let _traceDb = null
 
 const MEMORY_INSTRUCTIONS_TEXT = ''
 
-function killPreviousServer(pid) {
-  return _killPreviousServer(pid, __mixdogMemoryLog)
-}
-
 function acquireLock() {
   return _acquireLock(LOCK_FILE, __mixdogMemoryLog)
 }
@@ -352,7 +331,7 @@ async function _initStore() {
   } else {
     __mixdogMemoryLog('[memory-service] secondary mode; skipping llm worker\n')
   }
-  // Provider/session/agent modules live once in the backend daemon. Memory
+  // Provider/session/agent modules live once in the daemon. Memory
   // cycles cross the authenticated loopback broker instead of initializing a
   // second registry in this process.
   _bootTimestamp = Date.now()
@@ -587,31 +566,61 @@ export { TOOL_DEFS, handleToolCall, buildSessionCoreMemoryPayload }
 export { MEMORY_INSTRUCTIONS_TEXT as instructions }
 export { acquireLock, releaseLock }
 export { cwdFromTranscriptPath }
-function sendMemoryWorkerMessage(message) {
-  return safeIpcSend(process, message, {
-    onError: (error) => {
-      const code = error?.code ? ` code=${error.code}` : ''
-      __mixdogMemoryLog(`[memory-worker] IPC send failed${code}: ${error?.message || error}\n`)
-    },
+
+/** In-process write surface used by the unified channel/session daemon. */
+export async function appendEntry(data = {}) {
+  await init()
+  const role = String(data.role ?? 'user')
+  const content = String(data.content ?? '')
+  const cleaned = cleanMemoryText(content)
+  if (!cleaned || !cleaned.trim()) return { error: content ? 'empty after clean' : 'content required' }
+  const sourceRef = String(data.sourceRef ?? `manual:${Date.now()}-${process.pid}`)
+  const sessionId = data.sessionId ?? null
+  const tsMs = parseTsToMs(data.ts ?? Date.now())
+  const projectId = resolveProjectScope(typeof data.cwd === 'string' && data.cwd ? data.cwd : null)
+  const result = await db.query(`
+    INSERT INTO entries(ts, role, content, source_ref, session_id, project_id)
+    VALUES ($1, $2, $3, $4, $5, $6)
+    ON CONFLICT DO NOTHING
+    RETURNING id
+  `, [tsMs, role, cleaned, sourceRef, sessionId, projectId])
+  const insertedId = result.rows[0]?.id ?? null
+  return {
+    ok: true,
+    id: insertedId !== null ? Number(insertedId) : null,
+    changes: Number(result.rowCount ?? result.affectedRows ?? 0),
+  }
+}
+
+/** In-process transcript ingest surface used by the unified daemon. */
+export async function ingestTranscript(filePath, { cwd } = {}) {
+  await init()
+  if (!filePath) return { error: 'filePath required' }
+  const ingested = await ingestTranscriptFile(filePath, { cwd })
+  return { ok: true, ingested }
+}
+
+/** Direct trace sink for agent orchestration running in this daemon process. */
+export async function recordTraceEvents(events = []) {
+  await init()
+  if (!Array.isArray(events)) throw new TypeError('events must be an array')
+  if (events.length > 500) throw new RangeError('too many events (max 500)')
+  if (!_traceDb) {
+    _traceDb = await openTraceDatabase(DATA_DIR)
+    registerTraceExitDrain(_traceDb)
+  }
+  enqueueTraceEvents(_traceDb, events)
+  void insertAgentCalls(_traceDb, events).catch((error) => {
+    __mixdogMemoryLog(`[trace] insertAgentCalls error: ${error?.message}\n`)
   })
+  return { ok: true, queued: events.length }
 }
 export async function init() {
   if (_initialized) return
   __mixdogMemoryLog(`[boot-time] tag=memory-init-start tMs=${Date.now()}\n`)
-  if (process.env.MIXDOG_WORKER_MODE === '1' && process.send) {
-    // Single-worker daemon: acquire the owner lock (which reclaims a crashed
-    // predecessor's stale, dead-PID lock). If a LIVE peer still holds it — an
-    // anomaly, since server-main forks exactly one memory worker — exit so
-    // server-main respawns us instead of running a second owner.
-    if (!tryAcquireMemoryOwnerLock()) {
-      __mixdogMemoryLog('[memory-service] live peer holds owner lock — exiting for respawn\n')
-      process.exit(0)
-    }
-    process.on('exit', releaseMemoryOwnerLock)
-  }
   const runtimeReady = _beginRuntimeInit()
   let boundPort = null
-  if (!memorySecondaryMode()) {
+  if (!memorySecondaryMode() && !INTEGRATED_DAEMON_HOST) {
     boundPort = await _startHttpServer()
     advertiseMemoryPort(boundPort)
     try {
@@ -630,11 +639,10 @@ export async function init() {
   } else {
     await runtimeReady
   }
+  __mixdogMemoryLog(`[memory-service] init() complete (entries unified mode, version=${PLUGIN_VERSION})\n`)
   if (process.env.MIXDOG_WORKER_MODE === '1' && process.send) {
-    __mixdogMemoryLog(`[boot-time] tag=memory-ready tMs=${Date.now()}\n`)
-    sendMemoryWorkerMessage({ type: 'ready', port: boundPort })
+    safeIpcSend(process, { type: 'ready', port: boundPort })
   }
-  __mixdogMemoryLog(`[memory-service] init() complete (entries unified mode, version=${PLUGIN_VERSION})\n`)
   touchDaemonIdleTimer('init')
 }
 
@@ -669,49 +677,11 @@ export async function stop() {
     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.
+    // postmaster keeps running after the unified daemon exits.
     if (!memorySecondaryMode()) {
       try {
-        // Conservative check: only skip stopPgForShutdown when the owner
-        // record is unambiguously (a) a memory-runtime-daemon owner record
-        // (kind check — guards against a stale/foreign pid reusing this pid
-        // number for an unrelated process) and (b) that pid is alive AND not
-        // this process. Any read/parse failure or ambiguous state falls back
-        // to stopping PG (previous unconditional behavior) rather than
-        // risking an orphaned PG postmaster.
-        const anotherOwnerAlive = await (async () => {
-          try {
-            const { readSingletonOwner } = await import('../shared/singleton-owner.mjs')
-            const ownerPath = path.join(DATA_DIR, 'memory-runtime-owner.json')
-            const { owner, alive } = readSingletonOwner(ownerPath)
-            if (!alive) return false
-            if (owner?.kind !== 'memory-runtime-daemon') return false
-            const ownerPid = Number(owner?.pid)
-            if (!Number.isInteger(ownerPid) || ownerPid === process.pid) return false
-            // Best-effort process-name check (mirrors supervisor.mjs's
-            // isPostgresPid pattern) — confirms the pid is actually a node
-            // process before trusting it as a live sibling memory owner.
-            // Falls back to true (trust the owner file) when the platform
-            // check is unavailable or inconclusive.
-            try {
-              if (process.platform === 'win32') {
-                const { execFileSync } = await import('node:child_process')
-                const out = execFileSync('tasklist', ['/FI', `PID eq ${ownerPid}`, '/FO', 'CSV', '/NH'], { encoding: 'utf8', windowsHide: true })
-                if (!String(out || '').toLowerCase().includes('node')) return false
-              } else if (process.platform === 'linux') {
-                const comm = fs.readFileSync(`/proc/${ownerPid}/comm`, 'utf8').trim()
-                if (!comm.includes('node')) return false
-              }
-            } catch { /* inconclusive — trust the owner file (already alive+kind-matched) */ }
-            return true
-          } catch { return false }
-        })()
-        if (anotherOwnerAlive) {
-          __mixdogMemoryLog('[memory-service] shutdown: another live memory owner holds memory-runtime-owner.json — leaving PG running\n')
-        } else {
-          const { stopPgForShutdown } = await import('./lib/pg/supervisor.mjs')
-          await stopPgForShutdown()
-        }
+        const { stopPgForShutdown } = await import('./lib/pg/supervisor.mjs')
+        await stopPgForShutdown()
       } catch {}
     } else {
       __mixdogMemoryLog('[memory-service] secondary mode; leaving shared PG running\n')
@@ -778,120 +748,9 @@ function _startHttpServer() {
   return _httpReadyPromise
 }
 
-if (process.env.MIXDOG_WORKER_MODE === '1' && process.send) {
-  // SIGTERM/SIGINT handler for worker mode: call stop() (fsyncs,
-  // removes port file) then exit(0). Prevents taskkill /F from bypassing
-  // graceful shutdown and leaving pgdata in an inconsistent checkpoint state.
-  let _stopInFlight = false
-  let _syncPgStopRequested = false
-  const _workerSignalHandler = (sig) => {
-    if (_stopInFlight) {
-      __mixdogMemoryLog(`[memory-worker] ${sig} — stop already in flight, ignoring\n`)
-      return
-    }
-    _stopInFlight = true
-    _syncPgStopRequested = true
-    __mixdogMemoryLog(`[memory-worker] received ${sig} — calling stop() for clean shutdown\n`)
-    const _exitTimer = setTimeout(() => {
-      __mixdogMemoryLog(`[memory-worker] stop() timed out after 6000ms — forcing exit(2)\n`)
-      process.exit(2)
-    }, 6000)
-    stop().then(() => {
-      clearTimeout(_exitTimer)
-      __mixdogMemoryLog(`[memory-worker] stop() complete — exiting cleanly\n`)
-      process.exit(0)
-    }).catch((e) => {
-      clearTimeout(_exitTimer)
-      __mixdogMemoryLog(`[memory-worker] stop() error on ${sig}: ${e && (e.message || e)}\n`)
-      process.exit(1)
-    })
-  }
-  process.on('SIGTERM', () => _workerSignalHandler('SIGTERM'))
-  process.on('SIGINT',  () => _workerSignalHandler('SIGINT'))
-
-  // Windows-safe last resort: SIGTERM may TerminateProcess before the async
-  // stop() path runs, orphaning PG mid-write. Best-effort sync pg_ctl stop on
-  // exit (no-op after a completed graceful stop). Skip in secondary mode — we
-  // do not own the shared PG there.
-  if (!memorySecondaryMode()) process.on('exit', () => {
-    // Do not stop shared PG on an unexpected Memory crash. The singleton proxy
-    // will respawn a daemon that can attach to the still-healthy cluster. The
-    // sync stop is only a last resort after an explicit shutdown signal began.
-    if (_syncPgStopRequested) {
-      try { stopPgForShutdownSync() } catch {}
-    }
-  })
-
-  // callId → AbortController for in-flight IPC calls (cancel handler uses this).
-  const _inFlightCalls = new Map()
-
-  process.on('message', async (msg) => {
-    // Handle parent-initiated graceful shutdown IPC message.
-    if (msg.type === 'shutdown') {
-      __mixdogMemoryLog('[memory-worker] received IPC shutdown — calling stop()\n')
-      _workerSignalHandler('IPC:shutdown')
-      return
-    }
-    if (msg.type === 'cancel' && msg.callId) {
-      const entry = _inFlightCalls.get(msg.callId)
-      if (entry) {
-        // Mark cancelled so the in-flight call's result/error branch below
-        // does not double-respond after the AbortController fires.
-        entry.cancelled = true
-        entry.ac.abort()
-        _inFlightCalls.delete(msg.callId)
-        sendMemoryWorkerMessage({ type: 'result', callId: msg.callId, error: 'cancelled' })
-      }
-      return
-    }
-    if (msg.type !== 'call' || !msg.callId) return
-    const entry = { ac: new AbortController(), cancelled: false }
-    _inFlightCalls.set(msg.callId, entry)
-    try {
-      let result
-      try {
-        result = await handleToolCall(msg.name, msg.args || {}, entry.ac.signal)
-      } finally {
-        _inFlightCalls.delete(msg.callId)
-      }
-      if (!entry.cancelled) sendMemoryWorkerMessage({ type: 'result', callId: msg.callId, result })
-    } catch (e) {
-      if (!entry.cancelled) sendMemoryWorkerMessage({ type: 'result', callId: msg.callId, error: e.message })
-    }
-  })
-  init().catch(e => {
-    let detail
-    try {
-      const parts = []
-      if (e?.name) parts.push(`name=${e.name}`)
-      if (e?.code) parts.push(`code=${e.code}`)
-      if (e?.errno) parts.push(`errno=${e.errno}`)
-      if (e?.syscall) parts.push(`syscall=${e.syscall}`)
-      if (e?.path) parts.push(`path=${e.path}`)
-      if (e?.message) parts.push(`message=${e.message}`)
-      let stringified = null
-      try { stringified = JSON.stringify(e, Object.getOwnPropertyNames(e || {})) } catch {}
-      if (stringified && stringified !== '{}' && stringified !== '"{}"') parts.push(`json=${stringified}`)
-      if (e?.stack) parts.push(`\nstack=\n${e.stack}`)
-      if (parts.length === 0) parts.push(`raw=${typeof e}:${String(e)}`)
-      detail = parts.join(' | ')
-    } catch (logErr) {
-      detail = `(error formatting failed: ${logErr?.message}) raw=${String(e)}`
-    }
-    __mixdogMemoryLog(`[memory-worker] init failed: ${detail}\n`)
-    // Signal degraded state to parent before exiting so it records the failure
-    // rather than treating this as a normal pre-ready crash.
-    sendMemoryWorkerMessage({ type: 'ready', degraded: true, error: detail.slice(0, 800) })
-    process.exit(1)
-  })
-}
-
-// Standalone MCP launcher path. When this module is the entry script AND no
-// MIXDOG_WORKER_MODE flag is set, we own stdio and bring up the full MCP
-// 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 (IS_MEMORY_ENTRY && process.env.MIXDOG_WORKER_MODE !== '1') {
+// Standalone MCP launcher path. Product mode imports this module into the
+// unified daemon; running the module directly owns stdio for MCP clients.
+if (IS_MEMORY_ENTRY) {
   ;(async () => {
     acquireLock()
     process.on('exit', releaseLock)
@@ -908,10 +767,12 @@ if (IS_MEMORY_ENTRY && process.env.MIXDOG_WORKER_MODE !== '1') {
     process.on('SIGINT', stopFromSignal)
     process.on('SIGTERM', stopFromSignal)
     await init()
-    const transport = new StdioServerTransport()
-    await mcp.connect(transport)
-    await new Promise((resolve) => { mcp.onclose = resolve })
-    await stop()
+    if (!(process.env.MIXDOG_WORKER_MODE === '1' && process.send)) {
+      const transport = new StdioServerTransport()
+      await mcp.connect(transport)
+      await new Promise((resolve) => { mcp.onclose = resolve })
+      await stop()
+    }
   })().catch((err) => {
     __mixdogMemoryLog(`[memory-service] startup failed: ${err.stack || err.message}\n`)
     process.exit(1)

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

@@ -2,9 +2,9 @@
  * Agent-dispatch client for the memory process.
  *
  * PG/embedding/recall remain isolated in the memory process, while the heavy
- * provider/session graph lives exactly once in the machine-global backend
+ * 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 backend restart.
+ * can outlive its original fork parent and reconnect after a daemon restart.
  */
 import http from 'node:http'
 import { readFileSync } from 'node:fs'
@@ -37,12 +37,13 @@ function isPidAlive(value) {
 
 function readBrokerDiscovery() {
   try {
-    const raw = JSON.parse(readFileSync(join(runtimeRoot(), 'channel-daemon.json'), 'utf8'))
-    const port = Number(raw?.port)
-    if (!Number.isInteger(port) || port <= 0 || port >= 65536 || !raw?.token || !isPidAlive(raw?.pid)) {
+    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(raw.token) }
+    return { port, token: String(endpoint.token) }
   } catch {
     return null
   }
@@ -129,7 +130,7 @@ function cancelBrokerCall(discovery, callId, reason) {
 }
 
 /**
- * Dispatch through the singleton backend provider/session graph.
+ * Dispatch through the singleton daemon provider/session graph.
  *
  * @param {object} opts           agent-dispatch construction options
  * @param {string} [opts.agent]
@@ -144,7 +145,7 @@ function cancelBrokerCall(discovery, callId, reason) {
 export async function callAgentDispatch(opts = {}, prompt) {
   const discovery = readBrokerDiscovery()
   if (!discovery) {
-    throw new Error('agent-broker: backend daemon unavailable')
+    throw new Error('agent-broker: daemon unavailable')
   }
   const callId = nextCallId()
   const timeoutMs = Math.max(1000, Number(opts.timeout ?? 600000))

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

@@ -1,6 +1,6 @@
 // Cycle LLM dispatch adapters, extracted from index.mjs (pass 3).
 //
-// Each cycleN scheduler/handler routes its LLM work through the backend's
+// 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:
@@ -24,7 +24,7 @@ export function createCycleLlmAdapters({ callAgentDispatch }) {
   // 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/http-router.mjs

@@ -121,10 +121,7 @@ export function createHttpRouter({
   const _ownerInFlightHttpCalls = new Map()
 
   const requestHandler = async (req, res) => {
-    touchDaemonIdleTimer(`${req.method || 'HTTP'} ${req.url || '/'}`)
-    // Connected-client lifecycle. Proxies register on first use and
-    // deregister on CLI shutdown; the daemon reaps itself shortly after the
-    // last client leaves (see registerClient/deregisterClient in index.mjs).
+    touchDaemonIdleTimer?.(`${req.method || 'HTTP'} ${req.url || '/'}`)
     if (req.method === 'POST' && (req.url === '/client/register' || req.url === '/client/deregister')) {
       if (!isLocalOrigin(req)) {
         sendJson(res, { ok: false, error: 'forbidden: cross-origin' }, 403)
@@ -136,8 +133,6 @@ export function createHttpRouter({
       if (req.url === '/client/register') {
         const accepted = registerClient?.(clientPid)
         if (accepted === false) {
-          // Daemon is draining — distinct signal so the proxy respawns a fresh
-          // daemon and retries its pending RPC instead of binding to this one.
           sendJson(res, { ok: false, draining: true, error: 'memory worker draining' }, 503)
           return
         }

package/src/runtime/memory/lib/memory-config-flags.mjs

@@ -14,7 +14,7 @@ export function readMainConfig() {
 
 // Recap toggle lives in the `agent` config section (agent.recap.enabled,
 // default true) — the same file the session runtime persists via
-// saveConfigAndAdopt. The memory daemon runs as a detached cross-process HTTP
+// saveConfigAndAdopt. The memory runtime is hosted by the unified daemon
 // worker, so it re-reads this section from disk each cycle tick (poll-on-use)
 // rather than relying on IPC.
 

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

@@ -2,6 +2,7 @@
 // memory-cycle2.mjs). Logging shim, abort check, and resource-dir resolution.
 // No cycle2 business logic; safe to import from any cycle2 sub-module.
 import { fileURLToPath } from 'url'
+import { join } from 'path'
 
 import { __mixdogMemoryLog } from './memory-log.mjs'
 export { __mixdogMemoryLog }
@@ -11,5 +12,7 @@ export function throwIfAborted(signal) {
 }
 
 export function resourceDir() {
-  return process.env.MIXDOG_ROOT || fileURLToPath(new URL('../../../..', import.meta.url))
+  return process.env.MIXDOG_ROOT
+    ? join(process.env.MIXDOG_ROOT, 'src')
+    : fileURLToPath(new URL('../../..', import.meta.url))
 }

package/src/runtime/memory/lib/memory-daemon-lifecycle.mjs

@@ -24,6 +24,11 @@ export function createMemoryDaemonLifecycle({
       _idleShutdownTimer = null
     }
     _idleShutdownTimer = setTimeout(() => {
+      pruneDeadClients()
+      if (_connectedClients.size > 0) {
+        touchDaemonIdleTimer('live client retained')
+        return
+      }
       log(`[memory-service] daemon idle TTL elapsed after ${reason}; shutting down\n`)
       stop()
         .then(() => process.exit(0))

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

@@ -1,4 +1,4 @@
-// Shared memory-daemon stderr logger. The write is captured at import time so
+// Shared memory-runtime stderr logger. The write is captured at import time so
 // memory output stays visible even when a TUI log guard swaps
 // process.stderr.write later; MIXDOG_QUIET_MEMORY_LOG mutes it entirely.
 const __mixdogMemoryStderrWrite = process.stderr.write.bind(process.stderr);

package/src/runtime/memory/lib/memory-process-lock.mjs

@@ -1,6 +1,5 @@
-// Extracted from index.mjs — single/multi-instance process-lock + owner-election
-// helpers. Pure functions parameterized on lock-file paths so index.mjs retains
-// ownership of DATA_DIR-derived constants and the daemon logger.
+// Process lock for the standalone memory MCP entry. Product mode is hosted
+// A direct entry (including the isolated daemon child) owns this lock.
 import fs from 'node:fs'
 import { execFileSync } from 'node:child_process'
 
@@ -15,55 +14,7 @@ export function isPidAliveLocal(pid) {
   catch (e) { return e.code !== 'ESRCH' }
 }
 
-export function tryAcquireMemoryOwnerLock(ownerLockFile, log = () => {}) {
-  // Returns true on success (this process now owns memory worker for the data
-  // dir), false when a live peer holds the lock. Stale locks (dead PID) are
-  // unlinked and retried atomically. Throws on unexpected fs errors so callers
-  // surface lock-system corruption rather than silently downgrading.
-  //
-  // EPERM/EBUSY/EACCES at openSync are transient — AV scanners (SignKorea /
-  // SKCert / ezPDFWS etc) briefly lock newly-created files during inspection.
-  // The 0.1.x baseline threw immediately and the worker promoted to
-  // permanentlyDegraded, killing memory tools for the rest of the session.
-  // Treat the AV error codes as retryable with bounded backoff (~750ms total)
-  // before giving up and rethrowing.
-  for (let attempt = 0; attempt < 5; attempt++) {
-    try {
-      const fd = fs.openSync(ownerLockFile, 'wx')
-      fs.writeSync(fd, String(process.pid))
-      fs.closeSync(fd)
-      return true
-    } catch (e) {
-      if (e.code === 'EEXIST') {
-        let ownerPid = NaN
-        try { ownerPid = Number(fs.readFileSync(ownerLockFile, 'utf8').trim()) } catch {}
-        if (isPidAliveLocal(ownerPid)) return false
-        // Stale lock: dead owner — unlink and retry exclusive create.
-        try { fs.unlinkSync(ownerLockFile) } catch {}
-        continue
-      }
-      const transient = e.code === 'EPERM' || e.code === 'EBUSY' || e.code === 'EACCES'
-      if (transient && attempt < 4) {
-        // Sync busy-wait acceptable here: this runs on memory worker boot
-        // path, once per process; the parent handler is not blocked.
-        const end = Date.now() + 50 * (attempt + 1)
-        while (Date.now() < end) {}
-        continue
-      }
-      throw e
-    }
-  }
-  return false
-}
-
-export function releaseMemoryOwnerLock(ownerLockFile) {
-  try {
-    const ownerPid = Number(fs.readFileSync(ownerLockFile, 'utf8').trim())
-    if (ownerPid === process.pid) fs.unlinkSync(ownerLockFile)
-  } catch {}
-}
-
-export function killPreviousServer(pid, log = () => {}) {
+function killPreviousServer(pid, log = () => {}) {
   if (pid <= 0 || pid === process.pid) return false
   if (process.platform === 'win32') {
     try {
@@ -117,14 +68,8 @@ export function killPreviousServer(pid, log = () => {}) {
 }
 
 export function acquireLock(lockFile, log = () => {}) {
-  // Multi-instance guard. In multi-terminal mode the lock owner is a *peer*
-  // memory worker serving recall for another CC session. killPreviousServer
-  // would taskkill /F that healthy peer mid-flight, then this fork-proxy
-  // mode wouldn't even need a lock anyway. Skip the entire kill-the-previous
-  // protocol; fork-proxy detection in init() takes priority. If neither
-  // proxy nor lock-owner path applies (race window during simultaneous
-  // boot), the worker simply continues without the lock — server-main /
-  // PG / port-listen handle the actual conflict cases.
+  // Multi-instance mode is coordinated by the unified daemon, so a direct MCP
+  // entry does not evict an already-running peer from another client.
   if (process.env.MIXDOG_MULTI_INSTANCE === '1') return
   try {
     if (fs.existsSync(lockFile)) {

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

@@ -417,7 +417,7 @@ async function _migrateRecallIndexesIfStale(db) {
 
 export async function ensureCurrentSchemaExtensions(db, dims) {
   // One-time cleanup: attachment-only placeholder rows ('(attachment)' user
-  // content, e.g. Discord backend discord.mjs:724) predate the
+  // content, e.g. Discord provider discord.mjs:724) predate the
   // shouldExcludeIngestMessage() ingest-time filter (session-ingest.mjs).
   // Delete any already-persisted rows so they stop polluting recall/cycle1.
   // Idempotent (no-op once cleaned); best-effort so a failure never blocks boot.

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

@@ -305,7 +305,7 @@ export function shouldExcludeIngestMessage(m) {
   if (role === 'user' && typeof raw === 'string' && /^Reference files:\s*/i.test(raw.trimStart())) {
     return true
   }
-  // Attachment-only placeholder rows (e.g. Discord backend discord.mjs:724
+  // Attachment-only placeholder rows (e.g. Discord provider discord.mjs:724
   // `"(attachment)"` fallback when a message carries no text, only files).
   // Carries zero retrievable content — excluded so recall isn't polluted
   // with bare "(attachment)" memory rows.

package/src/runtime/search/index.mjs

@@ -286,9 +286,9 @@ function normalizeNativeSearchPayload(result, args, startedAt) {
 
 async function _searchCore(args, { cacheState, nativeSearch, signal }) {
   const cacheArgs = searchArgsForCacheKey(args)
-  const backend = 'native-web-search'
+  const provider = 'native-web-search'
   const searchCacheKey = buildCacheKey('search', {
-    provider: backend,
+    provider,
     ...cacheArgs,
   })
   const cachedSearch = getCachedEntry(cacheState, searchCacheKey)