@memtensor/memos-local-openclaw-plugin 1.0.4-beta.4 → 1.0.4-beta.6

package/index.ts

@@ -9,8 +9,8 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { Type } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
 import { buildContext } from "./src/config";
-import type { HostModelsConfig } from "./src/openclaw-api";
 import { ensureSqliteBinding } from "./src/storage/ensure-binding";
 import { SqliteStore } from "./src/storage/sqlite";
 import { Embedder } from "./src/embedding";
@@ -19,10 +19,6 @@ import { RecallEngine } from "./src/recall/engine";
 import { captureMessages, stripInboundMetadata } from "./src/capture";
 import { DEFAULTS } from "./src/types";
 import { ViewerServer } from "./src/viewer/server";
-import { HubServer } from "./src/hub/server";
-import { hubGetMemoryDetail, hubRequestJson, hubSearchMemories, hubSearchSkills, resolveHubClient } from "./src/client/hub";
-import { getHubStatus, connectToHub } from "./src/client/connector";
-import { fetchHubSkillBundle, publishSkillBundleToHub, restoreSkillBundleFromHub } from "./src/client/skill-sync";
 import { SkillEvolver } from "./src/skill/evolver";
 import { SkillInstaller } from "./src/skill/installer";
 import { Summarizer } from "./src/ingest/providers";
@@ -82,13 +78,20 @@ const memosLocalPlugin = {
 
   register(api: OpenClawPluginApi) {
     // ─── Ensure better-sqlite3 native module is available ───
-    const pluginDir = path.dirname(new URL(import.meta.url).pathname);
+    const pluginDir = path.dirname(fileURLToPath(import.meta.url));
+
+    function normalizeFsPath(p: string): string {
+      return path.resolve(p).replace(/\\/g, "/").toLowerCase();
+    }
+
     let sqliteReady = false;
 
     function trySqliteLoad(): boolean {
       try {
         const resolved = require.resolve("better-sqlite3", { paths: [pluginDir] });
-        if (!resolved.startsWith(pluginDir)) {
+        const resolvedNorm = normalizeFsPath(resolved);
+        const pluginNorm = normalizeFsPath(pluginDir);
+        if (!resolvedNorm.startsWith(pluginNorm + "/") && resolvedNorm !== pluginNorm) {
           api.logger.warn(`memos-local: better-sqlite3 resolved outside plugin dir: ${resolved}`);
           return false;
         }
@@ -170,37 +173,19 @@ const memosLocalPlugin = {
       }
     }
 
-    let pluginCfg = (api.pluginConfig ?? {}) as Record<string, unknown>;
+    const pluginCfg = (api.pluginConfig ?? {}) as Record<string, unknown>;
     const stateDir = api.resolvePath("~/.openclaw");
-
-    // Fallback: read config from file if not provided by OpenClaw
-    const configPath = path.join(stateDir, "state", "memos-local", "config.json");
-    if (Object.keys(pluginCfg).length === 0 && fs.existsSync(configPath)) {
-      try {
-        const fileConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-        pluginCfg = fileConfig;
-        api.logger.info(`memos-local: loaded config from ${configPath}`);
-      } catch (e) {
-        api.logger.warn(`memos-local: failed to load config from ${configPath}: ${e}`);
-      }
-    }
-
-    // Extract host model providers so OpenClawAPIClient can proxy completion/embedding
-    const hostModels: HostModelsConfig | undefined = api.config?.models?.providers
-      ? { providers: api.config.models.providers as Record<string, import("./src/openclaw-api").HostModelProvider> }
-      : undefined;
-
     const ctx = buildContext(stateDir, process.cwd(), pluginCfg as any, {
       debug: (msg: string) => api.logger.info(`[debug] ${msg}`),
       info: (msg: string) => api.logger.info(msg),
       warn: (msg: string) => api.logger.warn(msg),
       error: (msg: string) => api.logger.warn(`[error] ${msg}`),
-    }, hostModels);
+    });
 
     ensureSqliteBinding(ctx.log);
 
     const store = new SqliteStore(ctx.config.storage!.dbPath!, ctx.log);
-    const embedder = new Embedder(ctx.config.embedding, ctx.log, ctx.openclawAPI);
+    const embedder = new Embedder(ctx.config.embedding, ctx.log);
     const worker = new IngestWorker(store, embedder, ctx);
     const engine = new RecallEngine(store, embedder, ctx);
     const evidenceTag = ctx.config.capture?.evidenceWrapperTag ?? DEFAULTS.evidenceWrapperTag;
@@ -208,6 +193,7 @@ const memosLocalPlugin = {
     const workspaceDir = api.resolvePath("~/.openclaw/workspace");
     const skillCtx = { ...ctx, workspaceDir };
     const skillEvolver = new SkillEvolver(store, engine, skillCtx);
+    skillEvolver.onSkillEvolved = (name, type) => telemetry.trackSkillEvolved(name, type);
     const skillInstaller = new SkillInstaller(store, skillCtx);
 
     let pluginVersion = "0.0.0";
@@ -264,7 +250,7 @@ const memosLocalPlugin = {
       });
     });
 
-    const summarizer = new Summarizer(ctx.config.summarizer, ctx.log, ctx.openclawAPI);
+    const summarizer = new Summarizer(ctx.config.summarizer, ctx.log);
 
     api.logger.info(`memos-local: initialized (db: ${ctx.config.storage!.dbPath})`);
 
@@ -272,6 +258,18 @@ const memosLocalPlugin = {
     // Falls back to "main" when no hook has fired yet (single-agent setups).
     let currentAgentId = "main";
 
+    // ─── Check allowPromptInjection policy ───
+    // When allowPromptInjection=false, the prompt mutation fields (such as prependContext) in the hook return value
+    // will be stripped by the framework. Skip auto-recall to avoid unnecessary LLM/embedding calls.
+    const pluginEntry = (api.config as any)?.plugins?.entries?.[api.id];
+    const allowPromptInjection = pluginEntry?.hooks?.allowPromptInjection !== false;
+    if (!allowPromptInjection) {
+      api.logger.info("memos-local: allowPromptInjection=false, auto-recall disabled");
+    }
+    else {
+      api.logger.info("memos-local: allowPromptInjection=true, auto-recall enabled");
+    }
+
     const trackTool = (toolName: string, fn: (...args: any[]) => Promise<any>) =>
       async (...args: any[]) => {
         const t0 = performance.now();
@@ -283,6 +281,7 @@ const memosLocalPlugin = {
           return result;
         } catch (e) {
           ok = false;
+          telemetry.trackError(toolName, (e as Error)?.name ?? "unknown");
           throw e;
         } finally {
           const dur = performance.now() - t0;
@@ -322,10 +321,6 @@ const memosLocalPlugin = {
           const { query } = params as { query: string };
           const role = undefined;
           const minScore = undefined;
-          const searchScope = "local";
-          const searchLimit = 10;
-          const hubAddress: string | undefined = undefined;
-          const userToken: string | undefined = undefined;
 
           const agentId = currentAgentId;
           const ownerFilter = [`agent:${agentId}`, "public"];
@@ -349,6 +344,7 @@ const memosLocalPlugin = {
             };
           }
 
+          // LLM relevance + sufficiency filtering
           let filteredHits = result.hits;
           let sufficient = false;
 
@@ -374,51 +370,6 @@ const memosLocalPlugin = {
             }
           }
 
-          const beforeDedup = filteredHits.length;
-          filteredHits = deduplicateHits(filteredHits);
-          ctx.log.debug(`memory_search dedup: ${beforeDedup} → ${filteredHits.length}`);
-
-          const localDetailsHits = filteredHits.map((h) => {
-            let effectiveTaskId = h.taskId;
-            if (effectiveTaskId) {
-              const t = store.getTask(effectiveTaskId);
-              if (t && t.status === "skipped") effectiveTaskId = null;
-            }
-            return {
-              ref: h.ref,
-              chunkId: h.ref.chunkId,
-              taskId: effectiveTaskId,
-              skillId: h.skillId,
-              role: h.source.role,
-              score: h.score,
-              summary: h.summary,
-            };
-          });
-
-          if (searchScope !== "local") {
-            const hub = await hubSearchMemories(store, ctx, { query, maxResults: searchLimit, scope: searchScope as any, hubAddress, userToken }).catch(() => ({ hits: [], meta: { totalCandidates: 0, searchedGroups: [], includedPublic: searchScope === "all" } }));
-            const localText = filteredHits.length > 0
-              ? filteredHits.map((h, i) => {
-                  const excerpt = h.original_excerpt.length > 220 ? h.original_excerpt.slice(0, 217) + "..." : h.original_excerpt;
-                  return `${i + 1}. [${h.source.role}] ${excerpt}`;
-                }).join("\n")
-              : "(none)";
-            const hubText = hub.hits.length > 0
-              ? hub.hits.map((h, i) => `${i + 1}. [${h.ownerName}] ${h.summary}${h.groupName ? ` (${h.groupName})` : ""}`).join("\n")
-              : "(none)";
-
-            return {
-              content: [{
-                type: "text",
-                text: `Local results:\n${localText}\n\nHub results:\n${hubText}`,
-              }],
-              details: {
-                local: { hits: localDetailsHits, meta: result.meta },
-                hub,
-              },
-            };
-          }
-
           if (filteredHits.length === 0) {
             return {
               content: [{ type: "text", text: "No relevant memories found for this query." }],
@@ -426,6 +377,10 @@ const memosLocalPlugin = {
             };
           }
 
+          const beforeDedup = filteredHits.length;
+          filteredHits = deduplicateHits(filteredHits);
+          ctx.log.debug(`memory_search dedup: ${beforeDedup} → ${filteredHits.length}`);
+
           const lines = filteredHits.map((h, i) => {
             const excerpt = h.original_excerpt;
             const parts = [`${i + 1}. [${h.source.role}]`];
@@ -518,7 +473,7 @@ const memosLocalPlugin = {
           if (!anchorChunk) {
             return {
               content: [{ type: "text", text: `Chunk not found: ${chunkId}` }],
-              details: { error: "not_found", entries: [] },
+              details: { error: "not_found" },
             };
           }
 
@@ -567,7 +522,7 @@ const memosLocalPlugin = {
             Type.Number({ description: `Max chars (default ${DEFAULTS.getMaxCharsDefault}, max ${DEFAULTS.getMaxCharsMax})` }),
           ),
         }),
-        execute: trackTool("memory_get", async (_toolCallId: any, params: any, context?: any) => {
+        execute: trackTool("memory_get", async (_toolCallId: any, params: any) => {
           const { chunkId, maxChars } = params as { chunkId: string; maxChars?: number };
           const limit = Math.min(maxChars ?? DEFAULTS.getMaxCharsDefault, DEFAULTS.getMaxCharsMax);
 
@@ -674,207 +629,6 @@ const memosLocalPlugin = {
       { name: "task_summary" },
     );
 
-    // ─── Tool: task_share ───
-
-    api.registerTool(
-      {
-        name: "task_share",
-        label: "Task Share",
-        description:
-          "Share one existing local task and its chunks to the configured hub. " +
-          "Minimal MVP path for validating team task sharing.",
-        parameters: Type.Object({
-          taskId: Type.String({ description: "Local task ID to share" }),
-          visibility: Type.Optional(Type.String({ description: "Share visibility: 'public' (default) or 'group'" })),
-          groupId: Type.Optional(Type.String({ description: "Optional group ID when visibility='group'" })),
-        }),
-        execute: trackTool("task_share", async (_toolCallId: any, params: any) => {
-          const { taskId, visibility: rawVisibility, groupId } = params as {
-            taskId: string;
-            visibility?: string;
-            groupId?: string;
-          };
-
-          const task = store.getTask(taskId);
-          if (!task) {
-            return {
-              content: [{ type: "text", text: `Task not found: ${taskId}` }],
-              details: { error: "not_found", taskId },
-            };
-          }
-
-          const chunks = store.getChunksByTask(taskId);
-          if (chunks.length === 0) {
-            return {
-              content: [{ type: "text", text: `Task ${taskId} has no chunks to share.` }],
-              details: { error: "no_chunks", taskId },
-            };
-          }
-
-          const visibility = rawVisibility === "group" ? "group" : "public";
-          const hubClient = await resolveHubClient(store, ctx);
-          const { v4: uuidv4 } = require("uuid");
-          const hubTaskId = uuidv4();
-
-          const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/share", {
-            method: "POST",
-            body: JSON.stringify({
-              task: {
-                id: hubTaskId,
-                sourceTaskId: task.id,
-                sourceUserId: hubClient.userId,
-                title: task.title,
-                summary: task.summary,
-                groupId: visibility === "group" ? (groupId ?? null) : null,
-                visibility,
-                createdAt: task.startedAt,
-                updatedAt: task.updatedAt,
-              },
-              chunks: chunks.map((chunk) => ({
-                id: uuidv4(),
-                hubTaskId,
-                sourceTaskId: task.id,
-                sourceChunkId: chunk.id,
-                sourceUserId: hubClient.userId,
-                role: chunk.role,
-                content: chunk.content,
-                summary: chunk.summary,
-                kind: chunk.kind,
-                createdAt: chunk.createdAt,
-              })),
-            }),
-          }) as any;
-
-          store.markTaskShared(task.id, hubTaskId, chunks.length, visibility, groupId);
-
-          return {
-            content: [{ type: "text", text: `Shared task "${task.title}" with ${chunks.length} chunks to the hub.` }],
-            details: {
-              shared: true,
-              taskId: task.id,
-              visibility,
-              chunkCount: chunks.length,
-              hubUrl: hubClient.hubUrl,
-              response,
-            },
-          };
-        }),
-      },
-      { name: "task_share" },
-    );
-
-    // ─── Tool: task_unshare ───
-
-    api.registerTool(
-      {
-        name: "task_unshare",
-        label: "Task Unshare",
-        description: "Remove one previously shared task from the configured hub.",
-        parameters: Type.Object({
-          taskId: Type.String({ description: "Local task ID to unshare" }),
-        }),
-        execute: trackTool("task_unshare", async (_toolCallId: any, params: any) => {
-          const { taskId } = params as { taskId: string };
-
-          const task = store.getTask(taskId);
-          if (!task) {
-            return {
-              content: [{ type: "text", text: `Task not found: ${taskId}` }],
-              details: { error: "not_found", taskId },
-            };
-          }
-
-          const hubClient = await resolveHubClient(store, ctx);
-          await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/unshare", {
-            method: "POST",
-            body: JSON.stringify({
-              sourceUserId: hubClient.userId,
-              sourceTaskId: task.id,
-            }),
-          });
-
-          store.unmarkTaskShared(task.id);
-
-          return {
-            content: [{ type: "text", text: `Unshared task "${task.title}" from the hub.` }],
-            details: {
-              unshared: true,
-              taskId: task.id,
-              hubUrl: hubClient.hubUrl,
-            },
-          };
-        }),
-      },
-      { name: "task_unshare" },
-    );
-
-    api.registerTool(
-      {
-        name: "network_memory_detail",
-        label: "Network Memory Detail",
-        description: "Fetch the full detail for a Hub search hit returned by memory_search(scope=group|all).",
-        parameters: Type.Object({
-          remoteHitId: Type.String({ description: "The remoteHitId returned by a Hub search hit" }),
-          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override for tests or manual routing" })),
-          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override for tests" })),
-        }),
-        execute: trackTool("network_memory_detail", async (_toolCallId: any, params: any) => {
-          const { remoteHitId, hubAddress, userToken } = params as {
-            remoteHitId: string;
-            hubAddress?: string;
-            userToken?: string;
-          };
-
-          const detail = await hubGetMemoryDetail(store, ctx, { remoteHitId, hubAddress, userToken });
-          return {
-            content: [{
-              type: "text",
-              text: `## Shared Memory Detail
-
-${detail.summary}
-
-${detail.content}`,
-            }],
-            details: detail,
-          };
-        }),
-      },
-      { name: "network_memory_detail" },
-    );
-
-    api.registerTool(
-      {
-        name: "network_team_info",
-        label: "Network Team Info",
-        description: "Show current Hub connection status, signed-in user, role, and group memberships.",
-        parameters: Type.Object({}),
-        execute: trackTool("network_team_info", async () => {
-          const status = await getHubStatus(store, ctx.config);
-          if (!status.connected || !status.user) {
-            return {
-              content: [{ type: "text", text: "Hub is not connected." }],
-              details: status,
-            };
-          }
-
-          const groupNames = status.user.groups.map((group) => group.name);
-          return {
-            content: [{
-              type: "text",
-              text: `## Team Connection
-
-User: ${status.user.username}
-Role: ${status.user.role}
-Hub: ${status.hubUrl ?? "(unknown)"}
-Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
-            }],
-            details: status,
-          };
-        }),
-      },
-      { name: "network_team_info" },
-    );
-
     // ─── Tool: skill_get ───
 
     api.registerTool(
@@ -991,6 +745,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         parameters: Type.Object({}),
         execute: trackTool("memory_viewer", async () => {
           ctx.log.debug(`memory_viewer called`);
+          telemetry.trackViewerOpened();
           const url = `http://127.0.0.1:${viewerPort}`;
           return {
             content: [
@@ -1086,43 +841,17 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         name: "skill_search",
         label: "Skill Search",
         description:
-          "Search available skills by natural language. Searches local skills by default, or local + Hub skills when scope=group/all. " +
+          "Search available skills by natural language. Searches your own skills, public skills, or both. " +
           "Use when you need a capability or guide and don't have a matching skill at hand.",
         parameters: Type.Object({
           query: Type.String({ description: "Natural language description of the needed skill" }),
-          scope: Type.Optional(Type.String({ description: "Search scope: 'mix'/'self'/'public' for local search, or 'group'/'all' for local + Hub search" })),
+          scope: Type.Optional(Type.String({ description: "Search scope: 'mix' (default, self + public), 'self' (own only), 'public' (public only)" })),
         }),
-        execute: trackTool("skill_search", async (_toolCallId: any, params: any, context?: any) => {
+        execute: trackTool("skill_search", async (_toolCallId: any, params: any) => {
           const { query: skillQuery, scope: rawScope } = params as { query: string; scope?: string };
           const scope = (rawScope === "self" || rawScope === "public") ? rawScope : "mix";
           const currentOwner = `agent:${currentAgentId}`;
 
-          if (rawScope === "group" || rawScope === "all") {
-            const [localHits, hub] = await Promise.all([
-              engine.searchSkills(skillQuery, "mix" as any, currentOwner),
-              hubSearchSkills(store, ctx, { query: skillQuery, maxResults: 10 }).catch(() => ({ hits: [] })),
-            ]);
-
-            if (localHits.length === 0 && hub.hits.length === 0) {
-              return {
-                content: [{ type: "text", text: `No relevant skills found for: "${skillQuery}" (scope: ${rawScope})` }],
-                details: { query: skillQuery, scope: rawScope, local: { hits: [] }, hub },
-              };
-            }
-
-            const localText = localHits.length > 0
-              ? localHits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)}${h.visibility === "public" ? " (public)" : ""}`).join("\n")
-              : "(none)";
-            const hubText = hub.hits.length > 0
-              ? hub.hits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)} (${h.visibility}${h.groupName ? `:${h.groupName}` : ""}, owner=${h.ownerName})`).join("\n")
-              : "(none)";
-
-            return {
-              content: [{ type: "text", text: `Local skills:\n${localText}\n\nHub skills:\n${hubText}` }],
-              details: { query: skillQuery, scope: rawScope, local: { hits: localHits }, hub },
-            };
-          }
-
           const hits = await engine.searchSkills(skillQuery, scope as any, currentOwner);
 
           if (hits.length === 0) {
@@ -1154,28 +883,17 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         description: "Make a skill public so other agents can discover and install it via skill_search.",
         parameters: Type.Object({
           skillId: Type.String({ description: "The skill ID to publish" }),
-          scope: Type.Optional(Type.String({ description: "Publish scope: omit for local public, or use 'public' / 'group' to publish to Hub" })),
-          groupId: Type.Optional(Type.String({ description: "Optional group ID when scope='group'" })),
-          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override for tests or manual routing" })),
-          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override for tests" })),
         }),
         execute: trackTool("skill_publish", async (_toolCallId: any, params: any) => {
-          const { skillId: pubSkillId, scope, groupId, hubAddress, userToken } = params as { skillId: string; scope?: string; groupId?: string; hubAddress?: string; userToken?: string };
+          const { skillId: pubSkillId } = params as { skillId: string };
           const skill = store.getSkill(pubSkillId);
           if (!skill) {
             return { content: [{ type: "text", text: `Skill not found: ${pubSkillId}` }] };
           }
-          if (scope === "public" || scope === "group") {
-            const published = await publishSkillBundleToHub(store, ctx, { skillId: pubSkillId, visibility: scope, groupId, hubAddress, userToken });
-            return {
-              content: [{ type: "text", text: `Skill "${skill.name}" published to hub (${published.visibility}).` }],
-              details: { skillId: pubSkillId, name: skill.name, publishedToHub: true, hubSkillId: published.skillId, visibility: published.visibility },
-            };
-          }
           store.setSkillVisibility(pubSkillId, "public");
           return {
             content: [{ type: "text", text: `Skill "${skill.name}" is now public.` }],
-            details: { skillId: pubSkillId, name: skill.name, visibility: "public", publishedToHub: false },
+            details: { skillId: pubSkillId, name: skill.name, visibility: "public" },
           };
         }),
       },
@@ -1208,32 +926,10 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       { name: "skill_unpublish" },
     );
 
-    api.registerTool(
-      {
-        name: "network_skill_pull",
-        label: "Network Skill Pull",
-        description: "Download a published Hub skill bundle and restore it into local managed skills.",
-        parameters: Type.Object({
-          skillId: Type.String({ description: "The Hub skill ID to pull" }),
-          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override for tests or manual routing" })),
-          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override for tests" })),
-        }),
-        execute: trackTool("network_skill_pull", async (_toolCallId: any, params: any) => {
-          const { skillId, hubAddress, userToken } = params as { skillId: string; hubAddress?: string; userToken?: string };
-          const payload = await fetchHubSkillBundle(store, ctx, { skillId, hubAddress, userToken });
-          const restored = restoreSkillBundleFromHub(store, ctx, payload);
-          return {
-            content: [{ type: "text", text: `Pulled Hub skill "${restored.localName}" into local storage.` }],
-            details: { pulled: true, hubSkillId: skillId, localSkillId: restored.localSkillId, localName: restored.localName, dirPath: restored.dirPath },
-          };
-        }),
-      },
-      { name: "network_skill_pull" },
-    );
-
     // ─── Auto-recall: inject relevant memories before agent starts ───
 
     api.on("before_agent_start", async (event: { prompt?: string; messages?: unknown[] }, hookCtx?: { agentId?: string; sessionKey?: string }) => {
+      if (!allowPromptInjection) return {};
       if (!event.prompt || event.prompt.length < 3) return;
 
       const recallAgentId = hookCtx?.agentId ?? "main";
@@ -1535,74 +1231,11 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           worker.enqueue(captured);
           telemetry.trackMemoryIngested(captured.length);
         }
-
-        // Incremental push: sync new chunks for already-shared tasks
-        syncSharedTasksIncremental().catch((err) => {
-          ctx.log.warn(`incremental sync failed: ${err}`);
-        });
       } catch (err) {
         api.logger.warn(`memos-local: capture failed: ${String(err)}`);
       }
     });
 
-    async function syncSharedTasksIncremental(): Promise<void> {
-      if (!ctx.config.sharing?.enabled || ctx.config.sharing.role !== "client") return;
-      const shared = store.listLocalSharedTasks();
-      if (shared.length === 0) return;
-
-      let hubClient: { hubUrl: string; userToken: string; userId: string } | undefined;
-      try {
-        hubClient = await resolveHubClient(store, ctx);
-      } catch {
-        return;
-      }
-      const { v4: uuidv4 } = require("uuid");
-
-      for (const entry of shared) {
-        const task = store.getTask(entry.taskId);
-        if (!task) continue;
-        const chunks = store.getChunksByTask(entry.taskId);
-        if (chunks.length <= entry.syncedChunks) continue;
-
-        const newChunks = chunks.slice(entry.syncedChunks);
-        ctx.log.info(`incremental sync: task=${entry.taskId} pushing ${newChunks.length} new chunk(s)`);
-
-        try {
-          await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/share", {
-            method: "POST",
-            body: JSON.stringify({
-              task: {
-                id: entry.hubTaskId,
-                sourceTaskId: entry.taskId,
-                sourceUserId: hubClient.userId,
-                title: task.title,
-                summary: task.summary,
-                groupId: entry.visibility === "group" ? entry.groupId ?? null : null,
-                visibility: entry.visibility,
-                createdAt: task.startedAt ?? task.updatedAt ?? Date.now(),
-                updatedAt: task.updatedAt ?? Date.now(),
-              },
-              chunks: newChunks.map((chunk) => ({
-                id: uuidv4(),
-                hubTaskId: entry.hubTaskId,
-                sourceTaskId: entry.taskId,
-                sourceChunkId: chunk.id,
-                sourceUserId: hubClient.userId,
-                role: chunk.role,
-                content: chunk.content,
-                summary: chunk.summary,
-                kind: chunk.kind,
-                createdAt: chunk.createdAt,
-              })),
-            }),
-          });
-          store.markTaskShared(entry.taskId, entry.hubTaskId, chunks.length, entry.visibility, entry.groupId);
-        } catch (err) {
-          ctx.log.warn(`incremental sync failed for task=${entry.taskId}: ${err}`);
-        }
-      }
-    }
-
     // ─── Memory Viewer (web UI) ───
 
     const viewer = new ViewerServer({
@@ -1614,30 +1247,11 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       ctx,
     });
 
-    const hubServer = ctx.config.sharing?.enabled && ctx.config.sharing.role === "hub"
-      ? new HubServer({ store, log: ctx.log, config: ctx.config, dataDir: stateDir, embedder })
-      : null;
-
     // ─── Service lifecycle ───
 
     api.registerService({
       id: "memos-local-openclaw-plugin",
       start: async () => {
-        if (hubServer) {
-          const hubUrl = await hubServer.start();
-          api.logger.info(`memos-local: hub started at ${hubUrl}`);
-        }
-
-        // Auto-connect to Hub in client mode (handles both existing token and auto-join via teamToken)
-        if (ctx.config.sharing?.enabled && ctx.config.sharing.role === "client") {
-          try {
-            const session = await connectToHub(store, ctx.config, ctx.log);
-            api.logger.info(`memos-local: connected to Hub as "${session.username}" (${session.userId})`);
-          } catch (err) {
-            api.logger.warn(`memos-local: Hub connection failed: ${err}`);
-          }
-        }
-
         try {
           const viewerUrl = await viewer.start();
           api.logger.info(`memos-local: started (embedding: ${embedder.provider})`);
@@ -1663,9 +1277,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         );
       },
       stop: async () => {
-        await worker.flush();
         await telemetry.shutdown();
-        await hubServer?.stop();
         viewer.stop();
         store.close();
         api.logger.info("memos-local: stopped");

package/openclaw.plugin.json

@@ -32,6 +32,5 @@
       "Memory Viewer will be available at http://127.0.0.1:18799",
       "If better-sqlite3 fails to build, ensure you have C++ build tools: xcode-select --install (macOS) or build-essential (Linux)"
     ]
-  },
-  "extensions": ["./index.ts"]
+  }
 }