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

package/dist/storage/sqlite.js

@@ -146,11 +146,70 @@ class SqliteStore {
         this.migrateSkillEmbeddingsAndFts();
         this.migrateFtsToTrigram();
         this.migrateHubTables();
+        this.migrateHubFtsToTrigram();
+        this.migrateLocalSharedTasksOwner();
+        this.migrateHubUserIdentityFields();
+        this.migrateClientHubConnectionIdentityFields();
         this.log.debug("Database schema initialized");
     }
     migrateChunksIndexesForRecall() {
         this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_dedup_created ON chunks(dedup_status, created_at DESC)");
     }
+    migrateLocalSharedTasksOwner() {
+        try {
+            const cols = this.db.prepare("PRAGMA table_info(local_shared_tasks)").all();
+            if (cols.length > 0 && !cols.some((c) => c.name === "original_owner")) {
+                this.db.exec("ALTER TABLE local_shared_tasks ADD COLUMN original_owner TEXT NOT NULL DEFAULT 'agent:main'");
+                this.log.info("Migrated: added original_owner column to local_shared_tasks");
+            }
+        }
+        catch { /* table may not exist yet */ }
+    }
+    migrateHubUserIdentityFields() {
+        try {
+            const cols = this.db.prepare("PRAGMA table_info(hub_users)").all();
+            if (cols.length === 0)
+                return;
+            if (!cols.some(c => c.name === "identity_key")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN identity_key TEXT NOT NULL DEFAULT ''");
+                this.db.exec("CREATE INDEX IF NOT EXISTS idx_hub_users_identity_key ON hub_users(identity_key)");
+                this.log.info("Migrated: added identity_key to hub_users");
+            }
+            if (!cols.some(c => c.name === "left_at")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN left_at INTEGER");
+                this.log.info("Migrated: added left_at to hub_users");
+            }
+            if (!cols.some(c => c.name === "removed_at")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN removed_at INTEGER");
+                this.log.info("Migrated: added removed_at to hub_users");
+            }
+            if (!cols.some(c => c.name === "rejected_at")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN rejected_at INTEGER");
+                this.log.info("Migrated: added rejected_at to hub_users");
+            }
+            if (!cols.some(c => c.name === "rejoin_requested_at")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN rejoin_requested_at INTEGER");
+                this.log.info("Migrated: added rejoin_requested_at to hub_users");
+            }
+        }
+        catch { /* table may not exist yet */ }
+    }
+    migrateClientHubConnectionIdentityFields() {
+        try {
+            const cols = this.db.prepare("PRAGMA table_info(client_hub_connection)").all();
+            if (cols.length === 0)
+                return;
+            if (!cols.some(c => c.name === "identity_key")) {
+                this.db.exec("ALTER TABLE client_hub_connection ADD COLUMN identity_key TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added identity_key to client_hub_connection");
+            }
+            if (!cols.some(c => c.name === "last_known_status")) {
+                this.db.exec("ALTER TABLE client_hub_connection ADD COLUMN last_known_status TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added last_known_status to client_hub_connection");
+            }
+        }
+        catch { /* table may not exist yet */ }
+    }
     migrateOwnerFields() {
         const chunkCols = this.db.prepare("PRAGMA table_info(chunks)").all();
         if (!chunkCols.some((c) => c.name === "owner")) {
@@ -298,6 +357,54 @@ class SqliteStore {
             this.log.warn(`Failed to migrate skills_fts to trigram: ${err}`);
         }
     }
+    migrateHubFtsToTrigram() {
+        const tables = [
+            {
+                fts: "hub_chunks_fts", source: "hub_chunks", columns: "summary, content",
+                triggers: ["hub_chunks_ai", "hub_chunks_ad", "hub_chunks_au"],
+            },
+            {
+                fts: "hub_skills_fts", source: "hub_skills", columns: "name, description",
+                triggers: ["hub_skills_ai", "hub_skills_ad", "hub_skills_au"],
+            },
+            {
+                fts: "hub_memories_fts", source: "hub_memories", columns: "summary, content",
+                triggers: ["hub_memories_ai", "hub_memories_ad", "hub_memories_au"],
+            },
+        ];
+        for (const t of tables) {
+            try {
+                const row = this.db.prepare(`SELECT sql FROM sqlite_master WHERE name='${t.fts}'`).get();
+                if (!row || !row.sql)
+                    continue;
+                if (row.sql.includes("trigram"))
+                    continue;
+                this.log.info(`Migrating ${t.fts} to trigram tokenizer...`);
+                for (const tr of t.triggers)
+                    this.db.exec(`DROP TRIGGER IF EXISTS ${tr}`);
+                this.db.exec(`DROP TABLE IF EXISTS ${t.fts}`);
+                this.db.exec(`CREATE VIRTUAL TABLE ${t.fts} USING fts5(${t.columns}, content='${t.source}', content_rowid='rowid', tokenize='trigram')`);
+                this.db.exec(`
+          CREATE TRIGGER ${t.triggers[0]} AFTER INSERT ON ${t.source} BEGIN
+            INSERT INTO ${t.fts}(rowid, ${t.columns}) VALUES (new.rowid, ${t.columns.split(", ").map(c => "new." + c).join(", ")});
+          END;
+          CREATE TRIGGER ${t.triggers[1]} AFTER DELETE ON ${t.source} BEGIN
+            INSERT INTO ${t.fts}(${t.fts}, rowid, ${t.columns}) VALUES ('delete', old.rowid, ${t.columns.split(", ").map(c => "old." + c).join(", ")});
+          END;
+          CREATE TRIGGER ${t.triggers[2]} AFTER UPDATE ON ${t.source} BEGIN
+            INSERT INTO ${t.fts}(${t.fts}, rowid, ${t.columns}) VALUES ('delete', old.rowid, ${t.columns.split(", ").map(c => "old." + c).join(", ")});
+            INSERT INTO ${t.fts}(rowid, ${t.columns}) VALUES (new.rowid, ${t.columns.split(", ").map(c => "new." + c).join(", ")});
+          END
+        `);
+                this.db.exec(`INSERT INTO ${t.fts}(rowid, ${t.columns}) SELECT rowid, ${t.columns} FROM ${t.source}`);
+                const cnt = this.db.prepare(`SELECT COUNT(*) as c FROM ${t.fts}`).get().c;
+                this.log.info(`Migrated ${t.fts} to trigram: ${cnt} rows indexed`);
+            }
+            catch (err) {
+                this.log.warn(`Failed to migrate ${t.fts} to trigram: ${err}`);
+            }
+        }
+    }
     migrateTaskId() {
         const cols = this.db.prepare("PRAGMA table_info(chunks)").all();
         if (!cols.some((c) => c.name === "task_id")) {
@@ -503,15 +610,16 @@ class SqliteStore {
     recordToolCall(toolName, durationMs, success) {
         this.db.prepare("INSERT INTO tool_calls (tool_name, duration_ms, success, called_at) VALUES (?, ?, ?, ?)").run(toolName, Math.round(durationMs), success ? 1 : 0, Date.now());
     }
-    getToolMetrics(minutes) {
-        const since = Date.now() - minutes * 60 * 1000;
+    getToolMetrics(minutes, fromMs, toMs) {
+        const since = fromMs ?? (Date.now() - minutes * 60 * 1000);
+        const until = toMs ?? Date.now();
         const rows = this.db.prepare(`SELECT tool_name,
               duration_ms,
               success,
               strftime('%Y-%m-%d %H:%M', called_at/1000, 'unixepoch', 'localtime') as minute_key
        FROM tool_calls
-       WHERE called_at >= ?
-       ORDER BY called_at`).all(since);
+       WHERE called_at >= ? AND called_at <= ?
+       ORDER BY called_at`).all(since, until);
         const toolSet = new Set();
         const minuteMap = new Map();
         const aggMap = new Map();
@@ -644,33 +752,49 @@ class SqliteStore {
         shared_at     INTEGER NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS local_shared_memories (
+        chunk_id        TEXT PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+        original_owner  TEXT NOT NULL,
+        shared_at       INTEGER NOT NULL
+      );
+
+      -- Client: team share UI metadata only (no hub_memories row — avoids local FTS/embed recall duplication)
+      CREATE TABLE IF NOT EXISTS team_shared_chunks (
+        chunk_id       TEXT PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+        hub_memory_id  TEXT NOT NULL DEFAULT '',
+        visibility     TEXT NOT NULL DEFAULT 'public',
+        group_id       TEXT,
+        shared_at      INTEGER NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS hub_users (
-        id          TEXT PRIMARY KEY,
-        username    TEXT NOT NULL UNIQUE,
-        device_name TEXT NOT NULL DEFAULT '',
-        role        TEXT NOT NULL,
-        status      TEXT NOT NULL,
-        token_hash  TEXT NOT NULL DEFAULT '',
-        created_at  INTEGER NOT NULL,
-        approved_at INTEGER
+        id             TEXT PRIMARY KEY,
+        username       TEXT NOT NULL UNIQUE,
+        device_name    TEXT NOT NULL DEFAULT '',
+        role           TEXT NOT NULL,
+        status         TEXT NOT NULL,
+        token_hash     TEXT NOT NULL DEFAULT '',
+        created_at     INTEGER NOT NULL,
+        approved_at    INTEGER,
+        last_ip        TEXT NOT NULL DEFAULT '',
+        last_active_at INTEGER
       );
       CREATE INDEX IF NOT EXISTS idx_hub_users_status ON hub_users(status);
       CREATE INDEX IF NOT EXISTS idx_hub_users_role ON hub_users(role);
 
       CREATE TABLE IF NOT EXISTS hub_groups (
         id          TEXT PRIMARY KEY,
-        name        TEXT NOT NULL UNIQUE,
+        name        TEXT NOT NULL,
         description TEXT NOT NULL DEFAULT '',
         created_at  INTEGER NOT NULL
       );
 
       CREATE TABLE IF NOT EXISTS hub_group_members (
-        group_id    TEXT NOT NULL REFERENCES hub_groups(id) ON DELETE CASCADE,
-        user_id     TEXT NOT NULL REFERENCES hub_users(id) ON DELETE CASCADE,
-        joined_at   INTEGER NOT NULL,
+        group_id   TEXT NOT NULL REFERENCES hub_groups(id) ON DELETE CASCADE,
+        user_id    TEXT NOT NULL REFERENCES hub_users(id) ON DELETE CASCADE,
+        joined_at  INTEGER NOT NULL,
         PRIMARY KEY (group_id, user_id)
       );
-      CREATE INDEX IF NOT EXISTS idx_hub_group_members_user ON hub_group_members(user_id);
 
       CREATE TABLE IF NOT EXISTS hub_tasks (
         id             TEXT PRIMARY KEY,
@@ -713,7 +837,7 @@ class SqliteStore {
         content,
         content='hub_chunks',
         content_rowid='rowid',
-        tokenize='porter unicode61'
+        tokenize='trigram'
       );
 
       CREATE TRIGGER IF NOT EXISTS hub_chunks_ai AFTER INSERT ON hub_chunks BEGIN
@@ -763,7 +887,7 @@ class SqliteStore {
         description,
         content='hub_skills',
         content_rowid='rowid',
-        tokenize='porter unicode61'
+        tokenize='trigram'
       );
 
       CREATE TRIGGER IF NOT EXISTS hub_skills_ai AFTER INSERT ON hub_skills BEGIN
@@ -813,7 +937,7 @@ class SqliteStore {
         content,
         content='hub_memories',
         content_rowid='rowid',
-        tokenize='porter unicode61'
+        tokenize='trigram'
       );
 
       CREATE TRIGGER IF NOT EXISTS hub_memories_ai AFTER INSERT ON hub_memories BEGIN
@@ -833,6 +957,31 @@ class SqliteStore {
         VALUES (new.rowid, new.summary, new.content);
       END;
     `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS hub_notifications (
+        id          TEXT PRIMARY KEY,
+        user_id     TEXT NOT NULL,
+        type        TEXT NOT NULL,
+        resource    TEXT NOT NULL,
+        title       TEXT NOT NULL,
+        message     TEXT NOT NULL DEFAULT '',
+        read        INTEGER NOT NULL DEFAULT 0,
+        created_at  INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_hub_notif_user ON hub_notifications(user_id, read, created_at DESC);
+    `);
+        try {
+            const cols = this.db.prepare("PRAGMA table_info(hub_users)").all();
+            if (cols.length > 0 && !cols.some(c => c.name === "last_ip")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN last_ip TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added last_ip column to hub_users");
+            }
+            if (cols.length > 0 && !cols.some(c => c.name === "last_active_at")) {
+                this.db.exec("ALTER TABLE hub_users ADD COLUMN last_active_at INTEGER");
+                this.log.info("Migrated: added last_active_at column to hub_users");
+            }
+        }
+        catch { /* table may not exist yet */ }
     }
     // ─── Write ───
     insertChunk(chunk) {
@@ -959,6 +1108,30 @@ class SqliteStore {
             return [];
         }
     }
+    hubMemoryPatternSearch(patterns, opts = {}) {
+        if (patterns.length === 0)
+            return [];
+        const limit = opts.limit ?? 10;
+        const conditions = patterns.map(() => "(hm.content LIKE ? OR hm.summary LIKE ?)");
+        const params = [];
+        for (const p of patterns) {
+            params.push(`%${p}%`, `%${p}%`);
+        }
+        params.push(limit);
+        try {
+            const rows = this.db.prepare(`
+        SELECT hm.id as memory_id, hm.content, hm.role, hm.created_at
+        FROM hub_memories hm
+        WHERE ${conditions.join(" OR ")}
+        ORDER BY hm.created_at DESC
+        LIMIT ?
+      `).all(...params);
+            return rows.map(r => ({ memoryId: r.memory_id, content: r.content, role: r.role, createdAt: r.created_at }));
+        }
+        catch {
+            return [];
+        }
+    }
     // ─── Vector Search ───
     getAllEmbeddings(ownerFilter) {
         let sql = `SELECT e.chunk_id, e.vector, e.dimensions FROM embeddings e
@@ -1097,6 +1270,9 @@ class SqliteStore {
             "skill_embeddings",
             "skill_versions",
             "skills",
+            "local_shared_memories",
+            "team_shared_chunks",
+            "local_shared_tasks",
             "embeddings",
             "chunks",
             "tasks",
@@ -1208,8 +1384,8 @@ class SqliteStore {
             params.push(opts.status);
         }
         if (opts.owner) {
-            conditions.push("owner = ?");
-            params.push(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);
         }
         const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
         const countRow = this.db.prepare(`SELECT COUNT(*) as c FROM tasks ${whereClause}`).get(...params);
@@ -1475,16 +1651,18 @@ class SqliteStore {
     // ─── Hub / Client connection ───
     setClientHubConnection(conn) {
         this.db.prepare(`
-      INSERT INTO client_hub_connection (id, hub_url, user_id, username, user_token, role, connected_at)
-      VALUES (1, ?, ?, ?, ?, ?, ?)
+      INSERT INTO client_hub_connection (id, hub_url, user_id, username, user_token, role, connected_at, identity_key, last_known_status)
+      VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         hub_url = excluded.hub_url,
         user_id = excluded.user_id,
         username = excluded.username,
         user_token = excluded.user_token,
         role = excluded.role,
-        connected_at = excluded.connected_at
-    `).run(conn.hubUrl, conn.userId, conn.username, conn.userToken, conn.role, conn.connectedAt);
+        connected_at = excluded.connected_at,
+        identity_key = excluded.identity_key,
+        last_known_status = excluded.last_known_status
+    `).run(conn.hubUrl, conn.userId, conn.username, conn.userToken, conn.role, conn.connectedAt, conn.identityKey ?? "", conn.lastKnownStatus ?? "");
     }
     getClientHubConnection() {
         const row = this.db.prepare('SELECT * FROM client_hub_connection WHERE id = 1').get();
@@ -1519,11 +1697,66 @@ class SqliteStore {
         const rows = this.db.prepare('SELECT task_id, hub_task_id, visibility, group_id, synced_chunks FROM local_shared_tasks').all();
         return rows.map(r => ({ taskId: r.task_id, hubTaskId: r.hub_task_id, visibility: r.visibility, groupId: r.group_id, syncedChunks: r.synced_chunks }));
     }
+    // ─── Local Shared Memories (client-side tracking) ───
+    markMemorySharedLocally(chunkId) {
+        const chunk = this.getChunk(chunkId);
+        if (!chunk)
+            return { ok: false, reason: "not_found" };
+        if (chunk.owner === "public") {
+            const existing = this.getLocalSharedMemory(chunkId);
+            return {
+                ok: true,
+                owner: "public",
+                originalOwner: existing?.originalOwner ?? undefined,
+                sharedAt: existing?.sharedAt ?? undefined,
+            };
+        }
+        const sharedAt = Date.now();
+        this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO local_shared_memories (chunk_id, original_owner, shared_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(chunk_id) DO UPDATE SET
+          original_owner = excluded.original_owner,
+          shared_at = excluded.shared_at
+      `).run(chunkId, chunk.owner, sharedAt);
+            this.updateChunk(chunkId, { owner: "public" });
+        })();
+        return { ok: true, owner: "public", originalOwner: chunk.owner, sharedAt };
+    }
+    unmarkMemorySharedLocally(chunkId, fallbackOwner) {
+        const chunk = this.getChunk(chunkId);
+        if (!chunk)
+            return { ok: false, reason: "not_found" };
+        if (chunk.owner !== "public") {
+            return { ok: true, owner: chunk.owner };
+        }
+        const existing = this.getLocalSharedMemory(chunkId);
+        const restoreOwner = existing?.originalOwner ?? fallbackOwner;
+        if (!restoreOwner || restoreOwner === "public") {
+            return { ok: false, reason: "original_owner_missing" };
+        }
+        this.db.transaction(() => {
+            this.updateChunk(chunkId, { owner: restoreOwner });
+            this.db.prepare("DELETE FROM local_shared_memories WHERE chunk_id = ?").run(chunkId);
+        })();
+        return { ok: true, owner: restoreOwner, originalOwner: restoreOwner };
+    }
+    getLocalSharedMemory(chunkId) {
+        const row = this.db.prepare("SELECT chunk_id, original_owner, shared_at FROM local_shared_memories WHERE chunk_id = ?").get(chunkId);
+        if (!row)
+            return null;
+        return {
+            chunkId: row.chunk_id,
+            originalOwner: row.original_owner,
+            sharedAt: row.shared_at,
+        };
+    }
     // ─── Hub Users / Groups ───
     upsertHubUser(user) {
         this.db.prepare(`
-      INSERT INTO hub_users (id, username, device_name, role, status, token_hash, created_at, approved_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO hub_users (id, username, device_name, role, status, token_hash, created_at, approved_at, identity_key, left_at, removed_at, rejected_at, rejoin_requested_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         username = excluded.username,
         device_name = excluded.device_name,
@@ -1531,72 +1764,101 @@ class SqliteStore {
         status = excluded.status,
         token_hash = excluded.token_hash,
         created_at = excluded.created_at,
-        approved_at = excluded.approved_at
-    `).run(user.id, user.username, user.deviceName ?? "", user.role, user.status, user.tokenHash, user.createdAt, user.approvedAt);
+        approved_at = excluded.approved_at,
+        identity_key = excluded.identity_key,
+        left_at = excluded.left_at,
+        removed_at = excluded.removed_at,
+        rejected_at = excluded.rejected_at,
+        rejoin_requested_at = excluded.rejoin_requested_at
+    `).run(user.id, user.username, user.deviceName ?? "", user.role, user.status, user.tokenHash, user.createdAt, user.approvedAt, user.identityKey ?? "", user.leftAt ?? null, user.removedAt ?? null, user.rejectedAt ?? null, user.rejoinRequestedAt ?? null);
     }
     getHubUser(userId) {
         const row = this.db.prepare('SELECT * FROM hub_users WHERE id = ?').get(userId);
         if (!row)
             return null;
-        return this.attachGroupsToHubUser(rowToHubUser(row));
+        const user = rowToHubUser(row);
+        user.groups = this.getGroupsForHubUser(userId);
+        return user;
     }
     listHubUsers(status) {
         const rows = status
             ? this.db.prepare('SELECT * FROM hub_users WHERE status = ? ORDER BY created_at').all(status)
             : this.db.prepare('SELECT * FROM hub_users ORDER BY created_at').all();
-        return rows.map((row) => this.attachGroupsToHubUser(rowToHubUser(row)));
+        return rows.map(r => {
+            const user = rowToHubUser(r);
+            user.groups = this.getGroupsForHubUser(r.id);
+            return user;
+        });
+    }
+    deleteHubUser(userId, cleanResources = false) {
+        if (cleanResources) {
+            this.db.prepare('DELETE FROM hub_tasks WHERE source_user_id = ?').run(userId);
+            this.db.prepare('DELETE FROM hub_skills WHERE source_user_id = ?').run(userId);
+            this.db.prepare('DELETE FROM hub_memories WHERE source_user_id = ?').run(userId);
+            const result = this.db.prepare('DELETE FROM hub_users WHERE id = ?').run(userId);
+            return result.changes > 0;
+        }
+        const result = this.db.prepare("UPDATE hub_users SET status = 'removed', token_hash = '', removed_at = ? WHERE id = ?").run(Date.now(), userId);
+        return result.changes > 0;
     }
+    findHubUserByIdentityKey(identityKey) {
+        if (!identityKey)
+            return null;
+        const row = this.db.prepare('SELECT * FROM hub_users WHERE identity_key = ?').get(identityKey);
+        return row ? rowToHubUser(row) : null;
+    }
+    markHubUserLeft(userId) {
+        const result = this.db.prepare("UPDATE hub_users SET status = 'left', token_hash = '', left_at = ? WHERE id = ?").run(Date.now(), userId);
+        return result.changes > 0;
+    }
+    updateHubUserActivity(userId, ip, timestamp) {
+        this.db.prepare('UPDATE hub_users SET last_ip = ?, last_active_at = ? WHERE id = ?').run(ip, timestamp ?? Date.now(), userId);
+    }
+    // ─── Hub Groups ───
     upsertHubGroup(group) {
         this.db.prepare(`
       INSERT INTO hub_groups (id, name, description, created_at)
       VALUES (?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        name = excluded.name,
-        description = excluded.description,
-        created_at = excluded.created_at
-    `).run(group.id, group.name, group.description, group.createdAt);
-    }
-    listHubGroups() {
-        const rows = this.db.prepare('SELECT * FROM hub_groups ORDER BY name').all();
-        return rows.map(rowToHubGroup);
+      ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description
+    `).run(group.id, group.name, group.description ?? "", group.createdAt);
     }
-    addHubGroupMember(groupId, userId, joinedAt = Date.now()) {
+    addHubGroupMember(groupId, userId, joinedAt) {
         this.db.prepare(`
-      INSERT INTO hub_group_members (group_id, user_id, joined_at)
+      INSERT OR IGNORE INTO hub_group_members (group_id, user_id, joined_at)
       VALUES (?, ?, ?)
-      ON CONFLICT(group_id, user_id) DO UPDATE SET joined_at = excluded.joined_at
     `).run(groupId, userId, joinedAt);
     }
-    getHubGroupById(groupId) {
-        const row = this.db.prepare('SELECT * FROM hub_groups WHERE id = ?').get(groupId);
-        return row ? rowToHubGroup(row) : undefined;
-    }
-    deleteHubGroup(groupId) {
-        const result = this.db.prepare('DELETE FROM hub_groups WHERE id = ?').run(groupId);
-        return result.changes > 0;
-    }
-    listHubGroupMembers(groupId) {
-        const rows = this.db.prepare(`
-      SELECT gm.user_id, hu.username, gm.joined_at
-      FROM hub_group_members gm
-      JOIN hub_users hu ON hu.id = gm.user_id
-      WHERE gm.group_id = ?
-      ORDER BY gm.joined_at
-    `).all(groupId);
-        return rows.map(r => ({ userId: r.user_id, username: r.username, joinedAt: r.joined_at }));
-    }
     removeHubGroupMember(groupId, userId) {
         this.db.prepare('DELETE FROM hub_group_members WHERE group_id = ? AND user_id = ?').run(groupId, userId);
     }
     getGroupsForHubUser(userId) {
-        const rows = this.db.prepare(`
-      SELECT g.*
-      FROM hub_group_members gm
-      JOIN hub_groups g ON g.id = gm.group_id
-      WHERE gm.user_id = ?
-      ORDER BY g.name
+        return this.db.prepare(`
+      SELECT g.id, g.name, g.description FROM hub_groups g
+      JOIN hub_group_members m ON m.group_id = g.id
+      WHERE m.user_id = ?
     `).all(userId);
-        return rows.map((row) => ({ id: row.id, name: row.name, description: row.description || undefined }));
+    }
+    getHubUserContributions() {
+        const result = {};
+        const memRows = this.db.prepare('SELECT source_user_id, COUNT(*) as cnt FROM hub_memories GROUP BY source_user_id').all();
+        const taskRows = this.db.prepare('SELECT source_user_id, COUNT(*) as cnt FROM hub_tasks GROUP BY source_user_id').all();
+        const skillRows = this.db.prepare('SELECT source_user_id, COUNT(*) as cnt FROM hub_skills GROUP BY source_user_id').all();
+        for (const r of memRows) {
+            if (!result[r.source_user_id])
+                result[r.source_user_id] = { memoryCount: 0, taskCount: 0, skillCount: 0 };
+            result[r.source_user_id].memoryCount = r.cnt;
+        }
+        for (const r of taskRows) {
+            if (!result[r.source_user_id])
+                result[r.source_user_id] = { memoryCount: 0, taskCount: 0, skillCount: 0 };
+            result[r.source_user_id].taskCount = r.cnt;
+        }
+        for (const r of skillRows) {
+            if (!result[r.source_user_id])
+                result[r.source_user_id] = { memoryCount: 0, taskCount: 0, skillCount: 0 };
+            result[r.source_user_id].skillCount = r.cnt;
+        }
+        return result;
     }
     // ─── Hub Shared Data ───
     upsertHubTask(task) {
@@ -1616,6 +1878,10 @@ class SqliteStore {
         const row = this.db.prepare('SELECT * FROM hub_tasks WHERE source_user_id = ? AND source_task_id = ?').get(sourceUserId, sourceTaskId);
         return row ? rowToHubTask(row) : null;
     }
+    getHubTaskById(taskId) {
+        const row = this.db.prepare('SELECT * FROM hub_tasks WHERE id = ?').get(taskId);
+        return row ? rowToHubTask(row) : null;
+    }
     upsertHubChunk(chunk) {
         if (!chunk.sourceTaskId)
             throw new Error("sourceTaskId is required for hub chunk upserts");
@@ -1688,20 +1954,36 @@ class SqliteStore {
             out.push(row.vector.readFloatLE(i * 4));
         return out;
     }
+    getVisibleHubSkillEmbeddings() {
+        const rows = this.db.prepare(`
+      SELECT hse.skill_id, hse.vector, hse.dimensions
+      FROM hub_skill_embeddings hse
+      JOIN hub_skills hs ON hs.id = hse.skill_id
+    `).all();
+        return rows.map(r => ({
+            skillId: r.skill_id,
+            vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
+        }));
+    }
     searchHubChunks(query, options) {
         const limit = options?.maxResults ?? 10;
         const userId = options?.userId ?? "";
         const rows = this.db.prepare(`
-      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility, '' as group_name, hu.username as owner_name,
+      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility,
+             COALESCE(hg.name, '') as group_name, hu.username as owner_name,
              bm25(hub_chunks_fts) as rank
       FROM hub_chunks_fts f
       JOIN hub_chunks hc ON hc.rowid = f.rowid
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
       LEFT JOIN hub_users hu ON hu.id = ht.source_user_id
+      LEFT JOIN hub_groups hg ON hg.id = ht.group_id
       WHERE hub_chunks_fts MATCH ?
+        AND (ht.visibility = 'public'
+             OR ht.source_user_id = ?
+             OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?))
       ORDER BY rank
       LIMIT ?
-    `).all(sanitizeFtsQuery(query), limit);
+    `).all(sanitizeFtsQuery(query), userId, userId, limit);
         return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
     }
     upsertHubEmbedding(chunkId, vector) {
@@ -1724,7 +2006,10 @@ class SqliteStore {
       FROM hub_embeddings he
       JOIN hub_chunks hc ON hc.id = he.chunk_id
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
-    `).all();
+      WHERE ht.visibility = 'public'
+        OR ht.source_user_id = ?
+        OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?)
+    `).all(userId, userId);
         return rows.map(r => ({
             chunkId: r.chunk_id,
             vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
@@ -1732,14 +2017,19 @@ class SqliteStore {
     }
     getVisibleHubSearchHitByChunkId(chunkId, userId) {
         const row = this.db.prepare(`
-      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility, '' as group_name, hu.username as owner_name,
+      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility,
+             COALESCE(hg.name, '') as group_name, hu.username as owner_name,
              0 as rank
       FROM hub_chunks hc
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
       LEFT JOIN hub_users hu ON hu.id = ht.source_user_id
+      LEFT JOIN hub_groups hg ON hg.id = ht.group_id
       WHERE hc.id = ?
+        AND (ht.visibility = 'public'
+             OR ht.source_user_id = ?
+             OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?))
       LIMIT 1
-    `).get(chunkId);
+    `).get(chunkId, userId, userId);
         return row ?? null;
     }
     getHubChunkById(chunkId) {
@@ -1753,7 +2043,7 @@ class SqliteStore {
         let rows;
         if (sanitized) {
             rows = this.db.prepare(`
-        SELECT hs.id, hs.name, hs.description, hs.version, hs.visibility, '' AS group_name, hu.username AS owner_name, hs.quality_score,
+        SELECT hs.id, hs.name, hs.description, hs.version, hs.visibility, '' AS group_name, hu.username AS owner_name, hu.status AS owner_status, hs.quality_score,
                bm25(hub_skills_fts) as rank
         FROM hub_skills_fts f
         JOIN hub_skills hs ON hs.rowid = f.rowid
@@ -1765,7 +2055,7 @@ class SqliteStore {
         }
         else {
             rows = this.db.prepare(`
-        SELECT hs.id, hs.name, hs.description, hs.version, hs.visibility, '' AS group_name, hu.username AS owner_name, hs.quality_score,
+        SELECT hs.id, hs.name, hs.description, hs.version, hs.visibility, '' AS group_name, hu.username AS owner_name, hu.status AS owner_status, hs.quality_score,
                0 as rank
         FROM hub_skills hs
         LEFT JOIN hub_users hu ON hu.id = hs.source_user_id
@@ -1780,7 +2070,7 @@ class SqliteStore {
     }
     listVisibleHubTasks(userId, limit = 40) {
         const rows = this.db.prepare(`
-      SELECT t.*, u.username AS owner_name, NULL AS group_name,
+      SELECT t.*, u.username AS owner_name, u.status AS owner_status, NULL AS group_name,
         (SELECT COUNT(*) FROM hub_chunks c WHERE c.hub_task_id = t.id) AS chunk_count
       FROM hub_tasks t
       LEFT JOIN hub_users u ON u.id = t.source_user_id
@@ -1790,33 +2080,36 @@ class SqliteStore {
         return rows.map(r => ({
             id: r.id, sourceTaskId: r.source_task_id, sourceUserId: r.source_user_id,
             title: r.title, summary: r.summary, groupId: r.group_id, groupName: r.group_name ?? null,
-            visibility: r.visibility, ownerName: r.owner_name ?? "unknown", chunkCount: r.chunk_count ?? 0,
+            visibility: r.visibility, ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", chunkCount: r.chunk_count ?? 0,
             createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
     listAllHubTasks() {
         const rows = this.db.prepare(`
-      SELECT t.*, u.username AS owner_name, g.name AS group_name,
+      SELECT t.*, u.username AS owner_name, u.status AS owner_status,
         (SELECT COUNT(*) FROM hub_chunks c WHERE c.hub_task_id = t.id) AS chunk_count
       FROM hub_tasks t
       LEFT JOIN hub_users u ON u.id = t.source_user_id
-      LEFT JOIN hub_groups g ON g.id = t.group_id
       ORDER BY t.updated_at DESC
     `).all();
         return rows.map(r => ({
             id: r.id, sourceTaskId: r.source_task_id, sourceUserId: r.source_user_id,
-            title: r.title, summary: r.summary, groupId: r.group_id, groupName: r.group_name ?? null,
-            visibility: r.visibility, ownerName: r.owner_name ?? "unknown", chunkCount: r.chunk_count ?? 0,
+            title: r.title, summary: r.summary, groupId: r.group_id, groupName: null,
+            visibility: r.visibility, ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", chunkCount: r.chunk_count ?? 0,
             createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
+    listHubChunksByTaskId(hubTaskId) {
+        const rows = this.db.prepare('SELECT * FROM hub_chunks WHERE hub_task_id = ? ORDER BY created_at ASC').all(hubTaskId);
+        return rows.map(rowToHubChunk);
+    }
     deleteHubTaskById(taskId) {
         const info = this.db.prepare('DELETE FROM hub_tasks WHERE id = ?').run(taskId);
         return info.changes > 0;
     }
     listVisibleHubSkills(userId, limit = 40) {
         const rows = this.db.prepare(`
-      SELECT s.*, u.username AS owner_name, NULL AS group_name
+      SELECT s.*, u.username AS owner_name, u.status AS owner_status, NULL AS group_name
       FROM hub_skills s
       LEFT JOIN hub_users u ON u.id = s.source_user_id
       ORDER BY s.updated_at DESC
@@ -1826,23 +2119,22 @@ class SqliteStore {
             id: r.id, sourceSkillId: r.source_skill_id, sourceUserId: r.source_user_id,
             name: r.name, description: r.description, version: r.version,
             groupId: r.group_id, groupName: r.group_name ?? null, visibility: r.visibility,
-            ownerName: r.owner_name ?? "unknown", qualityScore: r.quality_score,
+            ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", qualityScore: r.quality_score,
             createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
     listAllHubSkills() {
         const rows = this.db.prepare(`
-      SELECT s.*, u.username AS owner_name, g.name AS group_name
+      SELECT s.*, u.username AS owner_name, u.status AS owner_status
       FROM hub_skills s
       LEFT JOIN hub_users u ON u.id = s.source_user_id
-      LEFT JOIN hub_groups g ON g.id = s.group_id
       ORDER BY s.updated_at DESC
     `).all();
         return rows.map(r => ({
             id: r.id, sourceSkillId: r.source_skill_id, sourceUserId: r.source_user_id,
             name: r.name, description: r.description, version: r.version,
-            groupId: r.group_id, groupName: r.group_name ?? null, visibility: r.visibility,
-            ownerName: r.owner_name ?? "unknown", qualityScore: r.quality_score,
+            groupId: r.group_id, groupName: null, visibility: r.visibility,
+            ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", qualityScore: r.quality_score,
             createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
@@ -1881,6 +2173,68 @@ class SqliteStore {
         const info = this.db.prepare('DELETE FROM hub_memories WHERE id = ?').run(memoryId);
         return info.changes > 0;
     }
+    // ─── Team share metadata (Client role — UI only, not used for local recall / FTS) ───
+    upsertTeamSharedChunk(chunkId, row) {
+        const now = Date.now();
+        const vis = row.visibility === "group" ? "group" : "public";
+        const gid = vis === "group" ? (row.groupId ?? null) : null;
+        this.db.prepare(`
+      INSERT INTO team_shared_chunks (chunk_id, hub_memory_id, visibility, group_id, shared_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET
+        hub_memory_id = excluded.hub_memory_id,
+        visibility = excluded.visibility,
+        group_id = excluded.group_id,
+        shared_at = excluded.shared_at
+    `).run(chunkId, row.hubMemoryId ?? "", vis, gid, now);
+    }
+    getTeamSharedChunk(chunkId) {
+        const r = this.db.prepare("SELECT chunk_id, hub_memory_id, visibility, group_id, shared_at FROM team_shared_chunks WHERE chunk_id = ?").get(chunkId);
+        if (!r)
+            return null;
+        return {
+            chunkId: r.chunk_id,
+            hubMemoryId: r.hub_memory_id,
+            visibility: r.visibility,
+            groupId: r.group_id,
+            sharedAt: r.shared_at,
+        };
+    }
+    deleteTeamSharedChunk(chunkId) {
+        const info = this.db.prepare("DELETE FROM team_shared_chunks WHERE chunk_id = ?").run(chunkId);
+        return info.changes > 0;
+    }
+    // ─── Hub Notifications ───
+    insertHubNotification(n) {
+        this.db.prepare('INSERT INTO hub_notifications (id, user_id, type, resource, title, message, read, created_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?)').run(n.id, n.userId, n.type, n.resource, n.title, n.message ?? '', Date.now());
+    }
+    hasRecentHubNotification(userId, type, resource, windowMs = 300_000) {
+        const since = Date.now() - windowMs;
+        const row = this.db.prepare('SELECT COUNT(*) AS cnt FROM hub_notifications WHERE user_id = ? AND type = ? AND resource = ? AND created_at > ?').get(userId, type, resource, since);
+        return row.cnt > 0;
+    }
+    listHubNotifications(userId, opts) {
+        const where = opts?.unreadOnly ? 'WHERE user_id = ? AND read = 0' : 'WHERE user_id = ?';
+        const limit = opts?.limit ?? 50;
+        const rows = this.db.prepare(`SELECT * FROM hub_notifications ${where} ORDER BY created_at DESC LIMIT ?`).all(userId, limit);
+        return rows.map(r => ({ id: r.id, userId: r.user_id, type: r.type, resource: r.resource, title: r.title, message: r.message, read: !!r.read, createdAt: r.created_at }));
+    }
+    countUnreadHubNotifications(userId) {
+        const row = this.db.prepare('SELECT COUNT(*) AS cnt FROM hub_notifications WHERE user_id = ? AND read = 0').get(userId);
+        return row.cnt;
+    }
+    markHubNotificationsRead(userId, ids) {
+        if (ids && ids.length > 0) {
+            const placeholders = ids.map(() => '?').join(',');
+            this.db.prepare(`UPDATE hub_notifications SET read = 1 WHERE user_id = ? AND id IN (${placeholders})`).run(userId, ...ids);
+        }
+        else {
+            this.db.prepare('UPDATE hub_notifications SET read = 1 WHERE user_id = ?').run(userId);
+        }
+    }
+    clearHubNotifications(userId) {
+        this.db.prepare('DELETE FROM hub_notifications WHERE user_id = ?').run(userId);
+    }
     upsertHubMemoryEmbedding(memoryId, vector) {
         const buf = Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
         this.db.prepare(`
@@ -1937,7 +2291,7 @@ class SqliteStore {
     }
     listVisibleHubMemories(userId, limit = 40) {
         const rows = this.db.prepare(`
-      SELECT m.*, u.username AS owner_name, NULL AS group_name
+      SELECT m.*, u.username AS owner_name, u.status AS owner_status, NULL AS group_name
       FROM hub_memories m
       LEFT JOIN hub_users u ON u.id = m.source_user_id
       ORDER BY m.updated_at DESC
@@ -1945,24 +2299,23 @@ class SqliteStore {
     `).all(limit);
         return rows.map(r => ({
             id: r.id, sourceChunkId: r.source_chunk_id, sourceUserId: r.source_user_id,
-            role: r.role, summary: r.summary, kind: r.kind,
+            role: r.role, content: r.content ?? "", summary: r.summary, kind: r.kind,
             groupId: r.group_id, groupName: r.group_name ?? null, visibility: r.visibility,
-            ownerName: r.owner_name ?? "unknown", createdAt: r.created_at, updatedAt: r.updated_at,
+            ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
     listAllHubMemories() {
         const rows = this.db.prepare(`
-      SELECT m.*, u.username AS owner_name, g.name AS group_name
+      SELECT m.*, u.username AS owner_name, u.status AS owner_status
       FROM hub_memories m
       LEFT JOIN hub_users u ON u.id = m.source_user_id
-      LEFT JOIN hub_groups g ON g.id = m.group_id
       ORDER BY m.updated_at DESC
     `).all();
         return rows.map(r => ({
             id: r.id, sourceChunkId: r.source_chunk_id, sourceUserId: r.source_user_id,
-            role: r.role, summary: r.summary, kind: r.kind,
-            groupId: r.group_id, groupName: r.group_name ?? null, visibility: r.visibility,
-            ownerName: r.owner_name ?? "unknown", createdAt: r.created_at, updatedAt: r.updated_at,
+            role: r.role, content: r.content ?? "", summary: r.summary, kind: r.kind,
+            groupId: r.group_id, groupName: null, visibility: r.visibility,
+            ownerName: r.owner_name ?? "unknown", ownerStatus: r.owner_status ?? "", createdAt: r.created_at, updatedAt: r.updated_at,
         }));
     }
     resolveCanonicalHubTaskId(taskId, sourceUserId, sourceTaskId) {
@@ -1987,12 +2340,6 @@ class SqliteStore {
         }
         throw new Error(`source skill not found for skillId=${skillId}`);
     }
-    attachGroupsToHubUser(user) {
-        return {
-            ...user,
-            groups: this.getGroupsForHubUser(user.id),
-        };
-    }
     getSessionOwnerMap(sessionKeys) {
         const result = new Map();
         if (sessionKeys.length === 0)
@@ -2102,6 +2449,8 @@ function rowToClientHubConnection(row) {
         userToken: row.user_token,
         role: row.role,
         connectedAt: row.connected_at,
+        identityKey: row.identity_key || "",
+        lastKnownStatus: row.last_known_status || "",
     };
 }
 function rowToHubUser(row) {
@@ -2115,14 +2464,13 @@ function rowToHubUser(row) {
         tokenHash: row.token_hash,
         createdAt: row.created_at,
         approvedAt: row.approved_at,
-    };
-}
-function rowToHubGroup(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        description: row.description,
-        createdAt: row.created_at,
+        lastIp: row.last_ip || "",
+        lastActiveAt: row.last_active_at ?? null,
+        identityKey: row.identity_key || "",
+        leftAt: row.left_at ?? null,
+        removedAt: row.removed_at ?? null,
+        rejectedAt: row.rejected_at ?? null,
+        rejoinRequestedAt: row.rejoin_requested_at ?? null,
     };
 }
 function rowToHubTask(row) {