@bcmyguest/openmem 0.6.3 → 0.8.0

package/cli/mcp/knowledge.mjs

@@ -0,0 +1,333 @@
+/**
+ * Provider-neutral knowledge tools: pages, initiatives, ingest status.
+ * Hindsight is the reference implementation (knowledge-base + operations API); other providers
+ * answer "unsupported" from PROVIDER_CAPABILITIES so prompts keep working across `switch`.
+ */
+
+import { providerSupports } from "../coding-agent/capabilities.mjs";
+
+const DEFAULT_BANK = "openmem-mcp";
+const PAGE_MAX_TOKENS = 4096;
+const PAGE_SEARCH_LIMIT = 5;
+const INITIATIVES_FOLDER = "Initiatives";
+const INITIATIVE_TAG = "knowledge:feature-work";
+const ACTIVE_STATUSES = ["pending", "processing"];
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "error"]);
+const CODING_AGENT_PREFIX = "coding-agent::";
+
+const BANK_PROP = {
+  type: "string",
+  description: "Hindsight bank (use memory_project_scope for the project bank; default openmem-mcp)",
+};
+
+export const KNOWLEDGE_MCP_TOOLS = [
+  {
+    name: "memory_pages_list",
+    title: "List knowledge pages",
+    description:
+      "List a bank's knowledge pages (ids, names, folders; no bodies). Hindsight only.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    inputSchema: { type: "object", properties: { bank: BANK_PROP }, additionalProperties: false },
+  },
+  {
+    name: "memory_pages_search",
+    title: "Search knowledge pages",
+    description:
+      "Search knowledge pages: past decisions and conventions. Check them before fixing a bug, changing a test or building something; " +
+      "verify claims against the code. Hindsight only.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "What you need to know" },
+        bank: BANK_PROP,
+        limit: { type: "number", description: "Max page hits (default 5)" },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "memory_pages_read",
+    title: "Read a knowledge page",
+    description:
+      "Read one knowledge page by id (from a page listing, search, or [[page:<id>]] link). Hindsight only.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        page_id: { type: "string", description: "Knowledge page id (kp-…)" },
+        bank: BANK_PROP,
+      },
+      required: ["page_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "memory_capture_initiative",
+    title: "Capture an initiative",
+    description:
+      "Record an approved feature plan as a knowledge page before writing code; relates_to_page_id records a plan change. " +
+      "Skip bug fixes and small tweaks. Hindsight only.",
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short, specific initiative name (reuse it on updates)" },
+        summary: { type: "string", description: "Two or three sentences: what is being built and why, current intent" },
+        relates_to_page_id: { type: "string", description: "Existing initiative page id when recording a change" },
+        bank: BANK_PROP,
+      },
+      required: ["title", "summary"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "memory_status",
+    title: "Ingest status",
+    description:
+      "Report whether async ingest has drained (ready, active and failed counts, memory_add operation ids). " +
+      "Check before recalling just-stored content. Hindsight only; mem0 is always ready.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        bank: BANK_PROP,
+        operation_ids: { type: "array", items: { type: "string" }, description: "Operation ids to check" },
+      },
+      additionalProperties: false,
+    },
+  },
+];
+
+export const KNOWLEDGE_TOOL_NAMES = new Set(KNOWLEDGE_MCP_TOOLS.map((t) => t.name));
+
+const TOOL_FEATURE = {
+  memory_pages_list: "knowledge_pages",
+  memory_pages_search: "knowledge_pages",
+  memory_pages_read: "knowledge_pages",
+  memory_capture_initiative: "initiatives",
+  memory_status: "ingest_status",
+};
+
+/** Scope clause appended to a page's source query (Hindsight coding-agent wording). */
+export function pageScopeRule(project) {
+  return (
+    ` Scope this page to ${project} ITSELF: the bank also holds facts about external tools, libraries and services that ${project} ` +
+    `merely uses, configures, deploys or discusses, and those belong to somebody else's codebase. Include something only when its ` +
+    `subject is ${project}'s own code, configuration or process; when it is about a dependency, leave it out however well-evidenced it ` +
+    `looks — including any commit SHA or identifier that belongs to that dependency's repository rather than this one.`
+  );
+}
+
+/** Hourly refresh at a minute derived from bank + page name, so pages do not all refresh at once. */
+export function initiativeTrigger(bank, name) {
+  let h = 0;
+  for (const ch of `${bank}\0${name}`) h = (h * 31 + ch.codePointAt(0)) >>> 0;
+  return { fact_types: ["world", "experience", "observation"], tags_match: "all", refresh_cron: `${h % 60} * * * *` };
+}
+
+export function slugify(s) {
+  return (
+    String(s)
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 60) || "initiative"
+  );
+}
+
+function projectOf(bank) {
+  return bank.startsWith(CODING_AGENT_PREFIX) ? bank.slice(CODING_AGENT_PREFIX.length) : bank;
+}
+
+function unsupported(provider, name) {
+  return { provider, supported: false, tool: name, reason: `${provider} has no ${TOOL_FEATURE[name]} support in OpenMem` };
+}
+
+/**
+ * @param {string} url
+ * @param {RequestInit} init
+ * @param {typeof fetch} fetchFn
+ * @param {number[]} [allow] non-2xx statuses returned as { status } instead of thrown
+ */
+async function hsJson(url, init, fetchFn, allow = []) {
+  const res = await fetchFn(url, init);
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = text;
+  }
+  if (!res.ok) {
+    if (allow.includes(res.status)) return { status: res.status, json };
+    throw new Error(`${init.method || "GET"} ${url} → ${res.status}: ${String(typeof json === "string" ? json : JSON.stringify(json)).slice(0, 400)}`);
+  }
+  return { status: res.status ?? 200, json };
+}
+
+function flattenPages(nodes, folder, out = []) {
+  for (const n of nodes || []) {
+    if (!n?.id || !n?.name) continue;
+    if (n.kind === "page") {
+      out.push({ id: n.id, name: n.name, ...(n.description ? { description: n.description } : {}), ...(folder ? { folder } : {}) });
+    }
+    if (n.children?.length) flattenPages(n.children, n.kind === "folder" ? n.name : folder, out);
+  }
+  return out;
+}
+
+async function ensureFolder(bankUrl, name, fetchFn) {
+  const tree = await hsJson(`${bankUrl}/knowledge-base/tree`, { method: "GET" }, fetchFn);
+  const hit = (tree.json?.roots || []).find((n) => n.kind === "folder" && String(n.name || "").toLowerCase() === name.toLowerCase());
+  if (hit?.id) return hit.id;
+  const created = await hsJson(
+    `${bankUrl}/knowledge-base/folders`,
+    { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ name }) },
+    fetchFn,
+  );
+  return created.json?.id;
+}
+
+async function countOps(bankUrl, status, fetchFn) {
+  const r = await hsJson(`${bankUrl}/operations?status=${status}&limit=1`, { method: "GET" }, fetchFn);
+  return Number(r.json?.total ?? r.json?.operations?.length ?? 0);
+}
+
+/**
+ * @param {ReturnType<import("./context.mjs").resolveMcpContext>} ctx
+ * @param {string} name
+ * @param {Record<string, unknown>} args
+ * @param {typeof fetch} fetchFn
+ */
+export async function callKnowledgeTool(ctx, name, args, fetchFn) {
+  if (ctx.provider === "mem0" && name === "memory_status") {
+    return { provider: "mem0", supported: true, ready: true, note: "mem0 ingest is synchronous (infer: false)" };
+  }
+  if (!providerSupports(ctx.provider, TOOL_FEATURE[name])) return unsupported(ctx.provider, name);
+  if (!ctx.hindsightUrl) throw new Error("Hindsight API URL not configured");
+
+  const bank = String(args.bank || DEFAULT_BANK).trim() || DEFAULT_BANK;
+  const bankUrl = `${ctx.hindsightUrl}/v1/default/banks/${encodeURIComponent(bank)}`;
+
+  if (name === "memory_pages_list") {
+    const r = await hsJson(`${bankUrl}/knowledge-base/tree`, { method: "GET" }, fetchFn, [404]);
+    return { provider: "hindsight", bank, pages: r.status === 404 ? [] : flattenPages(r.json?.roots) };
+  }
+  if (name === "memory_pages_search") {
+    const query = String(args.query || "").trim();
+    if (!query) throw new Error("query is required");
+    const limit = Number(args.limit) > 0 ? Number(args.limit) : PAGE_SEARCH_LIMIT;
+    const r = await hsJson(
+      `${bankUrl}/knowledge-base/search?q=${encodeURIComponent(query)}&limit=${limit}`,
+      { method: "GET" },
+      fetchFn,
+      [404],
+    );
+    const hits = r.status === 404 ? [] : (r.json?.results || []).map((x) => ({
+      id: x.id,
+      name: x.name,
+      snippet: x.snippet ?? "",
+      score: x.score ?? 0,
+    }));
+    return { provider: "hindsight", bank, query, hits };
+  }
+  if (name === "memory_pages_read") {
+    const pageId = String(args.page_id || "").trim();
+    if (!pageId) throw new Error("page_id is required");
+    const r = await hsJson(`${bankUrl}/knowledge-base/pages/${encodeURIComponent(pageId)}`, { method: "GET" }, fetchFn, [404]);
+    if (r.status === 404) throw new Error(`knowledge page not found: ${pageId}`);
+    const p = r.json || {};
+    const body = typeof p.body === "string" && p.body.trim() ? p.body : p.markdown;
+    return {
+      provider: "hindsight",
+      bank,
+      page: { id: p.id, name: p.name, ...(p.tags?.length ? { tags: p.tags } : {}), ...(p.timestamp ? { last_updated_at: p.timestamp } : {}), body },
+    };
+  }
+  if (name === "memory_capture_initiative") {
+    const title = String(args.title || "").trim();
+    const summary = String(args.summary || "").trim();
+    if (!title || !summary) throw new Error("title and summary are required");
+    const relatesTo = String(args.relates_to_page_id || "").trim();
+    let pageId = relatesTo;
+    if (!pageId) {
+      const folderId = await ensureFolder(bankUrl, INITIATIVES_FOLDER, fetchFn);
+      const r = await hsJson(
+        `${bankUrl}/knowledge-base/pages`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            name: title,
+            source_query:
+              `Summarize the "${title}" initiative: what is being built or changed and why, and its current state — drawn from the project's memory.` +
+              pageScopeRule(projectOf(bank)),
+            ...(folderId ? { parent_id: folderId } : {}),
+            tags: [INITIATIVE_TAG],
+            max_tokens: PAGE_MAX_TOKENS,
+            trigger: initiativeTrigger(bank, title),
+          }),
+        },
+        fetchFn,
+      );
+      pageId = String(r.json?.page_id || r.json?.id || "").trim();
+      if (!pageId) {
+        throw new Error(`Hindsight created no page id for initiative "${title}"; no marker retained. Check memory_pages_list before retrying.`);
+      }
+    }
+    const verb = relatesTo ? "Update to an existing initiative" : "New initiative";
+    const retained = await hsJson(
+      `${bankUrl}/memories`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          async: true,
+          items: [
+            {
+              content: `${verb}: ${title}. ${summary}`,
+              context: `initiative marker for [[page:${pageId}]]`,
+              document_id: `initiative-marker-${slugify(pageId)}${relatesTo ? "-update" : ""}`,
+              tags: [INITIATIVE_TAG],
+              metadata: { relatedPageId: pageId },
+            },
+          ],
+        }),
+      },
+      fetchFn,
+    );
+    return { provider: "hindsight", bank, page_id: pageId, updated: Boolean(relatesTo), operation_id: retained.json?.operation_id ?? null };
+  }
+  if (name === "memory_status") {
+    const [pending, processing, failed] = await Promise.all(
+      [...ACTIVE_STATUSES, "failed"].map((s) => countOps(bankUrl, s, fetchFn)),
+    );
+    const ids = Array.isArray(args.operation_ids) ? args.operation_ids.map(String).filter(Boolean) : [];
+    const operations = {};
+    for (const id of ids) {
+      const r = await hsJson(`${bankUrl}/operations/${encodeURIComponent(id)}`, { method: "GET" }, fetchFn, [404]);
+      operations[id] = r.status === 404 ? "not_found" : String(r.json?.status || "unknown").toLowerCase();
+    }
+    const statuses = Object.values(operations);
+    return {
+      provider: "hindsight",
+      bank,
+      supported: true,
+      active: pending + processing,
+      pending,
+      processing,
+      failed,
+      ...(ids.length
+        ? {
+            operations,
+            // ingested: every requested op completed; a failed or unknown op is never counted as stored.
+            ingested: statuses.every((s) => s === "completed"),
+          }
+        : {}),
+      ready: ids.length ? statuses.every((s) => TERMINAL_STATUSES.has(s)) : pending + processing === 0,
+    };
+  }
+  throw new Error(`unknown tool: ${name}`);
+}

