mr-memory 3.2.2 → 3.4.0

package/index.ts

@@ -10,11 +10,9 @@
 
 import { readFile, readdir, stat, lstat } from "node:fs/promises";
 import { join, resolve, relative, isAbsolute, sep } from "node:path";
-import { homedir } from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { syncWorkspaceFiles, runSyncCli, showManifestStatus } from "./sync.js";
 
 const DEFAULT_ENDPOINT = "https://api.memoryrouter.ai";
 
@@ -273,6 +271,7 @@ type MemoryRouterConfig = {
   mode?: "relay" | "proxy";
   logging?: boolean;
   embeddings?: string;
+  agentKeys?: Record<string, string>;
 };
 
 // ──────────────────────────────────────────────────────
@@ -382,51 +381,38 @@ const memoryRouterPlugin = {
     const mode = cfg?.mode || "relay";
     const logging = cfg?.logging ?? false;
     const embeddings = cfg?.embeddings; // undefined = bge (default), "qwen" = qwen3-8b
+    const agentKeys = cfg?.agentKeys;
     const log = (msg: string) => { if (logging) api.logger.info?.(msg); };
 
-    if (memoryKey) {
-      const modelLabel = embeddings ? `, embeddings: ${embeddings}` : "";
-      api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}..., mode: ${mode}${modelLabel})`);
+    // Resolve the correct memory key for a given agent context.
+    // Multi-agent gateways: each agent gets its own key via agentKeys map.
+    // Single-agent: falls back to the global key.
+    function resolveKey(ctx: any): string | undefined {
+      if (agentKeys && ctx?.workspaceDir) {
+        // Derive agentId from workspace path: ~/.openclaw/workspace-rex → "rex"
+        // Default workspace (~/.openclaw/workspace) → "main"
+        const dirName = ctx.workspaceDir.split("/").pop() || "";
+        const agentId = dirName === "workspace" ? "main" : dirName.replace(/^workspace-/, "");
+        if (agentId && agentKeys[agentId]) return agentKeys[agentId];
+      }
+      return memoryKey;
+    }
+
+    const hasAnyKey = !!(memoryKey || (agentKeys && Object.keys(agentKeys).length > 0));
+
+    if (hasAnyKey) {
+      if (memoryKey) api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
+      if (agentKeys) api.logger.info?.(`memoryrouter: ${Object.keys(agentKeys).length} agent key(s) configured`);
     } else {
       api.logger.info?.("memoryrouter: no key configured — run: openclaw mr <key>");
       api.logger.info?.("memoryrouter: get your free API key at https://memoryrouter.ai");
     }
 
-    // ==================================================================
-    // Workspace sync (debounced, fire-and-forget)
-    // ==================================================================
-
-    let lastSyncMs = 0;
-    const SYNC_DEBOUNCE_MS = 60_000; // At most once per 60 seconds
-
-    const triggerSync = (workspaceDir: string) => {
-      if (!memoryKey) return;
-      const now = Date.now();
-      if (now - lastSyncMs < SYNC_DEBOUNCE_MS) return;
-      lastSyncMs = now;
-      syncWorkspaceFiles({ workspaceDir, endpoint, memoryKey, embeddings, logging })
-        .then((result) => {
-          if (result.uploaded > 0 || result.deleted > 0) {
-            api.logger.info?.(
-              `memoryrouter: sync complete — ${result.uploaded} uploaded, ${result.deleted} deleted, ${result.unchanged} unchanged`,
-            );
-          } else {
-            log(`memoryrouter: sync complete — ${result.unchanged} files unchanged`);
-          }
-          if (result.errors.length > 0) {
-            api.logger.warn?.(`memoryrouter: sync had ${result.errors.length} errors`);
-          }
-        })
-        .catch((err) => {
-          log(`memoryrouter: sync error — ${err instanceof Error ? err.message : String(err)}`);
-        });
-    };
-
     // ==================================================================
     // Core: before_agent_start — search memories, inject context
     // ==================================================================
 
-    if (memoryKey) {
+    if (hasAnyKey) {
       // Track whether we've already fired for this prompt (dedup double-fire)
       let lastPreparedPrompt = "";
       // Track whether before_prompt_build already handled the first call in this run
@@ -437,7 +423,6 @@ const memoryRouterPlugin = {
       // When PR #24122 merges, OpenClaw will use the returned prependContext.
       // This gives forward compatibility — no plugin update needed.
       api.on("llm_input", async (event, ctx) => {
-        log(`memoryrouter: llm_input fired (sessionKey=${ctx.sessionKey}, promptBuildFired=${promptBuildFiredThisRun})`);
         // Skip the first call — before_prompt_build already handled it
         // (before_prompt_build includes workspace+tools+skills for accurate billing)
         if (promptBuildFiredThisRun) {
@@ -445,7 +430,11 @@ const memoryRouterPlugin = {
           return;
         }
 
+        const activeKey = resolveKey(ctx);
+        if (!activeKey) return; // No key for this agent
+
         try {
+          const startMs = Date.now();
           const prompt = event.prompt;
           if (prompt === lastPreparedPrompt && lastPreparedPrompt !== "") return;
           lastPreparedPrompt = prompt;
@@ -484,7 +473,7 @@ const memoryRouterPlugin = {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
-              Authorization: `Bearer ${memoryKey}`,
+              Authorization: `Bearer ${activeKey}`,
             },
             body: JSON.stringify({
               messages: contextPayload,
@@ -511,9 +500,8 @@ const memoryRouterPlugin = {
           };
 
           if (data.context) {
-            log(
-              `memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens)`,
-            );
+            const elapsed = Date.now() - startMs;
+            api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms) [llm_input]`);
             const wrapped = wrapForInjection(data.context);
             return { appendSystemContext: wrapped };
           }
