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

package/src/storage/sqlite.ts

@@ -110,9 +110,12 @@ export class SqliteStore {
     this.migrateOwnerFields();
     this.migrateSkillVisibility();
     this.migrateSkillEmbeddingsAndFts();
+    this.migrateTaskTopicColumn();
+    this.migrateTaskEmbeddingsAndFts();
     this.migrateFtsToTrigram();
     this.migrateHubTables();
     this.migrateHubFtsToTrigram();
+    this.migrateHubMemorySourceAgent();
     this.migrateLocalSharedTasksOwner();
     this.migrateHubUserIdentityFields();
     this.migrateClientHubConnectionIdentityFields();
@@ -124,6 +127,16 @@ export class SqliteStore {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_dedup_created ON chunks(dedup_status, created_at DESC)");
   }
 
+  private migrateHubMemorySourceAgent(): void {
+    try {
+      const cols = this.db.prepare("PRAGMA table_info(hub_memories)").all() as Array<{ name: string }>;
+      if (cols.length > 0 && !cols.some((c) => c.name === "source_agent")) {
+        this.db.exec("ALTER TABLE hub_memories ADD COLUMN source_agent TEXT NOT NULL DEFAULT ''");
+        this.log.info("Migrated: added source_agent column to hub_memories");
+      }
+    } catch { /* table may not exist yet */ }
+  }
+
   private migrateLocalSharedTasksOwner(): void {
     try {
       const cols = this.db.prepare("PRAGMA table_info(local_shared_tasks)").all() as Array<{ name: string }>;
@@ -290,6 +303,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 {
@@ -507,6 +569,14 @@ export class SqliteStore {
     }
   }
 
+  private migrateTaskTopicColumn(): void {
+    const cols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "topic")) {
+      this.db.exec("ALTER TABLE tasks ADD COLUMN topic TEXT DEFAULT NULL");
+      this.log.info("Migrated: added topic column to tasks");
+    }
+  }
+
   private migrateTaskSkillMeta(): void {
     const cols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
     if (!cols.some((c) => c.name === "skill_status")) {
@@ -992,6 +1062,7 @@ export class SqliteStore {
         id              TEXT PRIMARY KEY,
         source_chunk_id TEXT NOT NULL,
         source_user_id  TEXT NOT NULL,
+        source_agent    TEXT NOT NULL DEFAULT '',
         role            TEXT NOT NULL,
         content         TEXT NOT NULL,
         summary         TEXT NOT NULL DEFAULT '',
@@ -1207,7 +1278,7 @@ export class SqliteStore {
 
   // ─── Pattern Search (LIKE-based, for CJK text where FTS tokenization is weak) ───
 
-  patternSearch(patterns: string[], opts: { role?: string; limit?: number } = {}): Array<{ chunkId: string; content: string; role: string; createdAt: number }> {
+  patternSearch(patterns: string[], opts: { role?: string; limit?: number; ownerFilter?: string[] } = {}): Array<{ chunkId: string; content: string; role: string; createdAt: number }> {
     if (patterns.length === 0) return [];
     const limit = opts.limit ?? 10;
 
@@ -1216,13 +1287,21 @@ export class SqliteStore {
     const roleClause = opts.role ? " AND c.role = ?" : "";
     const params: (string | number)[] = patterns.map(p => `%${p}%`);
     if (opts.role) params.push(opts.role);
+
+    let ownerClause = "";
+    if (opts.ownerFilter && opts.ownerFilter.length > 0) {
+      const placeholders = opts.ownerFilter.map(() => "?").join(",");
+      ownerClause = ` AND c.owner IN (${placeholders})`;
+      params.push(...opts.ownerFilter);
+    }
+
     params.push(limit);
 
     try {
       const rows = this.db.prepare(`
         SELECT c.id as chunk_id, c.content, c.role, c.created_at
         FROM chunks c
-        WHERE (${whereClause})${roleClause} AND c.dedup_status = 'active'
+        WHERE (${whereClause})${roleClause}${ownerClause} AND c.dedup_status = 'active'
         ORDER BY c.created_at DESC
         LIMIT ?
       `).all(...params) as Array<{ chunk_id: string; content: string; role: string; created_at: number }>;
@@ -1425,8 +1504,15 @@ export class SqliteStore {
 
   deleteAll(): number {
     this.db.exec("PRAGMA foreign_keys = OFF");
+    try {
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ai");
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ad");
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_au");
+      this.db.exec("DELETE FROM tasks_fts");
+    } catch (_) {}
     const tables = [
       "task_skills",
+      "task_embeddings",
       "skill_embeddings",
       "skill_versions",
       "skills",
@@ -1449,6 +1535,7 @@ export class SqliteStore {
       }
     }
     this.db.exec("PRAGMA foreign_keys = ON");
+    this.migrateTaskEmbeddingsAndFts();
     const remaining = this.countChunks();
     return remaining === 0 ? 1 : 0;
   }
@@ -1469,6 +1556,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 {
@@ -1550,10 +1652,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);
@@ -1675,9 +1778,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);
   }
@@ -1767,6 +1885,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);
@@ -2430,9 +2603,10 @@ export class SqliteStore {
 
   upsertHubMemory(memory: HubMemoryRecord): void {
     this.db.prepare(`
-      INSERT INTO hub_memories (id, source_chunk_id, source_user_id, role, content, summary, kind, group_id, visibility, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO hub_memories (id, source_chunk_id, source_user_id, source_agent, role, content, summary, kind, group_id, visibility, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(source_user_id, source_chunk_id) DO UPDATE SET
+        source_agent = excluded.source_agent,
         role = excluded.role,
         content = excluded.content,
         summary = excluded.summary,
@@ -2441,7 +2615,7 @@ export class SqliteStore {
         visibility = excluded.visibility,
         created_at = excluded.created_at,
         updated_at = excluded.updated_at
-    `).run(memory.id, memory.sourceChunkId, memory.sourceUserId, memory.role, memory.content, memory.summary, memory.kind, memory.groupId, memory.visibility, memory.createdAt, memory.updatedAt);
+    `).run(memory.id, memory.sourceChunkId, memory.sourceUserId, memory.sourceAgent, memory.role, memory.content, memory.summary, memory.kind, memory.groupId, memory.visibility, memory.createdAt, memory.updatedAt);
   }
 
   getHubMemoryBySource(sourceUserId: string, sourceChunkId: string): HubMemoryRecord | null {
@@ -2550,6 +2724,11 @@ export class SqliteStore {
     this.db.prepare("UPDATE local_shared_tasks SET hub_task_id = '', hub_instance_id = '', visibility = 'public', group_id = NULL, synced_chunks = 0 WHERE task_id = ?").run(taskId);
   }
 
+  /** Client UI: remove team_shared_chunks rows for all chunks linked to this task (list badge chunk fallback). */
+  clearTeamSharedChunksForTask(taskId: string): void {
+    this.db.prepare("DELETE FROM team_shared_chunks WHERE chunk_id IN (SELECT id FROM chunks WHERE task_id = ?)").run(taskId);
+  }
+
   clearAllTeamSharingState(): void {
     this.clearTeamSharedChunks();
     this.clearTeamSharedSkills();
@@ -2607,7 +2786,7 @@ export class SqliteStore {
     if (!sanitized) return [];
     const rows = this.db.prepare(`
       SELECT hm.id, hm.content, hm.summary, hm.role, hm.created_at, hm.visibility, '' as group_name, hu.username as owner_name,
-             bm25(hub_memories_fts) as rank
+             COALESCE(hm.source_agent, '') as source_agent, bm25(hub_memories_fts) as rank
       FROM hub_memories_fts f
       JOIN hub_memories hm ON hm.rowid = f.rowid
       LEFT JOIN hub_users hu ON hu.id = hm.source_user_id
@@ -2623,7 +2802,7 @@ export class SqliteStore {
   getVisibleHubSearchHitByMemoryId(memoryId: string, userId: string): HubMemorySearchRow | null {
     const row = this.db.prepare(`
       SELECT hm.id, hm.content, hm.summary, hm.role, hm.created_at, hm.visibility, '' as group_name, hu.username as owner_name,
-             0 as rank
+             COALESCE(hm.source_agent, '') as source_agent, 0 as rank
       FROM hub_memories hm
       LEFT JOIN hub_users hu ON hu.id = hm.source_user_id
       WHERE hm.id = ?
@@ -3117,6 +3296,7 @@ export interface HubMemoryRecord {
   id: string;
   sourceChunkId: string;
   sourceUserId: string;
+  sourceAgent: string;
   role: string;
   content: string;
   summary: string;
@@ -3131,6 +3311,7 @@ interface HubMemoryRow {
   id: string;
   source_chunk_id: string;
   source_user_id: string;
+  source_agent: string;
   role: string;
   content: string;
   summary: string;
@@ -3146,6 +3327,7 @@ function rowToHubMemory(row: HubMemoryRow): HubMemoryRecord {
     id: row.id,
     sourceChunkId: row.source_chunk_id,
     sourceUserId: row.source_user_id,
+    sourceAgent: row.source_agent || "",
     role: row.role,
     content: row.content,
     summary: row.summary,
@@ -3166,6 +3348,7 @@ interface HubMemorySearchRow {
   visibility: string;
   group_name: string | null;
   owner_name: string | null;
+  source_agent: string;
   rank: number;
 }
 

package/src/types.ts

@@ -322,6 +322,8 @@ export interface MemosLocalConfig {
   skillEvolution?: SkillEvolutionConfig;
   telemetry?: TelemetryConfig;
   sharing?: SharingConfig;
+  /** Hours of inactivity after which an active task is automatically finalized. 0 = disabled. Default 4. */
+  taskAutoFinalizeHours?: number;
 }
 
 // ─── Defaults ───
@@ -357,6 +359,7 @@ export const DEFAULTS = {
   skillAutoRecallLimit: 2,
   skillPreferUpgrade: true,
   skillRedactSensitive: true,
+  taskAutoFinalizeHours: 4,
 } as const;
 
 // ─── Plugin Hooks (OpenClaw integration) ───