@memtensor/memos-local-openclaw-plugin 1.0.4-beta.2 → 1.0.4-beta.20

package/index.ts

@@ -9,19 +9,22 @@ 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";
 import { IngestWorker } from "./src/ingest/worker";
 import { RecallEngine } from "./src/recall/engine";
 import { captureMessages, stripInboundMetadata } from "./src/capture";
 import { DEFAULTS } from "./src/types";
+import type { SearchHit } 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 { fetchHubSkillBundle, publishSkillBundleToHub, restoreSkillBundleFromHub, unpublishSkillBundleFromHub } from "./src/client/skill-sync";
 import { SkillEvolver } from "./src/skill/evolver";
 import { SkillInstaller } from "./src/skill/installer";
 import { Summarizer } from "./src/ingest/providers";
@@ -81,13 +84,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,7 +180,7 @@ const memosLocalPlugin = {
     }
 
     let pluginCfg = (api.pluginConfig ?? {}) as Record<string, unknown>;
-    const stateDir = api.resolvePath("~/.openclaw");
+    const stateDir = process.env.OPENCLAW_STATE_DIR || api.resolvePath("~/.openclaw");
 
     // Fallback: read config from file if not provided by OpenClaw
     const configPath = path.join(stateDir, "state", "memos-local", "config.json");
@@ -196,6 +206,8 @@ const memosLocalPlugin = {
       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 worker = new IngestWorker(store, embedder, ctx);
@@ -205,6 +217,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";
@@ -269,6 +282,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();
@@ -280,6 +305,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;
@@ -293,6 +319,21 @@ const memosLocalPlugin = {
                 candidates: det.candidates,
                 filtered: det.hits ?? det.filtered ?? [],
               });
+            } else if (det && det.local && det.hub) {
+              const localHits = det.local?.hits ?? [];
+              const hubHits = (det.hub?.hits ?? []).map((h: any) => ({
+                score: h.score ?? 0,
+                role: h.source?.role ?? h.role ?? "assistant",
+                summary: h.summary ?? "",
+                original_excerpt: h.excerpt ?? h.summary ?? "",
+                origin: "hub-remote",
+                ownerName: h.ownerName ?? "",
+                groupName: h.groupName ?? "",
+              }));
+              outputText = JSON.stringify({
+                candidates: [...localHits, ...hubHits],
+                filtered: [...localHits, ...hubHits],
+              });
             } else {
               outputText = result?.content?.[0]?.text ?? JSON.stringify(result ?? "");
             }
@@ -301,6 +342,93 @@ const memosLocalPlugin = {
         }
       };
 
+    const getCurrentOwner = () => `agent:${currentAgentId}`;
+    const resolveMemorySearchScope = (scope?: string): "local" | "group" | "all" =>
+      scope === "group" || scope === "all" ? scope : "local";
+    const resolveMemoryShareTarget = (target?: string): "agents" | "hub" | "both" =>
+      target === "hub" || target === "both" ? target : "agents";
+    const resolveMemoryUnshareTarget = (target?: string): "agents" | "hub" | "all" =>
+      target === "agents" || target === "hub" ? target : "all";
+    const resolveSkillPublishTarget = (target?: string, scope?: string): "agents" | "hub" => {
+      if (target === "hub") return "hub";
+      if (target === "agents") return "agents";
+      return scope === "public" || scope === "group" ? "hub" : "agents";
+    };
+    const resolveSkillHubVisibility = (visibility?: string, scope?: string): "public" | "group" =>
+      visibility === "group" || scope === "group" ? "group" : "public";
+    const resolveSkillUnpublishTarget = (target?: string): "agents" | "hub" | "all" =>
+      target === "hub" || target === "all" ? target : "agents";
+
+    const shareMemoryToHub = async (
+      chunkId: string,
+      input?: { visibility?: "public" | "group"; groupId?: string; hubAddress?: string; userToken?: string },
+    ): Promise<{ memoryId: string; visibility: "public" | "group"; groupId: string | null }> => {
+      const chunk = store.getChunk(chunkId);
+      if (!chunk) {
+        throw new Error(`Memory not found: ${chunkId}`);
+      }
+
+      const visibility = input?.visibility === "group" ? "group" : "public";
+      const groupId = visibility === "group" ? (input?.groupId ?? null) : null;
+      const hubClient = await resolveHubClient(store, ctx, { hubAddress: input?.hubAddress, userToken: input?.userToken });
+      const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/share", {
+        method: "POST",
+        body: JSON.stringify({
+          memory: {
+            sourceChunkId: chunk.id,
+            role: chunk.role,
+            content: chunk.content,
+            summary: chunk.summary,
+            kind: chunk.kind,
+            groupId,
+            visibility,
+          },
+        }),
+      }) as { memoryId?: string; visibility?: "public" | "group" };
+
+      const memoryId = response?.memoryId ?? `${chunk.id}-hub`;
+
+      // Hub role: full hub_memories row for local recall/embeddings. Client: metadata only (team_shared_chunks) for UI.
+      if (ctx.config.sharing?.role === "hub") {
+        const now = Date.now();
+        const existing = store.getHubMemoryBySource(hubClient.userId, chunk.id);
+        store.upsertHubMemory({
+          id: memoryId,
+          sourceChunkId: chunk.id,
+          sourceUserId: hubClient.userId,
+          role: chunk.role,
+          content: chunk.content,
+          summary: chunk.summary ?? "",
+          kind: chunk.kind,
+          groupId,
+          visibility,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now,
+        });
+      } else if (ctx.config.sharing?.enabled && hubClient.userId) {
+        store.upsertTeamSharedChunk(chunk.id, { hubMemoryId: memoryId, visibility, groupId });
+      }
+
+      return { memoryId, visibility, groupId };
+    };
+
+    const unshareMemoryFromHub = async (
+      chunkId: string,
+      input?: { hubAddress?: string; userToken?: string },
+    ): Promise<void> => {
+      const chunk = store.getChunk(chunkId);
+      if (!chunk) {
+        throw new Error(`Memory not found: ${chunkId}`);
+      }
+      const hubClient = await resolveHubClient(store, ctx, { hubAddress: input?.hubAddress, userToken: input?.userToken });
+      await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/unshare", {
+        method: "POST",
+        body: JSON.stringify({ sourceChunkId: chunk.id }),
+      });
+      store.deleteHubMemoryBySource(hubClient.userId, chunk.id);
+      store.deleteTeamSharedChunk(chunk.id);
+    };
+
     // ─── Tool: memory_search ───
 
     api.registerTool(
@@ -309,24 +437,46 @@ const memosLocalPlugin = {
         label: "Memory Search",
         description:
           "Search long-term conversation memory for past conversations, user preferences, decisions, and experiences. " +
-          "Relevant memories are automatically injected at the start of each turn, but call this tool when you need " +
-          "to search with a different query or the auto-recalled context is insufficient. " +
-          "Pass only a short natural-language query (2-5 key words).",
+          "Use scope='local' for this agent plus local shared memories, or scope='group'/'all' to include Hub-shared memories. " +
+          "Supports optional maxResults, minScore, and role filtering when you need tighter control.",
         parameters: Type.Object({
           query: Type.String({ description: "Short natural language search query (2-5 key words)" }),
+          scope: Type.Optional(Type.String({ description: "Search scope: 'local' (default), 'group', or 'all'. Use group/all to include Hub-shared memories." })),
+          maxResults: Type.Optional(Type.Number({ description: "Maximum results to return. Default 10, max 20." })),
+          minScore: Type.Optional(Type.Number({ description: "Minimum score threshold for local recall. Default 0.45, floor 0.35." })),
+          role: Type.Optional(Type.String({ description: "Optional local role filter: 'user', 'assistant', 'tool', or 'system'." })),
+          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override for group/all search." })),
+          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override for group/all search." })),
         }),
         execute: trackTool("memory_search", async (_toolCallId: any, params: any) => {
-          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 {
+            query,
+            scope: rawScope,
+            maxResults,
+            minScore: rawMinScore,
+            role: rawRole,
+            hubAddress,
+            userToken,
+          } = params as {
+            query: string;
+            scope?: string;
+            maxResults?: number;
+            minScore?: number;
+            role?: string;
+            hubAddress?: string;
+            userToken?: string;
+          };
+          const role = rawRole === "user" || rawRole === "assistant" || rawRole === "tool" || rawRole === "system" ? rawRole : undefined;
+          const minScore = typeof rawMinScore === "number" ? Math.max(0.35, Math.min(1, rawMinScore)) : undefined;
+          let searchScope = resolveMemorySearchScope(rawScope);
+          if (searchScope === "local" && ctx.config?.sharing?.enabled) {
+            searchScope = "all";
+          }
+          const searchLimit = typeof maxResults === "number" ? Math.max(1, Math.min(20, Math.round(maxResults))) : 10;
 
           const agentId = currentAgentId;
-          const ownerFilter = [`agent:${agentId}`, "public"];
-          const effectiveMaxResults = 10;
+          const ownerFilter = [getCurrentOwner(), "public"];
+          const effectiveMaxResults = searchLimit;
           ctx.log.debug(`memory_search query="${query}" maxResults=${effectiveMaxResults} minScore=${minScore ?? 0.45} role=${role ?? "all"} owner=agent:${agentId}`);
           const result = await engine.search({ query, maxResults: effectiveMaxResults, minScore, role, ownerFilter });
           ctx.log.debug(`memory_search raw candidates: ${result.hits.length}`);
@@ -337,9 +487,10 @@ const memosLocalPlugin = {
             score: h.score,
             summary: h.summary,
             original_excerpt: (h.original_excerpt ?? "").slice(0, 200),
+            origin: h.origin || "local",
           }));
 
-          if (result.hits.length === 0) {
+          if (result.hits.length === 0 && searchScope === "local") {
             return {
               content: [{ type: "text", text: result.meta.note ?? "No relevant memories found." }],
               details: { candidates: [], meta: result.meta },
@@ -363,11 +514,13 @@ const memosLocalPlugin = {
               const indexSet = new Set(filterResult.relevant);
               filteredHits = result.hits.filter((_, i) => indexSet.has(i + 1));
               ctx.log.debug(`memory_search LLM filter: ${result.hits.length} → ${filteredHits.length} hits, sufficient=${sufficient}`);
-            } else {
+            } else if (searchScope === "local") {
               return {
                 content: [{ type: "text", text: "No relevant memories found for this query." }],
                 details: { candidates: rawCandidates, filtered: [], meta: result.meta },
               };
+            } else {
+              filteredHits = [];
             }
           }
 
@@ -389,29 +542,79 @@ const memosLocalPlugin = {
               role: h.source.role,
               score: h.score,
               summary: h.summary,
+              origin: h.origin || "local",
             };
           });
 
           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" } }));
+
+            let filteredHubHits = hub.hits;
+            if (hub.hits.length > 0) {
+              const hubCandidates = hub.hits.map((h, i) => ({
+                index: filteredHits.length + i + 1,
+                role: (h.source?.role || "assistant") as string,
+                content: (h.summary || h.excerpt || "").slice(0, 300),
+                time: h.source?.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
+              }));
+              const localCandidatesForMerge = filteredHits.map((h, i) => ({
+                index: i + 1,
+                role: h.source.role,
+                content: (h.original_excerpt ?? "").slice(0, 300),
+                time: h.source.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
+              }));
+              const mergedCandidates = [...localCandidatesForMerge, ...hubCandidates];
+              const mergedFilter = await summarizer.filterRelevant(query, mergedCandidates);
+              if (mergedFilter !== null && mergedFilter.relevant.length > 0) {
+                const relevantSet = new Set(mergedFilter.relevant);
+                const hubStartIdx = filteredHits.length + 1;
+                filteredHits = filteredHits.filter((_, i) => relevantSet.has(i + 1));
+                filteredHubHits = hub.hits.filter((_, i) => relevantSet.has(hubStartIdx + i));
+                ctx.log.debug(`memory_search LLM filter (merged): local ${localCandidatesForMerge.length}→${filteredHits.length}, hub ${hub.hits.length}→${filteredHubHits.length}`);
+              }
+            }
+
+            const originLabel = (h: SearchHit) => {
+              if (h.origin === "hub-memory") return " [团队缓存]";
+              if (h.origin === "local-shared") return " [本机共享]";
+              return "";
+            };
             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}`;
+                  return `${i + 1}. [${h.source.role}]${originLabel(h)} ${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")
+            const hubText = filteredHubHits.length > 0
+              ? filteredHubHits.map((h, i) => `${i + 1}. [${h.ownerName}] [团队] ${h.summary}${h.groupName ? ` (${h.groupName})` : ""}`).join("\n")
               : "(none)";
 
+            const localDetailsFiltered = 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,
+                origin: h.origin,
+              };
+            });
+
             return {
               content: [{
                 type: "text",
                 text: `Local results:\n${localText}\n\nHub results:\n${hubText}`,
               }],
               details: {
-                local: { hits: localDetailsHits, meta: result.meta },
-                hub,
+                local: { hits: localDetailsFiltered, meta: result.meta },
+                hub: { ...hub, hits: filteredHubHits },
               },
             };
           }
