gisool 0.0.0-stage → 0.1.0

package/dist/store/queries.js

@@ -0,0 +1,458 @@
+import { existsSync, readFileSync } from "node:fs";
+import { nameFromUri, parseJson, readIngestCounters, storeError } from "./writes.js";
+const DAY_MS = 86_400_000;
+const WEEK_MS = 7 * DAY_MS;
+const RUNTIMES = ["claude-code", "codex", "gemini", "cursor", "omo", "gajae", "openclaw", "unknown"];
+let rulesCache;
+/** tsc does not copy JSON into dist, so the rules are read beside the compiled module first, then from src/store. */
+export function taskTypeRules() {
+    if (rulesCache)
+        return rulesCache;
+    const candidates = [new URL("./task-types.json", import.meta.url), new URL("../../src/store/task-types.json", import.meta.url)];
+    const found = candidates.find((u) => existsSync(u));
+    if (!found)
+        throw storeError("task_types_missing", "task-types.json not found next to the store module or in src/store");
+    rulesCache = JSON.parse(readFileSync(found, "utf8"));
+    return rulesCache;
+}
+function tokens(s) {
+    return s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function keywordInText(keyword, text) {
+    const k = keyword.toLowerCase();
+    if (/^[\x20-\x7e]+$/.test(k)) {
+        const escaped = k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`(^|[^a-z0-9])${escaped}($|[^a-z0-9])`).test(text);
+    }
+    return text.includes(k);
+}
+function skillMatches(rule, skill) {
+    const tags = skill.tags.map((t) => t.toLowerCase());
+    if (rule.anyTags?.some((t) => tags.includes(t.toLowerCase())))
+        return true;
+    if (skill.groupId && rule.anyGroup?.some((g) => g.toLowerCase() === skill.groupId.toLowerCase()))
+        return true;
+    const nameTokens = tokens(skill.name);
+    const name = skill.name.toLowerCase();
+    return rule.anyNameKeywords?.some((k) => nameTokens.includes(k.toLowerCase()) || (/[-_ ]/.test(k) && name.includes(k.toLowerCase()))) ?? false;
+}
+export function classifyTaskType(skill, prompt, rules = taskTypeRules()) {
+    if (skill) {
+        const hit = rules.find((r) => skillMatches(r, skill));
+        if (hit)
+            return hit.taskType;
+        if (skill.groupId)
+            return skill.groupId;
+    }
+    if (prompt) {
+        const text = prompt.toLowerCase();
+        const hit = rules.find((r) => r.anyPromptKeywords?.some((k) => keywordInText(k, text)));
+        if (hit)
+            return hit.taskType;
+    }
+    return "unclassified";
+}
+const fmtCache = new Map();
+const WEEKDAYS = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+export function localDowHour(ts, tz) {
+    let fmt = fmtCache.get(tz);
+    if (!fmt) {
+        try {
+            fmt = new Intl.DateTimeFormat("en-US", { timeZone: tz, weekday: "short", hour: "numeric", hourCycle: "h23" });
+        }
+        catch {
+            throw storeError("invalid_tz", `unknown time zone: ${tz}`);
+        }
+        fmtCache.set(tz, fmt);
+    }
+    let dow = 0;
+    let hour = 0;
+    for (const p of fmt.formatToParts(ts)) {
+        if (p.type === "weekday")
+            dow = WEEKDAYS[p.value] ?? 0;
+        else if (p.type === "hour")
+            hour = Number(p.value) % 24;
+    }
+    return { dow, hour };
+}
+function candidatesOf(data) {
+    return Array.isArray(data.candidates) ? data.candidates : [];
+}
+/** Adoption precedence: loaded > exposed_only > no_match > aborted (error after a search) > not_used. */
+export function adoptionState(events) {
+    if (events.some((e) => e.kind === "load"))
+        return "loaded";
+    const searches = events.filter((e) => e.kind === "search");
+    if (searches.some((e) => candidatesOf(e.data).length >= 1))
+        return "exposed_only";
+    if (searches.some((e) => e.data.abstained !== undefined && e.data.abstained !== null))
+        return "no_match";
+    const firstSearch = events.findIndex((e) => e.kind === "search");
+    if (firstSearch >= 0 && events.slice(firstSearch + 1).some((e) => e.kind === "error"))
+        return "aborted";
+    return "not_used";
+}
+function isoWeekStart(ts) {
+    const d = new Date(ts);
+    const mondayOffset = (d.getUTCDay() + 6) % 7;
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()) - mondayOffset * DAY_MS;
+}
+function isoWeekLabel(weekStart) {
+    const thursday = new Date(weekStart + 3 * DAY_MS);
+    const year = thursday.getUTCFullYear();
+    const week1 = isoWeekStart(Date.UTC(year, 0, 4));
+    const week = 1 + Math.round((weekStart - week1) / WEEK_MS);
+    return `${year}-W${String(week).padStart(2, "0")}`;
+}
+function shortDigest(d) {
+    const s = typeof d === "string" ? d : "";
+    return s.replace(/^sha256[:-]/, "").slice(0, 12);
+}
+export function createQueries(ctx) {
+    const { db } = ctx;
+    const defaultTz = () => ctx.opts.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    function skillMeta() {
+        const rows = db.prepare("SELECT uri, name, tags_json, group_id FROM skills").all();
+        return new Map(rows.map((r) => [r.uri, { uri: r.uri, name: r.name, tags: parseJson(r.tags_json, []), ...(r.group_id ? { groupId: r.group_id } : {}) }]));
+    }
+    function metaFor(skills, uri) {
+        return skills.get(uri) ?? { uri, name: nameFromUri(uri), tags: [] };
+    }
+    function loadSessions(f, ignoreCellFilter = false) {
+        const where = [];
+        const params = [];
+        if (f.from !== undefined) {
+            where.push("started_at >= ?");
+            params.push(f.from);
+        }
+        if (f.to !== undefined) {
+            where.push("started_at < ?");
+            params.push(f.to);
+        }
+        if (f.runtime && f.runtime.length > 0) {
+            where.push(`runtime IN (${f.runtime.map(() => "?").join(",")})`);
+            params.push(...f.runtime);
+        }
+        const clause = where.length ? `WHERE ${where.join(" AND ")}` : "";
+        const rows = db.prepare(`SELECT id, runtime, started_at, ended_at, first_prompt FROM sessions ${clause}`).all(...params);
+        const events = db.prepare(`SELECT * FROM events WHERE session_id IN (SELECT id FROM sessions ${clause}) ORDER BY ts, rowid`).all(...params);
+        const bySession = new Map();
+        for (const e of events) {
+            const list = bySession.get(e.session_id);
+            if (list)
+                list.push(e);
+            else
+                bySession.set(e.session_id, [e]);
+        }
+        const tz = f.tz ?? defaultTz();
+        const out = [];
+        for (const r of rows) {
+            const evs = bySession.get(r.id) ?? [];
+            const parsed = evs.map((e) => ({ kind: e.kind, data: parseJson(e.data_json, {}) }));
+            const loaded = [];
+            const exposed = [];
+            let firstTop;
+            const texts = [];
+            evs.forEach((e, i) => {
+                const data = parsed[i].data;
+                if (e.kind === "load") {
+                    const uri = e.skill_uri ?? (typeof data.uri === "string" ? data.uri : undefined);
+                    if (uri && !loaded.includes(uri))
+                        loaded.push(uri);
+                }
+                else if (e.kind === "search") {
+                    const cands = [...candidatesOf(data)].sort((a, b) => a.rank - b.rank);
+                    if (firstTop === undefined && cands[0])
+                        firstTop = cands[0].uri;
+                    for (const c of cands)
+                        if (!exposed.includes(c.uri))
+                            exposed.push(c.uri);
+                    if (typeof data.query === "string")
+                        texts.push(data.query);
+                }
+                else if (e.kind === "prompt" && e.text)
+                    texts.push(e.text);
+            });
+            const attributed = evs.find((e) => e.attribution_method !== "none");
+            const info = {
+                id: r.id, runtime: r.runtime, startedAt: r.started_at, events: evs, loaded, exposed, state: adoptionState(parsed),
+                attribution: attributed?.attribution_method ?? "none", texts,
+                ...(r.ended_at !== null ? { endedAt: r.ended_at } : {}),
+                ...(r.first_prompt !== null ? { firstPrompt: r.first_prompt } : {}),
+                ...(firstTop !== undefined ? { firstTop } : {}),
+            };
+            if (f.state && f.state.length > 0 && !f.state.includes(info.state))
+                continue;
+            if (f.skill && f.skill.length > 0 && !f.skill.some((u) => loaded.includes(u) || exposed.includes(u)))
+                continue;
+            if (f.q) {
+                const q = f.q.toLowerCase();
+                if (![info.firstPrompt ?? "", ...texts].some((t) => t.toLowerCase().includes(q)))
+                    continue;
+            }
+            if (!ignoreCellFilter && (f.dow !== undefined || f.hour !== undefined)) {
+                const local = localDowHour(r.started_at, tz);
+                if (f.dow !== undefined && local.dow !== f.dow)
+                    continue;
+                if (f.hour !== undefined) {
+                    const span = f.hourSpan ?? 1;
+                    if (local.hour < f.hour || local.hour >= f.hour + span)
+                        continue;
+                }
+            }
+            out.push(info);
+        }
+        return out;
+    }
+    function sessionSkills(s) {
+        if (s.loaded.length > 0)
+            return s.loaded;
+        return s.firstTop ? [s.firstTop] : [];
+    }
+    return {
+        sessions(f) {
+            return loadSessions(f)
+                .sort((a, b) => b.startedAt - a.startedAt)
+                .map((s) => ({
+                id: s.id, runtime: s.runtime, startedAt: s.startedAt, skills: sessionSkills(s), state: s.state, attribution: s.attribution,
+                ...(s.endedAt !== undefined ? { endedAt: s.endedAt } : {}),
+                ...(s.firstPrompt !== undefined ? { firstPrompt: s.firstPrompt } : {}),
+            }));
+        },
+        trace(sessionId) {
+            const evs = db.prepare("SELECT * FROM events WHERE session_id = ? ORDER BY ts, rowid").all(sessionId);
+            const skills = skillMeta();
+            const loadsByTrace = new Map();
+            for (const e of evs) {
+                if (e.kind !== "load" || !e.trace_id || !e.skill_uri)
+                    continue;
+                const list = loadsByTrace.get(e.trace_id) ?? [];
+                list.push({ ts: e.ts, uri: e.skill_uri });
+                loadsByTrace.set(e.trace_id, list);
+            }
+            const loadRow = db.prepare("SELECT uri, manifest_digest FROM loads WHERE load_id = ?");
+            return evs.map((e) => {
+                const data = parseJson(e.data_json, {});
+                switch (e.kind) {
+                    case "prompt": {
+                        const textLength = e.text_length ?? e.text?.length;
+                        const summary = e.text ? e.text.slice(0, 200) : `(prompt not captured${textLength !== undefined ? `, ${textLength} chars` : ""})`;
+                        return { ts: e.ts, kind: e.kind, summary, detail: { kind: "prompt", ...(e.text !== null ? { text: e.text } : {}), ...(textLength !== undefined ? { textLength } : {}) } };
+                    }
+                    case "search": {
+                        const traceId = e.trace_id ?? (typeof data.traceId === "string" ? data.traceId : "");
+                        const later = (loadsByTrace.get(traceId) ?? []).filter((l) => l.ts >= e.ts).map((l) => l.uri);
+                        const cands = candidatesOf(data).map((c) => ({ ...c, chosen: later.includes(c.uri) }));
+                        const chosen = cands.filter((c) => c.chosen).map((c) => c.uri);
+                        const query = typeof data.query === "string" ? data.query : "";
+                        const abstained = data.abstained;
+                        const summary = abstained
+                            ? `search "${query}" abstained (${abstained.reason}) in ${Number(data.elapsedMs ?? 0)} ms`
+                            : `search "${query}" -> ${cands.length} candidates in ${Number(data.elapsedMs ?? 0)} ms`;
+                        return { ts: e.ts, kind: e.kind, summary, detail: { ...data, kind: "search", traceId, chosen, candidates: cands } };
+                    }
+                    case "load": {
+                        const loadId = e.load_id ?? (typeof data.loadId === "string" ? data.loadId : "");
+                        const stored = loadId ? loadRow.get(loadId) : undefined;
+                        const uri = e.skill_uri ?? stored?.uri ?? (typeof data.uri === "string" ? data.uri : "");
+                        const manifestDigest = typeof data.manifestDigest === "string" ? data.manifestDigest : stored?.manifest_digest ?? "";
+                        return { ts: e.ts, kind: e.kind, summary: `load ${metaFor(skills, uri).name} (${uri}) @${shortDigest(manifestDigest)}`,
+                            detail: { kind: "load", uri, loadId, manifestDigest } };
+                    }
+                    case "read_file": {
+                        const uri = typeof data.uri === "string" ? data.uri : "";
+                        const bytes = Number(data.bytes ?? data.size ?? 0);
+                        const skillUri = e.skill_uri ?? (typeof data.skillUri === "string" ? data.skillUri : "");
+                        return { ts: e.ts, kind: e.kind, summary: `read ${uri} (${bytes} bytes)`, detail: { kind: "read_file", skillUri, uri, bytes } };
+                    }
+                    case "native_skill": {
+                        const name = typeof data.name === "string" ? data.name : e.skill_uri ? nameFromUri(e.skill_uri) : "unknown";
+                        const via = typeof data.via === "string" ? data.via : "tool";
+                        return { ts: e.ts, kind: e.kind, summary: `native skill ${name} via ${via}`, detail: { kind: "native_skill", name, via } };
+                    }
+                    case "error": {
+                        const code = typeof data.code === "string" ? data.code : "error";
+                        const message = typeof data.message === "string" ? data.message : e.text ?? "";
+                        return { ts: e.ts, kind: e.kind, summary: `error ${code}${message ? `: ${message.slice(0, 200)}` : ""}`, detail: { kind: "error", code, message } };
+                    }
+                    default:
+                        return { ts: e.ts, kind: e.kind, summary: e.kind === "session_start" ? "session started" : "session ended", detail: { kind: e.kind } };
+                }
+            });
+        },
+        flow(f, unit, top = 7) {
+            const limit = Math.min(15, Math.max(1, Math.floor(top)));
+            const sessions = loadSessions(f);
+            const skills = skillMeta();
+            const paths = [];
+            for (const s of sessions) {
+                const primary = s.loaded[0] ?? s.firstTop;
+                const task = classifyTaskType(primary ? metaFor(skills, primary) : undefined, s.firstPrompt ?? s.texts[0]);
+                const skillList = unit === "all_loads" && s.loaded.length > 0 ? s.loaded : primary ? [primary] : ["(none)"];
+                for (const sk of skillList)
+                    paths.push({ session: s.id, task, skill: sk, state: s.state });
+            }
+            const OTHER = "__other__";
+            const otherMembers = [new Set(), new Set(), new Set()];
+            const keep = (values, column) => {
+                const sessionsBy = new Map();
+                paths.forEach((p, i) => {
+                    const v = values[i];
+                    const set = sessionsBy.get(v) ?? new Set();
+                    set.add(p.session);
+                    sessionsBy.set(v, set);
+                });
+                const ranked = [...sessionsBy.entries()].sort((a, b) => b[1].size - a[1].size || a[0].localeCompare(b[0]));
+                const map = new Map();
+                ranked.forEach(([v], i) => {
+                    if (i < limit)
+                        map.set(v, v);
+                    else {
+                        map.set(v, OTHER);
+                        otherMembers[column].add(v);
+                    }
+                });
+                return map;
+            };
+            const taskMap = keep(paths.map((p) => p.task), 0);
+            const skillMap = keep(paths.map((p) => p.skill), 1);
+            const stateMap = keep(paths.map((p) => p.state), 2);
+            const mapped = paths.map((p) => ({ session: p.session, state: p.state, task: taskMap.get(p.task), skill: skillMap.get(p.skill), stateNode: stateMap.get(p.state) }));
+            const countLinks = () => {
+                const left = new Map();
+                const right = new Map();
+                const add = (m, k, s) => { const set = m.get(k) ?? new Set(); set.add(s); m.set(k, set); };
+                for (const p of mapped) {
+                    add(left, `${p.task}\u0000${p.skill}\u0000${p.state}`, p.session);
+                    add(right, `${p.skill}\u0000${p.stateNode}\u0000${p.state}`, p.session);
+                }
+                return { left, right };
+            };
+            const before = countLinks();
+            for (const p of mapped) {
+                if (p.skill === OTHER)
+                    continue;
+                const weakLeft = (before.left.get(`${p.task}\u0000${p.skill}\u0000${p.state}`)?.size ?? 0) < 2;
+                const weakRight = (before.right.get(`${p.skill}\u0000${p.stateNode}\u0000${p.state}`)?.size ?? 0) < 2;
+                if (weakLeft || weakRight) {
+                    otherMembers[1].add(p.skill);
+                    p.skill = OTHER;
+                }
+            }
+            const after = countLinks();
+            const nodeId = (column, v) => `${["t", "s", "a"][column]}:${v}`;
+            const nodeSessions = new Map();
+            const touch = (column, v, s) => {
+                const id = nodeId(column, v);
+                const n = nodeSessions.get(id) ?? { column, value: v, sessions: new Set() };
+                n.sessions.add(s);
+                nodeSessions.set(id, n);
+            };
+            for (const p of mapped) {
+                touch(0, p.task, p.session);
+                touch(1, p.skill, p.session);
+                touch(2, p.stateNode, p.session);
+            }
+            const label = (column, v) => v === OTHER ? `Other (${otherMembers[column].size})` : column === 1 ? (v === "(none)" ? "(no skill)" : metaFor(skills, v).name) : v;
+            const nodes = [...nodeSessions.entries()]
+                .sort((a, b) => a[1].column - b[1].column || Number(a[1].value === OTHER) - Number(b[1].value === OTHER) || b[1].sessions.size - a[1].sessions.size)
+                .map(([id, n]) => ({ id, column: n.column, label: label(n.column, n.value), count: n.sessions.size, ...(n.value === OTHER ? { other: true } : {}) }));
+            const links = [];
+            for (const [k, set] of after.left) {
+                const [task, skill, state] = k.split("\u0000");
+                links.push({ source: nodeId(0, task), target: nodeId(1, skill), count: set.size, state });
+            }
+            for (const [k, set] of after.right) {
+                const [skill, stateNode, state] = k.split("\u0000");
+                links.push({ source: nodeId(1, skill), target: nodeId(2, stateNode), count: set.size, state });
+            }
+            links.sort((a, b) => b.count - a.count);
+            return { unit, columns: ["task_type", "skill", "state"], nodes, links, sessionCount: sessions.length };
+        },
+        heatmap(f, tz, weekStart, bucketHours) {
+            const buckets = 24 / bucketHours;
+            const grid = Array.from({ length: 7 }, () => new Array(buckets).fill(0));
+            for (const s of loadSessions(f, true)) {
+                const { dow, hour } = localDowHour(s.startedAt, tz);
+                grid[dow][Math.floor(hour / bucketHours)] += 1;
+            }
+            const cells = [];
+            for (let i = 0; i < 7; i++) {
+                const dow = (weekStart + i) % 7;
+                for (let b = 0; b < buckets; b++)
+                    cells.push({ dow, hour: b * bucketHours, count: grid[dow][b] });
+            }
+            const rowTotals = grid.map((row) => row.reduce((a, n) => a + n, 0));
+            const colTotals = Array.from({ length: buckets }, (_, b) => grid.reduce((a, row) => a + row[b], 0));
+            return { tz, weekStart, bucketHours, cells, rowTotals, colTotals };
+        },
+        skillWeek(f) {
+            const lastWeek = isoWeekStart(f.to !== undefined ? f.to - 1 : ctx.now());
+            const starts = Array.from({ length: 8 }, (_, i) => lastWeek - (7 - i) * WEEK_MS);
+            const from = starts[0];
+            const to = lastWeek + WEEK_MS;
+            const where = ["kind = 'load'", "skill_uri IS NOT NULL", "ts >= ?", "ts < ?"];
+            const params = [from, to];
+            if (f.runtime && f.runtime.length > 0) {
+                where.push(`runtime IN (${f.runtime.map(() => "?").join(",")})`);
+                params.push(...f.runtime);
+            }
+            if (f.skill && f.skill.length > 0) {
+                where.push(`skill_uri IN (${f.skill.map(() => "?").join(",")})`);
+                params.push(...f.skill);
+            }
+            const rows = db.prepare(`SELECT skill_uri, ts FROM events WHERE ${where.join(" AND ")}`).all(...params);
+            const skills = skillMeta();
+            const counts = new Map();
+            for (const r of rows) {
+                const idx = Math.floor((r.ts - from) / WEEK_MS);
+                const arr = counts.get(r.skill_uri) ?? new Array(8).fill(0);
+                arr[idx] += 1;
+                counts.set(r.skill_uri, arr);
+            }
+            const out = [...counts.entries()]
+                .map(([uri, c]) => ({ uri, name: metaFor(skills, uri).name, counts: c }))
+                .sort((a, b) => b.counts.reduce((x, y) => x + y, 0) - a.counts.reduce((x, y) => x + y, 0) || a.name.localeCompare(b.name));
+            return { weeks: starts.map(isoWeekLabel), rows: out };
+        },
+        stats(f = {}) {
+            const attributionRate = Object.fromEntries(RUNTIMES.map((r) => [r, null]));
+            const mcp = db.prepare(`SELECT runtime, COUNT(*) AS total, SUM(CASE WHEN session_id != 'unattributed' THEN 1 ELSE 0 END) AS attributed
+        FROM events WHERE source = 'mcp' GROUP BY runtime`).all();
+            for (const r of mcp)
+                attributionRate[r.runtime] = r.total > 0 ? r.attributed / r.total : null;
+            const where = ["source = 'mcp'", "session_id = 'unattributed'", "kind IN ('search', 'load')"];
+            const params = [];
+            if (f.from !== undefined) {
+                where.push("ts >= ?");
+                params.push(f.from);
+            }
+            if (f.to !== undefined) {
+                where.push("ts < ?");
+                params.push(f.to);
+            }
+            if (f.runtime && f.runtime.length > 0) {
+                where.push(`runtime IN (${f.runtime.map(() => "?").join(",")})`);
+                params.push(...f.runtime);
+            }
+            const orphan = db.prepare(`SELECT kind, COUNT(*) AS n FROM events WHERE ${where.join(" AND ")} GROUP BY kind`).all(...params);
+            const unattributed = { searches: orphan.find((o) => o.kind === "search")?.n ?? 0, loads: orphan.find((o) => o.kind === "load")?.n ?? 0 };
+            const searches = db.prepare("SELECT data_json FROM events WHERE kind = 'search'").all();
+            const abstained = searches.filter((s) => parseJson(s.data_json, {}).abstained).length;
+            const cutoff = ctx.now() - 56 * DAY_MS;
+            const unused = db.prepare(`SELECT uri FROM skills WHERE removed_at IS NULL AND uri NOT IN
+        (SELECT skill_uri FROM events WHERE kind = 'load' AND skill_uri IS NOT NULL AND ts >= ?) ORDER BY name`).all(cutoff);
+            const last = db.prepare("SELECT MAX(ts) AS ts FROM events").get();
+            const byRuntime = db.prepare("SELECT runtime, MAX(ts) AS ts FROM events GROUP BY runtime").all();
+            return {
+                attributionRate,
+                abstainRate: searches.length > 0 ? abstained / searches.length : 0,
+                unusedSkills: unused.map((u) => u.uri),
+                ...(last.ts !== null ? { lastEventTs: last.ts } : {}),
+                lastEventByRuntime: Object.fromEntries(byRuntime.map((r) => [r.runtime, r.ts])),
+                ingest: readIngestCounters(db),
+                unattributed,
+            };
+        },
+    };
+}

