@memtensor/memos-local-openclaw-plugin 0.1.4 → 0.1.5

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, Task, TaskStatus, Logger } from "../types";
+import type { Chunk, ChunkRef, DedupStatus, Task, TaskStatus, Skill, SkillStatus, SkillVersion, TaskSkillLink, TaskSkillRelation, Logger } from "../types";
 
 export class SqliteStore {
   private db: Database.Database;
@@ -95,6 +95,14 @@ export class SqliteStore {
 
     this.migrateTaskId();
     this.migrateContentHash();
+    this.migrateSkillTables();
+    this.migrateSkillId();
+    this.migrateSkillQualityScore();
+    this.migrateTaskSkillMeta();
+    this.migrateToolCalls();
+    this.migrateMergeFields();
+    this.migrateApiLogs();
+    this.migrateDedupStatus();
     this.log.debug("Database schema initialized");
   }
 
@@ -125,6 +133,295 @@ export class SqliteStore {
     }
   }
 
+  private migrateSkillTables(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS skills (
+        id          TEXT PRIMARY KEY,
+        name        TEXT NOT NULL UNIQUE,
+        description TEXT NOT NULL DEFAULT '',
+        version     INTEGER NOT NULL DEFAULT 1,
+        status      TEXT NOT NULL DEFAULT 'active',
+        tags        TEXT NOT NULL DEFAULT '[]',
+        source_type TEXT NOT NULL DEFAULT 'task',
+        dir_path    TEXT NOT NULL DEFAULT '',
+        installed   INTEGER NOT NULL DEFAULT 0,
+        created_at  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_skills_status ON skills(status);
+      CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
+
+      CREATE TABLE IF NOT EXISTS skill_versions (
+        id              TEXT PRIMARY KEY,
+        skill_id        TEXT NOT NULL REFERENCES skills(id),
+        version         INTEGER NOT NULL,
+        content         TEXT NOT NULL,
+        changelog       TEXT NOT NULL DEFAULT '',
+        upgrade_type    TEXT NOT NULL DEFAULT 'create',
+        source_task_id  TEXT,
+        metrics         TEXT NOT NULL DEFAULT '{}',
+        created_at      INTEGER NOT NULL,
+        UNIQUE(skill_id, version)
+      );
+      CREATE INDEX IF NOT EXISTS idx_skill_versions_skill ON skill_versions(skill_id);
+
+      CREATE TABLE IF NOT EXISTS task_skills (
+        task_id    TEXT NOT NULL REFERENCES tasks(id),
+        skill_id   TEXT NOT NULL REFERENCES skills(id),
+        relation   TEXT NOT NULL DEFAULT 'generated_from',
+        version_at INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (task_id, skill_id)
+      );
+    `);
+  }
+
+  private migrateSkillId(): void {
+    const cols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "skill_id")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN skill_id TEXT");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_skill ON chunks(skill_id)");
+      this.log.info("Migrated: added skill_id column to chunks");
+    }
+  }
+
+  private migrateSkillQualityScore(): void {
+    const skillCols = this.db.prepare("PRAGMA table_info(skills)").all() as Array<{ name: string }>;
+    if (!skillCols.some((c) => c.name === "quality_score")) {
+      this.db.exec("ALTER TABLE skills ADD COLUMN quality_score REAL");
+      this.log.info("Migrated: added quality_score column to skills");
+    }
+
+    const versionCols = this.db.prepare("PRAGMA table_info(skill_versions)").all() as Array<{ name: string }>;
+    if (!versionCols.some((c) => c.name === "quality_score")) {
+      this.db.exec("ALTER TABLE skill_versions ADD COLUMN quality_score REAL");
+      this.log.info("Migrated: added quality_score column to skill_versions");
+    }
+    if (!versionCols.some((c) => c.name === "change_summary")) {
+      this.db.exec("ALTER TABLE skill_versions ADD COLUMN change_summary TEXT NOT NULL DEFAULT ''");
+      this.log.info("Migrated: added change_summary column to skill_versions");
+    }
+  }
+
+  private migrateTaskSkillMeta(): void {
+    const cols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "skill_status")) {
+      this.db.exec("ALTER TABLE tasks ADD COLUMN skill_status TEXT DEFAULT NULL");
+      this.db.exec("ALTER TABLE tasks ADD COLUMN skill_reason TEXT DEFAULT NULL");
+      this.log.info("Migrated: added skill_status/skill_reason columns to tasks");
+    }
+  }
+
+  setTaskSkillMeta(taskId: string, meta: { skillStatus: string; skillReason: string }): void {
+    this.db.prepare("UPDATE tasks SET skill_status = ?, skill_reason = ?, updated_at = ? WHERE id = ?")
+      .run(meta.skillStatus, meta.skillReason, Date.now(), taskId);
+  }
+
+  private migrateMergeFields(): void {
+    const cols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "merge_count")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN merge_count INTEGER NOT NULL DEFAULT 0");
+      this.db.exec("ALTER TABLE chunks ADD COLUMN last_hit_at INTEGER");
+      this.db.exec("ALTER TABLE chunks ADD COLUMN merge_history TEXT NOT NULL DEFAULT '[]'");
+      this.log.info("Migrated: added merge_count/last_hit_at/merge_history columns to chunks");
+    }
+  }
+
+  private migrateApiLogs(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS api_logs (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        tool_name    TEXT NOT NULL,
+        input_data   TEXT NOT NULL DEFAULT '{}',
+        output_data  TEXT NOT NULL DEFAULT '',
+        duration_ms  INTEGER NOT NULL DEFAULT 0,
+        success      INTEGER NOT NULL DEFAULT 1,
+        called_at    INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_api_logs_at ON api_logs(called_at);
+      CREATE INDEX IF NOT EXISTS idx_api_logs_name ON api_logs(tool_name);
+    `);
+  }
+
+  private migrateDedupStatus(): void {
+    const cols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "dedup_status")) {
+      this.db.exec("ALTER TABLE chunks ADD COLUMN dedup_status TEXT NOT NULL DEFAULT 'active'");
+      this.db.exec("ALTER TABLE chunks ADD COLUMN dedup_target TEXT DEFAULT NULL");
+      this.db.exec("ALTER TABLE chunks ADD COLUMN dedup_reason TEXT DEFAULT NULL");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_dedup_status ON chunks(dedup_status)");
+      this.log.info("Migrated: added dedup_status/dedup_target/dedup_reason columns to chunks");
+    }
+  }
+
+  recordApiLog(toolName: string, input: unknown, output: string, durationMs: number, success: boolean): void {
+    const inputStr = typeof input === "string" ? input : JSON.stringify(input ?? {});
+    this.db.prepare(
+      "INSERT INTO api_logs (tool_name, input_data, output_data, duration_ms, success, called_at) VALUES (?, ?, ?, ?, ?, ?)",
+    ).run(toolName, inputStr, output, Math.round(durationMs), success ? 1 : 0, Date.now());
+  }
+
+  getApiLogs(limit: number = 50, offset: number = 0, toolFilter?: string): {
+    logs: Array<{ id: number; toolName: string; input: string; output: string; durationMs: number; success: boolean; calledAt: number }>;
+    total: number;
+  } {
+    const whereClause = toolFilter ? " WHERE tool_name = ?" : "";
+    const filterParams: unknown[] = toolFilter ? [toolFilter] : [];
+
+    const countRow = this.db.prepare("SELECT COUNT(*) as c FROM api_logs" + whereClause).get(...filterParams) as { c: number };
+
+    const rows = this.db.prepare(
+      "SELECT id, tool_name, input_data, output_data, duration_ms, success, called_at FROM api_logs" +
+      whereClause + " ORDER BY called_at DESC LIMIT ? OFFSET ?",
+    ).all(...filterParams, limit, offset) as Array<{
+      id: number; tool_name: string; input_data: string; output_data: string;
+      duration_ms: number; success: number; called_at: number;
+    }>;
+
+    return {
+      logs: rows.map((r) => ({
+        id: r.id,
+        toolName: r.tool_name,
+        input: r.input_data,
+        output: r.output_data,
+        durationMs: r.duration_ms,
+        success: r.success === 1,
+        calledAt: r.called_at,
+      })),
+      total: countRow.c,
+    };
+  }
+
+  getApiLogToolNames(): string[] {
+    const rows = this.db.prepare("SELECT DISTINCT tool_name FROM api_logs ORDER BY tool_name").all() as Array<{ tool_name: string }>;
+    return rows.map((r) => r.tool_name);
+  }
+
+  recordMergeHit(chunkId: string, action: "DUPLICATE" | "UPDATE", reason: string, oldSummary?: string, newSummary?: string): void {
+    const chunk = this.getChunk(chunkId);
+    if (!chunk) return;
+
+    const history = JSON.parse(chunk.mergeHistory || "[]") as any[];
+    const entry: Record<string, unknown> = { at: Date.now(), action, reason };
+    if (action === "UPDATE" && oldSummary && newSummary) {
+      entry.from = oldSummary;
+      entry.to = newSummary;
+    }
+    history.push(entry);
+
+    this.db.prepare(`
+      UPDATE chunks SET merge_count = merge_count + 1, last_hit_at = ?, merge_history = ?, updated_at = ?
+      WHERE id = ?
+    `).run(Date.now(), JSON.stringify(history), Date.now(), chunkId);
+  }
+
+  updateChunkSummaryAndContent(chunkId: string, newSummary: string, appendContent: string): void {
+    this.db.prepare(`
+      UPDATE chunks SET summary = ?, content = content || ? || ?, updated_at = ? WHERE id = ?
+    `).run(newSummary, "\n\n---\n\n", appendContent, Date.now(), chunkId);
+  }
+
+  private migrateToolCalls(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        tool_name    TEXT NOT NULL,
+        duration_ms  INTEGER NOT NULL,
+        success      INTEGER NOT NULL DEFAULT 1,
+        called_at    INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_at ON tool_calls(called_at);
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_name ON tool_calls(tool_name);
+    `);
+  }
+
+  recordToolCall(toolName: string, durationMs: number, success: boolean): void {
+    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: number): {
+    tools: string[];
+    series: Array<{ minute: string; [tool: string]: number | string }>;
+    aggregated: Array<{ tool: string; totalCalls: number; avgMs: number; p95Ms: number; errorCount: number }>;
+  } {
+    const since = Date.now() - minutes * 60 * 1000;
+
+    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) as Array<{ tool_name: string; duration_ms: number; success: number; minute_key: string }>;
+
+    const toolSet = new Set<string>();
+    const minuteMap = new Map<string, Map<string, { total: number; count: number }>>();
+    const aggMap = new Map<string, { durations: number[]; errors: number }>();
+
+    for (const r of rows) {
+      toolSet.add(r.tool_name);
+
+      if (!aggMap.has(r.tool_name)) aggMap.set(r.tool_name, { durations: [], errors: 0 });
+      const agg = aggMap.get(r.tool_name)!;
+      agg.durations.push(r.duration_ms);
+      if (!r.success) agg.errors++;
+
+      if (!minuteMap.has(r.minute_key)) minuteMap.set(r.minute_key, new Map());
+      const toolMap = minuteMap.get(r.minute_key)!;
+      if (!toolMap.has(r.tool_name)) toolMap.set(r.tool_name, { total: 0, count: 0 });
+      const entry = toolMap.get(r.tool_name)!;
+      entry.total += r.duration_ms;
+      entry.count++;
+    }
+
+    const tools = Array.from(toolSet).sort();
+
+    const allMinutes: string[] = [];
+    if (minutes > 0) {
+      const startMinute = new Date(since);
+      startMinute.setSeconds(0, 0);
+      const now = new Date();
+      for (let t = startMinute.getTime(); t <= now.getTime(); t += 60000) {
+        const d = new Date(t);
+        const pad = (n: number) => String(n).padStart(2, "0");
+        allMinutes.push(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`);
+      }
+    }
+
+    const series = allMinutes.map((m) => {
+      const entry: { minute: string; [tool: string]: number | string } = { minute: m };
+      const toolMap = minuteMap.get(m);
+      for (const t of tools) {
+        const data = toolMap?.get(t);
+        entry[t] = data ? Math.round(data.total / data.count) : 0;
+      }
+      return entry;
+    });
+
+    const p95 = (arr: number[]) => {
+      if (arr.length === 0) return 0;
+      const sorted = [...arr].sort((a, b) => a - b);
+      return sorted[Math.floor(sorted.length * 0.95)] ?? sorted[sorted.length - 1];
+    };
+
+    const aggregated = tools.map((t) => {
+      const agg = aggMap.get(t)!;
+      return {
+        tool: t,
+        totalCalls: agg.durations.length,
+        avgMs: Math.round(agg.durations.reduce((s, v) => s + v, 0) / agg.durations.length),
+        p95Ms: p95(agg.durations),
+        errorCount: agg.errors,
+      };
+    });
+
+    return { tools, series, aggregated };
+  }
+
   /** Record a viewer API call for analytics (list, search, etc.). */
   recordViewerEvent(eventType: string): void {
     this.db.prepare("INSERT INTO viewer_events (event_type, created_at) VALUES (?, ?)").run(eventType, Date.now());
@@ -202,8 +499,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, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       chunk.id,
@@ -216,11 +513,20 @@ export class SqliteStore {
       chunk.summary,
       chunk.taskId,
       contentHash(chunk.content),
+      chunk.dedupStatus ?? "active",
+      chunk.dedupTarget ?? null,
+      chunk.dedupReason ?? null,
       chunk.createdAt,
       chunk.updatedAt,
     );
   }
 
