@matrixorigin/thememoria 0.4.0 → 0.4.2

package/openclaw/http-client.ts

@@ -0,0 +1,454 @@
+/**
+ * MemoriaHttpTransport — direct HTTP client for the Memoria REST API.
+ *
+ * Replaces the MCP stdio bridge (MemoriaMcpSession) when backend === "api".
+ * No Rust binary needed. Uses native fetch().
+ */
+
+import type { MemoriaPluginConfig } from "./config.js";
+
+export class MemoriaHttpTransport {
+  private readonly apiUrl: string;
+  private readonly apiKey: string;
+  private readonly timeoutMs: number;
+
+  constructor(config: MemoriaPluginConfig, private readonly userId: string) {
+    if (!config.apiUrl) {
+      throw new Error("apiUrl is required for api backend mode");
+    }
+    if (!config.apiKey) {
+      throw new Error("apiKey is required for api backend mode");
+    }
+    this.apiUrl = config.apiUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.timeoutMs = config.timeoutMs;
+  }
+
+  /** Matches MemoriaMcpSession.isAlive() — HTTP transport is always "alive". */
+  isAlive(): boolean {
+    return true;
+  }
+
+  /** No-op for HTTP transport (no child process to kill). */
+  close(): void {}
+
+  /**
+   * Unified entry point that mirrors MemoriaMcpSession.callTool().
+   * Maps MCP tool names to REST API calls and returns the same
+   * text-content structure the MCP session would return.
+   */
+  async callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+    const result = await this.dispatch(name, args);
+    // Wrap in MCP-compatible content block so extractToolText() works unchanged
+    return { content: [{ type: "text", text: typeof result === "string" ? result : JSON.stringify(result) }] };
+  }
+
+  // ── REST dispatch ──────────────────────────────────────────────
+
+  private async dispatch(tool: string, args: Record<string, unknown>): Promise<unknown> {
+    switch (tool) {
+      case "memory_store":
+        return this.store(args);
+      case "memory_retrieve":
+        return this.retrieve(args);
+      case "memory_search":
+        return this.search(args);
+      case "memory_list":
+        return this.list(args);
+      case "memory_profile":
+        return this.profile();
+      case "memory_correct":
+        return this.correct(args);
+      case "memory_purge":
+        return this.purge(args);
+      case "memory_observe":
+        return this.observe(args);
+      case "memory_governance":
+        return this.governance(args);
+      case "memory_consolidate":
+        return this.consolidate(args);
+      case "memory_reflect":
+        return this.reflect(args);
+      case "memory_extract_entities":
+        return this.extractEntities(args);
+      case "memory_link_entities":
+        return this.linkEntities(args);
+      case "memory_rebuild_index":
+        return { message: "rebuild_index is managed by the cloud service and not available via API." };
+      case "memory_snapshot":
+        return this.createSnapshot(args);
+      case "memory_snapshots":
+        return this.listSnapshots(args);
+      case "memory_rollback":
+        return this.rollbackSnapshot(args);
+      case "memory_branch":
+        return this.branchCreate(args);
+      case "memory_branches":
+        return this.branchList();
+      case "memory_checkout":
+        return this.branchCheckout(args);
+      case "memory_branch_delete":
+        return this.branchDelete(args);
+      case "memory_merge":
+        return this.branchMerge(args);
+      case "memory_diff":
+        return this.branchDiff(args);
+      default:
+        throw new Error(`Unknown Memoria tool: ${tool}`);
+    }
+  }
+
+  // ── Memory CRUD ────────────────────────────────────────────────
+
+  private async store(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = { content: args.content };
+    if (args.memory_type) body.memory_type = args.memory_type;
+    if (args.session_id) body.session_id = args.session_id;
+    if (args.trust_tier) body.trust_tier = args.trust_tier;
+    const data = await this.post("/v1/memories", body);
+    const rec = this.asRecord(data);
+    const id = rec?.memory_id ?? "";
+    const content = rec?.content ?? args.content ?? "";
+    return `Stored memory ${id}: ${content}`;
+  }
+
+  private async retrieve(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = {
+      query: args.query,
+      top_k: args.top_k ?? 5,
+    };
+    if (args.session_id) body.session_id = args.session_id;
+    const data = await this.post("/v1/memories/retrieve", body);
+    return this.formatMemoryList(data);
+  }
+
+  private async search(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = {
+      query: args.query,
+      top_k: args.top_k ?? 10,
+    };
+    const data = await this.post("/v1/memories/search", body);
+    return this.formatMemoryList(data);
+  }
+
+  private async list(args: Record<string, unknown>) {
+    const limit = typeof args.limit === "number" ? args.limit : 100;
+    const data = await this.get(`/v1/memories?limit=${limit}`);
+    const rec = this.asRecord(data);
+    const items = Array.isArray(rec?.items) ? rec!.items : Array.isArray(data) ? data : [];
+    return this.formatMemoryItems(items);
+  }
+
+  private async profile() {
+    const data = await this.get("/v1/profiles/me");
+    const rec = this.asRecord(data);
+    if (rec?.profile && typeof rec.profile === "string") {
+      return rec.profile;
+    }
+    return "No profile memories found.";
+  }
+
+  private async correct(args: Record<string, unknown>) {
+    // Correct by ID or by query
+    if (args.memory_id && typeof args.memory_id === "string") {
+      const body: Record<string, unknown> = {
+        new_content: args.new_content,
+      };
+      if (args.reason) body.reason = args.reason;
+      const data = await this.put(`/v1/memories/${args.memory_id}/correct`, body);
+      const rec = this.asRecord(data);
+      return `Corrected memory ${rec?.memory_id ?? args.memory_id}: ${rec?.content ?? args.new_content}`;
+    }
+    // Correct by query
+    const body: Record<string, unknown> = {
+      query: args.query,
+      new_content: args.new_content,
+    };
+    if (args.reason) body.reason = args.reason;
+    const data = await this.post("/v1/memories/correct", body);
+    const rec = this.asRecord(data);
+    return `Corrected memory ${rec?.memory_id ?? ""}: ${rec?.content ?? args.new_content}`;
+  }
+
+  private async purge(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = {};
+    if (args.memory_id) body.memory_ids = [args.memory_id];
+    if (args.topic) body.topic = args.topic;
+    if (args.reason) body.reason = args.reason;
+    const data = await this.post("/v1/memories/purge", body);
+    const rec = this.asRecord(data);
+    const count = typeof rec?.purged === "number" ? rec.purged : 0;
+    return `Purged ${count} memory(ies).`;
+  }
+
+  private async observe(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = {
+      messages: args.messages,
+    };
+    if (args.session_id) body.session_id = args.session_id;
+    const data = await this.post("/v1/observe", body);
+    return JSON.stringify(data);
+  }
+
+  // ── Governance / Graph ──────────────────────────────────────────
+
+  private async governance(args: Record<string, unknown>) {
+    return this.post("/v1/governance", { force: args.force ?? false });
+  }
+
+  private async consolidate(args: Record<string, unknown>) {
+    return this.post("/v1/consolidate", { force: args.force ?? false });
+  }
+
+  private async reflect(args: Record<string, unknown>) {
+    return this.post("/v1/reflect", {
+      force: args.force ?? false,
+      mode: args.mode ?? "auto",
+    });
+  }
+
+  private async extractEntities(args: Record<string, unknown>) {
+    return this.post("/v1/extract-entities", { mode: args.mode ?? "auto" });
+  }
+
+  private async linkEntities(args: Record<string, unknown>) {
+    let entities = args.entities;
+    if (typeof entities === "string") {
+      try { entities = JSON.parse(entities); } catch { /* keep as-is */ }
+    }
+    return this.post("/v1/extract-entities/link", { entities });
+  }
+
+  // ── Snapshots ─────────────────────────────────────────────────
+
+  private async createSnapshot(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = { name: args.name };
+    if (args.description) body.description = args.description;
+    const data = await this.post("/v1/snapshots", body);
+    const rec = this.asRecord(data);
+    const name = rec?.name ?? args.name ?? "";
+    const ts = rec?.timestamp ?? rec?.created_at ?? "";
+    return `Snapshot '${name}' created at ${ts}`;
+  }
+
+  private async listSnapshots(args: Record<string, unknown>) {
+    const limit = typeof args.limit === "number" ? args.limit : 20;
+    const offset = typeof args.offset === "number" ? args.offset : 0;
+    const data = await this.get(`/v1/snapshots?limit=${limit}&offset=${offset}`);
+    // Format as MCP-compatible text so parseSnapshotList() in client.ts works
+    return this.formatSnapshotList(data);
+  }
+
+  private async rollbackSnapshot(args: Record<string, unknown>) {
+    return this.post(`/v1/snapshots/${encodeURIComponent(String(args.name))}/rollback`, {});
+  }
+
+  // ── Branches ──────────────────────────────────────────────────
+
+  private async branchCreate(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = { name: args.name };
+    if (args.from_snapshot) body.from_snapshot = args.from_snapshot;
+    if (args.from_timestamp) body.from_timestamp = args.from_timestamp;
+    return this.post("/v1/branches", body);
+  }
+
+  private async branchList() {
+    const data = await this.get("/v1/branches");
+    // Format as MCP-compatible text so parseBranches() in client.ts works
+    return this.formatBranchList(data);
+  }
+
+  private async branchCheckout(args: Record<string, unknown>) {
+    return this.post(`/v1/branches/${encodeURIComponent(String(args.name))}/checkout`, {});
+  }
+
+  private async branchDelete(args: Record<string, unknown>) {
+    return this.delete(`/v1/branches/${encodeURIComponent(String(args.name))}`);
+  }
+
+  private async branchMerge(args: Record<string, unknown>) {
+    const body: Record<string, unknown> = {};
+    if (args.strategy) body.strategy = args.strategy;
+    return this.post(`/v1/branches/${encodeURIComponent(String(args.source))}/merge`, body);
+  }
+
+  private async branchDiff(args: Record<string, unknown>) {
+    const limit = typeof args.limit === "number" ? args.limit : 50;
+    return this.get(`/v1/branches/${encodeURIComponent(String(args.source))}/diff?limit=${limit}`);
+  }
+
+  // ── Health ──────────────────────────────────────────────────────
+
+  async healthCheck(): Promise<{ status: string; instance_id?: string; db?: boolean }> {
+    const data = await this.get("/health/instance");
+    const rec = this.asRecord(data);
+    return {
+      status: typeof rec?.status === "string" ? rec.status : "ok",
+      instance_id: typeof rec?.instance_id === "string" ? rec.instance_id : undefined,
+      db: typeof rec?.db === "boolean" ? rec.db : undefined,
+    };
+  }
+
+  // ── HTTP primitives ───────────────────────────────────────────
+
+  private headers(): Record<string, string> {
+    // In api mode, the API key (sk-...) already scopes to its owning user.
+    // Sending X-User-Id is unnecessary and can cause cross-user leakage
+    // in open-auth deployments. Let the API key determine identity.
+    return {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "X-Memoria-Tool": "openclaw",
+    };
+  }
+
+  private async request(method: string, path: string, body?: unknown): Promise<unknown> {
+    const url = `${this.apiUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.headers(),
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+
+      const text = await response.text();
+
+      if (!response.ok) {
+        throw new Error(
+          `Memoria API ${method} ${path} returned ${response.status}: ${text.slice(0, 500)}`,
+        );
+      }
+
+      if (!text.trim()) {
+        return { ok: true };
+      }
+
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new Error(`Memoria API request timed out after ${this.timeoutMs}ms: ${method} ${path}`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  private get(path: string) {
+    return this.request("GET", path);
+  }
+
+  private post(path: string, body: unknown) {
+    return this.request("POST", path, body);
+  }
+
+  private put(path: string, body: unknown) {
+    return this.request("PUT", path, body);
+  }
+
+  private delete(path: string) {
+    return this.request("DELETE", path);
+  }
+
+  // ── Formatting helpers ────────────────────────────────────────
+  // Produce text output matching the Rust MCP binary's format so that
+  // the existing parsers in client.ts (parseMemoryTextList, etc.) work.
+
+  private formatMemoryList(data: unknown): string {
+    // The retrieve/search endpoints return either an array or { results: [...] }
+    const rec = this.asRecord(data);
+    const items = Array.isArray(data)
+      ? data
+      : Array.isArray(rec?.results)
+        ? rec!.results
+        : Array.isArray(rec?.items)
+          ? rec!.items
+          : [];
+    return this.formatMemoryItems(items);
+  }
+
+  private formatMemoryItems(items: unknown[]): string {
+    if (items.length === 0) {
+      return "No relevant memories found.";
+    }
+    const lines: string[] = [];
+    for (const item of items) {
+      const rec = this.asRecord(item);
+      if (!rec) continue;
+      const id = rec.memory_id ?? "";
+      const type = rec.memory_type ?? "semantic";
+      const content = typeof rec.content === "string" ? rec.content : "";
+      lines.push(`[${id}] (${type}) ${content}`);
+    }
+    return lines.join("\n");
+  }
+
+  private formatSnapshotList(data: unknown): string {
+    // Produce text matching Rust MCP format: "Snapshots (N):\n  name (timestamp)\n  ..."
+    const rec = this.asRecord(data);
+    const items = rec?.result ? this.asRecord(rec.result) : rec;
+    // The API may return an array or an object with items/snapshots
+    let snapshots: unknown[] = [];
+    if (Array.isArray(data)) {
+      snapshots = data;
+    } else if (items && Array.isArray(items)) {
+      snapshots = items;
+    } else if (rec) {
+      // Try common response shapes
+      if (Array.isArray(rec.snapshots)) snapshots = rec.snapshots;
+      else if (Array.isArray(rec.items)) snapshots = rec.items;
+      else if (typeof rec.result === "string") return rec.result as string;
+    }
+    if (snapshots.length === 0) {
+      return "Snapshots (0):";
+    }
+    const lines = [`Snapshots (${snapshots.length}):`];
+    for (const snap of snapshots) {
+      const s = this.asRecord(snap);
+      if (!s) continue;
+      const name = s.name ?? s.snapshot_name ?? "";
+      const ts = s.timestamp ?? s.created_at ?? "";
+      lines.push(`  ${name} (${ts})`);
+    }
+    return lines.join("\n");
+  }
+
+  private formatBranchList(data: unknown): string {
+    // Produce text matching Rust MCP format: "Branches:\n  name\n  name ← active"
+    const rec = this.asRecord(data);
+    let branches: unknown[] = [];
+    if (Array.isArray(data)) {
+      branches = data;
+    } else if (rec) {
+      if (Array.isArray(rec.branches)) branches = rec.branches;
+      else if (Array.isArray(rec.items)) branches = rec.items;
+      else if (typeof rec.result === "string") return rec.result as string;
+    }
+    if (branches.length === 0) {
+      return "Branches:\n  main ← active";
+    }
+    const lines = ["Branches:"];
+    for (const branch of branches) {
+      const b = this.asRecord(branch);
+      if (!b) continue;
+      const name = typeof b.name === "string" ? b.name : "";
+      const active = b.active === true;
+      lines.push(`  ${name}${active ? " ← active" : ""}`);
+    }
+    return lines.join("\n");
+  }
+
+  private asRecord(value: unknown): Record<string, unknown> | null {
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : null;
+  }
+}

package/openclaw/index.ts

@@ -432,7 +432,7 @@ function buildCapabilitiesPayload(config: MemoriaPluginConfig): Record<string, u
     userIdStrategy: config.userIdStrategy,
     autoRecall: config.autoRecall,
     autoObserve: config.autoObserve,
-    llmConfigured: Boolean(config.llmApiKey || config.backend === "http"),
+    llmConfigured: Boolean(config.llmApiKey || config.backend === "api"),
     tools: supportedToolNames(),
     embeddedOnly: [...EMBEDDED_ONLY_TOOL_NAMES],
     cliCommands: [...CLI_COMMAND_NAMES],
@@ -551,7 +551,7 @@ function shouldShowOnboardingHint(rawPluginConfig: unknown): boolean {
   const hasCloudConfig = hasNonEmptyString(raw.apiUrl) || hasNonEmptyString(raw.apiKey);
   const hasLocalConfig = hasNonEmptyString(raw.dbUrl);
 
-  return !(backend === "http" || hasCloudConfig || hasLocalConfig);
+  return !(backend === "api" || hasCloudConfig || hasLocalConfig);
 }
 
 const ONBOARDING_HINT_ONCE_KEY = "__memory_memoria_onboarding_hint_logged__";
@@ -566,9 +566,9 @@ function shouldLogOnboardingHintOnce(): boolean {
 }
 
 const plugin = {
-  id: "memory-memoria",
+  id: "thememoria",
   name: "Memory (Memoria)",
-  description: "Memoria-backed long-term memory plugin for OpenClaw powered by the Rust memoria CLI and API.",
+  description: "Memoria-backed long-term memory plugin for OpenClaw. Supports direct HTTP API mode (no binary) and embedded mode (local Rust CLI).",
   kind: "memory" as const,
   configSchema: memoriaPluginConfigSchema,
 
@@ -581,7 +581,7 @@ const plugin = {
 
     if (isFirstRegister) {
       api.logger.info(
-        `memory-memoria: registered (${needsSetup ? "pending setup" : config.backend})`,
+        `thememoria: registered (${needsSetup ? "pending setup" : config.backend})`,
       );
 
       const isEnableCommand =
@@ -589,7 +589,7 @@ const plugin = {
         process.argv.some((arg) => arg === "plugins");
       if (needsSetup && isEnableCommand) {
         api.logger.info(
-          "🧠 Memoria next step (Cloud, recommended): openclaw memoria setup --mode cloud --api-url <MEMORIA_API_URL> --api-key <MEMORIA_API_KEY> --install-memoria",
+          "🧠 Memoria next step (Cloud, recommended): openclaw memoria setup --mode cloud --api-url <MEMORIA_API_URL> --api-key <MEMORIA_API_KEY>",
         );
         api.logger.info(
           "🧩 Local quick start: openclaw memoria setup --mode local --install-memoria --embedding-api-key <EMBEDDING_API_KEY>",
@@ -1891,7 +1891,7 @@ const plugin = {
           };
         };
 
-        const applyConnectOptions = (normalized: NormalizedConnectOptions) => {
+        const applyConnectOptions = async (normalized: NormalizedConnectOptions) => {
           const resolvedConfigFile = resolveOpenClawConfigFile();
           let memoriaBinForConfig = normalized.memoriaBin;
           const installDirFallback =
@@ -1901,7 +1901,7 @@ const plugin = {
               : path.join(process.env.HOME ?? "", ".local", "bin"));
           let effectiveMemoriaExecutable = memoriaBinForConfig ?? config.memoriaExecutable;
 
-          if (normalized.installMemoria && !isExecutableAvailable(effectiveMemoriaExecutable)) {
+          if (normalized.mode === "local" && normalized.installMemoria && !isExecutableAvailable(effectiveMemoriaExecutable)) {
             runMemoriaInstaller({
               memoriaVersion: normalized.memoriaVersion,
               memoriaInstallDir: installDirFallback,
@@ -1941,12 +1941,39 @@ const plugin = {
           }
 
           if (normalized.healthCheck) {
-            assertMemoriaExecutableAvailable(effectiveMemoriaExecutable, normalized.mode);
-            const healthArgs = ["memoria", "health"];
-            if (normalized.userId) {
-              healthArgs.push("--user-id", normalized.userId);
+            if (normalized.mode === "cloud") {
+              // API mode: direct HTTP health check, no binary needed
+              const healthUrl = `${normalized.apiUrl}/health/instance`;
+              const controller = new AbortController();
+              const timer = setTimeout(() => controller.abort(), 10_000);
+              try {
+                const resp = await fetch(healthUrl, {
+                  headers: {
+                    "Authorization": `Bearer ${normalized.apiKey}`,
+                    "Content-Type": "application/json",
+                  },
+                  signal: controller.signal,
+                });
+                if (!resp.ok) {
+                  throw new Error(`Health check returned ${resp.status}: ${await resp.text()}`);
+                }
+                const data = await resp.json();
+                printJson({ healthCheck: "ok", ...data });
+              } catch (error) {
+                throw new Error(
+                  `Health check failed against ${healthUrl}: ${error instanceof Error ? error.message : String(error)}`,
+                );
+              } finally {
+                clearTimeout(timer);
+              }
+            } else {
+              assertMemoriaExecutableAvailable(effectiveMemoriaExecutable, normalized.mode);
+              const healthArgs = ["memoria", "health"];
+              if (normalized.userId) {
+                healthArgs.push("--user-id", normalized.userId);
+              }
+              runLocalCommand(openclawBin, healthArgs, { env: openclawEnv });
             }
-            runLocalCommand(openclawBin, healthArgs, { env: openclawEnv });
           }
 
           printJson({
@@ -2124,7 +2151,7 @@ const plugin = {
           .option("--skip-health-check", "Skip `openclaw memoria health`", false)
           .action(withCliClient(async (opts) => {
             const normalized = normalizeConnectOptions(opts as RawConnectCliOptions, "cloud");
-            applyConnectOptions(normalized);
+            await applyConnectOptions(normalized);
           }));
 
         memoria
@@ -2145,7 +2172,7 @@ const plugin = {
           .option("--skip-health-check", "Skip `openclaw memoria health`", false)
           .action(withCliClient(async (opts) => {
             const normalized = normalizeConnectOptions(opts as RawConnectCliOptions, "cloud");
-            applyConnectOptions(normalized);
+            await applyConnectOptions(normalized);
           }));
 
         ltm
@@ -2231,7 +2258,7 @@ const plugin = {
     const handleAutoRecall = async (
       prompt: string,
       ctx: PluginIdentityContext,
-    ): Promise<{ prependContext?: string } | void> => {
+    ): Promise<{ appendSystemContext?: string } | void> => {
       const trimmed = prompt.trim();
       if (trimmed.length < config.recallMinPromptLength) {
         return;
@@ -2251,12 +2278,12 @@ const plugin = {
         if (memories.length === 0) {
           return;
         }
-        api.logger.info(`memory-memoria: recalled ${memories.length} memories`);
+        api.logger.info(`thememoria: recalled ${memories.length} memories`);
         return {
-          prependContext: formatRelevantMemoriesContext(memories),
+          appendSystemContext: formatRelevantMemoriesContext(memories),
         };
       } catch (error) {
-        api.logger.warn(`memory-memoria: auto-recall failed: ${String(error)}`);
+        api.logger.warn(`thememoria: auto-recall failed: ${String(error)}`);
       }
     };
 
@@ -2264,10 +2291,6 @@ const plugin = {
       api.on("before_prompt_build", async (event, ctx) => {
         return await handleAutoRecall(event.prompt, ctx);
       });
-
-      api.on("before_agent_start", async (event, ctx) => {
-        return await handleAutoRecall(event.prompt, ctx);
-      });
     }
 
     if (config.autoObserve) {
@@ -2293,10 +2316,10 @@ const plugin = {
             sessionId: ctx.sessionId,
           });
           if (created.length > 0) {
-            api.logger.info(`memory-memoria: observed ${created.length} new memories`);
+            api.logger.info(`thememoria: observed ${created.length} new memories`);
           }
         } catch (error) {
-          api.logger.warn(`memory-memoria: auto-observe failed: ${String(error)}`);
+          api.logger.warn(`thememoria: auto-observe failed: ${String(error)}`);
         }
       });
 
@@ -2324,34 +2347,34 @@ const plugin = {
           });
           if (created.length > 0) {
             api.logger.info(
-              `memory-memoria: observed ${created.length} new memories before reset`,
+              `thememoria: observed ${created.length} new memories before reset`,
             );
           }
         } catch (error) {
-          api.logger.warn(`memory-memoria: before_reset observe failed: ${String(error)}`);
+          api.logger.warn(`thememoria: before_reset observe failed: ${String(error)}`);
         }
       });
     }
 
     api.on("after_compaction", async () => {
       api.logger.info(
-        "memory-memoria: compaction finished; next prompt will use live Memoria recall",
+        "thememoria: compaction finished; next prompt will use live Memoria recall",
       );
     });
 
     api.registerService({
-      id: "memory-memoria",
+      id: "thememoria",
       async start() {
         try {
           const result = await client.health(config.defaultUserId);
-          api.logger.info(`memory-memoria: connected (${String(result.status ?? "ok")})`);
+          api.logger.info(`thememoria: connected (${String(result.status ?? "ok")})`);
         } catch (error) {
-          api.logger.warn(`memory-memoria: health check failed: ${String(error)}`);
+          api.logger.warn(`thememoria: health check failed: ${String(error)}`);
         }
       },
       stop() {
         client.close();
-        api.logger.info("memory-memoria: stopped");
+        api.logger.info("thememoria: stopped");
       },
     });
   },