package/cli/mcp/memory-facade.mjs

@@ -1,6 +1,8 @@
 import { search as cogneeSearch } from "../cognee-mcp.mjs";
 import { callMemoryConsolidate, callMemoryReflect } from "./memory-reflect-consolidate.mjs";
 import { memoryExport, memoryImport } from "./portability.mjs";
+import { KNOWLEDGE_MCP_TOOLS, KNOWLEDGE_TOOL_NAMES, callKnowledgeTool } from "./knowledge.mjs";
+import { CONTEXT_STORE_MCP_TOOLS, CONTEXT_STORE_TOOL_NAMES, callContextStoreTool } from "./context-store.mjs";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -14,28 +16,42 @@ const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../
 export const UNIFIED_MCP_TOOLS = [
   {
     name: "memory_project_scope",
-    description: "Read the local project bank mapping and session access policy for a workspace. Makes no memory-provider calls.",
+    title: "Resolve project bank",
+    description:
+      "Resolve the project bank (user_id / dataset) and access policy for a workspace path. " +
+      "Call it instead of guessing a bank name. Local mapping only.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     inputSchema: {
       type: "object",
-      properties: { cwd: { type: "string", description: "Absolute workspace path (defaults to the MCP process working directory)" } },
+      properties: {
+        cwd: {
+          type: "string",
+          description: "Absolute workspace path (defaults to the MCP process working directory)",
+        },
+      },
       additionalProperties: false,
     },
   },
   {
     name: "memory_add",
+    title: "Store a memory",
     description:
-      "Store text in the active memory provider (Hindsight bank, mem0 user scope, or Cognee dataset ingest when supported). " +
-      "On Hindsight, defaults to async ingest so the MCP returns before LLM extraction finishes (avoids client timeouts).",
+      "Store durable facts, decisions or session notes in the active provider. " +
+      "Pass bank from memory_project_scope for project work. Hindsight ingests async by default.",
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        content: { type: "string", description: "Text to remember" },
-        bank: { type: "string", description: "Hindsight bank or mem0 user_id scope (default: openmem-mcp)" },
-        metadata: { type: "object", description: "Optional provider-specific metadata" },
+        content: { type: "string", description: "Plain text to store as a durable memory" },
+        bank: {
+          type: "string",
+          description: "Hindsight bank or mem0 user_id / Cognee dataset scope (default: openmem-mcp)",
+        },
+        metadata: { type: "object", description: "Optional provider-specific metadata object" },
         async: {
           type: "boolean",
           description:
-            "Hindsight only: queue background ingest (default true). Set false to wait for extraction (slow; may hit MCP timeouts).",
+            "Hindsight only: true (default) returns after enqueueing ingest; false waits for extraction (may hit MCP client timeouts).",
         },
       },
       required: ["content"],
@@ -44,13 +60,16 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_search",
-    description: "Semantic or graph search over memories in the active provider.",
+    title: "Search memories",
+    description:
+      "Return ranked raw hits from stored memories. memory_recall suits questions; memory_reflect synthesizes an answer.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string" },
-        bank: { type: "string", description: "Optional bank / user_id scope" },
-        limit: { type: "number", description: "Max results where supported" },
+        query: { type: "string", description: "Search query text" },
+        bank: { type: "string", description: "Optional bank / user_id / dataset scope" },
+        limit: { type: "number", description: "Max hits where the provider supports it" },
       },
       required: ["query"],
       additionalProperties: false,
@@ -58,14 +77,16 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_recall",
+    title: "Recall context for a question",
     description:
-      "Retrieve context for a question (Hindsight recall API; mem0/Cognee use search under the hood).",
+      "Retrieve stored context for a natural-language question (Hindsight recall; search on mem0 and Cognee).",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string" },
-        bank: { type: "string" },
-        limit: { type: "number" },
+        query: { type: "string", description: "Question or topic to recall context for" },
+        bank: { type: "string", description: "Optional bank / user_id / dataset scope" },
+        limit: { type: "number", description: "Max items where supported" },
       },
       required: ["query"],
       additionalProperties: false,
@@ -73,27 +94,37 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_forget",
-    description: "Delete a memory by id (mem0) or drop an entire Hindsight bank when bank is set without memory_id.",
+    title: "Delete memories",
+    description:
+      "Delete memories: mem0 needs memory_id; on Hindsight a bank without memory_id drops the whole bank. " +
+      "Confirm with the user first. Not available on Cognee.",
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        memory_id: { type: "string", description: "Provider memory id (mem0)" },
-        bank: { type: "string", description: "Hindsight bank to delete, or mem0 user_id scope for bulk delete" },
+        memory_id: { type: "string", description: "Provider memory id (required for mem0 deletes)" },
+        bank: {
+          type: "string",
+          description: "Hindsight bank to drop (when memory_id omitted), or mem0 user_id scope",
+        },
       },
       additionalProperties: false,
     },
   },
   {
     name: "memory_export",
+    title: "Export memories (PMM)",
     description:
-      "Export memories as PMM v1 (json/jsonl). Hindsight lists via /memories/list; mem0 GET /memories; Cognee dataset /data.",
+      "Export memories as PMM v1 JSON or JSONL for backup or migration. Pass bank for large stores.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        format: { type: "string", enum: ["json", "jsonl"], description: "Serialization (default json)" },
+        format: { type: "string", enum: ["json", "jsonl"], description: "Serialization format (default json)" },
         bank: {
           type: "string",
-          description: "Hindsight bank, mem0 user_id, or indexer bank for Cognee dataset mapping. Omit on Hindsight to export all banks.",
+          description:
+            "Hindsight bank, mem0 user_id, or indexer bank for Cognee. Omit on Hindsight to export all banks.",
         },
       },
       additionalProperties: false,
