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

package/src/storage/sqlite.ts

@@ -2,7 +2,7 @@ import Database from "better-sqlite3";
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-import type { Chunk, ChunkRef, DedupStatus, Task, TaskStatus, Skill, SkillStatus, SkillVersion, TaskSkillLink, TaskSkillRelation, Logger } from "../types";
+import type { Chunk, ChunkRef, DedupStatus, Task, TaskStatus, Skill, SkillStatus, SkillVisibility, SkillVersion, TaskSkillLink, TaskSkillRelation, Logger } from "../types";
 
 export class SqliteStore {
   private db: Database.Database;
@@ -106,6 +106,9 @@ export class SqliteStore {
     this.migrateApiLogs();
     this.migrateDedupStatus();
     this.migrateChunksIndexesForRecall();
+    this.migrateOwnerFields();
+    this.migrateSkillVisibility();
+    this.migrateSkillEmbeddingsAndFts();
     this.log.debug("Database schema initialized");
   }
 
@@ -113,6 +116,85 @@ export class SqliteStore {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_dedup_created ON chunks(dedup_status, created_at DESC)");
   }
 
+  private migrateOwnerFields(): void {
+    const chunkCols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
+    if (!chunkCols.some((c) => c.name === "owner")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN owner TEXT NOT NULL DEFAULT 'agent:main'");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_owner ON chunks(owner)");
+      this.log.info("Migrated: added owner column to chunks");
+    }
+    const taskCols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    if (!taskCols.some((c) => c.name === "owner")) {
+      this.db.exec("ALTER TABLE tasks ADD COLUMN owner TEXT NOT NULL DEFAULT 'agent:main'");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner)");
+      this.log.info("Migrated: added owner column to tasks");
+    }
+  }
+
+  private migrateSkillVisibility(): void {
+    const cols = this.db.prepare("PRAGMA table_info(skills)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "owner")) {
+      this.db.exec("ALTER TABLE skills ADD COLUMN owner TEXT NOT NULL DEFAULT 'agent:main'");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_skills_owner ON skills(owner)");
+      this.log.info("Migrated: added owner column to skills");
+    }
+    if (!cols.some((c) => c.name === "visibility")) {
+      this.db.exec("ALTER TABLE skills ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private'");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_skills_visibility ON skills(visibility)");
+      this.log.info("Migrated: added visibility column to skills");
+    }
+  }
+
+  private migrateSkillEmbeddingsAndFts(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_embeddings (
+        skill_id   TEXT PRIMARY KEY REFERENCES skills(id) ON DELETE CASCADE,
+        vector     BLOB NOT NULL,
+        dimensions INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+        name,
+        description,
+        content='skills',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+    `);
+
+    try {
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS skills_ai AFTER INSERT ON skills BEGIN
+          INSERT INTO skills_fts(rowid, name, description)
+          VALUES (new.rowid, new.name, new.description);
+        END;
+        CREATE TRIGGER IF NOT EXISTS skills_ad AFTER DELETE ON skills BEGIN
+          INSERT INTO skills_fts(skills_fts, rowid, name, description)
+          VALUES ('delete', old.rowid, old.name, old.description);
+        END;
+        CREATE TRIGGER IF NOT EXISTS skills_au AFTER UPDATE ON skills BEGIN
+          INSERT INTO skills_fts(skills_fts, rowid, name, description)
+          VALUES ('delete', old.rowid, old.name, old.description);
+          INSERT INTO skills_fts(rowid, name, description)
+          VALUES (new.rowid, new.name, new.description);
+        END;
+      `);
+    } catch {
+      // triggers may already exist
+    }
+
+    // Backfill FTS for existing skills
+    try {
+      const count = (this.db.prepare("SELECT COUNT(*) as c FROM skills_fts").get() as { c: number }).c;
+      const skillCount = (this.db.prepare("SELECT COUNT(*) as c FROM skills").get() as { c: number }).c;
+      if (count === 0 && skillCount > 0) {
+        this.db.exec("INSERT INTO skills_fts(rowid, name, description) SELECT rowid, name, description FROM skills");
+        this.log.info(`Migrated: backfilled skills_fts for ${skillCount} skills`);
+      }
+    } catch { /* best-effort */ }
+  }
+
   private migrateTaskId(): void {
     const cols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
     if (!cols.some((c) => c.name === "task_id")) {
@@ -506,8 +588,8 @@ export class SqliteStore {
 
   insertChunk(chunk: Chunk): void {
     const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO chunks (id, session_key, turn_id, seq, role, content, kind, summary, task_id, content_hash, dedup_status, dedup_target, dedup_reason, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT OR REPLACE INTO chunks (id, session_key, turn_id, seq, role, content, kind, summary, task_id, content_hash, owner, dedup_status, dedup_target, dedup_reason, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       chunk.id,
@@ -520,6 +602,7 @@ export class SqliteStore {
       chunk.summary,
       chunk.taskId,
       contentHash(chunk.content),
+      chunk.owner ?? "agent:main",
       chunk.dedupStatus ?? "active",
       chunk.dedupTarget ?? null,
       chunk.dedupReason ?? null,
@@ -581,19 +664,28 @@ export class SqliteStore {
 
   // ─── FTS Search ───
 
-  ftsSearch(query: string, limit: number): Array<{ chunkId: string; score: number }> {
+  ftsSearch(query: string, limit: number, ownerFilter?: string[]): Array<{ chunkId: string; score: number }> {
     const sanitized = sanitizeFtsQuery(query);
     if (!sanitized) return [];
 
     try {
-      const rows = this.db.prepare(`
+      let sql = `
         SELECT c.id as chunk_id, rank
         FROM chunks_fts f
         JOIN chunks c ON c.rowid = f.rowid
-        WHERE chunks_fts MATCH ? AND c.dedup_status = 'active'
-        ORDER BY rank
-        LIMIT ?
-      `).all(sanitized, limit) as Array<{ chunk_id: string; rank: number }>;
+        WHERE chunks_fts MATCH ? AND c.dedup_status = 'active'`;
+      const params: any[] = [sanitized];
+
+      if (ownerFilter && ownerFilter.length > 0) {
+        const placeholders = ownerFilter.map(() => "?").join(",");
+        sql += ` AND c.owner IN (${placeholders})`;
+        params.push(...ownerFilter);
+      }
+
+      sql += ` ORDER BY rank LIMIT ?`;
+      params.push(limit);
+
+      const rows = this.db.prepare(sql).all(...params) as Array<{ chunk_id: string; rank: number }>;
 
       if (rows.length === 0) return [];
       const maxAbsRank = Math.max(...rows.map((r) => Math.abs(r.rank)));
@@ -642,12 +734,19 @@ export class SqliteStore {
 
   // ─── Vector Search ───
 
-  getAllEmbeddings(): Array<{ chunkId: string; vector: number[] }> {
-    const rows = this.db.prepare(
-      `SELECT e.chunk_id, e.vector, e.dimensions FROM embeddings e
+  getAllEmbeddings(ownerFilter?: string[]): Array<{ chunkId: string; vector: number[] }> {
+    let sql = `SELECT e.chunk_id, e.vector, e.dimensions FROM embeddings e
        JOIN chunks c ON c.id = e.chunk_id
-       WHERE c.dedup_status = 'active'`,
-    ).all() as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
+       WHERE c.dedup_status = 'active'`;
+    const params: any[] = [];
+
+    if (ownerFilter && ownerFilter.length > 0) {
+      const placeholders = ownerFilter.map(() => "?").join(",");
+      sql += ` AND c.owner IN (${placeholders})`;
+      params.push(...ownerFilter);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
 
     return rows.map((r) => ({
       chunkId: r.chunk_id,
@@ -655,17 +754,25 @@ export class SqliteStore {
     }));
   }
 
-  /** Like getAllEmbeddings but only for the most recent N chunks (uses idx_chunks_dedup_created). Use for vector search cap to avoid full scan. */
-  getRecentEmbeddings(limit: number): Array<{ chunkId: string; vector: number[] }> {
-    if (limit <= 0) return this.getAllEmbeddings();
-    const rows = this.db.prepare(
-      `SELECT e.chunk_id, e.vector, e.dimensions
+  getRecentEmbeddings(limit: number, ownerFilter?: string[]): Array<{ chunkId: string; vector: number[] }> {
+    if (limit <= 0) return this.getAllEmbeddings(ownerFilter);
+
+    let sql = `SELECT e.chunk_id, e.vector, e.dimensions
        FROM chunks c
        JOIN embeddings e ON e.chunk_id = c.id
-       WHERE c.dedup_status = 'active'
-       ORDER BY c.created_at DESC
-       LIMIT ?`,
-    ).all(limit) as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
+       WHERE c.dedup_status = 'active'`;
+    const params: any[] = [];
+
+    if (ownerFilter && ownerFilter.length > 0) {
+      const placeholders = ownerFilter.map(() => "?").join(",");
+      sql += ` AND c.owner IN (${placeholders})`;
+      params.push(...ownerFilter);
+    }
+
+    sql += ` ORDER BY c.created_at DESC LIMIT ?`;
+    params.push(limit);
+
+    const rows = this.db.prepare(sql).all(...params) as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
 
     return rows.map((r) => ({
       chunkId: r.chunk_id,
@@ -683,7 +790,7 @@ export class SqliteStore {
 
   // ─── Update ───
 
-  updateChunk(chunkId: string, fields: { summary?: string; content?: string; role?: string; kind?: string }): boolean {
+  updateChunk(chunkId: string, fields: { summary?: string; content?: string; role?: string; kind?: string; owner?: string }): boolean {
     const sets: string[] = [];
     const params: unknown[] = [];
 
@@ -703,6 +810,10 @@ export class SqliteStore {
       sets.push("kind = ?");
       params.push(fields.kind);
     }
+    if (fields.owner !== undefined) {
+      sets.push("owner = ?");
+      params.push(fields.owner);
+    }
     if (sets.length === 0) return false;
 
     sets.push("updated_at = ?");
@@ -747,9 +858,9 @@ export class SqliteStore {
 
   insertTask(task: Task): void {
     this.db.prepare(`
-      INSERT OR REPLACE INTO tasks (id, session_key, title, summary, status, started_at, ended_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(task.id, task.sessionKey, task.title, task.summary, task.status, task.startedAt, task.endedAt, task.updatedAt);
+      INSERT OR REPLACE INTO tasks (id, session_key, title, summary, status, owner, started_at, ended_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(task.id, task.sessionKey, task.title, task.summary, task.status, task.owner ?? "agent:main", task.startedAt, task.endedAt, task.updatedAt);
   }
 
   getTask(taskId: string): Task | null {
@@ -757,7 +868,13 @@ export class SqliteStore {
     return row ? rowToTask(row) : null;
   }
 
-  getActiveTask(sessionKey: string): Task | null {
+  getActiveTask(sessionKey: string, owner?: string): Task | null {
+    if (owner) {
+      const row = this.db.prepare(
+        "SELECT * FROM tasks WHERE session_key = ? AND status = 'active' AND owner = ? ORDER BY started_at DESC LIMIT 1",
+      ).get(sessionKey, owner) as TaskRow | undefined;
+      return row ? rowToTask(row) : null;
+    }
     const row = this.db.prepare(
       "SELECT * FROM tasks WHERE session_key = ? AND status = 'active' ORDER BY started_at DESC LIMIT 1",
     ).get(sessionKey) as TaskRow | undefined;
@@ -785,7 +902,13 @@ export class SqliteStore {
     return rows.map(rowToTask);
   }
 
-  getAllActiveTasks(): Task[] {
+  getAllActiveTasks(owner?: string): Task[] {
+    if (owner) {
+      const rows = this.db.prepare(
+        "SELECT * FROM tasks WHERE status = 'active' AND owner = ? ORDER BY started_at DESC",
+      ).all(owner) as TaskRow[];
+      return rows.map(rowToTask);
+    }
     const rows = this.db.prepare(
       "SELECT * FROM tasks WHERE status = 'active' ORDER BY started_at DESC",
     ).all() as TaskRow[];
@@ -812,10 +935,11 @@ export class SqliteStore {
     return rows.map(rowToChunk);
   }
 
-  listTasks(opts: { status?: string; limit?: number; offset?: number } = {}): { tasks: Task[]; total: number } {
+  listTasks(opts: { status?: string; limit?: number; offset?: number; owner?: string } = {}): { tasks: Task[]; total: number } {
     const conditions: string[] = [];
     const params: unknown[] = [];
     if (opts.status) { conditions.push("status = ?"); params.push(opts.status); }
+    if (opts.owner) { conditions.push("owner = ?"); params.push(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) as { c: number };
@@ -839,7 +963,13 @@ export class SqliteStore {
     this.db.prepare("UPDATE chunks SET task_id = ?, updated_at = ? WHERE id = ?").run(taskId, Date.now(), chunkId);
   }
 
-  getUnassignedChunks(sessionKey: string): Chunk[] {
+  getUnassignedChunks(sessionKey: string, owner?: string): Chunk[] {
+    if (owner) {
+      const rows = this.db.prepare(
+        "SELECT * FROM chunks WHERE session_key = ? AND task_id IS NULL AND owner = ? ORDER BY created_at, seq",
+      ).all(sessionKey, owner) as ChunkRow[];
+      return rows.map(rowToChunk);
+    }
     const rows = this.db.prepare(
       "SELECT * FROM chunks WHERE session_key = ? AND task_id IS NULL ORDER BY created_at, seq",
     ).all(sessionKey) as ChunkRow[];
@@ -877,9 +1007,9 @@ export class SqliteStore {
 
   insertSkill(skill: Skill): void {
     this.db.prepare(`
-      INSERT OR REPLACE INTO skills (id, name, description, version, status, tags, source_type, dir_path, installed, quality_score, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(skill.id, skill.name, skill.description, skill.version, skill.status, skill.tags, skill.sourceType, skill.dirPath, skill.installed, skill.qualityScore, skill.createdAt, skill.updatedAt);
+      INSERT OR REPLACE INTO skills (id, name, description, version, status, tags, source_type, dir_path, installed, owner, visibility, quality_score, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(skill.id, skill.name, skill.description, skill.version, skill.status, skill.tags, skill.sourceType, skill.dirPath, skill.installed, skill.owner ?? "agent:main", skill.visibility ?? "private", skill.qualityScore, skill.createdAt, skill.updatedAt);
   }
 
   getSkill(skillId: string): Skill | null {
@@ -914,6 +1044,96 @@ export class SqliteStore {
     return rows.map(rowToSkill);
   }
 
+  // ─── Skill Visibility & Embeddings ───
+
+  setSkillVisibility(skillId: string, visibility: SkillVisibility): void {
+    this.db.prepare("UPDATE skills SET visibility = ?, updated_at = ? WHERE id = ?")
+      .run(visibility, Date.now(), skillId);
+  }
+
+  upsertSkillEmbedding(skillId: string, vector: number[]): void {
+    const buf = Buffer.from(new Float32Array(vector).buffer);
+    this.db.prepare(`
+      INSERT OR REPLACE INTO skill_embeddings (skill_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+    `).run(skillId, buf, vector.length, Date.now());
+  }
+
+  getSkillEmbedding(skillId: string): number[] | null {
+    const row = this.db.prepare(
+      "SELECT vector, dimensions FROM skill_embeddings WHERE skill_id = ?",
+    ).get(skillId) as { vector: Buffer; dimensions: number } | undefined;
+    if (!row) return null;
+    return Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions));
+  }
+
+  getSkillEmbeddings(scope: "self" | "public" | "mix", currentOwner: string): Array<{ skillId: string; vector: number[] }> {
+    let sql = `SELECT se.skill_id, se.vector, se.dimensions
+       FROM skill_embeddings se
+       JOIN skills s ON s.id = se.skill_id
+       WHERE s.status = 'active'`;
+    const params: any[] = [];
+
+    if (scope === "self") {
+      sql += ` AND s.owner = ?`;
+      params.push(currentOwner);
+    } else if (scope === "public") {
+      sql += ` AND s.visibility = 'public'`;
+    } else {
+      sql += ` AND (s.owner = ? OR s.visibility = 'public')`;
+      params.push(currentOwner);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as Array<{ skill_id: string; vector: Buffer; dimensions: number }>;
+    return rows.map((r) => ({
+      skillId: r.skill_id,
+      vector: Array.from(new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions)),
+    }));
+  }
+
+  skillFtsSearch(query: string, limit: number, scope: "self" | "public" | "mix", currentOwner: string): Array<{ skillId: string; score: number }> {
+    const sanitized = sanitizeFtsQuery(query);
+    if (!sanitized) return [];
+
+    try {
+      let sql = `
+        SELECT s.id as skill_id, rank
+        FROM skills_fts f
+        JOIN skills s ON s.rowid = f.rowid
+        WHERE skills_fts MATCH ? AND s.status = 'active'`;
+      const params: any[] = [sanitized];
+
+      if (scope === "self") {
+        sql += ` AND s.owner = ?`;
+        params.push(currentOwner);
+      } else if (scope === "public") {
+        sql += ` AND s.visibility = 'public'`;
+      } else {
+        sql += ` AND (s.owner = ? OR s.visibility = 'public')`;
+        params.push(currentOwner);
+      }
+
+      sql += ` ORDER BY rank LIMIT ?`;
+      params.push(limit);
+
+      const rows = this.db.prepare(sql).all(...params) as Array<{ skill_id: string; rank: number }>;
+      if (rows.length === 0) return [];
+      const maxAbsRank = Math.max(...rows.map((r) => Math.abs(r.rank)));
+      return rows.map((r) => ({
+        skillId: r.skill_id,
+        score: maxAbsRank > 0 ? Math.abs(r.rank) / maxAbsRank : 0,
+      }));
+    } catch {
+      this.log.warn(`Skill 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);
+  }
+
   // ─── Skill Versions ───
 
   insertSkillVersion(sv: SkillVersion): void {
@@ -1029,6 +1249,7 @@ interface ChunkRow {
   summary: string;
   task_id: string | null;
   skill_id: string | null;
+  owner: string;
   dedup_status: string;
   dedup_target: string | null;
   dedup_reason: string | null;
@@ -1052,6 +1273,7 @@ function rowToChunk(row: ChunkRow): Chunk {
     embedding: null,
     taskId: row.task_id,
     skillId: row.skill_id ?? null,
+    owner: row.owner ?? "agent:main",
     dedupStatus: (row.dedup_status ?? "active") as DedupStatus,
     dedupTarget: row.dedup_target ?? null,
     dedupReason: row.dedup_reason ?? null,
@@ -1069,6 +1291,7 @@ interface TaskRow {
   title: string;
   summary: string;
   status: string;
+  owner: string;
   started_at: number;
   ended_at: number | null;
   updated_at: number;
@@ -1081,6 +1304,7 @@ function rowToTask(row: TaskRow): Task {
     title: row.title,
     summary: row.summary,
     status: row.status as Task["status"],
+    owner: row.owner ?? "agent:main",
     startedAt: row.started_at,
     endedAt: row.ended_at,
     updatedAt: row.updated_at,
@@ -1097,6 +1321,8 @@ interface SkillRow {
   source_type: string;
   dir_path: string;
   installed: number;
+  owner: string;
+  visibility: string;
   quality_score: number | null;
   created_at: number;
   updated_at: number;
@@ -1113,6 +1339,8 @@ function rowToSkill(row: SkillRow): Skill {
     sourceType: row.source_type as Skill["sourceType"],
     dirPath: row.dir_path,
     installed: row.installed,
+    owner: row.owner ?? "agent:main",
+    visibility: (row.visibility ?? "private") as Skill["visibility"],
     qualityScore: row.quality_score ?? null,
     createdAt: row.created_at,
     updatedAt: row.updated_at,

package/src/storage/vector.ts

@@ -28,10 +28,11 @@ export function vectorSearch(
   queryVec: number[],
   topK: number,
   maxChunks?: number,
+  ownerFilter?: string[],
 ): VectorHit[] {
   const all = maxChunks != null && maxChunks > 0
-    ? store.getRecentEmbeddings(maxChunks)
-    : store.getAllEmbeddings();
+    ? store.getRecentEmbeddings(maxChunks, ownerFilter)
+    : store.getAllEmbeddings(ownerFilter);
   const scored: VectorHit[] = all.map((row) => ({
     chunkId: row.chunkId,
     score: cosineSimilarity(queryVec, row.vector),

package/src/types.ts

@@ -9,6 +9,7 @@ export interface ConversationMessage {
   turnId: string;
   sessionKey: string;
   toolName?: string;
+  owner?: string;
 }
 
 // ─── Chunk & Storage ───
@@ -27,6 +28,7 @@ export interface Chunk {
   embedding: number[] | null;
   taskId: string | null;
   skillId: string | null;
+  owner: string;
   dedupStatus: DedupStatus;
   dedupTarget: string | null;
   dedupReason: string | null;
@@ -47,6 +49,7 @@ export interface Task {
   title: string;
   summary: string;
   status: TaskStatus;
+  owner: string;
   startedAt: number;
   endedAt: number | null;
   updatedAt: number;
@@ -77,6 +80,7 @@ export interface SearchHit {
   score: number;
   taskId: string | null;
   skillId: string | null;
+  owner?: string;
   source: {
     ts: number;
     role: Role;
@@ -84,6 +88,16 @@ export interface SearchHit {
   };
 }
 
+export interface SkillSearchHit {
+  skillId: string;
+  name: string;
+  description: string;
+  owner: string;
+  visibility: SkillVisibility;
+  score: number;
+  reason: string;
+}
+
 export interface SearchResult {
   hits: SearchHit[];
   meta: {
@@ -176,6 +190,8 @@ export type SkillStatus = "active" | "archived" | "draft";
 export type SkillUpgradeType = "create" | "refine" | "extend" | "fix";
 export type TaskSkillRelation = "generated_from" | "evolved_from" | "applied_to";
 
+export type SkillVisibility = "private" | "public";
+
 export interface Skill {
   id: string;
   name: string;
@@ -186,6 +202,8 @@ export interface Skill {
   sourceType: "task" | "manual";
   dirPath: string;
   installed: number;
+  owner: string;
+  visibility: SkillVisibility;
   qualityScore: number | null;
   createdAt: number;
   updatedAt: number;