@@ -423,9 +626,15 @@ const memosLocalPlugin = {
             };
           }
 
+          const originTag = (o?: string) => {
+            if (o === "local-shared") return " [本机共享]";
+            if (o === "hub-memory") return " [团队缓存]";
+            if (o === "hub-remote") return " [团队]";
+            return "";
+          };
           const lines = filteredHits.map((h, i) => {
             const excerpt = h.original_excerpt;
-            const parts = [`${i + 1}. [${h.source.role}]`];
+            const parts = [`${i + 1}. [${h.source.role}]${originTag(h.origin)}`];
             if (excerpt) parts.push(`   ${excerpt}`);
             parts.push(`   chunkId="${h.ref.chunkId}"`);
             if (h.taskId) {
@@ -480,6 +689,7 @@ const memosLocalPlugin = {
                   score: h.score,
                   summary: h.summary,
                   original_excerpt: (h.original_excerpt ?? "").slice(0, 200),
+                  origin: h.origin || "local",
                 };
               }),
               meta: result.meta,
@@ -843,7 +1053,9 @@ ${detail.content}`,
       {
         name: "network_team_info",
         label: "Network Team Info",
-        description: "Show current Hub connection status, signed-in user, role, and group memberships.",
+        description:
+          "Show current Hub connection status, signed-in user, role, and group memberships. " +
+          "Use this as a preflight check before any Hub share/unshare or Hub pull operation.",
         parameters: Type.Object({}),
         execute: trackTool("network_team_info", async () => {
           const status = await getHubStatus(store, ctx.config);
@@ -927,10 +1139,31 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
             };
           }
 
+          const manifest = skillInstaller.getCompanionManifest(resolvedSkillId);
+          let footer = "\n\n---\n";
+
+          if (manifest && manifest.hasCompanionFiles) {
+            const fileSummary = manifest.files
+              .filter(f => f.type !== "eval")
+              .map(f => `\`${f.relativePath}\``)
+              .join(", ");
+            footer += `**Companion files available:** ${fileSummary}\n`;
+            footer += `→ call \`skill_files(skillId="${resolvedSkillId}")\` to list all files\n`;
+            footer += `→ call \`skill_file_get(skillId="${resolvedSkillId}", path="...")\` to read a specific file\n`;
+            if (manifest.installMode === "install_recommended") {
+              footer += `→ **Recommended:** call \`skill_install(skillId="${resolvedSkillId}")\` for persistent workspace access (many/large files)\n`;
+            }
+            if (manifest.installed && manifest.installedPath) {
+              footer += `> Already installed at: ${manifest.installedPath}/\n`;
+            }
+          } else {
+            footer += `To install this skill for persistent use: call skill_install(skillId="${resolvedSkillId}")`;
+          }
+
           return {
             content: [{
               type: "text",
-              text: `## Skill: ${skill.name} (v${skill.version})\n\n${sv.content}\n\n---\nTo install this skill for persistent use: call skill_install(skillId="${resolvedSkillId}")`,
+              text: `## Skill: ${skill.name} (v${skill.version})\n\n${sv.content}${footer}`,
             }],
             details: {
               skillId: skill.id,
@@ -938,6 +1171,8 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
               version: skill.version,
               status: skill.status,
               installed: skill.installed,
+              companionFiles: manifest?.hasCompanionFiles ?? false,
+              installMode: manifest?.installMode ?? "inline",
             },
           };
         }),
@@ -973,9 +1208,116 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       { name: "skill_install" },
     );
 
+    // ─── Tool: skill_files ───
+
+    api.registerTool(
+      {
+        name: "skill_files",
+        label: "List Skill Companion Files",
+        description:
+          "List companion files (scripts, references, evals) for a skill. " +
+          "Use this after skill_get to see what additional files are available. " +
+          "Returns file names, sizes, and whether the skill recommends installation.",
+        parameters: Type.Object({
+          skillId: Type.String({ description: "The skill_id to inspect" }),
+        }),
+        execute: trackTool("skill_files", async (_toolCallId: any, params: any) => {
+          const { skillId } = params as { skillId: string };
+          ctx.log.debug(`skill_files called for skill=${skillId}`);
+
+          const manifest = skillInstaller.getCompanionManifest(skillId);
+          if (!manifest) {
+            return {
+              content: [{ type: "text", text: `Skill not found: ${skillId}` }],
+              details: { error: "not_found" },
+            };
+          }
+
+          if (!manifest.hasCompanionFiles) {
+            return {
+              content: [{ type: "text", text: "This skill has no companion files (scripts, references). The SKILL.md from skill_get contains everything." }],
+              details: manifest,
+            };
+          }
+
+          const lines: string[] = [`## Companion Files (${manifest.files.length} files, ${Math.round(manifest.totalSize / 1024)}KB total)\n`];
+          if (manifest.scriptsCount > 0) {
+            lines.push(`### Scripts (${manifest.scriptsCount})`);
+            for (const f of manifest.files.filter(f => f.type === "script")) {
+              lines.push(`- \`${f.relativePath}\` (${f.size} bytes) → call \`skill_file_get(skillId="${skillId}", path="${f.relativePath}")\``);
+            }
+          }
+          if (manifest.referencesCount > 0) {
+            lines.push(`\n### References (${manifest.referencesCount})`);
+            for (const f of manifest.files.filter(f => f.type === "reference")) {
+              lines.push(`- \`${f.relativePath}\` (${f.size} bytes) → call \`skill_file_get(skillId="${skillId}", path="${f.relativePath}")\``);
+            }
+          }
+          if (manifest.evalsCount > 0) {
+            lines.push(`\n### Evals (${manifest.evalsCount})`);
+            for (const f of manifest.files.filter(f => f.type === "eval")) {
+              lines.push(`- \`${f.relativePath}\` (${f.size} bytes)`);
+            }
+          }
+
+          if (manifest.installMode === "install_recommended") {
+            lines.push(`\n> **Recommendation:** This skill has many/large companion files. Consider \`skill_install(skillId="${skillId}")\` for persistent workspace access.`);
+          }
+          if (manifest.installed && manifest.installedPath) {
+            lines.push(`\n> **Installed at:** ${manifest.installedPath}/`);
+          }
+
+          return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            details: manifest,
+          };
+        }),
+      },
+      { name: "skill_files" },
+    );
+
+    // ─── Tool: skill_file_get ───
+
+    api.registerTool(
+      {
+        name: "skill_file_get",
+        label: "Get Skill Companion File",
+        description:
+          "Read the content of a specific companion file (script, reference) from a skill. " +
+          "Use after skill_files to retrieve a script or reference document. " +
+          "Pass the relative path like 'scripts/deploy.sh' or 'references/api-notes.md'.",
+        parameters: Type.Object({
+          skillId: Type.String({ description: "The skill_id" }),
+          path: Type.String({ description: "Relative path within the skill, e.g. 'scripts/deploy.sh'" }),
+        }),
+        execute: trackTool("skill_file_get", async (_toolCallId: any, params: any) => {
+          const { skillId, path: filePath } = params as { skillId: string; path: string };
+          ctx.log.debug(`skill_file_get called for skill=${skillId} path=${filePath}`);
+
+          const result = skillInstaller.readCompanionFile(skillId, filePath);
+          if ("error" in result) {
+            return {
+              content: [{ type: "text", text: `Error: ${result.error}` }],
+              details: result,
+            };
+          }
+
+          const ext = filePath.split(".").pop() || "";
+          const lang = { sh: "bash", py: "python", ts: "typescript", js: "javascript", json: "json", md: "markdown", yml: "yaml", yaml: "yaml" }[ext] || "";
+
+          return {
+            content: [{ type: "text", text: `## ${filePath}\n\n\`\`\`${lang}\n${result.content}\n\`\`\`` }],
+            details: { path: filePath, size: result.size },
+          };
+        }),
+      },
+      { name: "skill_file_get" },
+    );
+
     // ─── Tool: memory_viewer ───
 