@@ -101,12 +132,19 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_import",
-    description: "Import PMM v1 payload into the active provider (best-effort cross-provider).",
+    title: "Import memories (PMM)",
+    description:
+      "Import a PMM v1 payload from memory_export. Content and scope carry over; embeddings and graphs do not.",
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        data: { type: "string", description: "Serialized export payload" },
-        merge_strategy: { type: "string", enum: ["skip_duplicates", "overwrite"] },
+        data: { type: "string", description: "Serialized PMM export (json or jsonl text)" },
+        merge_strategy: {
+          type: "string",
+          enum: ["skip_duplicates", "overwrite"],
+          description: "How to treat records that already exist (default skip_duplicates)",
+        },
       },
       required: ["data"],
       additionalProperties: false,
@@ -114,19 +152,24 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_provider_status",
-    description: "Report active MEMORY_PROVIDER and resolved backend URL (no secrets).",
+    title: "Provider status",
+    description:
+      "Report the active provider id and backend URL.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
   },
   {
     name: "memory_reflect",
+    title: "Reflect / synthesize an answer",
     description:
-      "Synthesize session context for a question. Hindsight uses recall; mem0/Cognee search then optional LiteLLM synthesis (PM_LLM_URL / stack LiteLLM).",
+      "Synthesize a reasoned answer from stored memories, with evidence. The answer is not stored.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string" },
-        bank: { type: "string" },
-        limit: { type: "number" },
+        query: { type: "string", description: "Question to answer from memory" },
+        bank: { type: "string", description: "Optional bank / user_id / dataset scope" },
+        limit: { type: "number", description: "Max evidence items where supported" },
       },
       required: ["query"],
       additionalProperties: false,
