mcp-agents-memory 0.9.10 → 0.9.12

package/README.md

@@ -89,6 +89,32 @@
 
 ---
 
+## 멀티머신 — 서버 / 클라이언트 (콜드패스 처리)
+
+여러 기기가 **하나의 공유 DB**를 쓸 때, Cold Path(태깅·프로필·클러스터링·alias 판정)는 **한 머신에서만** 돌아야 한다 — 안 그러면 같은 row를 여러 기기가 중복 처리하고 클라우드 비용이 배가된다. 같은 패키지를 **config로 역할만** 가른다:
+
+| | 클라이언트 | 서버 (처리) |
+|---|---|---|
+| **DB** | 원격 DB 접속 (SSH 터널 등) | DB 호스트 / 직접 접속 |
+| **Cold Path** | `COLD_PATH_ENABLED=false` | 전용 데몬으로 상시 가동 |
+| **하는 일** | `search` / `manage_knowledge`만 | 태깅 · 프로필 · 클러스터링 · alias 판정 |
+| **설정 난이도** | `.env` 몇 줄 (순수 config) | config + 로컬 LLM 인프라 |
+
+- **클라이언트**: editor가 띄우는 MCP 서버가 그대로 단말. `.env`에 `COLD_PATH_ENABLED=false`만 추가하면 끝.
+- **서버**: Cold Path를 MCP(=editor) 수명과 분리해 **독립 데몬**으로 상시 가동 (editor를 안 켜도 처리됨):
+  ```bash
+  mcp-agents-memory coldpath    # MCP 서버 없이 Cold Path 워커만 도는 데몬 (systemd 권장)
+  ```
+  데몬은 PostgreSQL advisory lock으로 **싱글톤** 보장 — 인스턴스가 몇 개든 락을 잡은 1개만 처리한다(중복 방지·자동 failover).
+
+### Cold Path LLM 백엔드 (config로 교체)
+
+`LOCAL_LLM_BASE_URL`로 OpenAI-호환 엔드포인트를 가리키면 로컬/셀프호스트 추론을 쓴다 (llama.cpp, ollama 등). 미설정 시 클라우드(`grok-4-1`) 기본. `LOCAL_GROK_FALLBACK=true`면 로컬 실패 시 grok으로 폴백.
+
+> 예) AMD/NVIDIA GPU에 llama.cpp `llama-server`로 Qwen3-14B를 올리고 `LOCAL_LLM_BASE_URL=http://localhost:8080/v1` → 콜드패스 클라우드 비용 ≈ $0. (json_schema 문법 + thinking off로 valid JSON 보장)
+
+---
+
 ## 메모리 로드 룰
 
 - **단기 메모리**: 최근 2-3일 raw 그대로, 또는 8000 토큰(약 12000-16000자) 중 먼저 도달하는 것