package/dist/store/schema.sql

@@ -0,0 +1,96 @@
+-- gisool store schema, user_version 1
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+
+CREATE TABLE IF NOT EXISTS skills (
+  uri TEXT PRIMARY KEY,
+  root_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  when_to_use TEXT,
+  examples_json TEXT NOT NULL DEFAULT '[]',
+  aliases_ko_json TEXT NOT NULL DEFAULT '[]',
+  group_id TEXT,
+  group_stage TEXT,
+  invocation TEXT NOT NULL DEFAULT 'automatic',
+  body_head TEXT NOT NULL DEFAULT '',
+  digest TEXT NOT NULL,
+  manifest_digest TEXT NOT NULL,
+  resources_json TEXT NOT NULL DEFAULT '[]',
+  mtime_ms INTEGER NOT NULL DEFAULT 0,
+  removed_at INTEGER
+);
+
+-- uri is stored UNINDEXED so rows join back to skills(uri).
+CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+  uri UNINDEXED,
+  name,
+  description,
+  when_to_use,
+  examples,
+  aliases_ko,
+  body_head,
+  tokenize = 'trigram'
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  runtime TEXT NOT NULL,
+  runtime_session_id TEXT,
+  conversation_id TEXT,
+  client_name TEXT,
+  cwd TEXT,
+  started_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  first_prompt TEXT
+);
+CREATE INDEX IF NOT EXISTS sessions_runtime_session ON sessions(runtime, runtime_session_id);
+CREATE INDEX IF NOT EXISTS sessions_runtime_conversation ON sessions(runtime, conversation_id);
+CREATE INDEX IF NOT EXISTS sessions_started ON sessions(started_at);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  ts INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  source TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  attribution_method TEXT NOT NULL,
+  attribution_reason TEXT,
+  runtime TEXT NOT NULL,
+  trace_id TEXT,
+  load_id TEXT,
+  skill_uri TEXT,
+  tool_use_id TEXT,
+  text TEXT,
+  text_digest TEXT,
+  text_length INTEGER,
+  data_json TEXT NOT NULL DEFAULT '{}'
+);
+CREATE INDEX IF NOT EXISTS events_session_ts ON events(session_id, ts);
+CREATE INDEX IF NOT EXISTS events_ts ON events(ts);
+CREATE INDEX IF NOT EXISTS events_trace ON events(trace_id);
+CREATE INDEX IF NOT EXISTS events_skill ON events(skill_uri);
+CREATE INDEX IF NOT EXISTS events_tool_use ON events(tool_use_id);
+
+CREATE TABLE IF NOT EXISTS loads (
+  load_id TEXT PRIMARY KEY,
+  trace_id TEXT,
+  uri TEXT NOT NULL,
+  manifest_digest TEXT NOT NULL,
+  resources_json TEXT NOT NULL DEFAULT '[]',
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS loads_uri_created ON loads(uri, created_at);
+
+CREATE TABLE IF NOT EXISTS eval_cases (
+  id TEXT PRIMARY KEY,
+  query TEXT NOT NULL,
+  expected_uri TEXT,
+  from_trace_id TEXT,
+  created_at INTEGER NOT NULL
+);
+
+PRAGMA user_version = 1;