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

package/index.ts

@@ -1151,6 +1151,10 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
             };
           }
 
+          const disabledWarning = skill.status === "archived"
+            ? "\n\n> **Warning:** This skill is currently **disabled** (archived). Its content is shown for reference only — it will not be used in search or auto-recall.\n\n"
+            : "";
+
           const manifest = skillInstaller.getCompanionManifest(resolvedSkillId);
           let footer = "\n\n---\n";
 
@@ -1175,7 +1179,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           return {
             content: [{
               type: "text",
-              text: `## Skill: ${skill.name} (v${skill.version})\n\n${sv.content}${footer}`,
+              text: `## Skill: ${skill.name} (v${skill.version})${disabledWarning}\n\n${sv.content}${footer}`,
             }],
             details: {
               skillId: skill.id,

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "MemOS Local Memory",
   "description": "Full-write local conversation memory with hybrid search (RRF + MMR + recency), task summarization, skill evolution, and team sharing (Hub-Client). Provides memory_search, memory_get, task_summary, skill_search, task_share, network_skill_pull, network_team_info, memory_viewer for layered retrieval and team collaboration.",
   "kind": "memory",
-  "version": "1.0.6-beta.11",
+  "version": "1.0.8-beta.2",
   "skills": [
     "skill/memos-memory-guide"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "1.0.8-beta",
+  "version": "1.0.8-beta.2",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",

package/src/storage/sqlite.ts

@@ -110,6 +110,7 @@ export class SqliteStore {
     this.migrateOwnerFields();
     this.migrateSkillVisibility();
     this.migrateSkillEmbeddingsAndFts();
+    this.migrateTaskEmbeddingsAndFts();
     this.migrateFtsToTrigram();
     this.migrateHubTables();
     this.migrateHubFtsToTrigram();
@@ -290,6 +291,55 @@ export class SqliteStore {
     } catch { /* best-effort */ }
   }
 
+  private migrateTaskEmbeddingsAndFts(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_embeddings (
+        task_id    TEXT PRIMARY KEY REFERENCES tasks(id) ON DELETE CASCADE,
+        vector     BLOB NOT NULL,
+        dimensions INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+        summary,
+        topic,
+        content='tasks',
+        content_rowid='rowid',
+        tokenize='trigram'
+      );
+    `);
+
+    try {
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_ai AFTER INSERT ON tasks BEGIN
+          INSERT INTO tasks_fts(rowid, summary, topic)
+          VALUES (new.rowid, new.summary, COALESCE(new.topic, ''));
+        END;
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_ad AFTER DELETE ON tasks BEGIN
+          INSERT INTO tasks_fts(tasks_fts, rowid, summary, topic)
+          VALUES ('delete', old.rowid, old.summary, COALESCE(old.topic, ''));
+        END;
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_au AFTER UPDATE ON tasks BEGIN
+          INSERT INTO tasks_fts(tasks_fts, rowid, summary, topic)
+          VALUES ('delete', old.rowid, old.summary, COALESCE(old.topic, ''));
+          INSERT INTO tasks_fts(rowid, summary, topic)
+          VALUES (new.rowid, new.summary, COALESCE(new.topic, ''));
+        END;
+      `);
+    } catch {
+      // triggers may already exist
+    }
+
+    try {
+      const count = (this.db.prepare("SELECT COUNT(*) as c FROM tasks_fts").get() as { c: number }).c;
+      const taskCount = (this.db.prepare("SELECT COUNT(*) as c FROM tasks").get() as { c: number }).c;
+      if (count === 0 && taskCount > 0) {
+        this.db.exec("INSERT INTO tasks_fts(rowid, summary, topic) SELECT rowid, summary, COALESCE(topic, '') FROM tasks");
+        this.log.info(`Migrated: backfilled tasks_fts for ${taskCount} tasks`);
+      }
+    } catch { /* best-effort */ }
+  }
+
   private migrateFtsToTrigram(): void {
     // Check if chunks_fts still uses the old tokenizer (porter unicode61)
     try {
@@ -1477,6 +1527,21 @@ export class SqliteStore {
     return result.changes > 0;
   }
 
+  disableSkill(skillId: string): boolean {
+    const skill = this.getSkill(skillId);
+    if (!skill || skill.status === "archived") return false;
+    this.db.prepare("DELETE FROM skill_embeddings WHERE skill_id = ?").run(skillId);
+    this.updateSkill(skillId, { status: "archived", installed: 0 });
+    return true;
+  }
+
+  enableSkill(skillId: string): boolean {
+    const skill = this.getSkill(skillId);
+    if (!skill || skill.status !== "archived") return false;
+    this.updateSkill(skillId, { status: "active" });
+    return true;
+  }
+
   // ─── Task CRUD ───
 
   insertTask(task: Task): void {
@@ -1558,10 +1623,11 @@ export class SqliteStore {
     return rows.map(rowToChunk);
   }
 
-  listTasks(opts: { status?: string; limit?: number; offset?: number; owner?: string } = {}): { tasks: Task[]; total: number } {
+  listTasks(opts: { status?: string; limit?: number; offset?: number; owner?: string; session?: string } = {}): { tasks: Task[]; total: number } {
     const conditions: string[] = [];
     const params: unknown[] = [];
     if (opts.status) { conditions.push("status = ?"); params.push(opts.status); }
+    if (opts.session) { conditions.push("session_key = ?"); params.push(opts.session); }
     if (opts.owner) {
       conditions.push("(owner = ? OR (owner = 'public' AND id IN (SELECT task_id FROM local_shared_tasks WHERE original_owner = ?)))");
       params.push(opts.owner, opts.owner);
@@ -1683,9 +1749,24 @@ export class SqliteStore {
     this.db.prepare(`UPDATE skills SET ${sets.join(", ")} WHERE id = ?`).run(...params);
   }
 
-  listSkills(opts: { status?: string } = {}): Skill[] {
-    const cond = opts.status ? "WHERE status = ?" : "";
-    const params = opts.status ? [opts.status] : [];
+  listSkills(opts: { status?: string; session?: string; owner?: string } = {}): Skill[] {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+    if (opts.status) { conditions.push("status = ?"); params.push(opts.status); }
+    if (opts.owner) {
+      conditions.push("(owner = ? OR owner = 'public')");
+      params.push(opts.owner);
+    }
+    if (opts.session) {
+      conditions.push(`EXISTS (
+        SELECT 1
+        FROM task_skills ts
+        JOIN tasks t ON t.id = ts.task_id
+        WHERE ts.skill_id = skills.id AND t.session_key = ?
+      )`);
+      params.push(opts.session);
+    }
+    const cond = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const rows = this.db.prepare(`SELECT * FROM skills ${cond} ORDER BY updated_at DESC`).all(...params) as SkillRow[];
     return rows.map(rowToSkill);
   }
@@ -1775,6 +1856,61 @@ export class SqliteStore {
     }
   }
 
+  // ─── Task Embeddings & Search ───
+
+  upsertTaskEmbedding(taskId: string, vector: number[]): void {
+    const buf = Buffer.from(new Float32Array(vector).buffer);
+    this.db.prepare(`
+      INSERT OR REPLACE INTO task_embeddings (task_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+    `).run(taskId, buf, vector.length, Date.now());
+  }
+
+  getTaskEmbeddings(owner?: string): Array<{ taskId: string; vector: number[] }> {
+    let sql = `SELECT te.task_id, te.vector, te.dimensions
+       FROM task_embeddings te
+       JOIN tasks t ON t.id = te.task_id`;
+    const params: any[] = [];
+    if (owner) {
+      sql += ` WHERE (t.owner = ? OR t.owner = 'public')`;
+      params.push(owner);
+    }
+    const rows = this.db.prepare(sql).all(...params) as Array<{ task_id: string; vector: Buffer; dimensions: number }>;
+    return rows.map((r) => ({
+      taskId: r.task_id,
+      vector: Array.from(new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions)),
+    }));
+  }
+
+  taskFtsSearch(query: string, limit: number, owner?: string): Array<{ taskId: string; score: number }> {
+    const sanitized = sanitizeFtsQuery(query);
+    if (!sanitized) return [];
+    try {
+      let sql = `
+        SELECT t.id as task_id, rank
+        FROM tasks_fts f
+        JOIN tasks t ON t.rowid = f.rowid
+        WHERE tasks_fts MATCH ?`;
+      const params: any[] = [sanitized];
+      if (owner) {
+        sql += ` AND (t.owner = ? OR t.owner = 'public')`;
+        params.push(owner);
+      }
+      sql += ` ORDER BY rank LIMIT ?`;
+      params.push(limit);
+      const rows = this.db.prepare(sql).all(...params) as Array<{ task_id: string; rank: number }>;
+      if (rows.length === 0) return [];
+      const maxAbsRank = Math.max(...rows.map((r) => Math.abs(r.rank)));
+      return rows.map((r) => ({
+        taskId: r.task_id,
+        score: maxAbsRank > 0 ? Math.abs(r.rank) / maxAbsRank : 0,
+      }));
+    } catch {
+      this.log.warn(`Task FTS query failed for: "${sanitized}", returning empty`);
+      return [];
+    }
+  }
+
   listPublicSkills(): Skill[] {
     const rows = this.db.prepare("SELECT * FROM skills WHERE visibility = 'public' AND status = 'active' ORDER BY updated_at DESC").all() as SkillRow[];
     return rows.map(rowToSkill);