@@ -140,10 +166,10 @@ manage_knowledge({
 | 역할 | 사용 기술 |
 |---|---|
 | **Embedding** | OpenAI `text-embedding-3-large` (3072 dim) |
-| **Tagger (Cold Path)** | Google `gemini-2.5-flash` (predefined + dynamic) |
+| **Cold Path LLM** (tagger / librarian / clusterer / project-alias judge) | 로컬 `Qwen3-14B` (llama.cpp, json_schema 문법 + thinking off → valid JSON 보장) **또는** 클라우드 `grok-4-1-fast-non-reasoning` — `LOCAL_LLM_BASE_URL`로 선택 |
 | **검색 fallback** | PostgreSQL `ILIKE` (cosine 임계값 미만 시) |
 | **DB** | PostgreSQL + pgvector |
-| **Librarian (memory → user)** | local `qwen3.6:35b-a3b` (Q4_K_M, ollama) — 30 메시지 + 24h 게이트 |
+| **Librarian (memory → user)** | 위 Cold Path 백엔드 공유 — recency-bias 저항 큐레이션(core 정체성 ↔ sub 작업 분리 + null-preserve), 게이트 env tunable |
 | **Skill 시스템** | TBD (다음 라운드) |
 
 ---
@@ -164,11 +190,22 @@ SSH_HOST=...
 
 # 모델
 EMBEDDING_MODEL=text-embedding-3-large
-TAGGER_MODEL=gemini-2.5-flash
-OPENAI_API_KEY=...
-GEMINI_API_KEY=...
+OPENAI_API_KEY=...                 # embedding (필수)
+XAI_API_KEY=...                    # grok-4-1 (Cold Path 기본 + 로컬 폴백)
+
+# Cold Path LLM 백엔드 — 로컬 추론 쓰려면 OpenAI-호환 엔드포인트 지정 (없으면 클라우드)
+LOCAL_LLM_BASE_URL=http://localhost:8080/v1   # llama.cpp / ollama 등
+LOCAL_GROK_FALLBACK=true           # 로컬 실패 시 grok 폴백
+TAGGER_PROVIDER=local              # local / xai
+TAGGER_MODEL=qwen3-14b
+LIBRARIAN_PROVIDER=local
+LIBRARIAN_MODEL=qwen3-14b
+LIBRARIAN_ENABLED=true
+LIBRARIAN_MSG_THRESHOLD=30         # 라이브러리언 게이트 (기본 보수적)
+LIBRARIAN_COOLDOWN_HOURS=24
 
 # Hot/Cold path 제어
+COLD_PATH_ENABLED=true             # false = 단말(Cold Path 안 돎). 멀티머신에선 처리 서버만 true
 COLD_PATH_INTERVAL_SEC=60          # 1분 단위 스케줄
 COLD_PATH_BATCH_SIZE=5             # 또는 5메시지 단위
 

package/build/index.js

@@ -55458,16 +55458,38 @@ async function callSpec(spec, opts) {
     }
     case "local": {
       const client2 = getLocalClient();
-      const res = await client2.chat.completions.create({
+      let effectiveThinking = opts.enableThinking;
+      if (opts.enableThinking === true && opts.jsonSchema) {
+        console.warn(
+          "[ModelRegistry] enableThinking + jsonSchema both set \u2014 forcing thinking OFF (llama.cpp #20345 silently bypasses grammar when thinking is on)."
+        );
+        effectiveThinking = false;
+      }
+      const responseFormat = opts.jsonSchema ? {
+        type: "json_schema",
+        json_schema: {
+          name: "librarian_profile",
+          strict: true,
+          schema: opts.jsonSchema
+        }
+      } : useJson ? { type: "json_object" } : void 0;
+      const params = {
         model: spec.model_name,
         messages: [
           { role: "system", content: opts.system },
           { role: "user", content: opts.user }
         ],
-        ...useJson ? { response_format: { type: "json_object" } } : {},
+        ...responseFormat ? { response_format: responseFormat } : {},
         temperature: 0.1,
         max_tokens: maxTokens
-      });
+      };
+      const res = await client2.chat.completions.create(
+        // narrow cast: only this call site is widened to accommodate chat_template_kwargs
+        {
+          ...params,
+          ...effectiveThinking !== void 0 ? { chat_template_kwargs: { enable_thinking: effectiveThinking } } : {}
+        }
+      );
       const raw = res.choices[0]?.message?.content || "";
       return raw.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/```json|```/g, "").trim();
     }
@@ -55539,6 +55561,15 @@ async function listProjectTagCandidates(limit2 = 20) {
 function invalidateCandidateCache() {
   _candidateCache = null;
 }
+var TAGGER_SCHEMA = {
+  type: "object",
+  properties: {
+    p_tag: { type: ["string", "null"] },
+    d_tag: { type: "array", items: { type: "string" }, maxItems: 5 }
+  },
+  required: ["p_tag", "d_tag"],
+  additionalProperties: false
+};
 var SYSTEM_PROMPT = `Tagger for one user's personal long-term memory across AI agents.
 
 OUTPUT (strict JSON):
@@ -55598,9 +55629,11 @@ async function tagMessage(input) {
       raw = await callRole("tagger", {
         system: SYSTEM_PROMPT,
         user: userPrompt,
-        responseFormat: "json"
-        // thinking: false — 태거는 단순 매핑 작업. thinking 켜면 reasoning이 모든 토큰 소비해 content 비어버림.
-        // Librarian 등 복잡한 분석 역할에서만 thinking: true 사용.
+        responseFormat: "json",
+        jsonSchema: TAGGER_SCHEMA,
+        enableThinking: false
+        // thinking off — 태거는 단순 매핑 작업. thinking 켜면 reasoning이 모든 토큰 소비해 content 비어버림.
+        // jsonSchema → llama.cpp grammar로 <think> bleed 차단 (Qwen3 bug #20345).
       });
     } catch (err2) {
       if (!localFallbackEnabled) throw err2;
@@ -56218,6 +56251,20 @@ var SOURCE_WEIGHT = {
   name_similarity: 16,
   low_frequency_tag: 8
 };
+var JUDGE_SCHEMA = {
+  type: "object",
+  properties: {
+    relation: { type: "string", enum: ["rename", "alias", "same_project", "different", "misfile_suspected", "insufficient"] },
+    same_project: { type: "boolean" },
+    source_should_alias_target: { type: "boolean" },
+    confidence: { type: "number" },
+    evidence_memory_ids: { type: "array", items: { type: "integer" } },
+    conflict_memory_ids: { type: "array", items: { type: "integer" } },
+    rationale: { type: "string" }
+  },
+  required: ["relation", "same_project", "source_should_alias_target", "confidence", "evidence_memory_ids", "conflict_memory_ids", "rationale"],
+  additionalProperties: false
+};
 var JUDGE_SYSTEM_PROMPT = `You are a project-tag alias judge for one user's personal memory system.
 
 Decide whether two CANONICAL project tags refer to the same project identity.
@@ -56771,7 +56818,7 @@ async function judgePair(pair, tagsById, memoriesByTag) {
   const raw = await callSpec(spec, {
     system: JUDGE_SYSTEM_PROMPT,
     user: userPrompt,
-    ...spec.provider === "local" ? {} : { responseFormat: "json" },
+    ...spec.provider === "local" ? { jsonSchema: JUDGE_SCHEMA, enableThinking: false } : { responseFormat: "json" },
     maxTokens: envInt("PROJECT_ALIAS_JUDGE_MAX_TOKENS", 8192)
   });
   if (!raw) throw new Error("project_alias_judge returned empty content");
@@ -58877,11 +58924,10 @@ var CLUSTER_SYSTEM = `You are a keyword clustering assistant for a personal memo
 Given a list of d_tags (short hyphenated keywords) with their occurrence counts,
 group semantically similar tags that refer to the same project or topic.
 
-OUTPUT strict JSON array:
-[
-  { "canonical": "<best-slug>", "members": ["<tag1>", "<tag2>", ...] },
-  ...
-]
+OUTPUT strict JSON object (NOT a bare array):
+{ "clusters": [
+  { "canonical": "<best-slug>", "members": ["<tag1>", "<tag2>", ...] }
+] }
 
 Rules:
 - canonical must be one of the input tags (pick the most descriptive one) or a clean slug if none fit
@@ -58889,6 +58935,25 @@ Rules:
 - Only group tags that clearly refer to the same project/topic
 - Tags with no similar counterparts become their own single-member cluster
 - Do NOT merge unrelated topics just because they share one word`;
+var CLUSTER_SCHEMA = {
+  type: "object",
+  properties: {
+    clusters: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          canonical: { type: "string" },
+          members: { type: "array", items: { type: "string" } }
+        },
+        required: ["canonical", "members"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["clusters"],
+  additionalProperties: false
+};
 async function clusterDTags(tags) {
   if (tags.length === 0) return [];
   const tagList = tags.map((t) => `${t.tag} (${t.cnt}x)`).join(", ");
@@ -58899,8 +58964,10 @@ ${tagList}`;
     raw = await callRole("clusterer", {
       system: CLUSTER_SYSTEM,
       user: userPrompt,
-      responseFormat: "json",
-      maxTokens: 512
+      jsonSchema: CLUSTER_SCHEMA,
+      enableThinking: false,
+      maxTokens: 4096
+      // was 512 — 50개 태그 클러스터링 출력이 잘려 invalid JSON 폴백됨 (ctx 8192 내 여유)
     });
   } catch (err2) {
     console.error("\u26A0\uFE0F [DTagPromoter] clusterer call failed, falling back to no clustering:", err2);
@@ -58908,8 +58975,9 @@ ${tagList}`;
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) throw new Error("not an array");
+    const obj = JSON.parse(raw);
+    parsed = obj?.clusters;
+    if (!Array.isArray(parsed)) throw new Error("no clusters array");
   } catch {
     console.error("\u26A0\uFE0F [DTagPromoter] clusterer returned invalid JSON, falling back:", raw.slice(0, 200));
     return tags.map((t) => ({ canonical: t.tag, members: [t.tag], total: t.cnt }));
@@ -58993,35 +59061,63 @@ async function runDtagPromotion() {
 
 // src/librarian.ts
 init_db();
-var LIBRARIAN_MSG_THRESHOLD = 30;
-var LIBRARIAN_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
-var LIBRARIAN_RECENT_LIMIT = 50;
-var LIBRARIAN_MAX_TOKENS = 32768;
+var LIBRARIAN_MSG_THRESHOLD = Number(process.env.LIBRARIAN_MSG_THRESHOLD ?? 30);
+var LIBRARIAN_COOLDOWN_MS = Number(process.env.LIBRARIAN_COOLDOWN_HOURS ?? 24) * 60 * 60 * 1e3;
+var LIBRARIAN_RECENT_SLICE = Number(process.env.LIBRARIAN_RECENT_SLICE ?? 25);
+var LIBRARIAN_HISTORY_SLICE = Number(process.env.LIBRARIAN_HISTORY_SLICE ?? 25);
+var LIBRARIAN_MAX_TOKENS = Number(process.env.LIBRARIAN_MAX_TOKENS ?? 2048);
+var LIBRARIAN_PROFILE_SCHEMA = {
+  type: "object",
+  properties: {
+    core_profile: { type: ["string", "null"] },
+    sub_profile: { type: ["string", "null"] }
+  },
+  required: ["core_profile", "sub_profile"],
+  additionalProperties: false
+};
 var SYSTEM_PROMPT2 = `You are the Librarian for one user's personal memory system.
 
 YOUR JOB
-Look at the user's recent first-person messages (role='user' only \u2014 ignore
-assistant replies). Identify any STABLE, MEMORABLE facts about WHO THE USER IS
-or HOW THEY WORK that should be promoted to their long-term profile.
-
-OUTPUT TWO SECTIONS:
-1. core_profile: critically important user identity (name, role, expertise,
-   strong preferences). Should be SHORT (5-10 lines max) and high-signal.
-2. sub_profile: secondary memorable info (tools, environment quirks,
-   ongoing project focus, working style preferences). Can be longer but
-   still curated.
-
-RULES
-- The user is one person. Output is the WHOLE profile (replacing existing,
-  not appending) \u2014 so include relevant existing facts that are still true.
+Look at the user's first-person messages (role='user' only \u2014 ignore assistant
+replies). Identify any STABLE, DURABLE facts about WHO THE USER IS that should
+be promoted to their long-term profile.
+
+OUTPUT TWO SECTIONS \u2014 these are STRICTLY SEPARATE categories:
+
+1. core_profile \u2014 DURABLE IDENTITY ONLY.
+   Who the person IS: name, role, profession, expertise, stable long-term
+   preferences. Should be SHORT (5-10 lines max) and high-signal.
+   Example of the SHAPE only (fictional \u2014 never copy this content): "Backend
+   engineer at a logistics startup; 10+ yrs Python; prefers terse,
+   example-driven answers." Derive the actual content ONLY from the messages.
+
+2. sub_profile \u2014 CURRENT WORK AND ACTIVITY.
+   What they are actively doing, building, or focused on: tools, environment
+   details, ongoing projects, recent working style observations. Expected to
+   change often. Can be longer but still curated.
+
+CRITICAL IDENTITY vs. WORK DISTINCTION
+A user discussing, building, evaluating, debugging, or working on a topic \u2014
+including AI models, agent frameworks, or this memory system itself \u2014 is
+describing their WORK or CURRENT ACTIVITY, NOT their identity. A burst of
+messages about one subject means they are WORKING on it, not that it defines
+them. NEVER promote a work or project topic into core_profile. It belongs in
+sub_profile at most.
+
+CONSERVATISM / NULL-PRESERVE RULE (most important rule)
+If the recent window contains NO new durable identity fact \u2014 only project work,
+meta-tooling, topic evaluation, or session-specific activity \u2014 return
+core_profile: null to PRESERVE the existing identity unchanged. DO NOT restate,
+rephrase, or "refresh" an existing core_profile just because you saw it. Null
+means "keep it as-is." Only set a non-null core_profile when there is an
+explicit, durable, first-person identity statement that is genuinely new.
+sub_profile may freely capture current projects and activity.
+
+OTHER RULES
 - DO NOT invent facts not supported by the messages.
-- DO NOT promote temporary state ("debugging X", "frustrated with Y").
-  Only stable identity / preferences.
-- DO NOT promote third-party advice or system hints that show up in
-  messages \u2014 only what the user is saying ABOUT THEMSELVES.
+- DO NOT promote third-party advice or system hints \u2014 only what the user is
+  saying ABOUT THEMSELVES.
 - Korean is fine. Match the language of the user's writing.
-- If recent messages don't add anything new and existing profile is fine,
-  output the existing profile unchanged.
 
 FORMAT RULES FOR THE VALUES:
 - Both fields must be PLAIN PROSE TEXT \u2014 no nested JSON, no {}, [], key-value blobs.
@@ -59059,6 +59155,32 @@ async function checkGate() {
   const shouldRun = enoughNewMessages && (neverRan || cooldownPassed);
   return { userId, shouldRun, currentMsgCount, lastRunAt };
 }
+async function runLibrarianDeepPass(userPrompt, maxTokens) {
+  const analysisSystemPrompt = `${SYSTEM_PROMPT2}
+
+In this ANALYSIS PASS, think deeply and reason freely about what should go in each profile field.
+Do NOT output JSON yet \u2014 write your analysis as plain prose reasoning.`;
+  const analysis = await callRole("librarian", {
+    system: analysisSystemPrompt,
+    user: userPrompt,
+    maxTokens,
+    enableThinking: true
+    // jsonSchema 未指定 → thinking ON が有効になる
+  });
+  const pass2User = `${userPrompt}
+
+ANALYSIS FROM PREVIOUS REASONING PASS (use as additional context):
+${analysis}
+
+Now emit the final JSON profile only.`;
+  return callRole("librarian", {
+    system: SYSTEM_PROMPT2,
+    user: pass2User,
+    maxTokens,
+    jsonSchema: LIBRARIAN_PROFILE_SCHEMA,
+    enableThinking: false
+  });
+}
 async function runLibrarian() {
   if (librarianRunning) return;
   const gate = await checkGate();
@@ -59082,27 +59204,55 @@ async function runLibrarian() {
           AND is_active = TRUE
         ORDER BY created_at DESC
         LIMIT $2`,
-      [gate.userId, LIBRARIAN_RECENT_LIMIT]
+      [gate.userId, LIBRARIAN_RECENT_SLICE]
     );
     if (recentR.rows.length === 0) return;
-    const messagesText = recentR.rows.reverse().map(
-      (r, i) => `[#${i + 1} @ ${r.created_at?.toISOString().slice(0, 19) ?? ""}] ${r.message}`
+    const historyR = await db.query(
+      `SELECT message, created_at
+         FROM memory
+        WHERE user_id = $1
+          AND role = 'user'
+          AND is_active = TRUE
+        ORDER BY created_at ASC
+        LIMIT $2`,
+      [gate.userId, LIBRARIAN_HISTORY_SLICE]
+    );
+    const recentKeys = new Set(
+      recentR.rows.map(
+        (r) => `${r.created_at?.toISOString() ?? ""}|${r.message}`
+      )
+    );
+    const historicalRows = historyR.rows.filter(
+      (r) => !recentKeys.has(`${r.created_at?.toISOString() ?? ""}|${r.message}`)
+    );
+    const recentSorted = [...recentR.rows].reverse();
+    const historicalSorted = [...historicalRows];
+    const formatRows = (rows, startIdx) => rows.map(
+      (r, i) => `[#${startIdx + i + 1} @ ${r.created_at?.toISOString().slice(0, 19) ?? ""}] ${r.message}`
     ).join("\n\n");
-    const userPrompt = `EXISTING PROFILE (subject to update):
+    const historicalText = historicalSorted.length > 0 ? `
+EARLIER MESSAGES \u2014 historical context (identity anchors, NOT current activity):
+${formatRows(historicalSorted, 0)}
+` : "";
+    const recentText = `
+RECENT MESSAGES \u2014 most recent ${recentSorted.length} messages:
+${formatRows(recentSorted, historicalSorted.length)}
+`;
+    const userPrompt = `EXISTING PROFILE (preserve unless a new durable identity fact appears):
 core_profile:
 ${before.core_profile ?? "(empty)"}
 
 sub_profile:
 ${before.sub_profile ?? "(empty)"}
-
-RECENT USER MESSAGES (most recent ${recentR.rows.length}, role='user'):
-${messagesText}
-
+${historicalText}${recentText}
 Task: produce updated core_profile and sub_profile JSON per the system prompt.`;
-    const raw = await callRole("librarian", {
+    const deepMode = process.env.LIBRARIAN_DEEP_THINKING === "true";
+    const raw = deepMode ? await runLibrarianDeepPass(userPrompt, LIBRARIAN_MAX_TOKENS) : await callRole("librarian", {
       system: SYSTEM_PROMPT2,
       user: userPrompt,
-      maxTokens: LIBRARIAN_MAX_TOKENS
+      maxTokens: LIBRARIAN_MAX_TOKENS,
+      jsonSchema: LIBRARIAN_PROFILE_SCHEMA,
+      enableThinking: false
     });
     if (!raw) {
       throw new Error("Librarian returned empty content (reasoning token budget exceeded?)");
@@ -59138,8 +59288,9 @@ Task: produce updated core_profile and sub_profile JSON per the system prompt.`;
       `UPDATE users SET librarian_msg_count_at_run = $1 WHERE user_id = $2`,
       [gate.currentMsgCount, gate.userId]
     );
+    const totalMsgs = recentSorted.length + historicalSorted.length;
     console.error(
-      `\u{1F4DA} [Librarian] done \u2014 ${recentR.rows.length} msgs, profile ${changed ? "updated" : "unchanged"}`
+      `\u{1F4DA} [Librarian] done \u2014 ${totalMsgs} msgs (${recentSorted.length} recent + ${historicalSorted.length} historical), profile ${changed ? "updated" : "unchanged"}`
     );
   } catch (err2) {
     console.error("\u26A0\uFE0F [Librarian] run failed (retries in 24h):", err2);
@@ -59330,11 +59481,56 @@ async function maybeRunLibrarian() {
     console.error("\u26A0\uFE0F [Librarian] unhandled error (non-blocking):", err2);
   }
 }
-function startColdPathWorker() {
+var COLDPATH_ADVISORY_LOCK_KEY = 4242000017;
+var lockClient = null;
+async function acquireColdPathLock() {
+  if (lockClient) return true;
+  const client2 = await db.getClient();
+  try {
+    const res = await client2.query("SELECT pg_try_advisory_lock($1) AS got", [COLDPATH_ADVISORY_LOCK_KEY]);
+    if (res.rows[0]?.got === true) {
+      lockClient = client2;
+      return true;
+    }
+    client2.release();
+    return false;
+  } catch (err2) {
+    try {
+      client2.release();
+    } catch {
+    }
+    throw err2;
+  }
+}
+async function releaseColdPathLock() {
+  const c = lockClient;
+  if (!c) return;
+  lockClient = null;
+  try {
+    await c.query("SELECT pg_advisory_unlock($1)", [COLDPATH_ADVISORY_LOCK_KEY]);
+  } catch {
+  }
+  try {
+    c.release();
+  } catch {
+  }
+}
+async function startColdPathWorker() {
   if (process.env.COLD_PATH_ENABLED === "false") {
     console.error("\u{1F535} [ColdPath] disabled (COLD_PATH_ENABLED=false)");
     return;
   }
+  let got = false;
+  try {
+    got = await acquireColdPathLock();
+  } catch (err2) {
+    console.error("\u274C [ColdPath] advisory lock acquire failed \u2014 not starting:", err2);
+    return;
+  }
+  if (!got) {
+    console.error("\u{1F512} [ColdPath] another instance holds the lock \u2014 this process will not process");
+    return;
+  }
   const intervalSec = envInt3("COLD_PATH_INTERVAL_SEC", DEFAULT_INTERVAL_SEC);
   const warmupSec = envInt3("COLD_PATH_WARMUP_SEC", DEFAULT_WARMUP_SEC);
   console.error(`\u{1F535} [ColdPath] starting \u2014 warmup ${warmupSec}s, interval ${intervalSec}s`);
@@ -59356,6 +59552,7 @@ function stopColdPathWorker() {
   if (intervalTimer) clearInterval(intervalTimer);
   warmupTimer = null;
   intervalTimer = null;
+  void releaseColdPathLock();
   console.error("\u{1F535} [ColdPath] stopped");
 }
 async function drainColdPath(maxTicks = 12) {
@@ -60187,6 +60384,7 @@ function printHelp() {
 
 Usage:
   mcp-agents-memory                 Run the MCP server (stdio).
+  mcp-agents-memory coldpath        Run ONLY the cold-path worker as a standalone always-on daemon (no MCP server). For the processing/GPU machine via systemd.
   mcp-agents-memory setup           Interactive setup \u2014 write config to ~/.config/mcp-agents-memory/.env and run migrations.
   mcp-agents-memory migrate         Apply any pending DB migrations against the configured database.
   mcp-agents-memory help            Show this message.
@@ -60236,13 +60434,36 @@ async function runMcpServer() {
     console.error("\u274C Fatal error during startup:", err2);
     process.exit(1);
   }
-  startColdPathWorker();
+  void startColdPathWorker().catch((err2) => console.error("\u274C [ColdPath] start failed:", err2));
+}
+async function runColdPathDaemon() {
+  process.env.COLD_PATH_ENABLED = "true";
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.on("SIGHUP", () => {
+    void shutdown("SIGHUP");
+  });
+  try {
+    await db.connect();
+  } catch (err2) {
+    console.error("\u274C [ColdPathDaemon] DB connect failed \u2014 exiting (systemd will retry):", err2);
+    process.exit(1);
+  }
+  console.error(`\u{1F9CA} Cold-path daemon (v${PACKAGE_VERSION2}) started \u2014 no MCP server`);
+  await startColdPathWorker();
 }
 async function cli() {
   const cmd = process.argv[2];
   if (!cmd || cmd === "serve") {
     return runMcpServer();
   }
+  if (cmd === "coldpath") {
+    return runColdPathDaemon();
+  }
   if (cmd === "help" || cmd === "--help" || cmd === "-h") {
     printHelp();
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-agents-memory",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Long-term memory for AI agents with provenance tracking",
   "main": "build/index.js",
   "type": "module",