+  markDedupStatus(chunkId: string, status: "duplicate" | "merged", targetChunkId: string | null, reason: string): void {
+    this.db.prepare(
+      "UPDATE chunks SET dedup_status = ?, dedup_target = ?, dedup_reason = ?, updated_at = ? WHERE id = ?",
+    ).run(status, targetChunkId, reason, Date.now(), chunkId);
+  }
+
   updateSummary(chunkId: string, summary: string): void {
     this.db.prepare("UPDATE chunks SET summary = ?, updated_at = ? WHERE id = ?").run(
       summary,
@@ -277,7 +583,7 @@ export class SqliteStore {
         SELECT c.id as chunk_id, rank
         FROM chunks_fts f
         JOIN chunks c ON c.rowid = f.rowid
-        WHERE chunks_fts MATCH ?
+        WHERE chunks_fts MATCH ? AND c.dedup_status = 'active'
         ORDER BY rank
         LIMIT ?
       `).all(sanitized, limit) as Array<{ chunk_id: string; rank: number }>;
@@ -311,7 +617,7 @@ export class SqliteStore {
       const rows = this.db.prepare(`
         SELECT c.id as chunk_id, c.content, c.role, c.created_at
         FROM chunks c
-        WHERE (${whereClause})${roleClause}
+        WHERE (${whereClause})${roleClause} AND c.dedup_status = 'active'
         ORDER BY c.created_at DESC
         LIMIT ?
       `).all(...params) as Array<{ chunk_id: string; content: string; role: string; created_at: number }>;
@@ -331,7 +637,9 @@ export class SqliteStore {
 
   getAllEmbeddings(): Array<{ chunkId: string; vector: number[] }> {
     const rows = this.db.prepare(
-      "SELECT chunk_id, vector, dimensions FROM embeddings",
+      `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 }>;
 
     return rows.map((r) => ({
@@ -395,9 +703,14 @@ export class SqliteStore {
   }
 
   deleteAll(): number {
+    this.db.exec("PRAGMA foreign_keys = OFF");
+    this.db.prepare("DELETE FROM task_skills").run();
+    this.db.prepare("DELETE FROM skill_versions").run();
+    this.db.prepare("DELETE FROM skills").run();
     this.db.prepare("DELETE FROM chunks").run();
     this.db.prepare("DELETE FROM tasks").run();
     this.db.prepare("DELETE FROM viewer_events").run();
+    this.db.exec("PRAGMA foreign_keys = ON");
     const remaining = this.countChunks();
     return remaining === 0 ? 1 : 0;
   }
@@ -511,6 +824,119 @@ export class SqliteStore {
     return row.cnt;
   }
 
+  // ─── Skill CRUD ───
+
+  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);
+  }
+
+  getSkill(skillId: string): Skill | null {
+    const row = this.db.prepare("SELECT * FROM skills WHERE id = ?").get(skillId) as SkillRow | undefined;
+    return row ? rowToSkill(row) : null;
+  }
+
+  getSkillByName(name: string): Skill | null {
+    const row = this.db.prepare("SELECT * FROM skills WHERE name = ?").get(name) as SkillRow | undefined;
+    return row ? rowToSkill(row) : null;
+  }
+
+  updateSkill(skillId: string, fields: { description?: string; version?: number; status?: SkillStatus; installed?: number; qualityScore?: number | null; updatedAt?: number }): void {
+    const sets: string[] = [];
+    const params: unknown[] = [];
+    if (fields.description !== undefined) { sets.push("description = ?"); params.push(fields.description); }
+    if (fields.version !== undefined) { sets.push("version = ?"); params.push(fields.version); }
+    if (fields.status !== undefined) { sets.push("status = ?"); params.push(fields.status); }
+    if (fields.installed !== undefined) { sets.push("installed = ?"); params.push(fields.installed); }
+    if (fields.qualityScore !== undefined) { sets.push("quality_score = ?"); params.push(fields.qualityScore); }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    params.push(fields.updatedAt ?? Date.now());
+    params.push(skillId);
+    this.db.prepare(`UPDATE skills SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+
+  listSkills(opts: { status?: string } = {}): Skill[] {
+    const cond = opts.status ? "WHERE status = ?" : "";
+    const params = opts.status ? [opts.status] : [];
+    const rows = this.db.prepare(`SELECT * FROM skills ${cond} ORDER BY updated_at DESC`).all(...params) as SkillRow[];
+    return rows.map(rowToSkill);
+  }
+
+  // ─── Skill Versions ───
+
+  insertSkillVersion(sv: SkillVersion): void {
+    this.db.prepare(`
+      INSERT OR REPLACE INTO skill_versions (id, skill_id, version, content, changelog, change_summary, upgrade_type, source_task_id, metrics, quality_score, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(sv.id, sv.skillId, sv.version, sv.content, sv.changelog, sv.changeSummary, sv.upgradeType, sv.sourceTaskId, sv.metrics, sv.qualityScore, sv.createdAt);
+  }
+
+  getLatestSkillVersion(skillId: string): SkillVersion | null {
+    const row = this.db.prepare("SELECT * FROM skill_versions WHERE skill_id = ? ORDER BY version DESC LIMIT 1").get(skillId) as SkillVersionRow | undefined;
+    return row ? rowToSkillVersion(row) : null;
+  }
+
+  getSkillVersions(skillId: string): SkillVersion[] {
+    const rows = this.db.prepare("SELECT * FROM skill_versions WHERE skill_id = ? ORDER BY version DESC").all(skillId) as SkillVersionRow[];
+    return rows.map(rowToSkillVersion);
+  }
+
+  getSkillVersion(skillId: string, version: number): SkillVersion | null {
+    const row = this.db.prepare("SELECT * FROM skill_versions WHERE skill_id = ? AND version = ?").get(skillId, version) as SkillVersionRow | undefined;
+    return row ? rowToSkillVersion(row) : null;
+  }
+
+  // ─── Task-Skill Links ───
+
+  linkTaskSkill(taskId: string, skillId: string, relation: TaskSkillRelation, versionAt: number): void {
+    this.db.prepare(`
+      INSERT OR REPLACE INTO task_skills (task_id, skill_id, relation, version_at, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(taskId, skillId, relation, versionAt, Date.now());
+  }
+
+  getSkillsByTask(taskId: string): Array<{ skill: Skill; relation: TaskSkillRelation; versionAt: number }> {
+    const rows = this.db.prepare(`
+      SELECT s.*, ts.relation, ts.version_at
+      FROM task_skills ts JOIN skills s ON s.id = ts.skill_id
+      WHERE ts.task_id = ?
+    `).all(taskId) as Array<SkillRow & { relation: string; version_at: number }>;
+    return rows.map(r => ({
+      skill: rowToSkill(r),
+      relation: r.relation as TaskSkillRelation,
+      versionAt: r.version_at,
+    }));
+  }
+
+  getTasksBySkill(skillId: string): Array<{ task: Task; relation: TaskSkillRelation }> {
+    const rows = this.db.prepare(`
+      SELECT t.*, ts.relation
+      FROM task_skills ts JOIN tasks t ON t.id = ts.task_id
+      WHERE ts.skill_id = ?
+      ORDER BY t.started_at DESC
+    `).all(skillId) as Array<TaskRow & { relation: string }>;
+    return rows.map(r => ({
+      task: rowToTask(r),
+      relation: r.relation as TaskSkillRelation,
+    }));
+  }
+
+  countSkills(status?: string): number {
+    const cond = status ? "WHERE status = ?" : "";
+    const params = status ? [status] : [];
+    const row = this.db.prepare(`SELECT COUNT(*) as c FROM skills ${cond}`).get(...params) as { c: number };
+    return row.c;
+  }
+
+  // ─── Chunk-Skill ───
+
+  setChunkSkillId(chunkId: string, skillId: string): void {
+    this.db.prepare("UPDATE chunks SET skill_id = ?, updated_at = ? WHERE id = ?").run(skillId, Date.now(), chunkId);
+  }
+
   close(): void {
     this.db.close();
   }
@@ -548,6 +974,13 @@ interface ChunkRow {
   kind: string;
   summary: string;
   task_id: string | null;
+  skill_id: string | null;
+  dedup_status: string;
+  dedup_target: string | null;
+  dedup_reason: string | null;
+  merge_count: number;
+  last_hit_at: number | null;
+  merge_history: string;
   created_at: number;
   updated_at: number;
 }
@@ -564,6 +997,13 @@ function rowToChunk(row: ChunkRow): Chunk {
     summary: row.summary,
     embedding: null,
     taskId: row.task_id,
+    skillId: row.skill_id ?? null,
+    dedupStatus: (row.dedup_status ?? "active") as DedupStatus,
+    dedupTarget: row.dedup_target ?? null,
+    dedupReason: row.dedup_reason ?? null,
+    mergeCount: row.merge_count ?? 0,
+    lastHitAt: row.last_hit_at ?? null,
+    mergeHistory: row.merge_history ?? "[]",
     createdAt: row.created_at,
     updatedAt: row.updated_at,
   };
@@ -593,6 +1033,68 @@ function rowToTask(row: TaskRow): Task {
   };
 }
 
+interface SkillRow {
+  id: string;
+  name: string;
+  description: string;
+  version: number;
+  status: string;
+  tags: string;
+  source_type: string;
+  dir_path: string;
+  installed: number;
+  quality_score: number | null;
+  created_at: number;
+  updated_at: number;
+}
+
+function rowToSkill(row: SkillRow): Skill {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    version: row.version,
+    status: row.status as Skill["status"],
+    tags: row.tags,
+    sourceType: row.source_type as Skill["sourceType"],
+    dirPath: row.dir_path,
+    installed: row.installed,
+    qualityScore: row.quality_score ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+interface SkillVersionRow {
+  id: string;
+  skill_id: string;
+  version: number;
+  content: string;
+  changelog: string;
+  change_summary: string;
+  upgrade_type: string;
+  source_task_id: string | null;
+  metrics: string;
+  quality_score: number | null;
+  created_at: number;
+}
+
+function rowToSkillVersion(row: SkillVersionRow): SkillVersion {
+  return {
+    id: row.id,
+    skillId: row.skill_id,
+    version: row.version,
+    content: row.content,
+    changelog: row.changelog,
+    changeSummary: row.change_summary ?? "",
+    upgradeType: row.upgrade_type as SkillVersion["upgradeType"],
+    sourceTaskId: row.source_task_id,
+    metrics: row.metrics,
+    qualityScore: row.quality_score ?? null,
+    createdAt: row.created_at,
+  };
+}
+
 function contentHash(content: string): string {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }