@memtensor/memos-local-openclaw-plugin 0.3.18 → 0.3.20

package/src/capture/index.ts

@@ -7,6 +7,10 @@ const SELF_TOOLS = new Set([
   "memory_timeline",
   "memory_get",
   "memory_viewer",
+  "memory_write_public",
+  "skill_search",
+  "skill_publish",
+  "skill_unpublish",
 ]);
 
 // OpenClaw inbound metadata sentinels — these are AI-facing prefixes,
@@ -37,6 +41,7 @@ export function captureMessages(
   turnId: string,
   _evidenceTag: string,
   log: Logger,
+  owner?: string,
 ): ConversationMessage[] {
   const now = Date.now();
   const result: ConversationMessage[] = [];
@@ -64,10 +69,11 @@ export function captureMessages(
       turnId,
       sessionKey,
       toolName: role === "tool" ? msg.toolName : undefined,
+      owner: owner ?? "agent:main",
     });
   }
 
-  log.debug(`Captured ${result.length}/${messages.length} messages for session=${sessionKey} turn=${turnId}`);
+  log.debug(`Captured ${result.length}/${messages.length} messages for session=${sessionKey} turn=${turnId} owner=${owner ?? "agent:main"}`);
   return result;
 }
 

package/src/index.ts

@@ -11,7 +11,7 @@ import type { MemosLocalConfig, ToolDefinition, Logger } from "./types";
 export interface MemosLocalPlugin {
   id: string;
   tools: ToolDefinition[];
-  onConversationTurn: (messages: Array<{ role: string; content: string }>, sessionKey?: string) => void;
+  onConversationTurn: (messages: Array<{ role: string; content: string }>, sessionKey?: string, owner?: string) => void;
   /** Wait for all pending ingest operations to complete. */
   flush: () => Promise<void>;
   shutdown: () => void;
@@ -75,12 +75,13 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
     onConversationTurn(
       messages: Array<{ role: string; content: string }>,
       sessionKey?: string,
+      owner?: string,
     ): void {
       const session = sessionKey ?? "default";
       const turnId = uuid();
       const tag = ctx.config.capture?.evidenceWrapperTag ?? "STORED_MEMORY";
 
-      const captured = captureMessages(messages, session, turnId, tag, ctx.log);
+      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner);
       if (captured.length > 0) {
         worker.enqueue(captured);
       }

package/src/ingest/dedup.ts

@@ -14,8 +14,9 @@ export function findDuplicate(
   newVec: number[],
   threshold: number,
   log: Logger,
+  ownerFilter?: string[],
 ): string | null {
-  const all = store.getAllEmbeddings();
+  const all = store.getAllEmbeddings(ownerFilter);
 
   let bestId: string | null = null;
   let bestScore = 0;
@@ -46,8 +47,9 @@ export function findTopSimilar(
   threshold: number,
   topN: number,
   log: Logger,
+  ownerFilter?: string[],
 ): Array<{ chunkId: string; score: number }> {
-  const all = store.getAllEmbeddings();
+  const all = store.getAllEmbeddings(ownerFilter);
   const scored: Array<{ chunkId: string; score: number }> = [];
 
   for (const { chunkId, vector } of all) {

package/src/ingest/task-processor.ts

@@ -47,15 +47,15 @@ export class TaskProcessor {
    * Called after new chunks are ingested.
    * Determines if a new task boundary was crossed and handles transition.
    */
-  async onChunksIngested(sessionKey: string, latestTimestamp: number): Promise<void> {
-    this.ctx.log.debug(`TaskProcessor.onChunksIngested called session=${sessionKey} ts=${latestTimestamp} processing=${this.processing}`);
+  async onChunksIngested(sessionKey: string, latestTimestamp: number, owner?: string): Promise<void> {
+    this.ctx.log.debug(`TaskProcessor.onChunksIngested called session=${sessionKey} ts=${latestTimestamp} owner=${owner ?? "agent:main"} processing=${this.processing}`);
     if (this.processing) {
       this.ctx.log.debug("TaskProcessor.onChunksIngested skipped — already processing");
       return;
     }
     this.processing = true;
     try {
-      await this.detectAndProcess(sessionKey, latestTimestamp);
+      await this.detectAndProcess(sessionKey, latestTimestamp, owner ?? "agent:main");
     } catch (err) {
       this.ctx.log.error(`TaskProcessor error: ${err}`);
     } finally {
@@ -63,23 +63,23 @@ export class TaskProcessor {
     }
   }
 
-  private async detectAndProcess(sessionKey: string, latestTimestamp: number): Promise<void> {
-    this.ctx.log.debug(`TaskProcessor.detectAndProcess session=${sessionKey}`);
+  private async detectAndProcess(sessionKey: string, latestTimestamp: number, owner: string): Promise<void> {
+    this.ctx.log.debug(`TaskProcessor.detectAndProcess session=${sessionKey} owner=${owner}`);
 
-    // Finalize any active tasks from OTHER sessions (session change = task boundary)
-    const allActive = this.store.getAllActiveTasks();
+    // Finalize any active tasks from OTHER sessions for the SAME owner (session change = task boundary)
+    const allActive = this.store.getAllActiveTasks(owner);
     for (const t of allActive) {
       if (t.sessionKey !== sessionKey) {
-        this.ctx.log.info(`Session changed: finalizing task=${t.id} from session=${t.sessionKey}`);
+        this.ctx.log.info(`Session changed: finalizing task=${t.id} from session=${t.sessionKey} (owner=${owner})`);
         await this.finalizeTask(t);
       }
     }
 
-    const activeTask = this.store.getActiveTask(sessionKey);
-    this.ctx.log.debug(`TaskProcessor.detectAndProcess activeTask=${activeTask?.id ?? "none"}`);
+    const activeTask = this.store.getActiveTask(sessionKey, owner);
+    this.ctx.log.debug(`TaskProcessor.detectAndProcess activeTask=${activeTask?.id ?? "none"} owner=${owner}`);
 
     if (!activeTask) {
-      await this.createNewTask(sessionKey, latestTimestamp);
+      await this.createNewTask(sessionKey, latestTimestamp, owner);
       return;
     }
 
@@ -87,7 +87,7 @@ export class TaskProcessor {
 
     if (isNewTask) {
       await this.finalizeTask(activeTask);
-      await this.createNewTask(sessionKey, latestTimestamp);
+      await this.createNewTask(sessionKey, latestTimestamp, owner);
     } else {
       this.assignUnassignedChunks(sessionKey, activeTask.id);
       this.store.updateTask(activeTask.id, { endedAt: undefined });
@@ -151,7 +151,7 @@ export class TaskProcessor {
       .join("\n");
   }
 
-  private async createNewTask(sessionKey: string, timestamp: number): Promise<void> {
+  private async createNewTask(sessionKey: string, timestamp: number, owner: string = "agent:main"): Promise<void> {
     const taskId = uuid();
     const task: Task = {
       id: taskId,
@@ -159,6 +159,7 @@ export class TaskProcessor {
       title: "",
       summary: "",
       status: "active",
+      owner,
       startedAt: timestamp,
       endedAt: null,
       updatedAt: timestamp,

package/src/ingest/worker.ts

@@ -48,6 +48,7 @@ export class IngestWorker {
     const t0 = performance.now();
 
     let lastSessionKey: string | undefined;
+    let lastOwner: string | undefined;
     let lastTimestamp = 0;
     let stored = 0;
     let skipped = 0;
@@ -64,6 +65,7 @@ export class IngestWorker {
       try {
         const result = await this.ingestMessage(msg);
         lastSessionKey = msg.sessionKey;
+        lastOwner = msg.owner ?? "agent:main";
         lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
         if (result === "skipped") {
           skipped++;
@@ -101,9 +103,9 @@ export class IngestWorker {
     }
 
     if (lastSessionKey) {
-      this.ctx.log.debug(`Calling TaskProcessor.onChunksIngested session=${lastSessionKey} ts=${lastTimestamp}`);
+      this.ctx.log.debug(`Calling TaskProcessor.onChunksIngested session=${lastSessionKey} ts=${lastTimestamp} owner=${lastOwner}`);
       this.taskProcessor
-        .onChunksIngested(lastSessionKey, lastTimestamp)
+        .onChunksIngested(lastSessionKey, lastTimestamp, lastOwner)
         .catch((err) => this.ctx.log.error(`TaskProcessor post-ingest error: ${err}`));
     }
 
@@ -147,7 +149,8 @@ export class IngestWorker {
     // Smart dedup: find Top-5 similar chunks, then ask LLM to judge
     if (embedding) {
       const similarThreshold = this.ctx.config.dedup?.similarityThreshold ?? 0.75;
-      const topSimilar = findTopSimilar(this.store, embedding, similarThreshold, 5, this.ctx.log);
+      const dedupOwnerFilter = msg.owner ? [msg.owner, "public"] : undefined;
+      const topSimilar = findTopSimilar(this.store, embedding, similarThreshold, 5, this.ctx.log, dedupOwnerFilter);
 
       if (topSimilar.length > 0) {
         const candidates = topSimilar.map((s, i) => {
@@ -214,6 +217,7 @@ export class IngestWorker {
       embedding: null,
       taskId: null,
       skillId: null,
+      owner: msg.owner ?? "agent:main",
       dedupStatus,
       dedupTarget,
       dedupReason,

package/src/recall/engine.ts

@@ -1,16 +1,20 @@
 import type { SqliteStore } from "../storage/sqlite";
 import type { Embedder } from "../embedding";
-import type { PluginContext, SearchHit, SearchResult } from "../types";
-import { vectorSearch } from "../storage/vector";
+import type { PluginContext, SearchHit, SearchResult, SkillSearchHit, Skill } from "../types";
+import { vectorSearch, cosineSimilarity } from "../storage/vector";
 import { rrfFuse } from "./rrf";
 import { mmrRerank } from "./mmr";
 import { applyRecencyDecay } from "./recency";
+import { Summarizer } from "../ingest/providers";
+
+export type SkillSearchScope = "mix" | "self" | "public";
 
 export interface RecallOptions {
   query?: string;
   maxResults?: number;
   minScore?: number;
   role?: string;
+  ownerFilter?: string[];
 }
 
 const MAX_RECENT_QUERIES = 20;
@@ -36,10 +40,11 @@ export class RecallEngine {
 
     const repeatNote = this.checkRepeat(query, maxResults, minScore);
     const candidatePool = maxResults * 5;
+    const ownerFilter = opts.ownerFilter;
 
     // Step 1: Gather candidates from both FTS and vector search
     const ftsCandidates = query
-      ? this.store.ftsSearch(query, candidatePool)
+      ? this.store.ftsSearch(query, candidatePool, ownerFilter)
       : [];
 
     let vecCandidates: Array<{ chunkId: string; score: number }> = [];
@@ -49,7 +54,7 @@ export class RecallEngine {
         const maxChunks = recallCfg.vectorSearchMaxChunks && recallCfg.vectorSearchMaxChunks > 0
           ? recallCfg.vectorSearchMaxChunks
           : undefined;
-        vecCandidates = vectorSearch(this.store, queryVec, candidatePool, maxChunks);
+        vecCandidates = vectorSearch(this.store, queryVec, candidatePool, maxChunks, ownerFilter);
       } catch (err) {
         this.ctx.log.warn(`Vector search failed, using FTS only: ${err}`);
       }
@@ -181,6 +186,91 @@ export class RecallEngine {
       this.recentQueries.shift();
     }
   }
+
+  async searchSkills(query: string, scope: SkillSearchScope, currentOwner: string): Promise<SkillSearchHit[]> {
+    const RRF_K = 60;
+    const TOP_CANDIDATES = 20;
+
+    // FTS on name + description
+    const ftsCandidates = this.store.skillFtsSearch(query, TOP_CANDIDATES, scope, currentOwner);
+
+    // Vector search on description embedding
+    let vecCandidates: Array<{ skillId: string; score: number }> = [];
+    try {
+      const queryVec = await this.embedder.embedQuery(query);
+      const allEmb = this.store.getSkillEmbeddings(scope, currentOwner);
+      vecCandidates = allEmb.map((row) => ({
+        skillId: row.skillId,
+        score: cosineSimilarity(queryVec, row.vector),
+      }));
+      vecCandidates.sort((a, b) => b.score - a.score);
+      vecCandidates = vecCandidates.slice(0, TOP_CANDIDATES);
+    } catch (err) {
+      this.ctx.log.warn(`Skill vector search failed, using FTS only: ${err}`);
+    }
+
+    // RRF fusion
+    const ftsRanked = ftsCandidates.map((c) => ({ id: c.skillId, score: c.score }));
+    const vecRanked = vecCandidates.map((c) => ({ id: c.skillId, score: c.score }));
+    const rrfScores = rrfFuse([ftsRanked, vecRanked], RRF_K);
+
+    if (rrfScores.size === 0) return [];
+
+    const sorted = [...rrfScores.entries()]
+      .map(([id, score]) => ({ id, score }))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, TOP_CANDIDATES);
+
+    // Load skill details for LLM judgment
+    const candidateSkills: Array<{ skill: Skill; rrfScore: number }> = [];
+    for (const item of sorted) {
+      const skill = this.store.getSkill(item.id);
+      if (skill) candidateSkills.push({ skill, rrfScore: item.score });
+    }
+
+    if (candidateSkills.length === 0) return [];
+
+    // LLM relevance judgment
+    const summarizer = new Summarizer(this.ctx.config.summarizer, this.ctx.log);
+    const relevantIndices = await this.judgeSkillRelevance(summarizer, query, candidateSkills);
+
+    return relevantIndices.map((idx) => {
+      const { skill, rrfScore } = candidateSkills[idx];
+      return {
+        skillId: skill.id,
+        name: skill.name,
+        description: skill.description,
+        owner: skill.owner,
+        visibility: skill.visibility,
+        score: rrfScore,
+        reason: "relevant",
+      };
+    });
+  }
+
+  private async judgeSkillRelevance(
+    summarizer: Summarizer,
+    query: string,
+    candidates: Array<{ skill: Skill; rrfScore: number }>,
+  ): Promise<number[]> {
+    const candidateList = candidates.map((c, i) => ({
+      index: i,
+      summary: `[${c.skill.name}] ${c.skill.description}`,
+      role: "skill" as const,
+    }));
+
+    try {
+      const result = await summarizer.filterRelevant(query, candidateList);
+      if (result && result.relevant.length > 0) {
+        return result.relevant.map((r) => r);
+      }
+    } catch (err) {
+      this.ctx.log.warn(`Skill relevance judgment failed, returning all: ${err}`);
+    }
+
+    // Fallback: return all candidates
+    return candidates.map((_, i) => i);
+  }
 }
 
 function makeExcerpt(content: string): string {

package/src/skill/evolver.ts

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import type { SqliteStore } from "../storage/sqlite";
 import type { RecallEngine } from "../recall/engine";
+import type { Embedder } from "../embedding";
 import type { Task, Skill, Chunk, PluginContext } from "../types";
 import { DEFAULTS } from "../types";
 import { SkillEvaluator } from "./evaluator";
@@ -20,9 +21,10 @@ export class SkillEvolver {
     private store: SqliteStore,
     private engine: RecallEngine,
     private ctx: PluginContext,
+    embedder?: Embedder,
   ) {
     this.evaluator = new SkillEvaluator(ctx);
-    this.generator = new SkillGenerator(store, engine, ctx);
+    this.generator = new SkillGenerator(store, engine, ctx, embedder);
     this.upgrader = new SkillUpgrader(store, ctx);
     this.installer = new SkillInstaller(store, ctx);
   }

package/src/skill/generator.ts

@@ -3,6 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import type { SqliteStore } from "../storage/sqlite";
 import type { RecallEngine } from "../recall/engine";
+import type { Embedder } from "../embedding";
 import type { Chunk, Task, Skill, PluginContext, SummarizerConfig, SkillGenerateOutput } from "../types";
 import { DEFAULTS } from "../types";
 import type { CreateEvalResult } from "./evaluator";
@@ -176,13 +177,16 @@ If no references should be extracted, reply with: []`;
 
 export class SkillGenerator {
   private validator: SkillValidator;
+  private embedder: Embedder | null = null;
 
   constructor(
     private store: SqliteStore,
     private engine: RecallEngine,
     private ctx: PluginContext,
+    embedder?: Embedder,
   ) {
     this.validator = new SkillValidator(ctx);
+    this.embedder = embedder ?? null;
   }
 
   async generate(task: Task, chunks: Chunk[], evalResult: CreateEvalResult): Promise<Skill> {
@@ -270,12 +274,23 @@ export class SkillGenerator {
       sourceType: "task",
       dirPath,
       installed: 0,
+      owner: "agent:main",
+      visibility: "private",
       qualityScore: validation.qualityScore,
       createdAt: now,
       updatedAt: now,
     };
     this.store.insertSkill(skill);
 
+    if (description && this.embedder) {
+      try {
+        const [descEmb] = await this.embedder.embed([description]);
+        if (descEmb) this.store.upsertSkillEmbedding(skillId, descEmb);
+      } catch (err) {
+        this.ctx.log.warn(`SkillGenerator: embedding for description failed: ${err}`);
+      }
+    }
+
     this.store.insertSkillVersion({
       id: uuid(),
       skillId,