@@ -134,13 +177,20 @@ export const UNIFIED_MCP_TOOLS = [
   },
   {
     name: "memory_consolidate",
-    description: "Provider maintenance: Cognee cognify for a bank/dataset; Hindsight notes LiteLLM route; mem0 skips.",
+    title: "Consolidate / cognify",
+    description:
+      "Rebuild the provider's graph or index after bulk ingest (Cognee cognify; no-op on mem0).",
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     inputSchema: {
       type: "object",
-      properties: { bank: { type: "string" } },
+      properties: {
+        bank: { type: "string", description: "Bank / dataset to consolidate (required for Cognee cognify)" },
+      },
       additionalProperties: false,
     },
   },
+  ...KNOWLEDGE_MCP_TOOLS,
+  ...CONTEXT_STORE_MCP_TOOLS,
 ];
 
 export function textResult(value, isError = false) {
@@ -254,6 +304,22 @@ export async function callUnifiedTool(ctx, name, args = {}, fetchFn = fetch) {
     }
   }
 
+  if (CONTEXT_STORE_TOOL_NAMES.has(name)) {
+    try {
+      return textResult(await callContextStoreTool(name, args));
+    } catch (err) {
+      return textResult(err instanceof Error ? err.message : String(err), true);
+    }
+  }
+
+  if (KNOWLEDGE_TOOL_NAMES.has(name)) {
+    try {
+      return textResult(await callKnowledgeTool(ctx, name, args, fetchFn));
+    } catch (err) {
+      return textResult(err instanceof Error ? err.message : String(err), true);
+    }
+  }
+
   if (ctx.provider === "hindsight") {
     return callHindsight(ctx, name, args, fetchFn);
   }
@@ -431,7 +497,7 @@ export async function handleUnifiedMessage(msg, ctx, fetchFn = fetch) {
       result: {
         protocolVersion,
         capabilities: { tools: {} },
-        serverInfo: { name: "openmem", version: "0.1.0" },
+        serverInfo: { name: "openmem", version: "0.6.4" },
       },
     };
   }

package/cli/openmem-mcp.mjs

@@ -13,6 +13,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { isMainModule } from "./is-main.mjs";
 import { resolveMcpContext } from "./mcp/context.mjs";
+import { startContextStore } from "./mcp/context-store.mjs";
 import { handleUnifiedMessage } from "./mcp/memory-facade.mjs";
 import { serveStdio } from "./mcp/stdio.mjs";
 import { resolveStackRoot } from "./stack.mjs";
@@ -23,6 +24,8 @@ async function main() {
   const home = process.env.HOME || os.homedir();
   const stack = resolveStackRoot({ pkgRoot: PKG_ROOT, env: process.env, home });
   const ctx = resolveMcpContext({ home, stackRoot: stack.root, repoRoot: PKG_ROOT, env: process.env });
+  // Session-file TTL cleanup (docs/context-store.md, "Retention"), at most once a day; never throws.
+  await startContextStore(process.env, { home, stackRoot: stack.root });
   process.stdin.resume();
   await serveStdio(process.stdin, (msg) => handleUnifiedMessage(msg, ctx));
 }

package/cli/openmem.mjs

@@ -2,7 +2,7 @@
 /**
  * openmem: npx entry point for the memory-stack setup wizard.
  *
- *   openmem [setup|configure|up|down|doctor|providers|init|--help|--version]
+ *   openmem [setup|configure|up|down|doctor|providers|init|context|--help|--version]
  *
  * The wizard code runs from this package (read-only, may be an npx cache). Everything it
  * writes, and the compose files it drives, live in a stable stack root; see cli/stack.mjs.
@@ -30,8 +30,11 @@ Usage (prefer npx once published: npx ${BIN} <command>):
   ${BIN} doctor [flags]        validate the configuration without the smoke test
   ${BIN} wiring [--json]       report provider, API URLs, and MCP alignment
   ${BIN} feed-sync             fetch RSS/OpenAlex into feeds.out_dir (then indexer watches it)
+  ${BIN} schedule <install|remove> [--dry-run]  manage hourly feed sync with the OS scheduler
   ${BIN} install-mcp [flags]   merge memory MCP servers into ~/.cursor/mcp.json
   ${BIN} install-coding-agent [flags]  Hindsight plugin or MCP session path (Claude/Codex/OpenCode/Cursor)
+  ${BIN} context <on|off|status> [--dry-run]
+                               context management (smart compaction): config, agent wiring, proxy service
   ${BIN} switch <provider> [flags]
                                change MEMORY_PROVIDER (stack + MCP; no data migration)
   ${BIN} providers [--json]    list memory providers and their status
@@ -179,6 +182,20 @@ if (cmd === "--version" || cmd === "-v" || cmd === "version") {
     env: process.env,
   });
   process.exit(r.status ?? 1);
+} else if (cmd === "schedule") {
+  const r = spawnSync(process.execPath, [path.join(PKG_ROOT, "cli/schedule.mjs"), ...argv.slice(1)], {
+    stdio: "inherit",
+    env: process.env,
+  });
+  process.exit(r.status ?? 1);
+} else if (cmd === "context") {
+  // on/off run compose from the stack root, so materialize it first.
+  const { sr } = ensureStack({ quiet: true });
+  const r = spawnSync(process.execPath, [path.join(PKG_ROOT, "cli/context-management.mjs"), ...argv.slice(1)], {
+    stdio: "inherit",
+    env: { ...process.env, PM_STACK_ROOT: sr.root },
+  });
+  process.exit(r.status ?? 1);
 } else if (cmd === "wiring") {
   const r = spawnSync(process.execPath, [path.join(PKG_ROOT, "cli/wiring-report.mjs"), ...argv.slice(1)], {
     stdio: "inherit",