-    const viewerPort = (pluginCfg as any).viewerPort ?? 18799;
+    const gatewayPort = (api.config as any)?.gateway?.port ?? 18789;
+    const viewerPort = (pluginCfg as any).viewerPort ?? (gatewayPort + 10);
 
     api.registerTool(
       {
@@ -988,6 +1330,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: [
@@ -1018,12 +1361,13 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
     api.registerTool(
       {
         name: "memory_write_public",
-        label: "Write Public Memory",
+        label: "Write Local Shared Memory",
         description:
-          "Write a piece of information to public memory. Public memories are visible to all agents during memory_search. " +
-          "Use this for shared knowledge, team decisions, or cross-agent coordination information.",
+          "Write a piece of information to local shared memory for all agents in this OpenClaw workspace. " +
+          "Use this when you are creating a new shared note from scratch. This does not publish to Hub. " +
+          "If you already have a memory chunk and want to expose it, use memory_share instead.",
         parameters: Type.Object({
-          content: Type.String({ description: "The content to write to public memory" }),
+          content: Type.String({ description: "The content to write to local shared memory" }),
           summary: Type.Optional(Type.String({ description: "Optional short summary of the content" })),
         }),
         execute: trackTool("memory_write_public", async (_toolCallId: any, params: any) => {
@@ -1068,7 +1412,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           }
 
           return {
-            content: [{ type: "text", text: `Public memory written successfully (id: ${chunkId}).` }],
+            content: [{ type: "text", text: `Memory shared to local agents successfully (id: ${chunkId}).` }],
             details: { chunkId, owner: "public" },
           };
         }),
@@ -1076,6 +1420,164 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       { name: "memory_write_public" },
     );
 
+    api.registerTool(
+      {
+        name: "memory_share",
+        label: "Share Memory",
+        description:
+          "Share an existing memory either with local OpenClaw agents, to the Hub team, or to both targets. " +
+          "Use this only for an existing chunkId. Use target='agents' for local multi-agent sharing, target='hub' for team sharing, or target='both' for both. " +
+          "If you need to create a brand new shared memory instead of exposing an existing one, use memory_write_public.",
+        parameters: Type.Object({
+          chunkId: Type.String({ description: "Existing local memory chunk ID to share" }),
+          target: Type.Optional(Type.String({ description: "Share target: 'agents' (default), 'hub', or 'both'" })),
+          visibility: Type.Optional(Type.String({ description: "Hub visibility when target includes hub: 'public' (default) or 'group'" })),
+          groupId: Type.Optional(Type.String({ description: "Optional Hub group ID when visibility='group'" })),
+          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override" })),
+          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override" })),
+        }),
+        execute: trackTool("memory_share", async (_toolCallId: any, params: any) => {
+          const {
+            chunkId,
+            target: rawTarget,
+            visibility: rawVisibility,
+            groupId,
+            hubAddress,
+            userToken,
+          } = params as {
+            chunkId: string;
+            target?: string;
+            visibility?: string;
+            groupId?: string;
+            hubAddress?: string;
+            userToken?: string;
+          };
+
+          const chunk = store.getChunk(chunkId);
+          if (!chunk) {
+            return { content: [{ type: "text", text: `Memory not found: ${chunkId}` }], details: { error: "not_found", chunkId } };
+          }
+
+          const target = resolveMemoryShareTarget(rawTarget);
+          const visibility = rawVisibility === "group" ? "group" : "public";
+          const details: Record<string, unknown> = { chunkId, target };
+          const messages: string[] = [];
+
+          if (target === "agents" || target === "both") {
+            const local = store.markMemorySharedLocally(chunkId);
+            if (!local.ok) {
+              return { content: [{ type: "text", text: `Failed to share memory ${chunkId} to local agents.` }], details: { error: local.reason ?? "local_share_failed", chunkId, target } };
+            }
+            details.local = {
+              shared: true,
+              owner: local.owner,
+              originalOwner: local.originalOwner ?? null,
+            };
+            messages.push("shared to local agents");
+          }
+
+          if (target === "hub" || target === "both") {
+            const hub = await shareMemoryToHub(chunkId, { visibility, groupId, hubAddress, userToken });
+            details.hub = {
+              shared: true,
+              memoryId: hub.memoryId,
+              visibility: hub.visibility,
+              groupId: hub.groupId,
+            };
+            messages.push(`shared to Hub (${hub.visibility})`);
+          }
+
+          return {
+            content: [{ type: "text", text: `Memory "${chunk.summary || chunk.id}" ${messages.join(" and ")}.` }],
+            details,
+          };
+        }),
+      },
+      { name: "memory_share" },
+    );
+
+    api.registerTool(
+      {
+        name: "memory_unshare",
+        label: "Unshare Memory",
+        description:
+          "Remove sharing from an existing memory. Use target='agents' to stop local multi-agent sharing, target='hub' to remove it from Hub, or target='all' (default) to remove both. " +
+          "privateOwner is only needed for older public memories that were never tracked with an original owner.",
+        parameters: Type.Object({
+          chunkId: Type.String({ description: "Existing local memory chunk ID to unshare" }),
+          target: Type.Optional(Type.String({ description: "Unshare target: 'agents', 'hub', or 'all' (default)" })),
+          privateOwner: Type.Optional(Type.String({ description: "Optional owner to restore when converting a public memory back to private and no original owner was tracked" })),
+          hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override" })),
+          userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override" })),
+        }),
+        execute: trackTool("memory_unshare", async (_toolCallId: any, params: any) => {
+          const {
+            chunkId,
+            target: rawTarget,
+            privateOwner,
+            hubAddress,
+            userToken,
+          } = params as {
+            chunkId: string;
+            target?: string;
+            privateOwner?: string;
+            hubAddress?: string;
+            userToken?: string;
+          };
+
+          const chunk = store.getChunk(chunkId);
+          if (!chunk) {
+            return { content: [{ type: "text", text: `Memory not found: ${chunkId}` }], details: { error: "not_found", chunkId } };
+          }
+
+          const target = resolveMemoryUnshareTarget(rawTarget);
+          const details: Record<string, unknown> = { chunkId, target };
+          const messages: string[] = [];
+
+          if (target === "agents" || target === "all") {
+            const local = store.unmarkMemorySharedLocally(chunkId, privateOwner);
+            if (!local.ok) {
+              return {
+                content: [{
+                  type: "text",
+                  text: local.reason === "original_owner_missing"
+                    ? `Cannot restore memory "${chunk.summary || chunk.id}" to a private owner automatically. Pass privateOwner to unshare it locally.`
+                    : `Failed to stop local sharing for memory ${chunkId}.`,
+                }],
+                details: { error: local.reason ?? "local_unshare_failed", chunkId, target },
+              };
+            }
+            details.local = {
+              shared: false,
+              owner: local.owner,
+            };
+            messages.push("removed from local agent sharing");
+          }
+
+          if (target === "hub" || target === "all") {
+            try {
+              await unshareMemoryFromHub(chunkId, { hubAddress, userToken });
+              details.hub = { shared: false };
+              messages.push("removed from Hub");
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              if (target === "all" && msg.includes("hub client connection is not configured")) {
+                details.hub = { shared: false, skipped: true, reason: "hub_not_configured" };
+              } else {
+                throw err;
+              }
+            }
+          }
+
+          return {
+            content: [{ type: "text", text: `Memory "${chunk.summary || chunk.id}" ${messages.join(" and ")}.` }],
+            details,
+          };
+        }),
+      },
+      { name: "memory_unshare" },
+    );
+
     // ─── Tool: skill_search ───
 
     api.registerTool(
@@ -1083,16 +1585,16 @@ 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. " +
-          "Use when you need a capability or guide and don't have a matching skill at hand.",
+          "Search available skills by natural language. Use scope='mix' (default) for this agent plus local shared skills, 'self' for this agent only, 'public' for local shared skills only, or 'group'/'all' to include Hub skills as well. " +
+          "Use this 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', 'group', or 'all'." })),
         }),
         execute: trackTool("skill_search", async (_toolCallId: any, params: any, context?: any) => {
           const { query: skillQuery, scope: rawScope } = params as { query: string; scope?: string };
           const scope = (rawScope === "self" || rawScope === "public") ? rawScope : "mix";
-          const currentOwner = `agent:${currentAgentId}`;
+          const currentOwner = getCurrentOwner();
 
           if (rawScope === "group" || rawScope === "all") {
             const [localHits, hub] = await Promise.all([
@@ -1108,7 +1610,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
             }
 
             const localText = localHits.length > 0
-              ? localHits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)}${h.visibility === "public" ? " (public)" : ""}`).join("\n")
+              ? localHits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)}${h.visibility === "public" ? " (shared to local agents)" : ""}`).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")
@@ -1130,7 +1632,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           }
 
           const text = hits.map((h, i) =>
-            `${i + 1}. [${h.name}] ${h.description}${h.visibility === "public" ? " (public)" : ""}`,
+            `${i + 1}. [${h.name}] ${h.description}${h.visibility === "public" ? " (shared to local agents)" : ""}`,
           ).join("\n");
 
           return {
@@ -1148,31 +1650,54 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       {
         name: "skill_publish",
         label: "Publish Skill",
-        description: "Make a skill public so other agents can discover and install it via skill_search.",
+        description:
+          "Share a skill with local agents or publish it to the Hub. " +
+          "Use target='agents' for local sharing, or target='hub' with visibility='public'/'group' for Hub publishing. " +
+          "The old scope parameter is still accepted for backward compatibility.",
         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" })),
+          target: Type.Optional(Type.String({ description: "Publish target: 'agents' (default) or 'hub'." })),
+          visibility: Type.Optional(Type.String({ description: "Hub visibility when target='hub': 'public' (default) or 'group'." })),
+          scope: Type.Optional(Type.String({ description: "Deprecated alias: omit for local agents, 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,
+            target: rawTarget,
+            visibility: rawVisibility,
+            scope,
+            groupId,
+            hubAddress,
+            userToken,
+          } = params as {
+            skillId: string;
+            target?: string;
+            visibility?: string;
+            scope?: string;
+            groupId?: string;
+            hubAddress?: string;
+            userToken?: 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 });
+          const target = resolveSkillPublishTarget(rawTarget, scope);
+          const visibility = resolveSkillHubVisibility(rawVisibility, scope);
+          if (target === "hub") {
+            const published = await publishSkillBundleToHub(store, ctx, { skillId: pubSkillId, visibility, 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 },
+              content: [{ type: "text", text: `Skill "${skill.name}" shared to Hub (${published.visibility}).` }],
+              details: { skillId: pubSkillId, name: skill.name, target, 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 },
+            content: [{ type: "text", text: `Skill "${skill.name}" is now shared with local agents.` }],
+            details: { skillId: pubSkillId, name: skill.name, target, visibility: "public", publishedToHub: false },
           };
         }),
       },
@@ -1185,20 +1710,46 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       {
         name: "skill_unpublish",
         label: "Unpublish Skill",
-        description: "Make a skill private. Other agents will no longer be able to discover it.",
+        description:
+          "Stop sharing a skill with local agents, remove it from the Hub, or do both. " +
+          "Use target='agents' (default), 'hub', or 'all'.",
         parameters: Type.Object({
           skillId: Type.String({ description: "The skill ID to unpublish" }),
+          target: Type.Optional(Type.String({ description: "Unpublish target: 'agents' (default), 'hub', or 'all'." })),
+          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_unpublish", async (_toolCallId: any, params: any) => {
-          const { skillId: unpubSkillId } = params as { skillId: string };
+          const { skillId: unpubSkillId, target, hubAddress, userToken } = params as { skillId: string; target?: string; hubAddress?: string; userToken?: string };
           const skill = store.getSkill(unpubSkillId);
           if (!skill) {
             return { content: [{ type: "text", text: `Skill not found: ${unpubSkillId}` }] };
           }
-          store.setSkillVisibility(unpubSkillId, "private");
+          const resolvedTarget = resolveSkillUnpublishTarget(target);
+          const messages: string[] = [];
+          const details: Record<string, unknown> = { skillId: unpubSkillId, name: skill.name, target: resolvedTarget };
+          if (resolvedTarget === "hub" || resolvedTarget === "all") {
+            try {
+              await unpublishSkillBundleFromHub(store, ctx, { skillId: unpubSkillId, hubAddress, userToken });
+              details.hub = { unpublished: true };
+              messages.push("removed from Hub sharing");
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              if (resolvedTarget === "all" && msg.includes("hub client connection is not configured")) {
+                details.hub = { unpublished: false, skipped: true, reason: "hub_not_configured" };
+              } else {
+                throw err;
+              }
+            }
+          }
+          if (resolvedTarget === "agents" || resolvedTarget === "all") {
+            store.setSkillVisibility(unpubSkillId, "private");
+            details.local = { visibility: "private" };
+            messages.push("limited to this agent");
+          }
           return {
-            content: [{ type: "text", text: `Skill "${skill.name}" is now private.` }],
-            details: { skillId: unpubSkillId, name: skill.name, visibility: "private" },
+            content: [{ type: "text", text: `Skill "${skill.name}" ${messages.join(" and ")}.` }],
+            details,
           };
         }),
       },
@@ -1231,6 +1782,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
     // ─── 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";
@@ -1272,11 +1824,73 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         ctx.log.debug(`auto-recall: query="${query.slice(0, 80)}"`);
 
         const result = await engine.search({ query, maxResults: 10, minScore: 0.45, ownerFilter: recallOwnerFilter });
+
+        // Hub fallback helper: search team shared memories when local search has no relevant results
+        const hubFallback = async (): Promise<SearchHit[]> => {
+          if (!ctx.config?.sharing?.enabled) return [];
+          try {
+            const hubResult = await hubSearchMemories(store, ctx, { query, maxResults: 10, scope: "all" });
+            if (hubResult.hits.length === 0) return [];
+            ctx.log.debug(`auto-recall: hub fallback returned ${hubResult.hits.length} hit(s)`);
+            return hubResult.hits.map((h) => ({
+              summary: h.summary,
+              original_excerpt: h.excerpt || h.summary,
+              ref: { sessionKey: "", chunkId: h.remoteHitId, turnId: "", seq: 0 },
+              score: 0.9,
+              taskId: null,
+              skillId: null,
+              origin: "hub-remote" as const,
+              source: { ts: h.source.ts, role: h.source.role, sessionKey: "" },
+            }));
+          } catch (err) {
+            ctx.log.debug(`auto-recall: hub fallback failed (${err})`);
+            return [];
+          }
+        };
+
+        if (result.hits.length === 0) {
+          // Local found nothing — try hub before giving up
+          const hubHits = await hubFallback();
+          if (hubHits.length > 0) {
+            result.hits.push(...hubHits);
+            ctx.log.debug(`auto-recall: local empty, using ${hubHits.length} hub hit(s)`);
+          }
+        }
         if (result.hits.length === 0) {
-          ctx.log.debug("auto-recall: no candidates found");
+          ctx.log.debug("auto-recall: no memory candidates found");
           const dur = performance.now() - recallT0;
           store.recordToolCall("memory_search", dur, true);
           store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({ candidates: [], filtered: [] }), dur, true);
+
+          // Even without memory hits, try skill recall
+          const skillAutoRecallEarly = ctx.config.skillEvolution?.autoRecallSkills ?? DEFAULTS.skillAutoRecall;
+          if (skillAutoRecallEarly) {
+            try {
+              const skillLimit = ctx.config.skillEvolution?.autoRecallSkillLimit ?? DEFAULTS.skillAutoRecallLimit;
+              const skillHits = await engine.searchSkills(query, "mix" as any, getCurrentOwner());
+              const topSkills = skillHits.slice(0, skillLimit);
+              if (topSkills.length > 0) {
+                const skillLines = topSkills.map((sc, i) => {
+                  const manifest = skillInstaller.getCompanionManifest(sc.skillId);
+                  let badge = "";
+                  if (manifest?.installed) badge = " [installed]";
+                  else if (manifest?.installMode === "install_recommended") badge = " [has scripts, install recommended]";
+                  else if (manifest?.hasCompanionFiles) badge = " [has companion files]";
+                  return `${i + 1}. **${sc.name}**${badge} — ${sc.description.slice(0, 200)}\n   → call \`skill_get(skillId="${sc.skillId}")\` for the full guide`;
+                });
+                const skillContext = "## Relevant skills from past experience\n\n" +
+                  "No direct memory matches were found, but these skills from past tasks may help:\n\n" +
+                  skillLines.join("\n\n") +
+                  "\n\nYou SHOULD call `skill_get` to retrieve the full guide before attempting the task.";
+                ctx.log.info(`auto-recall-skill (no-memory path): injecting ${topSkills.length} skill(s)`);
+                try { store.recordApiLog("skill_search", { type: "auto_recall_skill", query }, JSON.stringify(topSkills), dur, true); } catch { /* best-effort */ }
+                return { prependContext: skillContext };
+              }
+            } catch (err) {
+              ctx.log.debug(`auto-recall-skill (no-memory path): failed: ${err}`);
+            }
+          }
+
           if (query.length > 50) {
             const noRecallHint =
               "## Memory system — ACTION REQUIRED\n\n" +
@@ -1305,22 +1919,36 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
             const indexSet = new Set(filterResult.relevant);
             filteredHits = result.hits.filter((_, i) => indexSet.has(i + 1));
           } else {
-            ctx.log.debug("auto-recall: LLM filter returned no relevant hits");
-            const dur = performance.now() - recallT0;
-            store.recordToolCall("memory_search", dur, true);
-            store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
-              candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt })),
-              filtered: []
-            }), dur, true);
-            if (query.length > 50) {
-              const noRecallHint =
-                "## Memory system — ACTION REQUIRED\n\n" +
-                "Auto-recall found no relevant results for a long query. " +
-                "You MUST call `memory_search` now with a shortened query (2-5 key words) before answering. " +
-                "Do NOT skip this step. Do NOT answer without searching first.";
-              return { prependContext: noRecallHint };
+            ctx.log.debug("auto-recall: LLM filter returned no relevant local hits, trying hub fallback");
+            const hubHits = await hubFallback();
+            if (hubHits.length > 0) {
+              ctx.log.debug(`auto-recall: hub fallback provided ${hubHits.length} hit(s) after local filter yielded 0`);
+              filteredHits = hubHits;
+            } else {
+              const dur = performance.now() - recallT0;
+              store.recordToolCall("memory_search", dur, true);
+              store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
+                candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
+                filtered: []
+              }), dur, true);
+              if (query.length > 50) {
+                const noRecallHint =
+                  "## Memory system — ACTION REQUIRED\n\n" +
+                  "Auto-recall found no relevant results for a long query. " +
+                  "You MUST call `memory_search` now with a shortened query (2-5 key words) before answering. " +
+                  "Do NOT skip this step. Do NOT answer without searching first.";
+                return { prependContext: noRecallHint };
+              }
+              return;
             }
