memorylake-openclaw 1.1.7 → 1.1.8

package/dist/index.js

@@ -240,7 +240,7 @@ import { Type } from "@sinclair/typebox";
 
 // lib/telemetry.ts
 import { createHash } from "crypto";
-var PLUGIN_VERSION = true ? "1.1.7" : "dev";
+var PLUGIN_VERSION = true ? "1.1.8" : "dev";
 var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
 var POSTHOG_API_KEY = process.env.MEMORYLAKE_POSTHOG_API_KEY?.trim() ?? "";
 var POSTHOG_HOST = normalizePosthogHost(
@@ -565,7 +565,7 @@ function getProvider(effectiveCfg) {
 }
 
 // lib/utils/builders.ts
-var PLUGIN_VERSION2 = true ? "1.1.7" : "dev";
+var PLUGIN_VERSION2 = true ? "1.1.8" : "dev";
 function buildDocumentContext(results, maxChunkLength = 1e4) {
   const parts = [];
   for (const result of results) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",
@@ -26,6 +26,9 @@
   ],
   "scripts": {
     "build": "tsup",
+    "sync-skills": "node scripts/sync-skills.mjs",
+    "prepare": "node scripts/sync-skills.mjs",
+    "test": "node --test",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {

package/skills/agent-memorylake-config/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user asks to configure agent-specific memorylake prope
 
 # Agent MemoryLake Config
 
-Configure agent-specific memorylake properties for the current agent. The config file is located at `{workspace}/.memorylake/config.json`, where `{workspace}` is the agent's workspace directory. This config overrides corresponding properties from the global config.
+Configure agent-specific memorylake properties for the current agent. The config file is located at `{workspace}/.memorylake/config.json`, where `{workspace}` is the current agent's workspace directory. This config overrides corresponding properties from the global config.
 
 ## Step 1 — Confirm projectId
 
@@ -15,7 +15,7 @@ If the user has already provided the `projectId` in their message, skip the ques
 
 ## Step 2 — Write Config
 
-1. Ensure the `.memorylake/` directory exists inside the agent's workspace directory:
+1. Ensure the `.memorylake/` directory exists inside the current agent's workspace directory:
 
 ```bash
 cd {workspace}

package/skills/common/get-config.mjs

@@ -6,24 +6,43 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import JSON5 from "json5";
 
+// ---------------------------------------------------------------------------
+// CANONICAL SOURCE. This file is synced verbatim into each consuming skill's
+// `scripts/` directory by `scripts/sync-skills.mjs` (run via the package
+// `prepare` script). Edit THIS file only — never edit the generated copies.
+//
+// Why the copies exist: the OpenClaw skill mechanism links each skill
+// individually into `~/.openclaw/skills/<name>/`, so a shared sibling such as
+// `skills/common/` is no longer reachable from a skill via a relative path.
+// Each skill therefore carries its own copy and references it as
+// `{path-to-this-skill}/scripts/get-config.mjs`.
+// ---------------------------------------------------------------------------
+
 /**
- * Load the merged MemoryLake plugin config for a given agent.
+ * Load the merged MemoryLake plugin config for a given workspace.
  *
  * Reads the global `~/.openclaw/openclaw.json` config, picks up the
- * `memorylake-openclaw` plugin config, resolves the agent workspace,
- * and merges any per-workspace overrides from `<workspace>/.memorylake/config.json`.
+ * `memorylake-openclaw` plugin config, and merges any per-workspace overrides
+ * from `<workspace>/.memorylake/config.json`.
+ *
+ * The caller passes the workspace directly — the running agent already knows
+ * its own workspace (it is the agent's working directory, the same value the
+ * `agent-memorylake-config` skill writes into). We deliberately do NOT shell
+ * out to resolve it from an agent id: the only thing a workspace is needed for
+ * here is locating the per-workspace override file, so taking it as input keeps
+ * this script dependency-free and side-effect-free.
  *
- * @param {{ agentId: string }} opts
+ * @param {{ workspace: string }} opts
  * @returns {{ apiKey: string, projectId: string, host: string, workspace: string, [key: string]: unknown }}
- *   Merged config object. Throws on any failure (missing agent, missing
+ *   Merged config object. Throws on any failure (missing workspace, missing
  *   plugin config, missing required fields, parse errors).
  */
-export function loadConfig({ agentId }) {
-  if (!agentId || typeof agentId !== "string") {
-    throw new Error("agentId is required");
+export function loadConfig({ workspace }) {
+  if (!workspace || typeof workspace !== "string") {
+    throw new Error("workspace is required");
   }
 
-  // Read global config
+  // Read global plugin config (apiKey/projectId/host/...) from openclaw.json.
   const openclawPath = join(homedir(), ".openclaw", "openclaw.json");
   let openclaw;
   try {
@@ -36,15 +55,7 @@ export function loadConfig({ agentId }) {
     throw new Error("memorylake-openclaw plugin config not found");
   }
 
-  // Resolve workspace
-  const agents = openclaw?.agents;
-  const agentEntry = agents?.list?.find((a) => a.id === agentId);
-  const workspace = agentEntry?.workspace || agents?.defaults?.workspace;
-  if (!workspace) {
-    throw new Error(`no workspace found for agent "${agentId}"`);
-  }
-
-  // Merge per-agent overrides
+  // Merge per-workspace overrides
   const merged = { ...globalCfg };
   const localPath = join(workspace, ".memorylake", "config.json");
   if (existsSync(localPath)) {
@@ -73,15 +84,15 @@ export function loadConfig({ agentId }) {
 // identical (JSON to stdout, errors to stderr, non-zero exit on failure).
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   const args = process.argv.slice(2);
-  const agentIdx = args.indexOf("--agent");
-  if (agentIdx === -1 || !args[agentIdx + 1]) {
-    console.error("Usage: node get-config.mjs --agent <agentId>");
+  const wsIdx = args.indexOf("--workspace");
+  if (wsIdx === -1 || !args[wsIdx + 1]) {
+    console.error("Usage: node get-config.mjs --workspace <workspaceDir>");
     process.exit(1);
   }
-  const agentId = args[agentIdx + 1];
+  const workspace = args[wsIdx + 1];
 
   try {
-    const merged = loadConfig({ agentId });
+    const merged = loadConfig({ workspace });
     console.log(JSON.stringify(merged, null, 2));
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);

package/skills/memorylake-api/SKILL.md

@@ -19,13 +19,13 @@ Directly call MemoryLake's REST APIs by discovering endpoints from the live Open
 
 ## Step 1 — Read MemoryLake Config
 
-Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `../common/get-config.mjs`):
+Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `scripts/get-config.mjs`):
 
 ```bash
-node {path-to-this-skill}/../common/get-config.mjs --agent {agent}
+node {path-to-this-skill}/scripts/get-config.mjs --workspace {workspace}
 ```
 
-Where `{agent}` is the current agent ID. The script outputs JSON config with `host`, `apiKey`, `projectId`, etc.
+Where `{workspace}` is the current agent's workspace directory. The script outputs JSON config with `host`, `apiKey`, `projectId`, etc.
 
 If the script exits with an error, stop and inform the user.
 
@@ -186,7 +186,7 @@ All responses follow the same wrapper format:
 
 | Item | Value |
 |------|-------|
-| Config script | `{path-to-this-skill}/../common/get-config.mjs --agent {agent}` |
+| Config script | `{path-to-this-skill}/scripts/get-config.mjs --workspace {workspace}` |
 | Server base path | `/openapi/memorylake` |
 | OpenAPI spec URL | `{host}/openapi/memorylake/api-docs/open-api` |
 | Auth header | `Authorization: Bearer {apiKey}` |

package/skills/memorylake-api/scripts/get-config.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import JSON5 from "json5";
+
+// ---------------------------------------------------------------------------
+// CANONICAL SOURCE. This file is synced verbatim into each consuming skill's
+// `scripts/` directory by `scripts/sync-skills.mjs` (run via the package
+// `prepare` script). Edit THIS file only — never edit the generated copies.
+//
+// Why the copies exist: the OpenClaw skill mechanism links each skill
+// individually into `~/.openclaw/skills/<name>/`, so a shared sibling such as
+// `skills/common/` is no longer reachable from a skill via a relative path.
+// Each skill therefore carries its own copy and references it as
+// `{path-to-this-skill}/scripts/get-config.mjs`.
+// ---------------------------------------------------------------------------
+
+/**
+ * Load the merged MemoryLake plugin config for a given workspace.
+ *
+ * Reads the global `~/.openclaw/openclaw.json` config, picks up the
+ * `memorylake-openclaw` plugin config, and merges any per-workspace overrides
+ * from `<workspace>/.memorylake/config.json`.
+ *
+ * The caller passes the workspace directly — the running agent already knows
+ * its own workspace (it is the agent's working directory, the same value the
+ * `agent-memorylake-config` skill writes into). We deliberately do NOT shell
+ * out to resolve it from an agent id: the only thing a workspace is needed for
+ * here is locating the per-workspace override file, so taking it as input keeps
+ * this script dependency-free and side-effect-free.
+ *
+ * @param {{ workspace: string }} opts
+ * @returns {{ apiKey: string, projectId: string, host: string, workspace: string, [key: string]: unknown }}
+ *   Merged config object. Throws on any failure (missing workspace, missing
+ *   plugin config, missing required fields, parse errors).
+ */
+export function loadConfig({ workspace }) {
+  if (!workspace || typeof workspace !== "string") {
+    throw new Error("workspace is required");
+  }
+
+  // Read global plugin config (apiKey/projectId/host/...) from openclaw.json.
+  const openclawPath = join(homedir(), ".openclaw", "openclaw.json");
+  let openclaw;
+  try {
+    openclaw = JSON5.parse(readFileSync(openclawPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`failed to parse JSON5 config file "${openclawPath}": ${String(err)}`);
+  }
+  const globalCfg = openclaw?.plugins?.entries?.["memorylake-openclaw"]?.config;
+  if (!globalCfg) {
+    throw new Error("memorylake-openclaw plugin config not found");
+  }
+
+  // Merge per-workspace overrides
+  const merged = { ...globalCfg };
+  const localPath = join(workspace, ".memorylake", "config.json");
+  if (existsSync(localPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(localPath, "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        Object.assign(merged, raw);
+      }
+    } catch (err) {
+      throw new Error(`failed to parse workspace config at ${localPath}: ${String(err)}`);
+    }
+  }
+  merged.host = merged.host || "https://app.memorylake.ai";
+  merged.workspace = workspace;
+
+  // Validate required fields
+  if (!merged.apiKey || !merged.projectId) {
+    throw new Error("apiKey and projectId are required");
+  }
+
+  return merged;
+}
+
+// CLI mode: only run when invoked directly via `node get-config.mjs ...`,
+// not when imported as a module. Keeps the SKILL.md-documented CLI behavior
+// identical (JSON to stdout, errors to stderr, non-zero exit on failure).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = process.argv.slice(2);
+  const wsIdx = args.indexOf("--workspace");
+  if (wsIdx === -1 || !args[wsIdx + 1]) {
+    console.error("Usage: node get-config.mjs --workspace <workspaceDir>");
+    process.exit(1);
+  }
+  const workspace = args[wsIdx + 1];
+
+  try {
+    const merged = loadConfig({ workspace });
+    console.log(JSON.stringify(merged, null, 2));
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/skills/memorylake-upload/SKILL.md

@@ -18,13 +18,13 @@ Upload local files, archives, or directories to MemoryLake using the multipart u
 
 ## Step 1 -- Read MemoryLake Config
 
-Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `../common/get-config.mjs`):
+Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `scripts/get-config.mjs`):
 
 ```bash
-node {path-to-this-skill}/../common/get-config.mjs --agent {agent}
+node {path-to-this-skill}/scripts/get-config.mjs --workspace {workspace}
 ```
 
-Where `{agent}` is the current agent ID. The script outputs JSON config with `host`, `apiKey`, `projectId`, etc.
+Where `{workspace}` is the current agent's workspace directory. The script outputs JSON config with `host`, `apiKey`, `projectId`, etc.
 
 If the script exits with an error, stop and inform the user.
 

package/skills/memorylake-upload/scripts/get-config.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import JSON5 from "json5";
+
+// ---------------------------------------------------------------------------
+// CANONICAL SOURCE. This file is synced verbatim into each consuming skill's
+// `scripts/` directory by `scripts/sync-skills.mjs` (run via the package
+// `prepare` script). Edit THIS file only — never edit the generated copies.
+//
+// Why the copies exist: the OpenClaw skill mechanism links each skill
+// individually into `~/.openclaw/skills/<name>/`, so a shared sibling such as
+// `skills/common/` is no longer reachable from a skill via a relative path.
+// Each skill therefore carries its own copy and references it as
+// `{path-to-this-skill}/scripts/get-config.mjs`.
+// ---------------------------------------------------------------------------
+
+/**
+ * Load the merged MemoryLake plugin config for a given workspace.
+ *
+ * Reads the global `~/.openclaw/openclaw.json` config, picks up the
+ * `memorylake-openclaw` plugin config, and merges any per-workspace overrides
+ * from `<workspace>/.memorylake/config.json`.
+ *
+ * The caller passes the workspace directly — the running agent already knows
+ * its own workspace (it is the agent's working directory, the same value the
+ * `agent-memorylake-config` skill writes into). We deliberately do NOT shell
+ * out to resolve it from an agent id: the only thing a workspace is needed for
+ * here is locating the per-workspace override file, so taking it as input keeps
+ * this script dependency-free and side-effect-free.
+ *
+ * @param {{ workspace: string }} opts
+ * @returns {{ apiKey: string, projectId: string, host: string, workspace: string, [key: string]: unknown }}
+ *   Merged config object. Throws on any failure (missing workspace, missing
+ *   plugin config, missing required fields, parse errors).
+ */
+export function loadConfig({ workspace }) {
+  if (!workspace || typeof workspace !== "string") {
+    throw new Error("workspace is required");
+  }
+
+  // Read global plugin config (apiKey/projectId/host/...) from openclaw.json.
+  const openclawPath = join(homedir(), ".openclaw", "openclaw.json");
+  let openclaw;
+  try {
+    openclaw = JSON5.parse(readFileSync(openclawPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`failed to parse JSON5 config file "${openclawPath}": ${String(err)}`);
+  }
+  const globalCfg = openclaw?.plugins?.entries?.["memorylake-openclaw"]?.config;
+  if (!globalCfg) {
+    throw new Error("memorylake-openclaw plugin config not found");
+  }
+
+  // Merge per-workspace overrides
+  const merged = { ...globalCfg };
+  const localPath = join(workspace, ".memorylake", "config.json");
+  if (existsSync(localPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(localPath, "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        Object.assign(merged, raw);
+      }
+    } catch (err) {
+      throw new Error(`failed to parse workspace config at ${localPath}: ${String(err)}`);
+    }
+  }
+  merged.host = merged.host || "https://app.memorylake.ai";
+  merged.workspace = workspace;
+
+  // Validate required fields
+  if (!merged.apiKey || !merged.projectId) {
+    throw new Error("apiKey and projectId are required");
+  }
+
+  return merged;
+}
+
+// CLI mode: only run when invoked directly via `node get-config.mjs ...`,
+// not when imported as a module. Keeps the SKILL.md-documented CLI behavior
+// identical (JSON to stdout, errors to stderr, non-zero exit on failure).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = process.argv.slice(2);
+  const wsIdx = args.indexOf("--workspace");
+  if (wsIdx === -1 || !args[wsIdx + 1]) {
+    console.error("Usage: node get-config.mjs --workspace <workspaceDir>");
+    process.exit(1);
+  }
+  const workspace = args[wsIdx + 1];
+
+  try {
+    const merged = loadConfig({ workspace });
+    console.log(JSON.stringify(merged, null, 2));
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/skills/migrate-memories-to-memorylake/SKILL.md

@@ -25,7 +25,7 @@ The caller must provide:
 **Always try the script first.** The script is at `scripts/migrate.mjs` relative to this SKILL.md (i.e., in the `scripts/` subdirectory of this skill). Run:
 
 ```bash
-node <path-to-this-skill-directory>/scripts/migrate.mjs --agent {agent} --user-id {user_id}
+node <path-to-this-skill-directory>/scripts/migrate.mjs --agent {agent} --workspace {workspace} --user-id {user_id}
 ```
 
 The script handles everything: config reading, session filtering, JSONL parsing, memory file collection, and API submission.
@@ -40,10 +40,10 @@ If the script fails, follow these steps manually.
 
 ### Step 1 — Read MemoryLake Config
 
-Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `../common/get-config.mjs`):
+Run the common config script (path is relative to **this skill's SKILL.md**, i.e. `scripts/get-config.mjs`):
 
 ```bash
-node {path-to-this-skill}/../common/get-config.mjs --agent {agent}
+node {path-to-this-skill}/scripts/get-config.mjs --workspace {workspace}
 ```
 
 The script outputs JSON config with `host`, `apiKey`, `projectId`, `workspace`, etc. If the script exits with an error, stop and inform the user.
@@ -74,7 +74,7 @@ The script outputs JSON config with `host`, `apiKey`, `projectId`, `workspace`,
 
 ### Step 3 — Read Memory Files
 
-Use the `workspace` path from the config output in Step 1. Then read:
+Use the agent's `{workspace}` directory (the same path passed in Step 1, and echoed back as the `workspace` field in the config output). Then read:
 - `{workspace}/MEMORY.md`
 - All files in `{workspace}/memory/` directory
 
@@ -184,10 +184,10 @@ At the end, print a summary:
 
 | Item | Path / Value |
 |------|-------------|
-| Config script | `{path-to-this-skill}/../common/get-config.mjs --agent {agent}` |
+| Config script | `{path-to-this-skill}/scripts/get-config.mjs --workspace {workspace}` |
 | Session index | `~/.openclaw/agents/{agent}/sessions/sessions.json` |
 | Session files | `~/.openclaw/agents/{agent}/sessions/{id}.jsonl` |
-| Workspace path | from config script output (`workspace` field) |
+| Workspace path | the current agent's workspace directory (`{workspace}`; echoed back in the config output) |
 | API endpoint | `{host}/openapi/memorylake/api/v2/projects/{projectId}/memories` |
 | Auth header | `Authorization: Bearer {apiKey}` |
 | Default host | `https://app.memorylake.ai` |

package/skills/migrate-memories-to-memorylake/scripts/get-config.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import JSON5 from "json5";
+
+// ---------------------------------------------------------------------------
+// CANONICAL SOURCE. This file is synced verbatim into each consuming skill's
+// `scripts/` directory by `scripts/sync-skills.mjs` (run via the package
+// `prepare` script). Edit THIS file only — never edit the generated copies.
+//
+// Why the copies exist: the OpenClaw skill mechanism links each skill
+// individually into `~/.openclaw/skills/<name>/`, so a shared sibling such as
+// `skills/common/` is no longer reachable from a skill via a relative path.
+// Each skill therefore carries its own copy and references it as
+// `{path-to-this-skill}/scripts/get-config.mjs`.
+// ---------------------------------------------------------------------------
+
+/**
+ * Load the merged MemoryLake plugin config for a given workspace.
+ *
+ * Reads the global `~/.openclaw/openclaw.json` config, picks up the
+ * `memorylake-openclaw` plugin config, and merges any per-workspace overrides
+ * from `<workspace>/.memorylake/config.json`.
+ *
+ * The caller passes the workspace directly — the running agent already knows
+ * its own workspace (it is the agent's working directory, the same value the
+ * `agent-memorylake-config` skill writes into). We deliberately do NOT shell
+ * out to resolve it from an agent id: the only thing a workspace is needed for
+ * here is locating the per-workspace override file, so taking it as input keeps
+ * this script dependency-free and side-effect-free.
+ *
+ * @param {{ workspace: string }} opts
+ * @returns {{ apiKey: string, projectId: string, host: string, workspace: string, [key: string]: unknown }}
+ *   Merged config object. Throws on any failure (missing workspace, missing
+ *   plugin config, missing required fields, parse errors).
+ */
+export function loadConfig({ workspace }) {
+  if (!workspace || typeof workspace !== "string") {
+    throw new Error("workspace is required");
+  }
+
+  // Read global plugin config (apiKey/projectId/host/...) from openclaw.json.
+  const openclawPath = join(homedir(), ".openclaw", "openclaw.json");
+  let openclaw;
+  try {
+    openclaw = JSON5.parse(readFileSync(openclawPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`failed to parse JSON5 config file "${openclawPath}": ${String(err)}`);
+  }
+  const globalCfg = openclaw?.plugins?.entries?.["memorylake-openclaw"]?.config;
+  if (!globalCfg) {
+    throw new Error("memorylake-openclaw plugin config not found");
+  }
+
+  // Merge per-workspace overrides
+  const merged = { ...globalCfg };
+  const localPath = join(workspace, ".memorylake", "config.json");
+  if (existsSync(localPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(localPath, "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        Object.assign(merged, raw);
+      }
+    } catch (err) {
+      throw new Error(`failed to parse workspace config at ${localPath}: ${String(err)}`);
+    }
+  }
+  merged.host = merged.host || "https://app.memorylake.ai";
+  merged.workspace = workspace;
+
+  // Validate required fields
+  if (!merged.apiKey || !merged.projectId) {
+    throw new Error("apiKey and projectId are required");
+  }
+
+  return merged;
+}
+
+// CLI mode: only run when invoked directly via `node get-config.mjs ...`,
+// not when imported as a module. Keeps the SKILL.md-documented CLI behavior
+// identical (JSON to stdout, errors to stderr, non-zero exit on failure).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = process.argv.slice(2);
+  const wsIdx = args.indexOf("--workspace");
+  if (wsIdx === -1 || !args[wsIdx + 1]) {
+    console.error("Usage: node get-config.mjs --workspace <workspaceDir>");
+    process.exit(1);
+  }
+  const workspace = args[wsIdx + 1];
+
+  try {
+    const merged = loadConfig({ workspace });
+    console.log(JSON.stringify(merged, null, 2));
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/skills/migrate-memories-to-memorylake/scripts/migrate.mjs

@@ -11,14 +11,14 @@ import { readFileSync, readdirSync, existsSync, statSync } from "fs";
 import { join, basename } from "path";
 import { homedir } from "os";
 import { parseArgs } from "util";
-import { loadConfig as loadConfigShared } from "../../common/get-config.mjs";
+import { loadConfig as loadConfigShared } from "./get-config.mjs";
 
 const BATCH_SIZE = 20;
 const API_USER_ID = "default";
 
-function loadConfig(agent) {
+function loadConfig(workspace) {
   try {
-    return loadConfigShared({ agentId: agent });
+    return loadConfigShared({ workspace });
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
@@ -249,22 +249,28 @@ async function main() {
   const { values } = parseArgs({
     options: {
       agent: { type: "string" },
+      workspace: { type: "string" },
       "user-id": { type: "string" },
     },
     strict: true,
   });
 
   const agent = values.agent;
+  const workspace = values.workspace;
   const userId = values["user-id"];
 
-  if (!agent || !userId) {
-    console.error("Usage: node migrate.mjs --agent <agent> --user-id <user_id>");
+  if (!agent || !workspace || !userId) {
+    console.error(
+      "Usage: node migrate.mjs --agent <agent> --workspace <path> --user-id <user_id>",
+    );
     process.exit(1);
   }
 
   console.log("=== Migrate Memories to MemoryLake ===\n");
 
-  const { host, apiKey, projectId, workspace } = loadConfig(agent);
+  // `agent` keys the sessions dir (~/.openclaw/agents/<agent>/sessions); the
+  // workspace holds the memory files and the per-workspace config override.
+  const { host, apiKey, projectId } = loadConfig(workspace);
   console.log(`Host: ${host}`);
   console.log(`Project: ${projectId}`);
   console.log(`Agent: ${agent}`);