@@ -525,12 +513,10 @@ const memoryRouterPlugin = {
       // ── before_prompt_build: fires once per run (primary, includes full billing context)
       api.on("before_prompt_build", async (event, ctx) => {
         promptBuildFiredThisRun = true;
-        log(`memoryrouter: before_prompt_build fired (sessionKey=${ctx.sessionKey}, promptLen=${event.prompt?.length})`);
-
-        // Trigger workspace sync (fire-and-forget, debounced — catches new files mid-run)
-        if (ctx.workspaceDir) triggerSync(ctx.workspaceDir);
-
+        const activeKey = resolveKey(ctx);
+        if (!activeKey) return; // No key for this agent
         try {
+          const startMs = Date.now();
           const prompt = event.prompt;
 
           // Deduplicate — if we already prepared this exact prompt, skip
@@ -599,7 +585,7 @@ const memoryRouterPlugin = {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
-              Authorization: `Bearer ${memoryKey}`,
+              Authorization: `Bearer ${activeKey}`,
             },
             body: JSON.stringify({
               messages: contextPayload,
@@ -625,16 +611,11 @@ const memoryRouterPlugin = {
             memory_tokens?: number;
           };
 
-          log(`memoryrouter: prepare response — memories_found=${data.memories_found || 0}, context_length=${data.context?.length || 0}, tokens=${data.memory_tokens || 0}, embeddings=${embeddings || 'bge'}`);
-
           if (data.context) {
-            log(
-              `memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens)`,
-            );
+            const elapsed = Date.now() - startMs;
+            api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms)`);
             const wrapped = wrapForInjection(data.context);
             return { appendSystemContext: wrapped };
-          } else {
-            log(`memoryrouter: prepare returned no context (memories_found=${data.memories_found || 0})`);
           }
         } catch (err) {
           log(
@@ -648,6 +629,8 @@ const memoryRouterPlugin = {
       // ==================================================================
 
       api.on("agent_end", async (event, ctx) => {
+        const activeKey = resolveKey(ctx);
+        if (!activeKey) return; // No key for this agent
         try {
           const msgs = event.messages;
           if (!msgs || !Array.isArray(msgs) || msgs.length === 0) return;
@@ -720,7 +703,7 @@ const memoryRouterPlugin = {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
-              Authorization: `Bearer ${memoryKey}`,
+              Authorization: `Bearer ${activeKey}`,
             },
             body: JSON.stringify({
               messages: toStore,
@@ -754,6 +737,7 @@ const memoryRouterPlugin = {
 
       // memory_search — calls MR /v1/memory/search
       api.registerTool((ctx) => {
+        const toolKey = resolveKey(ctx);
         return {
           label: "Memory Search",
           name: "memory_search",
@@ -768,14 +752,15 @@ const memoryRouterPlugin = {
             required: ["query"],
           } as any,
           execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+            if (!toolKey) return jsonToolResult({ results: [], error: "No memory key configured for this agent" });
             const query = typeof params.query === "string" ? params.query.trim() : "";
             if (!query) return jsonToolResult({ results: [], error: "query required" });
-            const limit = typeof params.maxResults === "number" ? params.maxResults : 10;
+            const limit = typeof params.maxResults === "number" ? params.maxResults : 50;
             try {
               const res = await fetch(`${endpoint}/v1/memory/search`, {
                 method: "POST",
                 headers: {
-                  Authorization: `Bearer ${memoryKey}`,
+                  Authorization: `Bearer ${toolKey}`,
                   "Content-Type": "application/json",
                   ...(embeddings && { "X-Embedding-Model": embeddings }),
                 },
@@ -850,7 +835,7 @@ const memoryRouterPlugin = {
           },
         };
       });
-    } // end if (memoryKey)
+    } // end if (hasAnyKey)
 
     // ==================================================================
     // CLI Commands
@@ -1011,71 +996,17 @@ const memoryRouterPlugin = {
             }
           });
 
-        // Mode commands
-        for (const [modeName, modeDesc] of [
-          ["relay", "Relay mode — hooks only, works on stock OpenClaw [default]"],
-          ["proxy", "Proxy mode — memory on every LLM call (requires registerStreamFnWrapper)"],
-        ] as const) {
-          mr.command(modeName)
-            .description(modeDesc)
-            .action(async () => {
-              if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
-              try {
-                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density, mode: modeName });
-                console.log(`✓ Mode set to ${modeName}`);
-              } catch (err) {
-                console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
-              }
-            });
-        }
 
-        // Embedding model command
-        mr.command("embeddings")
-          .description("Get or set embedding model (bge, qwen)")
-          .argument("[model]", "Embedding model: bge (default, 1024d) or qwen (4096d)")
-          .action(async (model: string | undefined) => {
-            if (!model) {
-              console.log(`Current embedding model: ${embeddings || "bge (default)"}`);
-              console.log(`\nAvailable models:`);
-              console.log(`  bge    BGE-M3 1024 dims  (Cloudflare Workers AI, ~18ms, free)`);
-              console.log(`  qwen   Qwen3-8B 4096 dims (HuggingFace, ~69ms, $0.80/hr)`);
-              console.log(`\nUsage: openclaw mr embeddings <model>`);
-              return;
-            }
-            const normalized = model.toLowerCase().trim();
-            const valid = ["bge", "bge-m3", "qwen", "qwen3", "qwen3-8b", "default"];
-            if (!valid.includes(normalized)) {
-              console.error(`Unknown model: "${model}". Valid options: bge, qwen`);
-              return;
-            }
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
-            // "bge" / "default" → clear embeddings (use server default)
-            const newEmbeddings = (normalized === "bge" || normalized === "bge-m3" || normalized === "default")
-              ? undefined
-              : normalized.startsWith("qwen") ? "qwen" : normalized;
-            try {
-              await setPluginConfig(api, {
-                key: memoryKey,
-                endpoint: cfg?.endpoint,
-                density,
-                mode,
-                logging,
-                ...(newEmbeddings && { embeddings: newEmbeddings }),
-              });
-              const label = newEmbeddings || "bge (default)";
-              console.log(`✓ Embedding model set to ${label}`);
-              console.log(`  All future prepare/ingest/search will use ${label}`);
-              console.log(`\n  Restart gateway to apply: openclaw gateway restart`);
-            } catch (err) {
-              console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-          });
+
+
 
         mr.command("status")
           .description("Show MemoryRouter vault stats")
           .option("--json", "JSON output")
-          .action(async (opts) => {
-            if (!memoryKey) {
+          .option("--key <key>", "Override memory key (for subagent vaults)")
+          .action(async (opts: { json?: boolean; key?: string }) => {
+            const effectiveKey = opts.key || memoryKey;
+            if (!effectiveKey) {
               if (opts.json) {
                 console.log(JSON.stringify({ enabled: false, key: null }, null, 2));
               } else {
@@ -1092,19 +1023,17 @@ const memoryRouterPlugin = {
                 ? `${endpoint}/v1/memory/stats?embeddings=${encodeURIComponent(embeddings)}`
                 : `${endpoint}/v1/memory/stats`;
               const res = await fetch(statsUrl, {
-                headers: { Authorization: `Bearer ${memoryKey}` },
+                headers: { Authorization: `Bearer ${effectiveKey}` },
               });
               const data = (await res.json()) as { totalVectors?: number; totalTokens?: number };
               if (opts.json) {
-                console.log(JSON.stringify({ enabled: true, key: memoryKey, density, mode, embeddings: embeddings || "bge", stats: data }, null, 2));
+                console.log(JSON.stringify({ enabled: true, key: effectiveKey, density, stats: data }, null, 2));
               } else {
                 console.log("MemoryRouter Status");
                 console.log("───────────────────────────");
                 console.log(`Enabled:     ✓ Yes`);
-                console.log(`Key:         ${memoryKey.slice(0, 6)}...${memoryKey.slice(-3)}`);
-                console.log(`Mode:        ${mode}`);
+                console.log(`Key:         ${effectiveKey.slice(0, 6)}...${effectiveKey.slice(-3)}`);
                 console.log(`Density:     ${density}`);
-                console.log(`Embeddings:  ${embeddings || "bge (default)"}`);
                 console.log(`Endpoint:    ${endpoint}`);
                 console.log(`Memories:    ${data.totalVectors ?? 0}`);
                 console.log(`Tokens:      ${data.totalTokens ?? 0}`);
@@ -1119,8 +1048,10 @@ const memoryRouterPlugin = {
           .argument("[path]", "Specific file or directory to upload")
           .option("--workspace <dir>", "Workspace directory")
           .option("--brain <dir>", "State directory with sessions")
-          .action(async (targetPath: string | undefined, opts: { workspace?: string; brain?: string }) => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+          .option("--key <key>", "Override memory key (for subagent vaults)")
+          .action(async (targetPath: string | undefined, opts: { workspace?: string; brain?: string; key?: string }) => {
+            const effectiveKey = opts.key || memoryKey;
+            if (!effectiveKey) { console.error("Not configured. Run: openclaw mr <key> or pass --key <key>"); return; }
             const os = await import("node:os");
             const path = await import("node:path");
             const stateDir = opts.brain ? path.resolve(opts.brain) : path.join(os.homedir(), ".openclaw");
@@ -1131,22 +1062,24 @@ const memoryRouterPlugin = {
                 ? path.resolve(configWorkspace.replace(/^~/, os.homedir()))
                 : path.join(os.homedir(), ".openclaw", "workspace");
             const { runUpload } = await import("./upload.js");
-            await runUpload({ memoryKey, endpoint, targetPath, stateDir, workspacePath, hasWorkspaceFlag: !!opts.workspace, hasBrainFlag: !!opts.brain, embeddings });
+            await runUpload({ memoryKey: effectiveKey, endpoint, targetPath, stateDir, workspacePath, hasWorkspaceFlag: !!opts.workspace, hasBrainFlag: !!opts.brain, embeddings });
           });
 
         mr.command("search")
           .description("Search memories in vault")
           .argument("<query>", "Search query")
-          .option("-n, --limit <number>", "Number of results", "5")
+          .option("-n, --limit <number>", "Number of results", "50")
           .option("--json", "Output raw JSON response")
-          .action(async (query: string, opts: { limit: string; json?: boolean }) => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
-            const limit = parseInt(opts.limit, 10) || 5;
+          .option("--key <key>", "Override memory key (for subagent vaults)")
+          .action(async (query: string, opts: { limit: string; json?: boolean; key?: string }) => {
+            const effectiveKey = opts.key || memoryKey;
+            if (!effectiveKey) { console.error("Not configured. Run: openclaw mr <key> or pass --key <key>"); return; }
+            const limit = parseInt(opts.limit, 10) || 50;
             try {
               const res = await fetch(`${endpoint}/v1/memory/search`, {
                 method: "POST",
                 headers: {
-                  Authorization: `Bearer ${memoryKey}`,
+                  Authorization: `Bearer ${effectiveKey}`,
                   "Content-Type": "application/json",
                   ...(embeddings && { "X-Embedding-Model": embeddings }),
                 },
@@ -1211,15 +1144,17 @@ const memoryRouterPlugin = {
 
         mr.command("delete")
           .description("Clear all memories from vault")
-          .action(async () => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+          .option("--key <key>", "Override memory key (for subagent vaults)")
+          .action(async (opts: { key?: string }) => {
+            const effectiveKey = opts.key || memoryKey;
+            if (!effectiveKey) { console.error("Not configured. Run: openclaw mr <key> or pass --key <key>"); return; }
             try {
               const deleteUrl = embeddings
                 ? `${endpoint}/v1/memory?embeddings=${encodeURIComponent(embeddings)}`
                 : `${endpoint}/v1/memory`;
               const res = await fetch(deleteUrl, {
                 method: "DELETE",
-                headers: { Authorization: `Bearer ${memoryKey}` },
+                headers: { Authorization: `Bearer ${effectiveKey}` },
               });
               const data = (await res.json()) as { message?: string };
               const modelLabel = embeddings ? ` (${embeddings})` : "";
@@ -1228,33 +1163,6 @@ const memoryRouterPlugin = {
               console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
             }
           });
-
-        // ── Workspace Sync ──
-        mr.command("sync")
-          .description("Sync workspace files to vault using source_hash tracking")
-          .option("--workspace <dir>", "Workspace directory")
-          .option("--status", "Show manifest status instead of syncing")
-          .action(async (opts: { workspace?: string; status?: boolean }) => {
-            if (opts.status) {
-              await showManifestStatus();
-              return;
-            }
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
-            const os = await import("node:os");
-            const configWorkspace = (api.config as any).workspace || (api.config as any).agents?.defaults?.workspace;
-            const workspaceDir = opts.workspace
-              ? path.resolve(opts.workspace)
-              : configWorkspace
-                ? path.resolve(configWorkspace.replace(/^~/, os.homedir()))
-                : path.join(os.homedir(), ".openclaw", "workspace");
-            await runSyncCli({
-              workspaceDir,
-              endpoint,
-              memoryKey,
-              embeddings,
-              logging: true,
-            });
-          });
       },
       { commands: ["mr"] },
     );
@@ -1265,17 +1173,8 @@ const memoryRouterPlugin = {
 
     api.registerService({
       id: "mr-memory",
-      start: async () => {
-        if (memoryKey) {
-          api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
-
-          // ── Auto-sync workspace files (non-blocking) ──
-          const configWorkspace = (api.config as any).workspace || (api.config as any).agents?.defaults?.workspace;
-          const workspaceDir = configWorkspace
-            ? path.resolve(configWorkspace.replace(/^~/, homedir()))
-            : path.join(homedir(), ".openclaw", "workspace");
-          triggerSync(workspaceDir);
-        }
+      start: () => {
+        if (memoryKey) api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
       },
       stop: () => {
         api.logger.info?.("memoryrouter: stopped");

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "mr-memory",
-  "version": "3.2.2",
+  "version": "3.4.0",
   "description": "MemoryRouter persistent memory plugin for OpenClaw — your AI remembers every conversation",
   "type": "module",
   "files": [
     "README.md",
     "index.ts",
     "openclaw.plugin.json",
-    "upload.ts",
-    "sync.ts"
+    "upload.ts"
   ],
   "keywords": [
     "openclaw",

package/upload.ts

@@ -370,11 +370,10 @@ export async function runUpload(params: {
 
   const workspacePath = params.workspacePath ?? process.cwd();
 
-  // ── Target path: specific file/dir upload (old behavior, no sync) ──
+  let files: string[];
   if (targetPath) {
     const resolved = path.resolve(targetPath);
     const stat = await fs.stat(resolved);
-    let files: string[];
     if (stat.isDirectory()) {
       const allDirFiles = await fs.readdir(resolved, { recursive: true });
       files = (allDirFiles as string[])
@@ -386,58 +385,19 @@ export async function runUpload(params: {
     } else {
       files = [resolved];
     }
-    await uploadFilesLegacy(files, memoryKey, endpoint, embeddings);
-    return;
-  }
-
-  // ── Determine what to upload ──
-  const doWorkspace = !params.hasBrainFlag || params.hasWorkspaceFlag;  // default: yes
-  const doSessions = !params.hasWorkspaceFlag || params.hasBrainFlag;   // default: yes
-
-  // ── Workspace files: use source_hash sync (smart, tracks changes) ──
-  if (doWorkspace) {
-    console.log("📁 Syncing workspace files...");
-    const { syncWorkspaceFiles } = await import("./sync.js");
-    const syncResult = await syncWorkspaceFiles({
-      workspaceDir: workspacePath,
-      endpoint,
-      memoryKey,
-      embeddings,
-      logging: true,
-    });
-    console.log(`\n   Workspace: ${syncResult.uploaded} uploaded, ${syncResult.deleted} deleted, ${syncResult.unchanged} unchanged`);
-    if (syncResult.errors.length > 0) {
-      console.log(`   ⚠️ ${syncResult.errors.length} errors`);
-      for (const err of syncResult.errors.slice(0, 3)) {
-        console.log(`      • ${err}`);
-      }
-    }
+  } else if (params.hasBrainFlag && !params.hasWorkspaceFlag) {
+    // --brain only: upload sessions from brain path
+    files = await discoverBrainFiles(stateDir);
+  } else if (params.hasWorkspaceFlag && !params.hasBrainFlag) {
+    // --workspace only: upload workspace files only
+    files = await discoverWorkspaceFiles(workspacePath);
+  } else {
+    // No flags or both flags: upload both workspace + sessions
+    const wsFiles = await discoverWorkspaceFiles(workspacePath);
+    const brainFiles = await discoverBrainFiles(stateDir);
+    files = [...wsFiles, ...brainFiles];
   }
 
-  // ── Session transcripts: batch upload (append-only, no sync needed) ──
-  if (doSessions) {
-    console.log("\n📝 Uploading session transcripts...");
-    const sessionFiles = await discoverBrainFiles(stateDir);
-    if (sessionFiles.length === 0) {
-      console.log("   No session files found.");
-    } else {
-      await uploadFilesLegacy(sessionFiles, memoryKey, endpoint, embeddings);
-    }
-  }
-}
-
-/**
- * Legacy batch upload for session transcripts and specific-path uploads.
- * Sessions are append-only, so they don't need source_hash tracking.
- */
-async function uploadFilesLegacy(
-  files: string[],
-  memoryKey: string,
-  endpoint: string,
-  embeddings?: string,
-): Promise<void> {
-  const uploadUrl = `${endpoint}/v1/memory/upload`;
-
   if (files.length === 0) {
     console.log("No files found to upload.");
     return;
@@ -536,6 +496,7 @@ async function uploadFilesLegacy(
       if (batchFailed > 0) {
         const errHint = result.errors?.[0] ? ` (${result.errors[0].slice(0, 120)})` : "";
         console.log(`⚠ ${batchStored} stored, ${batchFailed} skipped${errHint}`);
+        // Show detailed error diagnostics (up to 5 per batch)
         if (result.errors && result.errors.length > 1) {
           for (const err of result.errors.slice(0, 5)) {
             console.log(`    → ${err.slice(0, 200)}`);

package/sync.ts

@@ -1,367 +0,0 @@
-/**
- * MemoryRouter Workspace Sync — source_hash-based file tracking.
- *
- * Tracks workspace files via SHA-256 content hashes. When files change,
- * old chunks are deleted and new content is uploaded with the new hash.
- * This enables clean replacement without stale chunk accumulation.
- *
- * IMPORTANT: source_hash is ONLY for workspace files, NEVER for sessions.
- */
-
-import { readFile, writeFile, readdir, lstat, mkdir } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { join, relative, sep } from "node:path";
-import { homedir } from "node:os";
-
-// ── Types ──
-
-export interface ManifestFileEntry {
-  source_hash: string;
-  size: number;
-  chunks: number;
-  uploaded_at: number;
-}
-
-export interface Manifest {
-  version: number;
-  lastSync: number;
-  files: Record<string, ManifestFileEntry>;
-}
-
-export interface SyncResult {
-  uploaded: number;
-  deleted: number;
-  unchanged: number;
-  errors: string[];
-}
-
-export interface SyncOptions {
-  workspaceDir: string;
-  endpoint: string;
-  memoryKey: string;
-  embeddings?: string;
-  logging?: boolean;
-}
-
-// ── Constants ──
-
-const MANIFEST_PATH = join(homedir(), ".openclaw", "mr-memory-manifest.json");
-const MAX_FILE_SIZE = 1_000_000; // 1MB limit
-const TEXT_EXTENSIONS = new Set(["md", "txt"]);
-
-// ── Manifest I/O ──
-
-export async function loadManifest(): Promise<Manifest> {
-  try {
-    const raw = await readFile(MANIFEST_PATH, "utf-8");
-    return JSON.parse(raw) as Manifest;
-  } catch {
-    // First run or corrupted — create empty manifest
-    return { version: 1, lastSync: 0, files: {} };
-  }
-}
-
-export async function saveManifest(manifest: Manifest): Promise<void> {
-  manifest.lastSync = Date.now();
-  // Ensure directory exists
-  const dir = join(homedir(), ".openclaw");
-  await mkdir(dir, { recursive: true });
-  await writeFile(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
-}
-
-// ── Hash Computation ──
-
-export function computeSourceHash(content: string): string {
-  const hash = createHash("sha256").update(content).digest("hex");
-  return hash.substring(0, 16); // First 16 hex chars, matching MR API format
-}
-
-// ── File Discovery ──
-
-/**
- * Discover ALL workspace files to sync:
- * - All .md and .txt files in workspace root
- * - All files recursively under memory/ directory
- * - Excludes: hidden files/dirs, node_modules/, files > 1MB, binary files
- */
-export async function discoverWorkspaceFiles(workspaceDir: string): Promise<string[]> {
-  const files: string[] = [];
-
-  async function walk(dir: string) {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return; // Directory doesn't exist or not readable
-    }
-
-    for (const entry of entries) {
-      // Skip hidden dirs/files and node_modules
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-
-      const fullPath = join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        await walk(fullPath);
-      } else if (entry.isFile()) {
-        // Only text files we want to index
-        const ext = entry.name.toLowerCase().split(".").pop() || "";
-        if (!TEXT_EXTENSIONS.has(ext)) continue;
-
-        // Check file size
-        try {
-          const stat = await lstat(fullPath);
-          if (stat.size > MAX_FILE_SIZE) continue;
-          if (stat.size === 0) continue; // Skip empty files
-          files.push(relative(workspaceDir, fullPath));
-        } catch {
-          continue; // Skip unreadable files
-        }
-      }
-    }
-  }
-
-  await walk(workspaceDir);
-  return files.sort();
-}
-
-// ── API Helpers ──
-
-/**
- * Upload file content with source_hash using isolated chunking.
- * Uses POST /v1/memory/upload-source endpoint.
- */
-export async function uploadSourceFile(
-  endpoint: string,
-  memoryKey: string,
-  content: string,
-  sourceHash: string,
-  embeddings?: string,
-): Promise<{ stored: number; chunks: number }> {
-  const res = await fetch(`${endpoint}/v1/memory/upload-source`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${memoryKey}`,
-      "Content-Type": "application/json",
-      ...(embeddings && { "X-Embedding-Model": embeddings }),
-    },
-    body: JSON.stringify({ content, source_hash: sourceHash }),
-  });
-
-  if (!res.ok) {
-    const errText = await res.text().catch(() => "");
-    throw new Error(`Upload failed: HTTP ${res.status} — ${errText.slice(0, 200)}`);
-  }
-
-  const data = (await res.json()) as { stored: number; chunks: number; source_hash: string };
-  return { stored: data.stored || 0, chunks: data.chunks || data.stored || 0 };
-}
-
-/**
- * Delete all chunks with a given source_hash.
- * Uses POST /v1/memory/source/delete (POST fallback for clients that can't send DELETE with body).
- */
-export async function deleteBySourceHash(
-  endpoint: string,
-  memoryKey: string,
-  sourceHash: string,
-): Promise<number> {
-  const res = await fetch(`${endpoint}/v1/memory/source/delete`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${memoryKey}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ source_hash: sourceHash }),
-  });
-
-  if (!res.ok) {
-    const errText = await res.text().catch(() => "");
-    throw new Error(`Delete failed: HTTP ${res.status} — ${errText.slice(0, 200)}`);
-  }
-
-  const data = (await res.json()) as { deleted: number; source_hash: string };
-  return data.deleted || 0;
-}
-
-// ── Main Sync Flow ──
-
-/**
- * Sync workspace files to MemoryRouter using source_hash tracking.
- *
- * Algorithm:
- * 1. Load manifest (previous state)
- * 2. Discover current workspace files, compute hashes
- * 3. Diff current vs manifest:
- *    - NEW: upload with source_hash
- *    - CHANGED: delete old hash, upload new
- *    - DELETED: delete from MR
- *    - UNCHANGED: skip
- * 4. Save updated manifest
- */
-export async function syncWorkspaceFiles(options: SyncOptions): Promise<SyncResult> {
-  const { workspaceDir, endpoint, memoryKey, embeddings, logging } = options;
-  const log = (msg: string) => {
-    if (logging) console.log(msg);
-  };
-
-  const result: SyncResult = { uploaded: 0, deleted: 0, unchanged: 0, errors: [] };
-
-  // 1. Load manifest
-  const manifest = await loadManifest();
-  log(`memoryrouter: sync starting (${Object.keys(manifest.files).length} files in manifest)`);
-
-  // 2. Discover workspace files and compute hashes
-  const diskFiles = await discoverWorkspaceFiles(workspaceDir);
-  log(`memoryrouter: discovered ${diskFiles.length} workspace files`);
-
-  const diskState = new Map<string, { hash: string; size: number; content: string }>();
-
-  for (const relPath of diskFiles) {
-    const absPath = join(workspaceDir, relPath);
-    try {
-      const content = await readFile(absPath, "utf-8");
-      const trimmed = content.trim();
-      if (!trimmed) continue; // Skip empty files
-
-      const hash = computeSourceHash(content);
-      const size = Buffer.byteLength(content, "utf-8");
-      diskState.set(relPath, { hash, size, content });
-    } catch (err) {
-      result.errors.push(`Read error: ${relPath} — ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  // 3a. Process disk files (new + changed)
-  for (const [relPath, { hash, size, content }] of diskState) {
-    const manifestEntry = manifest.files[relPath];
-
-    if (!manifestEntry) {
-      // NEW FILE — upload
-      try {
-        const { chunks } = await uploadSourceFile(endpoint, memoryKey, content, hash, embeddings);
-        manifest.files[relPath] = {
-          source_hash: hash,
-          size,
-          chunks,
-          uploaded_at: Date.now(),
-        };
-        result.uploaded++;
-        log(`memoryrouter: sync uploaded new file ${relPath} (${chunks} chunks)`);
-      } catch (err) {
-        result.errors.push(`Upload error: ${relPath} — ${err instanceof Error ? err.message : String(err)}`);
-      }
-    } else if (manifestEntry.source_hash !== hash) {
-      // CHANGED FILE — delete old, upload new
-      try {
-        const deleted = await deleteBySourceHash(endpoint, memoryKey, manifestEntry.source_hash);
-        log(`memoryrouter: sync deleted old version of ${relPath} (${deleted} chunks)`);
-      } catch (err) {
-        // Log but continue — old chunks may have been deleted manually
-        log(`memoryrouter: sync delete warning for ${relPath} — ${err instanceof Error ? err.message : String(err)}`);
-      }
-
-      try {
-        const { chunks } = await uploadSourceFile(endpoint, memoryKey, content, hash, embeddings);
-        manifest.files[relPath] = {
-          source_hash: hash,
-          size,
-          chunks,
-          uploaded_at: Date.now(),
-        };
-        result.uploaded++;
-        log(`memoryrouter: sync updated file ${relPath} (${chunks} new chunks)`);
-      } catch (err) {
-        result.errors.push(`Upload error: ${relPath} — ${err instanceof Error ? err.message : String(err)}`);
-      }
-    } else {
-      // UNCHANGED — skip
-      result.unchanged++;
-    }
-  }
-
-  // 3b. Handle deleted files (in manifest but not on disk)
-  for (const relPath of Object.keys(manifest.files)) {
-    if (!diskState.has(relPath)) {
-      try {
-        const deleted = await deleteBySourceHash(endpoint, memoryKey, manifest.files[relPath].source_hash);
-        delete manifest.files[relPath];
-        result.deleted++;
-        log(`memoryrouter: sync deleted removed file ${relPath} (${deleted} chunks)`);
-      } catch (err) {
-        result.errors.push(`Delete error: ${relPath} — ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-  }
-
-  // 4. Save updated manifest
-  await saveManifest(manifest);
-
-  log(
-    `memoryrouter: sync complete — ${result.uploaded} uploaded, ${result.deleted} deleted, ${result.unchanged} unchanged`,
-  );
-
-  return result;
-}
-
-// ── CLI Helper ──
-
-/**
- * Run sync from CLI with console output.
- */
-export async function runSyncCli(options: SyncOptions): Promise<void> {
-  const { workspaceDir, embeddings } = options;
-
-  const modelLabel = embeddings ? `(model: ${embeddings})` : "(model: bge)";
-  console.log(`Syncing workspace to MemoryRouter ${modelLabel}...`);
-  console.log(`  Workspace: ${workspaceDir}`);
-
-  try {
-    const result = await syncWorkspaceFiles({ ...options, logging: true });
-
-    console.log("\n────────────────────────────────");
-    console.log(`✅ Sync complete`);
-    console.log(`   Uploaded: ${result.uploaded}`);
-    console.log(`   Deleted:  ${result.deleted}`);
-    console.log(`   Unchanged: ${result.unchanged}`);
-
-    if (result.errors.length > 0) {
-      console.log(`\n⚠️ ${result.errors.length} errors:`);
-      for (const err of result.errors.slice(0, 5)) {
-        console.log(`   • ${err}`);
-      }
-      if (result.errors.length > 5) {
-        console.log(`   • ... and ${result.errors.length - 5} more`);
-      }
-    }
-  } catch (err) {
-    console.error(`\n❌ Sync failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-
-/**
- * Show manifest status from CLI.
- */
-export async function showManifestStatus(): Promise<void> {
-  const manifest = await loadManifest();
-  const fileCount = Object.keys(manifest.files).length;
-
-  console.log("Workspace Sync Manifest");
-  console.log("───────────────────────────────");
-  console.log(`  Path:       ${MANIFEST_PATH}`);
-  console.log(`  Version:    ${manifest.version}`);
-  console.log(`  Last sync:  ${manifest.lastSync ? new Date(manifest.lastSync).toLocaleString() : "never"}`);
-  console.log(`  Files:      ${fileCount}`);
-
-  if (fileCount > 0) {
-    console.log("\n  Tracked files:");
-    const files = Object.entries(manifest.files).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [path, entry] of files.slice(0, 20)) {
-      const date = new Date(entry.uploaded_at).toLocaleDateString();
-      console.log(`    • ${path} (${entry.chunks} chunks, ${date})`);
-    }
-    if (files.length > 20) {
-      console.log(`    ... and ${files.length - 20} more`);
-    }
-  }
-}