-            return;
+          }
+        }
+
+        if (!sufficient && filteredHits.length > 0 && ctx.config?.sharing?.enabled) {
+          const hubSupp = await hubFallback();
+          if (hubSupp.length > 0) {
+            ctx.log.debug(`auto-recall: local insufficient, supplementing with ${hubSupp.length} hub hit(s)`);
+            filteredHits.push(...hubSupp);
           }
         }
 
@@ -1330,7 +1958,8 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
 
         const lines = filteredHits.map((h, i) => {
           const excerpt = h.original_excerpt;
-          const parts: string[] = [`${i + 1}. [${h.source.role}]`];
+          const oTag = h.origin === "local-shared" ? " [本机共享]" : h.origin === "hub-memory" ? " [团队缓存]" : "";
+          const parts: string[] = [`${i + 1}. [${h.source.role}]${oTag}`];
           if (excerpt) parts.push(`   ${excerpt}`);
           parts.push(`   chunkId="${h.ref.chunkId}"`);
           if (h.taskId) {
@@ -1365,17 +1994,86 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           lines.join("\n\n"),
         ];
         if (tipsText) contextParts.push(tipsText);
+
+        // ─── Skill auto-recall ───
+        const skillAutoRecall = ctx.config.skillEvolution?.autoRecallSkills ?? DEFAULTS.skillAutoRecall;
+        const skillLimit = ctx.config.skillEvolution?.autoRecallSkillLimit ?? DEFAULTS.skillAutoRecallLimit;
+        let skillSection = "";
+
+        if (skillAutoRecall) {
+          try {
+            const skillCandidateMap = new Map<string, { name: string; description: string; skillId: string; source: string }>();
+
+            // Source 1: direct skill search based on user query
+            try {
+              const directSkillHits = await engine.searchSkills(query, "mix" as any, getCurrentOwner());
+              for (const sh of directSkillHits.slice(0, skillLimit + 2)) {
+                if (!skillCandidateMap.has(sh.skillId)) {
+                  skillCandidateMap.set(sh.skillId, { name: sh.name, description: sh.description, skillId: sh.skillId, source: "query" });
+                }
+              }
+            } catch (err) {
+              ctx.log.debug(`auto-recall-skill: direct search failed: ${err}`);
+            }
+
+            // Source 2: skills linked to tasks from memory hits
+            const taskIds = new Set<string>();
+            for (const h of filteredHits) {
+              if (h.taskId) {
+                const t = store.getTask(h.taskId);
+                if (t && t.status !== "skipped") taskIds.add(h.taskId);
+              }
+            }
+            for (const tid of taskIds) {
+              const linked = store.getSkillsByTask(tid);
+              for (const rs of linked) {
+                if (!skillCandidateMap.has(rs.skill.id)) {
+                  skillCandidateMap.set(rs.skill.id, { name: rs.skill.name, description: rs.skill.description, skillId: rs.skill.id, source: `task:${tid}` });
+                }
+              }
+            }
+
+            const skillCandidates = [...skillCandidateMap.values()].slice(0, skillLimit);
+
+            if (skillCandidates.length > 0) {
+              const skillLines = skillCandidates.map((sc, i) => {
+                const manifest = skillInstaller.getCompanionManifest(sc.skillId);
+                let badge = "";
+                if (manifest?.installed) badge = " [installed]";
+                else if (manifest?.installMode === "install_recommended") badge = " [has scripts, install recommended]";
+                else if (manifest?.hasCompanionFiles) badge = " [has companion files]";
+                const action = `call \`skill_get(skillId="${sc.skillId}")\``;
+                return `${i + 1}. **${sc.name}**${badge} — ${sc.description.slice(0, 200)}\n   → ${action}`;
+              });
+              skillSection = "\n\n## Relevant skills from past experience\n\n" +
+                "The following skills were distilled from similar previous tasks. " +
+                "You SHOULD call `skill_get` to retrieve the full guide before attempting the task.\n\n" +
+                skillLines.join("\n\n");
+
+              ctx.log.info(`auto-recall-skill: injecting ${skillCandidates.length} skill(s): ${skillCandidates.map(s => s.name).join(", ")}`);
+              try {
+                store.recordApiLog("skill_search", { type: "auto_recall_skill", query }, JSON.stringify(skillCandidates), performance.now() - recallT0, true);
+              } catch { /* best-effort */ }
+            } else {
+              ctx.log.debug("auto-recall-skill: no matching skills found");
+            }
+          } catch (err) {
+            ctx.log.debug(`auto-recall-skill: failed: ${err}`);
+          }
+        }
+
+        if (skillSection) contextParts.push(skillSection);
         const context = contextParts.join("\n");
 
         const recallDur = performance.now() - recallT0;
         store.recordToolCall("memory_search", recallDur, true);
         store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
-          candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt })),
-          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt }))
+          candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
+          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" }))
         }), recallDur, true);
         telemetry.trackAutoRecall(filteredHits.length, recallDur);
 
-        ctx.log.info(`auto-recall: returning prependContext (${context.length} chars), sufficient=${sufficient}`);
+        ctx.log.info(`auto-recall: returning prependContext (${context.length} chars), sufficient=${sufficient}, skills=${skillSection ? "yes" : "no"}`);
 
         if (!sufficient) {
           const searchHint =
@@ -1602,6 +2300,8 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
 
     // ─── Memory Viewer (web UI) ───
 
+    const derivedHubPort = gatewayPort + 11;
+
     const viewer = new ViewerServer({
       store,
       embedder,
@@ -1609,10 +2309,10 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       log: ctx.log,
       dataDir: stateDir,
       ctx,
+      defaultHubPort: derivedHubPort,
     });
-
     const hubServer = ctx.config.sharing?.enabled && ctx.config.sharing.role === "hub"
-      ? new HubServer({ store, log: ctx.log, config: ctx.config, dataDir: stateDir, embedder })
+      ? new HubServer({ store, log: ctx.log, config: ctx.config, dataDir: stateDir, embedder, defaultHubPort: derivedHubPort })
       : null;
 
     // ─── Service lifecycle ───