@memtensor/memos-local-openclaw-plugin 1.0.4-beta.6 → 1.0.4-beta.7

package/dist/storage/sqlite.js

@@ -145,11 +145,23 @@ class SqliteStore {
         this.migrateSkillVisibility();
         this.migrateSkillEmbeddingsAndFts();
         this.migrateFtsToTrigram();
+        this.migrateHubTables();
+        this.migrateLocalSharedTasksOwner();
         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 */ }
+    }
     migrateOwnerFields() {
         const chunkCols = this.db.prepare("PRAGMA table_info(chunks)").all();
         if (!chunkCols.some((c) => c.name === "owner")) {
@@ -502,15 +514,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();
@@ -622,6 +635,235 @@ class SqliteStore {
             },
         };
     }
+    migrateHubTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS client_hub_connection (
+        id           INTEGER PRIMARY KEY CHECK (id = 1),
+        hub_url      TEXT NOT NULL,
+        user_id      TEXT NOT NULL,
+        username     TEXT NOT NULL,
+        user_token   TEXT NOT NULL,
+        role         TEXT NOT NULL,
+        connected_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS local_shared_tasks (
+        task_id       TEXT PRIMARY KEY,
+        hub_task_id   TEXT NOT NULL,
+        visibility    TEXT NOT NULL DEFAULT 'public',
+        group_id      TEXT,
+        synced_chunks INTEGER NOT NULL DEFAULT 0,
+        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
+      );
+
+      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,
+        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_tasks (
+        id             TEXT PRIMARY KEY,
+        source_task_id TEXT NOT NULL,
+        source_user_id TEXT NOT NULL,
+        title          TEXT NOT NULL,
+        summary        TEXT NOT NULL DEFAULT '',
+        group_id       TEXT,
+        visibility     TEXT NOT NULL,
+        created_at     INTEGER NOT NULL,
+        updated_at     INTEGER NOT NULL,
+        UNIQUE(source_user_id, source_task_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_hub_tasks_visibility ON hub_tasks(visibility);
+      CREATE INDEX IF NOT EXISTS idx_hub_tasks_group ON hub_tasks(group_id);
+
+      CREATE TABLE IF NOT EXISTS hub_chunks (
+        id              TEXT PRIMARY KEY,
+        hub_task_id     TEXT NOT NULL REFERENCES hub_tasks(id) ON DELETE CASCADE,
+        source_chunk_id TEXT NOT NULL,
+        source_user_id  TEXT NOT NULL,
+        role            TEXT NOT NULL,
+        content         TEXT NOT NULL,
+        summary         TEXT NOT NULL DEFAULT '',
+        kind            TEXT NOT NULL DEFAULT 'paragraph',
+        created_at      INTEGER NOT NULL,
+        UNIQUE(source_user_id, source_chunk_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_hub_chunks_task ON hub_chunks(hub_task_id);
+
+      CREATE TABLE IF NOT EXISTS hub_embeddings (
+        chunk_id    TEXT PRIMARY KEY REFERENCES hub_chunks(id) ON DELETE CASCADE,
+        vector      BLOB NOT NULL,
+        dimensions  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS hub_chunks_fts USING fts5(
+        summary,
+        content,
+        content='hub_chunks',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS hub_chunks_ai AFTER INSERT ON hub_chunks BEGIN
+        INSERT INTO hub_chunks_fts(rowid, summary, content)
+        VALUES (new.rowid, new.summary, new.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_chunks_ad AFTER DELETE ON hub_chunks BEGIN
+        INSERT INTO hub_chunks_fts(hub_chunks_fts, rowid, summary, content)
+        VALUES ('delete', old.rowid, old.summary, old.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_chunks_au AFTER UPDATE ON hub_chunks BEGIN
+        INSERT INTO hub_chunks_fts(hub_chunks_fts, rowid, summary, content)
+        VALUES ('delete', old.rowid, old.summary, old.content);
+        INSERT INTO hub_chunks_fts(rowid, summary, content)
+        VALUES (new.rowid, new.summary, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS hub_skills (
+        id              TEXT PRIMARY KEY,
+        source_skill_id TEXT NOT NULL,
+        source_user_id  TEXT NOT NULL,
+        name            TEXT NOT NULL,
+        description     TEXT NOT NULL DEFAULT '',
+        version         INTEGER NOT NULL,
+        group_id        TEXT,
+        visibility      TEXT NOT NULL,
+        bundle          TEXT NOT NULL,
+        quality_score   REAL,
+        created_at      INTEGER NOT NULL,
+        updated_at      INTEGER NOT NULL,
+        UNIQUE(source_user_id, source_skill_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_hub_skills_visibility ON hub_skills(visibility);
+      CREATE INDEX IF NOT EXISTS idx_hub_skills_group ON hub_skills(group_id);
+
+      CREATE TABLE IF NOT EXISTS hub_skill_embeddings (
+        skill_id     TEXT PRIMARY KEY REFERENCES hub_skills(id) ON DELETE CASCADE,
+        vector       BLOB NOT NULL,
+        dimensions   INTEGER NOT NULL,
+        updated_at   INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS hub_skills_fts USING fts5(
+        name,
+        description,
+        content='hub_skills',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS hub_skills_ai AFTER INSERT ON hub_skills BEGIN
+        INSERT INTO hub_skills_fts(rowid, name, description)
+        VALUES (new.rowid, new.name, new.description);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_skills_ad AFTER DELETE ON hub_skills BEGIN
+        INSERT INTO hub_skills_fts(hub_skills_fts, rowid, name, description)
+        VALUES ('delete', old.rowid, old.name, old.description);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_skills_au AFTER UPDATE ON hub_skills BEGIN
+        INSERT INTO hub_skills_fts(hub_skills_fts, rowid, name, description)
+        VALUES ('delete', old.rowid, old.name, old.description);
+        INSERT INTO hub_skills_fts(rowid, name, description)
+        VALUES (new.rowid, new.name, new.description);
+      END;
+
+      -- Independent shared memories (not tied to a task)
+      CREATE TABLE IF NOT EXISTS hub_memories (
+        id              TEXT PRIMARY KEY,
+        source_chunk_id TEXT NOT NULL,
+        source_user_id  TEXT NOT NULL,
+        role            TEXT NOT NULL,
+        content         TEXT NOT NULL,
+        summary         TEXT NOT NULL DEFAULT '',
+        kind            TEXT NOT NULL DEFAULT 'paragraph',
+        group_id        TEXT,
+        visibility      TEXT NOT NULL,
+        created_at      INTEGER NOT NULL,
+        updated_at      INTEGER NOT NULL,
+        UNIQUE(source_user_id, source_chunk_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_hub_memories_visibility ON hub_memories(visibility);
+      CREATE INDEX IF NOT EXISTS idx_hub_memories_group ON hub_memories(group_id);
+
+      CREATE TABLE IF NOT EXISTS hub_memory_embeddings (
+        memory_id    TEXT PRIMARY KEY REFERENCES hub_memories(id) ON DELETE CASCADE,
+        vector       BLOB NOT NULL,
+        dimensions   INTEGER NOT NULL,
+        updated_at   INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS hub_memories_fts USING fts5(
+        summary,
+        content,
+        content='hub_memories',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS hub_memories_ai AFTER INSERT ON hub_memories BEGIN
+        INSERT INTO hub_memories_fts(rowid, summary, content)
+        VALUES (new.rowid, new.summary, new.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_memories_ad AFTER DELETE ON hub_memories BEGIN
+        INSERT INTO hub_memories_fts(hub_memories_fts, rowid, summary, content)
+        VALUES ('delete', old.rowid, old.summary, old.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS hub_memories_au AFTER UPDATE ON hub_memories BEGIN
+        INSERT INTO hub_memories_fts(hub_memories_fts, rowid, summary, content)
+        VALUES ('delete', old.rowid, old.summary, old.content);
+        INSERT INTO hub_memories_fts(rowid, summary, content)
+        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) {
         const stmt = this.db.prepare(`
@@ -885,6 +1127,8 @@ class SqliteStore {
             "skill_embeddings",
             "skill_versions",
             "skills",
+            "local_shared_memories",
+            "local_shared_tasks",
             "embeddings",
             "chunks",
             "tasks",
@@ -1260,6 +1504,585 @@ class SqliteStore {
         return this.db.prepare("SELECT DISTINCT session_key FROM chunks ORDER BY session_key").all()
             .map(r => r.session_key);
     }
+    // ─── 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, ?, ?, ?, ?, ?, ?)
+      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);
+    }
+    getClientHubConnection() {
+        const row = this.db.prepare('SELECT * FROM client_hub_connection WHERE id = 1').get();
+        return row ? rowToClientHubConnection(row) : null;
+    }
+    clearClientHubConnection() {
+        this.db.prepare('DELETE FROM client_hub_connection WHERE id = 1').run();
+    }
+    // ─── Local Shared Tasks (client-side tracking) ───
+    markTaskShared(taskId, hubTaskId, syncedChunks, visibility, groupId) {
+        this.db.prepare(`
+      INSERT INTO local_shared_tasks (task_id, hub_task_id, visibility, group_id, synced_chunks, shared_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(task_id) DO UPDATE SET
+        hub_task_id = excluded.hub_task_id,
+        visibility = excluded.visibility,
+        group_id = excluded.group_id,
+        synced_chunks = excluded.synced_chunks,
+        shared_at = excluded.shared_at
+    `).run(taskId, hubTaskId, visibility, groupId ?? null, syncedChunks, Date.now());
+    }
+    unmarkTaskShared(taskId) {
+        this.db.prepare('DELETE FROM local_shared_tasks WHERE task_id = ?').run(taskId);
+    }
+    getLocalSharedTask(taskId) {
+        const row = this.db.prepare('SELECT * FROM local_shared_tasks WHERE task_id = ?').get(taskId);
+        if (!row)
+            return null;
+        return { taskId: row.task_id, hubTaskId: row.hub_task_id, visibility: row.visibility, groupId: row.group_id, syncedChunks: row.synced_chunks, sharedAt: row.shared_at };
+    }
+    listLocalSharedTasks() {
+        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 (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        username = excluded.username,
+        device_name = excluded.device_name,
+        role = excluded.role,
+        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);
+    }
+    getHubUser(userId) {
+        const row = this.db.prepare('SELECT * FROM hub_users WHERE id = ?').get(userId);
+        if (!row)
+            return null;
+        return rowToHubUser(row);
+    }
+    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(rowToHubUser);
+    }
+    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;
+    }
+    updateHubUserActivity(userId, ip) {
+        this.db.prepare('UPDATE hub_users SET last_ip = ?, last_active_at = ? WHERE id = ?').run(ip, Date.now(), userId);
+    }
+    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) {
+        this.db.prepare(`
+      INSERT INTO hub_tasks (id, source_task_id, source_user_id, title, summary, group_id, visibility, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_user_id, source_task_id) DO UPDATE SET
+        title = excluded.title,
+        summary = excluded.summary,
+        group_id = excluded.group_id,
+        visibility = excluded.visibility,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at
+    `).run(task.id, task.sourceTaskId, task.sourceUserId, task.title, task.summary, task.groupId, task.visibility, task.createdAt, task.updatedAt);
+    }
+    getHubTaskBySource(sourceUserId, sourceTaskId) {
+        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");
+        const taskId = this.resolveCanonicalHubTaskId(chunk.hubTaskId, chunk.sourceUserId, chunk.sourceTaskId);
+        this.db.prepare(`
+      INSERT INTO hub_chunks (id, hub_task_id, source_chunk_id, source_user_id, role, content, summary, kind, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_user_id, source_chunk_id) DO UPDATE SET
+        hub_task_id = excluded.hub_task_id,
+        role = excluded.role,
+        content = excluded.content,
+        summary = excluded.summary,
+        kind = excluded.kind,
+        created_at = excluded.created_at
+    `).run(chunk.id, taskId, chunk.sourceChunkId, chunk.sourceUserId, chunk.role, chunk.content, chunk.summary, chunk.kind, chunk.createdAt);
+    }
+    getHubChunkBySource(sourceUserId, sourceChunkId) {
+        const row = this.db.prepare('SELECT * FROM hub_chunks WHERE source_user_id = ? AND source_chunk_id = ?').get(sourceUserId, sourceChunkId);
+        return row ? rowToHubChunk(row) : null;
+    }
+    deleteHubTaskBySource(sourceUserId, sourceTaskId) {
+        this.db.prepare('DELETE FROM hub_tasks WHERE source_user_id = ? AND source_task_id = ?').run(sourceUserId, sourceTaskId);
+    }
+    upsertHubSkill(skill) {
+        this.db.prepare(`
+      INSERT INTO hub_skills (id, source_skill_id, source_user_id, name, description, version, group_id, visibility, bundle, quality_score, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_user_id, source_skill_id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        version = excluded.version,
+        group_id = excluded.group_id,
+        visibility = excluded.visibility,
+        bundle = excluded.bundle,
+        quality_score = excluded.quality_score,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at
+    `).run(skill.id, skill.sourceSkillId, skill.sourceUserId, skill.name, skill.description, skill.version, skill.groupId, skill.visibility, skill.bundle, skill.qualityScore, skill.createdAt, skill.updatedAt);
+    }
+    getHubSkillBySource(sourceUserId, sourceSkillId) {
+        const row = this.db.prepare('SELECT * FROM hub_skills WHERE source_user_id = ? AND source_skill_id = ?').get(sourceUserId, sourceSkillId);
+        return row ? rowToHubSkill(row) : null;
+    }
+    getHubSkillById(skillId) {
+        const row = this.db.prepare('SELECT * FROM hub_skills WHERE id = ?').get(skillId);
+        return row ? rowToHubSkill(row) : null;
+    }
+    upsertHubSkillEmbedding(skillId, vector, sourceUserId, sourceSkillId) {
+        if (!sourceUserId || !sourceSkillId)
+            throw new Error("sourceUserId and sourceSkillId are required for hub skill embedding upserts");
+        const canonicalSkillId = this.resolveCanonicalHubSkillId(skillId, sourceUserId, sourceSkillId);
+        const buf = Buffer.allocUnsafe(vector.length * 4);
+        for (let i = 0; i < vector.length; i++)
+            buf.writeFloatLE(vector[i], i * 4);
+        this.db.prepare(`
+      INSERT INTO hub_skill_embeddings (skill_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(skill_id) DO UPDATE SET
+        vector = excluded.vector,
+        dimensions = excluded.dimensions,
+        updated_at = excluded.updated_at
+    `).run(canonicalSkillId, buf, vector.length, Date.now());
+    }
+    getHubSkillEmbedding(skillId) {
+        const row = this.db.prepare('SELECT vector, dimensions FROM hub_skill_embeddings WHERE skill_id = ?').get(skillId);
+        if (!row)
+            return null;
+        const out = [];
+        for (let i = 0; i < row.dimensions; i++)
+            out.push(row.vector.readFloatLE(i * 4));
+        return out;
+    }
+    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,
+             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
+      WHERE hub_chunks_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(sanitizeFtsQuery(query), limit);
+        return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
+    }
+    upsertHubEmbedding(chunkId, vector) {
+        const buf = Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+        this.db.prepare(`
+      INSERT INTO hub_embeddings (chunk_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET vector = excluded.vector, dimensions = excluded.dimensions, updated_at = excluded.updated_at
+    `).run(chunkId, buf, vector.length, Date.now());
+    }
+    getHubEmbedding(chunkId) {
+        const row = this.db.prepare('SELECT vector, dimensions FROM hub_embeddings WHERE chunk_id = ?').get(chunkId);
+        if (!row)
+            return null;
+        return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions);
+    }
+    getVisibleHubEmbeddings(userId) {
+        const rows = this.db.prepare(`
+      SELECT he.chunk_id, he.vector, he.dimensions
+      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();
+        return rows.map(r => ({
+            chunkId: r.chunk_id,
+            vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
+        }));
+    }
+    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,
+             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
+      WHERE hc.id = ?
+      LIMIT 1
+    `).get(chunkId);
+        return row ?? null;
+    }
+    getHubChunkById(chunkId) {
+        const row = this.db.prepare('SELECT * FROM hub_chunks WHERE id = ?').get(chunkId);
+        return row ? rowToHubChunk(row) : null;
+    }
+    searchHubSkills(query, options) {
+        const limit = options?.maxResults ?? 10;
+        const userId = options?.userId ?? "";
+        const sanitized = sanitizeFtsQuery(query);
+        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,
+               bm25(hub_skills_fts) as rank
+        FROM hub_skills_fts f
+        JOIN hub_skills hs ON hs.rowid = f.rowid
+        LEFT JOIN hub_users hu ON hu.id = hs.source_user_id
+        WHERE hub_skills_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(sanitized, limit);
+        }
+        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,
+               0 as rank
+        FROM hub_skills hs
+        LEFT JOIN hub_users hu ON hu.id = hs.source_user_id
+        ORDER BY hs.updated_at DESC
+        LIMIT ?
+      `).all(limit);
+        }
+        return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
+    }
+    deleteHubSkillBySource(sourceUserId, sourceSkillId) {
+        this.db.prepare('DELETE FROM hub_skills WHERE source_user_id = ? AND source_skill_id = ?').run(sourceUserId, sourceSkillId);
+    }
+    listVisibleHubTasks(userId, limit = 40) {
+        const rows = this.db.prepare(`
+      SELECT t.*, u.username AS owner_name, 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
+      ORDER BY t.updated_at DESC
+      LIMIT ?
+    `).all(limit);
+        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,
+            createdAt: r.created_at, updatedAt: r.updated_at,
+        }));
+    }
+    listAllHubTasks() {
+        const rows = this.db.prepare(`
+      SELECT t.*, u.username AS owner_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
+      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: null,
+            visibility: r.visibility, ownerName: r.owner_name ?? "unknown", chunkCount: r.chunk_count ?? 0,
+            createdAt: r.created_at, updatedAt: r.updated_at,
+        }));
+    }
+    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
+      FROM hub_skills s
+      LEFT JOIN hub_users u ON u.id = s.source_user_id
+      ORDER BY s.updated_at DESC
+      LIMIT ?
+    `).all(limit);
+        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,
+            createdAt: r.created_at, updatedAt: r.updated_at,
+        }));
+    }
+    listAllHubSkills() {
+        const rows = this.db.prepare(`
+      SELECT s.*, u.username AS owner_name
+      FROM hub_skills s
+      LEFT JOIN hub_users u ON u.id = s.source_user_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: null, visibility: r.visibility,
+            ownerName: r.owner_name ?? "unknown", qualityScore: r.quality_score,
+            createdAt: r.created_at, updatedAt: r.updated_at,
+        }));
+    }
+    deleteHubSkillById(skillId) {
+        const info = this.db.prepare('DELETE FROM hub_skills WHERE id = ?').run(skillId);
+        return info.changes > 0;
+    }
+    // ─── Hub Shared Memories (independent) ───
+    upsertHubMemory(memory) {
+        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_user_id, source_chunk_id) DO UPDATE SET
+        role = excluded.role,
+        content = excluded.content,
+        summary = excluded.summary,
+        kind = excluded.kind,
+        group_id = excluded.group_id,
+        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);
+    }
+    getHubMemoryBySource(sourceUserId, sourceChunkId) {
+        const row = this.db.prepare('SELECT * FROM hub_memories WHERE source_user_id = ? AND source_chunk_id = ?').get(sourceUserId, sourceChunkId);
+        return row ? rowToHubMemory(row) : null;
+    }
+    getHubMemoryById(memoryId) {
+        const row = this.db.prepare('SELECT * FROM hub_memories WHERE id = ?').get(memoryId);
+        return row ? rowToHubMemory(row) : null;
+    }
+    deleteHubMemoryBySource(sourceUserId, sourceChunkId) {
+        this.db.prepare('DELETE FROM hub_memories WHERE source_user_id = ? AND source_chunk_id = ?').run(sourceUserId, sourceChunkId);
+    }
+    deleteHubMemoryById(memoryId) {
+        const info = this.db.prepare('DELETE FROM hub_memories WHERE id = ?').run(memoryId);
+        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());
+    }
+    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(`
+      INSERT INTO hub_memory_embeddings (memory_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, dimensions = excluded.dimensions, updated_at = excluded.updated_at
+    `).run(memoryId, buf, vector.length, Date.now());
+    }
+    getHubMemoryEmbedding(memoryId) {
+        const row = this.db.prepare('SELECT vector, dimensions FROM hub_memory_embeddings WHERE memory_id = ?').get(memoryId);
+        if (!row)
+            return null;
+        return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions);
+    }
+    searchHubMemories(query, options) {
+        const limit = options?.maxResults ?? 10;
+        const userId = options?.userId ?? "";
+        const sanitized = sanitizeFtsQuery(query);
+        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
+      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
+      WHERE hub_memories_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(sanitized, limit);
+        return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
+    }
+    getVisibleHubMemoryEmbeddings(userId) {
+        const rows = this.db.prepare(`
+      SELECT hme.memory_id, hme.vector, hme.dimensions
+      FROM hub_memory_embeddings hme
+      JOIN hub_memories hm ON hm.id = hme.memory_id
+    `).all();
+        return rows.map(r => ({
+            memoryId: r.memory_id,
+            vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
+        }));
+    }
+    getVisibleHubSearchHitByMemoryId(memoryId, userId) {
+        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
+      FROM hub_memories hm
+      LEFT JOIN hub_users hu ON hu.id = hm.source_user_id
+      WHERE hm.id = ?
+      LIMIT 1
+    `).get(memoryId);
+        return row ?? null;
+    }
+    listVisibleHubMemories(userId, limit = 40) {
+        const rows = this.db.prepare(`
+      SELECT m.*, u.username AS owner_name, 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
+      LIMIT ?
+    `).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,
+            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,
+        }));
+    }
+    listAllHubMemories() {
+        const rows = this.db.prepare(`
+      SELECT m.*, u.username AS owner_name
+      FROM hub_memories m
+      LEFT JOIN hub_users u ON u.id = m.source_user_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: null, visibility: r.visibility,
+            ownerName: r.owner_name ?? "unknown", createdAt: r.created_at, updatedAt: r.updated_at,
+        }));
+    }
+    resolveCanonicalHubTaskId(taskId, sourceUserId, sourceTaskId) {
+        if (sourceTaskId) {
+            const bySource = this.db.prepare('SELECT id FROM hub_tasks WHERE source_user_id = ? AND source_task_id = ?').get(sourceUserId, sourceTaskId);
+            if (!bySource)
+                throw new Error(`source task not found for user=${sourceUserId} sourceTaskId=${sourceTaskId}`);
+            if (bySource.id != taskId)
+                throw new Error(`mismatch between source task and hubTaskId: expected ${bySource.id}, got ${taskId}`);
+            return bySource.id;
+        }
+        throw new Error(`source task not found for user=${sourceUserId} taskId=${taskId}`);
+    }
+    resolveCanonicalHubSkillId(skillId, sourceUserId, sourceSkillId) {
+        if (sourceUserId && sourceSkillId) {
+            const bySource = this.db.prepare('SELECT id FROM hub_skills WHERE source_user_id = ? AND source_skill_id = ?').get(sourceUserId, sourceSkillId);
+            if (!bySource)
+                throw new Error(`source skill not found for user=${sourceUserId} sourceSkillId=${sourceSkillId}`);
+            if (bySource.id != skillId)
+                throw new Error(`mismatch between source skill and skillId: expected ${bySource.id}, got ${skillId}`);
+            return bySource.id;
+        }
+        throw new Error(`source skill not found for skillId=${skillId}`);
+    }
     getSessionOwnerMap(sessionKeys) {
         const result = new Map();
         if (sessionKeys.length === 0)
@@ -1361,6 +2184,88 @@ function rowToSkillVersion(row) {
         createdAt: row.created_at,
     };
 }
+function rowToClientHubConnection(row) {
+    return {
+        hubUrl: row.hub_url,
+        userId: row.user_id,
+        username: row.username,
+        userToken: row.user_token,
+        role: row.role,
+        connectedAt: row.connected_at,
+    };
+}
+function rowToHubUser(row) {
+    return {
+        id: row.id,
+        username: row.username,
+        deviceName: row.device_name || undefined,
+        role: row.role,
+        status: row.status,
+        groups: [],
+        tokenHash: row.token_hash,
+        createdAt: row.created_at,
+        approvedAt: row.approved_at,
+        lastIp: row.last_ip || "",
+        lastActiveAt: row.last_active_at ?? null,
+    };
+}
+function rowToHubTask(row) {
+    return {
+        id: row.id,
+        sourceTaskId: row.source_task_id,
+        sourceUserId: row.source_user_id,
+        title: row.title,
+        summary: row.summary,
+        groupId: row.group_id,
+        visibility: row.visibility,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToHubChunk(row) {
+    return {
+        id: row.id,
+        hubTaskId: row.hub_task_id,
+        sourceChunkId: row.source_chunk_id,
+        sourceUserId: row.source_user_id,
+        role: row.role,
+        content: row.content,
+        summary: row.summary,
+        kind: row.kind,
+        createdAt: row.created_at,
+    };
+}
+function rowToHubSkill(row) {
+    return {
+        id: row.id,
+        sourceSkillId: row.source_skill_id,
+        sourceUserId: row.source_user_id,
+        name: row.name,
+        description: row.description,
+        version: row.version,
+        groupId: row.group_id,
+        visibility: row.visibility,
+        bundle: row.bundle,
+        qualityScore: row.quality_score,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToHubMemory(row) {
+    return {
+        id: row.id,
+        sourceChunkId: row.source_chunk_id,
+        sourceUserId: row.source_user_id,
+        role: row.role,
+        content: row.content,
+        summary: row.summary,
+        kind: row.kind,
+        groupId: row.group_id,
+        visibility: row.visibility,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
 function contentHash(content) {
     return (0, crypto_1.createHash)("sha256").update(content).digest("hex").slice(0, 16);
 }