dsh-continual-evolve 0.15.4 → 0.15.6

package/lib/store.js

@@ -10,11 +10,14 @@
  * guarantees v26). Unavailability is a typed error the entry point degrades
  * on — injection and tooling switch off, the host keeps running.
  */
-import { mkdirSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { secretLeakReason } from "./memory-rules.js";
+import { globalSkillsDir, projectSkillsDir, renderSkillMarkdown, SKILL_GENERATED_MARKER, skillDir, skillFieldGateReasons, slugifySkillId, validateRenderedSkill, } from "./skill-rules.js";
+import { isValidMemoryId } from "./memory-rules.js";
 import { applyProposals } from "./store-apply.js";
+import { normalizeUsage, sumUsage, zeroUsage } from "./token-usage.js";
 /** Thrown when the runtime lacks `node:sqlite` — the degrade signal. */
 export class StoreUnavailableError extends Error {
 }
@@ -72,8 +75,47 @@ CREATE TABLE IF NOT EXISTS extraction_log (
 CREATE TABLE IF NOT EXISTS state (
   workspace_id TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL,
   PRIMARY KEY (workspace_id, key)
+);
+CREATE TABLE IF NOT EXISTS skills (
+  workspace_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL,
+  body TEXT NOT NULL CHECK (length(body) <= 65536),
+  status TEXT NOT NULL DEFAULT 'active'
+    CHECK (status IN ('active','quarantined','archived')),
+  source_session TEXT,
+  source_seqs TEXT,
+  source_run TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, id)
+) STRICT;
+CREATE INDEX IF NOT EXISTS idx_skill_ws_status ON skills(workspace_id, status);
+CREATE INDEX IF NOT EXISTS idx_skill_ws_updated ON skills(workspace_id, updated_at);
+CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+  workspace_id, id, title, description, body, tokenize='trigram');
+-- Like memories_fts, synced in code by the skill apply path (plain DELETE +
+-- INSERT), never by triggers, for the same node:sqlite FTS5 reason.
+CREATE TABLE IF NOT EXISTS skill_log (
+  run_id TEXT, ts TEXT NOT NULL, session_id TEXT, workspace_id TEXT,
+  trigger TEXT, decision TEXT, status TEXT, files TEXT, warnings TEXT
+);
+-- Skill usage counters (V2 usage loop): one aggregate row per skill, never a
+-- per-hit ledger, so the table cannot grow without bound and needs no prune.
+CREATE TABLE IF NOT EXISTS skill_usage (
+  workspace_id TEXT NOT NULL,
+  skill_id TEXT NOT NULL,
+  scope TEXT NOT NULL CHECK (scope IN ('project','global')),
+  use_count INTEGER NOT NULL DEFAULT 0,
+  last_used_at TEXT,
+  PRIMARY KEY (workspace_id, skill_id, scope)
 ) STRICT;
 `;
+/** The empty audit view: no rows, no signal — never a failure. */
+export function zeroReviewSummary() {
+    return { applied: 0, rejected: 0, skipped: 0, failed: 0, topSkips: [], tokens: zeroUsage() };
+}
 /** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
 export function defaultStorePath() {
     const home = process.env.DSH_HOME?.trim();
@@ -95,6 +137,21 @@ function recordOf(row) {
         updatedAt: row.updated_at,
     };
 }
+function skillRecordOf(row) {
+    return {
+        workspaceId: row.workspace_id,
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        body: row.body,
+        status: row.status,
+        sourceSession: row.source_session,
+        sourceSeqs: row.source_seqs,
+        sourceRun: row.source_run,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
 const LIST_ORDER = "ORDER BY CASE type WHEN 'feedback' THEN 0 WHEN 'user' THEN 1 ELSE 2 END, updated_at DESC";
 /** Quote one token as an FTS5 phrase (trigram needs ≥3 chars to match). */
 function ftsPhrase(token) {
@@ -113,6 +170,83 @@ function queryTokens(query) {
 function likePattern(token) {
     return `%${token.replaceAll(/[\\%_]/g, "\\$&")}%`;
 }
+/** The materialized directory for one skill partition (global vs project). */
+function skillRootOf(workspaceId) {
+    return workspaceId === "" ? globalSkillsDir() : projectSkillsDir(workspaceId);
+}
+/** Read a materialized file, undefined when missing or unreadable. */
+function readSkillFile(root, id) {
+    let dir;
+    try {
+        dir = skillDir(root, id);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return readFileSync(join(dir, "SKILL.md"), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write one active skill row as its SKILL.md (atomic tmp + rename so the
+ * host watcher never sees a partial file). Returns materialization warnings —
+ * the row already landed, so the caller surfaces them instead of failing.
+ */
+function writeSkillFile(root, record) {
+    const rendered = renderSkillMarkdown(record);
+    const warnings = validateRenderedSkill(record).map((problem) => ({ id: record.id, warning: `skill ${record.id}: ${problem}` }));
+    let dir;
+    try {
+        dir = skillDir(root, record.id);
+    }
+    catch (error) {
+        return [{ id: record.id, warning: `skill ${record.id}: ${error instanceof Error ? error.message : String(error)}` }];
+    }
+    try {
+        mkdirSync(dir, { recursive: true });
+        const temp = join(dir, `SKILL.md.${process.pid}.tmp`);
+        writeFileSync(temp, rendered, "utf8");
+        renameSync(temp, join(dir, "SKILL.md"));
+    }
+    catch (error) {
+        warnings.push({ id: record.id, warning: `skill ${record.id}: file write failed, patrol will retry: ${error instanceof Error ? error.message : String(error)}` });
+    }
+    return warnings;
+}
+/**
+ * Remove one skill's materialized directory after its row left the active
+ * set. Only files carrying the generated marker are removed — a hand-written
+ * skill that happens to share the directory is left in place with a warning.
+ */
+function removeSkillFile(root, id) {
+    let dir;
+    try {
+        dir = skillDir(root, id);
+    }
+    catch (error) {
+        return [{ id, warning: `skill ${id}: ${error instanceof Error ? error.message : String(error)}` }];
+    }
+    let current;
+    try {
+        current = readFileSync(join(dir, "SKILL.md"), "utf8");
+    }
+    catch {
+        return [];
+    }
+    if (!current.includes(SKILL_GENERATED_MARKER)) {
+        return [{ id, warning: `skill ${id}: ${join(dir, "SKILL.md")} is hand-written, left in place` }];
+    }
+    try {
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch (error) {
+        return [{ id, warning: `skill ${id}: file removal failed, patrol will retry: ${error instanceof Error ? error.message : String(error)}` }];
+    }
+    return [];
+}
 /** Open (creating on first use) the central store. */
 export async function openMemoryStore(explicitPath) {
     const path = explicitPath === undefined ? defaultStorePath() : resolve(explicitPath);
@@ -145,6 +279,8 @@ export async function openMemoryStore(explicitPath) {
             "WHERE workspace_id IS NOT NULL AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
         recentMemory: database.prepare("SELECT workspace_id, MAX(updated_at) AS ts FROM memories " +
             "WHERE status = 'active' AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
+        recentSkill: database.prepare("SELECT workspace_id, MAX(ts) AS ts FROM skill_log " +
+            "WHERE workspace_id IS NOT NULL AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
         ledger: database.prepare("INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
             "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
         latestSkip: database.prepare("SELECT rowid AS rid, skip_reason AS reason, status FROM extraction_log " +
@@ -155,6 +291,30 @@ export async function openMemoryStore(explicitPath) {
         ftsDrop: database.prepare("DELETE FROM memories_fts WHERE rowid = ?"),
         activeRows: database.prepare("SELECT * FROM memories WHERE status = 'active'"),
         quarantine: database.prepare("UPDATE memories SET status = 'quarantined' WHERE workspace_id = ? AND id = ?"),
+        skillGet: database.prepare("SELECT * FROM skills WHERE workspace_id = ? AND id = ?"),
+        skillList: database.prepare("SELECT * FROM skills WHERE workspace_id = ? AND status = 'active' ORDER BY updated_at DESC"),
+        skillListAll: database.prepare("SELECT * FROM skills WHERE workspace_id = ? AND status != 'archived' ORDER BY updated_at DESC"),
+        skillFts: database.prepare(`SELECT s.* FROM skills s WHERE (s.workspace_id, s.id) IN (
+				 SELECT workspace_id, id FROM skills_fts WHERE skills_fts MATCH ? AND workspace_id = ?
+				) AND s.status = 'active' ORDER BY updated_at DESC LIMIT ?`),
+        skillInsert: database.prepare("INSERT INTO skills (workspace_id, id, title, description, body, status, source_session, source_seqs, source_run, created_at, updated_at) " +
+            "VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)"),
+        skillUpdate: database.prepare("UPDATE skills SET title = ?, description = ?, body = ?, updated_at = ? WHERE workspace_id = ? AND id = ?"),
+        skillArchive: database.prepare("UPDATE skills SET status = 'archived', updated_at = ? WHERE workspace_id = ? AND id = ?"),
+        skillDelete: database.prepare("DELETE FROM skills WHERE workspace_id = ? AND id = ?"),
+        skillSameBody: database.prepare("SELECT id FROM skills WHERE workspace_id = ? AND status = 'active' AND body = ? LIMIT 1"),
+        skillLog: database.prepare("INSERT INTO skill_log (run_id, ts, session_id, workspace_id, trigger, decision, status, files, warnings) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        skillPrune: database.prepare("DELETE FROM skill_log WHERE ts < ?"),
+        skillFtsOrphans: database.prepare("SELECT f.rowid AS rid FROM skills_fts f LEFT JOIN skills m ON m.workspace_id = f.workspace_id AND m.id = f.id WHERE m.id IS NULL"),
+        skillFtsDrop: database.prepare("DELETE FROM skills_fts WHERE rowid = ?"),
+        skillActiveRows: database.prepare("SELECT * FROM skills WHERE status = 'active'"),
+        skillQuarantine: database.prepare("UPDATE skills SET status = 'quarantined' WHERE workspace_id = ? AND id = ?"),
+        skillWorkspaces: database.prepare("SELECT workspace_id, COUNT(*) AS n, MAX(updated_at) AS u FROM skills WHERE status = 'active' GROUP BY workspace_id ORDER BY u DESC"),
+        reviewRows: database.prepare("SELECT status, skip_reason, usage FROM extraction_log WHERE workspace_id = ? AND ts >= ?"),
+        skillUseGet: database.prepare("SELECT use_count, last_used_at FROM skill_usage WHERE workspace_id = ? AND skill_id = ? AND scope = ?"),
+        skillUseUpsert: database.prepare("INSERT INTO skill_usage (workspace_id, skill_id, scope, use_count, last_used_at) VALUES (?, ?, ?, 1, ?) " +
+            "ON CONFLICT (workspace_id, skill_id, scope) DO UPDATE SET use_count = use_count + 1, last_used_at = excluded.last_used_at"),
     };
     // LIKE fallback: one OR-triplet per token, every token required. Statements
     // are cached by token count — the query set repeats, the counts don't grow.
@@ -195,6 +355,261 @@ export async function openMemoryStore(explicitPath) {
         stmts.bumpSkip.run(new Date().toISOString(), latest.rid);
         return true;
     };
+    // Skill LIKE fallback mirrors the memory one: one OR-triplet per token,
+    // every token required, statements cached by token count.
+    const skillLikeStmts = new Map();
+    const skillLikeSearch = (workspaceId, tokens, limit) => {
+        let stmt = skillLikeStmts.get(tokens.length);
+        if (stmt === undefined) {
+            const clause = tokens
+                .map(() => "(title LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\' OR body LIKE ? ESCAPE '\\')")
+                .join(" AND ");
+            stmt = database.prepare(`SELECT * FROM skills WHERE workspace_id = ? AND status = 'active' AND ${clause} ORDER BY updated_at DESC LIMIT ?`);
+            skillLikeStmts.set(tokens.length, stmt);
+        }
+        const patterns = tokens.flatMap((token) => {
+            const pattern = likePattern(token);
+            return [pattern, pattern, pattern];
+        });
+        return stmt.all(workspaceId, ...patterns, limit).map(skillRecordOf);
+    };
+    /** Re-sync the FTS row for one skill id from its table row (delete + insert). */
+    const skillFtsSync = (workspaceId, id) => {
+        database.prepare("DELETE FROM skills_fts WHERE rowid IN (SELECT rowid FROM skills_fts WHERE workspace_id = ? AND id = ?)").run(workspaceId, id);
+        database.prepare("INSERT INTO skills_fts (workspace_id, id, title, description, body) SELECT workspace_id, id, title, description, body FROM skills WHERE workspace_id = ? AND id = ?").run(workspaceId, id);
+    };
+    const writeSkillLedger = (entry) => {
+        stmts.skillLog.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.status ?? null, entry.files === undefined ? null : JSON.stringify(entry.files), entry.warnings === undefined ? null : JSON.stringify(entry.warnings));
+    };
+    /** The proposal id, derived from the title (slug, CJK-hash fallback) on create. */
+    const skillIdFor = (proposal) => {
+        if (proposal.id !== undefined && proposal.id.trim().length > 0) {
+            return proposal.id.trim();
+        }
+        if (proposal.action === "create" && typeof proposal.title === "string") {
+            return slugifySkillId(proposal.title);
+        }
+        return "";
+    };
+    /** The scope update/delete targets (`global` only when asked for). */
+    const skillScopeOf = (proposal) => {
+        if (proposal.scope !== undefined && proposal.scope !== "project" && proposal.scope !== "global") {
+            return { reason: `scope must be "project" or "global", got "${proposal.scope}"` };
+        }
+        return proposal.scope ?? "project";
+    };
+    /** The partition a scope names: global rows live in `""`, project rows in the context workspace. */
+    const skillPartitionOf = (ctx, scope) => (scope === "global" ? "" : ctx.workspaceId);
+    const skillFail = (proposal, reason) => ({
+        id: proposal.id ?? "",
+        action: proposal.action,
+        ok: false,
+        reason,
+    });
+    /** The merged field values a skill create/update would write. */
+    const mergedSkillFields = (proposal, existing, action) => {
+        const pick = (value, fallback) => (typeof value === "string" ? value : fallback);
+        if (action === "create") {
+            if (typeof proposal.title !== "string" || typeof proposal.description !== "string" || typeof proposal.body !== "string") {
+                return { reason: "create requires id?, title, description, body" };
+            }
+            return { fields: { title: proposal.title, description: proposal.description, body: proposal.body } };
+        }
+        if (existing === undefined) {
+            return { reason: "no skill to merge into" };
+        }
+        return {
+            fields: {
+                title: pick(proposal.title, existing.title),
+                description: pick(proposal.description, existing.description),
+                body: pick(proposal.body, existing.body),
+            },
+        };
+    };
+    const identicalSkill = (a, fields) => a.title === fields.title && a.description === fields.description && a.body === fields.body;
+    /** Validate one skill proposal and land it; file work happens post-commit via intents. */
+    const applySkillOne = (ctx, proposal, now, files, intents) => {
+        const action = proposal.action;
+        if (action !== "create" && action !== "update" && action !== "delete" && action !== "move-to-global") {
+            return skillFail(proposal, `unknown action ${String(action)}`);
+        }
+        const id = skillIdFor(proposal);
+        if (!isValidMemoryId(id)) {
+            return skillFail(proposal, id.length === 0 ? "id missing and cannot be derived from the title" : `malformed id "${id}"`);
+        }
+        if (action === "create") {
+            if (ctx.workspaceId === "") {
+                return skillFail(proposal, "skills are created in a project — move one to global explicitly afterwards");
+            }
+            const merged = mergedSkillFields(proposal, undefined, "create");
+            if ("reason" in merged) {
+                return skillFail(proposal, merged.reason);
+            }
+            const reasons = skillFieldGateReasons(merged.fields);
+            if (reasons.length > 0) {
+                return skillFail(proposal, reasons[0] ?? "invalid skill");
+            }
+            const projectRow = stmts.skillGet.get(ctx.workspaceId, id);
+            if (projectRow !== undefined && projectRow.status !== "archived") {
+                return skillFail(proposal, `skill "${id}" already exists in this project — update it instead of creating a duplicate`);
+            }
+            const globalRow = stmts.skillGet.get("", id);
+            if (globalRow !== undefined && globalRow.status !== "archived") {
+                const global = skillRecordOf(globalRow);
+                if (identicalSkill(global, merged.fields)) {
+                    return skillFail(proposal, `identical global skill "${id}" already exists — call it directly, nothing to create`);
+                }
+                return skillFail(proposal, `global skill "${id}" exists with different content — rename yours, or delete the global row first`);
+            }
+            const sameBody = stmts.skillSameBody.get(ctx.workspaceId, merged.fields.body);
+            if (sameBody !== undefined && sameBody.id !== id) {
+                return skillFail(proposal, `identical skill "${sameBody.id}" already exists in this project — reuse it instead of duplicating`);
+            }
+            const sameGlobalBody = stmts.skillSameBody.get("", merged.fields.body);
+            if (sameGlobalBody !== undefined) {
+                return skillFail(proposal, `identical global skill "${sameGlobalBody.id}" already exists — call it directly instead of duplicating`);
+            }
+            stmts.skillInsert.run(ctx.workspaceId, id, merged.fields.title, merged.fields.description, merged.fields.body, ctx.sessionId ?? null, proposal.sourceSeqs ?? null, ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : null), now, now);
+            skillFtsSync(ctx.workspaceId, id);
+            files.push({ id, action, scope: "project", after: skillRecordOf(stmts.skillGet.get(ctx.workspaceId, id)), sourceSeqs: proposal.sourceSeqs });
+            intents.push({ partition: ctx.workspaceId, id, op: "write" });
+            return { id, action, ok: true };
+        }
+        if (action === "move-to-global") {
+            const projectRow = stmts.skillGet.get(ctx.workspaceId, id);
+            if (projectRow === undefined || projectRow.status === "archived") {
+                return skillFail(proposal, `no project skill "${id}" to move — create it in the project first`);
+            }
+            const project = skillRecordOf(projectRow);
+            if (project.status !== "active") {
+                return skillFail(proposal, `project skill "${id}" is ${project.status} — only active skills move to global`);
+            }
+            const globalRow = stmts.skillGet.get("", id);
+            if (globalRow !== undefined && globalRow.status !== "archived") {
+                return skillFail(proposal, `global skill "${id}" already exists — delete it first, or keep the project copy shadowing it`);
+            }
+            const reasons = skillFieldGateReasons({ title: project.title, description: project.description, body: project.body });
+            if (reasons.length > 0) {
+                return skillFail(proposal, reasons[0] ?? "invalid skill");
+            }
+            stmts.skillInsert.run("", id, project.title, project.description, project.body, project.sourceSession, project.sourceSeqs, ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : null), now, now);
+            skillFtsSync("", id);
+            stmts.skillArchive.run(now, ctx.workspaceId, id);
+            skillFtsSync(ctx.workspaceId, id);
+            files.push({ id, action, scope: "project", before: project });
+            files.push({ id, action, scope: "global", after: skillRecordOf(stmts.skillGet.get("", id)) });
+            intents.push({ partition: "", id, op: "write" });
+            intents.push({ partition: ctx.workspaceId, id, op: "remove" });
+            return { id, action, ok: true };
+        }
+        const scope = skillScopeOf(proposal);
+        if (typeof scope !== "string") {
+            return skillFail(proposal, scope.reason);
+        }
+        const partition = skillPartitionOf(ctx, scope);
+        const existingRow = stmts.skillGet.get(partition, id);
+        const existing = existingRow === undefined || existingRow.status === "archived" ? undefined : skillRecordOf(existingRow);
+        if (action === "delete") {
+            if (existing === undefined) {
+                return skillFail(proposal, `no ${scope} skill "${id}" to delete`);
+            }
+            stmts.skillDelete.run(partition, id);
+            skillFtsSync(partition, id);
+            files.push({ id, action, scope, before: existing });
+            intents.push({ partition, id, op: "remove" });
+            return { id, action, ok: true };
+        }
+        // action === "update"
+        if (existing === undefined) {
+            return skillFail(proposal, `no ${scope} skill "${id}" to update — create it in the project instead`);
+        }
+        const merged = mergedSkillFields(proposal, existing, "update");
+        if ("reason" in merged) {
+            return skillFail(proposal, merged.reason);
+        }
+        const reasons = skillFieldGateReasons(merged.fields);
+        if (reasons.length > 0) {
+            return skillFail(proposal, reasons[0] ?? "invalid skill");
+        }
+        stmts.skillUpdate.run(merged.fields.title, merged.fields.description, merged.fields.body, now, partition, id);
+        skillFtsSync(partition, id);
+        files.push({ id, action, scope, before: existing, after: skillRecordOf(stmts.skillGet.get(partition, id)) });
+        intents.push({ partition, id, op: "write" });
+        return { id, action, ok: true };
+    };
+    /**
+     * Bring every managed SKILL.md back in line with the store: rewrite
+     * missing or drifted files, drop orphan managed files. Only files
+     * carrying the generated marker are ever written or removed.
+     */
+    const reconcileSkillFiles = (result) => {
+        const active = stmts.skillActiveRows.all();
+        for (const row of active) {
+            const record = skillRecordOf(row);
+            const root = skillRootOf(record.workspaceId);
+            let current;
+            try {
+                current = readSkillFile(root, record.id);
+            }
+            catch {
+                current = undefined;
+            }
+            if (current === renderSkillMarkdown(record)) {
+                continue;
+            }
+            try {
+                const problems = writeSkillFile(root, record);
+                if (problems.length === 0) {
+                    result.skillFilesReconciled += 1;
+                }
+                else {
+                    result.skillFileErrors += 1;
+                }
+            }
+            catch {
+                result.skillFileErrors += 1;
+            }
+        }
+        const roots = new Map();
+        for (const row of active) {
+            roots.set(skillRootOf(row.workspace_id), row.workspace_id);
+        }
+        roots.set(skillRootOf(""), "");
+        for (const [root, partition] of roots) {
+            let names;
+            try {
+                names = readdirSync(root, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => entry.name);
+            }
+            catch {
+                continue;
+            }
+            for (const name of names) {
+                let content;
+                try {
+                    content = readFileSync(join(root, name, "SKILL.md"), "utf8");
+                }
+                catch {
+                    continue;
+                }
+                if (!content.includes(SKILL_GENERATED_MARKER)) {
+                    continue;
+                }
+                const row = stmts.skillGet.get(partition, name);
+                if (row !== undefined && row.status === "active") {
+                    continue;
+                }
+                try {
+                    rmSync(join(root, name), { recursive: true, force: true });
+                    result.skillOrphanFilesRemoved += 1;
+                }
+                catch {
+                    result.skillFileErrors += 1;
+                }
+            }
+        }
+    };
     const store = {
         path,
         get(workspaceId, id) {
@@ -251,9 +666,9 @@ export async function openMemoryStore(explicitPath) {
             }));
         },
         mostRecentlyActiveWorkspace() {
-            // Both instants are ISO-8601 UTC, so the newer one is the greater
-            // string; comparing them keeps the two sources one ordering.
-            const rows = [stmts.recentLedger.get(), stmts.recentMemory.get()];
+            // All instants are ISO-8601 UTC, so the newer one is the greater
+            // string; comparing them keeps the three sources one ordering.
+            const rows = [stmts.recentLedger.get(), stmts.recentMemory.get(), stmts.recentSkill.get()];
             let best;
             for (const row of rows) {
                 const workspaceId = row?.workspace_id;
@@ -268,7 +683,16 @@ export async function openMemoryStore(explicitPath) {
             return best?.workspaceId;
         },
         patrol() {
-            const result = { ts: new Date().toISOString(), orphanFtsRows: 0, quarantined: [] };
+            const result = {
+                ts: new Date().toISOString(),
+                orphanFtsRows: 0,
+                quarantined: [],
+                skillOrphanFtsRows: 0,
+                skillQuarantined: [],
+                skillFilesReconciled: 0,
+                skillOrphanFilesRemoved: 0,
+                skillFileErrors: 0,
+            };
             for (const row of stmts.ftsOrphans.all()) {
                 stmts.ftsDrop.run(row.rid);
                 result.orphanFtsRows += 1;
@@ -280,15 +704,174 @@ export async function openMemoryStore(explicitPath) {
                     result.quarantined.push({ workspaceId: row.workspace_id, id: row.id, reason });
                 }
             }
+            for (const row of stmts.skillFtsOrphans.all()) {
+                stmts.skillFtsDrop.run(row.rid);
+                result.skillOrphanFtsRows += 1;
+            }
+            for (const row of stmts.skillActiveRows.all()) {
+                const reason = secretLeakReason(`${row.title}\n${row.description}\n${row.body}`);
+                if (reason !== undefined) {
+                    stmts.skillQuarantine.run(row.workspace_id, row.id);
+                    result.skillQuarantined.push({ workspaceId: row.workspace_id, id: row.id, reason });
+                    // A quarantined skill must stop loading immediately: drop
+                    // its managed file (hand-written files stay, with an error
+                    // counted so the residue stays visible).
+                    for (const warning of removeSkillFile(skillRootOf(row.workspace_id), row.id)) {
+                        void warning;
+                        result.skillFileErrors += 1;
+                    }
+                }
+            }
+            reconcileSkillFiles(result);
             stmts.stateSet.run(GLOBAL_WORKSPACE, PATROL_STATE_KEY, JSON.stringify(result));
             return result;
         },
         pruneLedger(beforeIso) {
-            return Number(stmts.prune.run(beforeIso).changes);
+            const memory = Number(stmts.prune.run(beforeIso).changes);
+            const skills = Number(stmts.skillPrune.run(beforeIso).changes);
+            return memory + skills;
         },
         close() {
             database.close();
         },
+        getSkill(workspaceId, id) {
+            const row = stmts.skillGet.get(workspaceId, id);
+            return row === undefined ? undefined : skillRecordOf(row);
+        },
+        listSkills(workspaceId) {
+            return stmts.skillList.all(workspaceId).map(skillRecordOf);
+        },
+        listAllSkills(workspaceId) {
+            return stmts.skillListAll.all(workspaceId).map(skillRecordOf);
+        },
+        searchSkills(workspaceId, query, limit = 20) {
+            const tokens = queryTokens(query);
+            if (tokens.length === 0) {
+                return [];
+            }
+            if (tokens.every((token) => token.length >= 3)) {
+                const hits = stmts.skillFts.all(tokens.map(ftsPhrase).join(" AND "), workspaceId, limit);
+                if (hits.length > 0) {
+                    return hits.map(skillRecordOf);
+                }
+            }
+            return skillLikeSearch(workspaceId, tokens, limit);
+        },
+        applySkillProposals(ctx, proposals) {
+            const outcomes = [];
+            const files = [];
+            const intents = [];
+            const runId = ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : undefined);
+            const now = new Date().toISOString();
+            database.exec("BEGIN");
+            for (const proposal of proposals) {
+                const outcome = applySkillOne(ctx, proposal, now, files, intents);
+                outcomes.push(outcome);
+                if (!outcome.ok) {
+                    break;
+                }
+            }
+            const applied = outcomes.every((outcome) => outcome.ok);
+            database.exec(applied ? "COMMIT" : "ROLLBACK");
+            // The database is the source of truth: files sync after the commit
+            // and never fail the batch — patrol retries whatever refuses.
+            const warnings = [];
+            if (applied) {
+                for (const intent of intents) {
+                    const root = skillRootOf(intent.partition);
+                    const row = stmts.skillGet.get(intent.partition, intent.id);
+                    if (intent.op === "write") {
+                        if (row === undefined || row.status !== "active") {
+                            continue;
+                        }
+                        warnings.push(...writeSkillFile(root, skillRecordOf(row)));
+                    }
+                    else {
+                        warnings.push(...removeSkillFile(root, intent.id));
+                    }
+                }
+            }
+            const decision = applied ? ctx.decision : `${ctx.decision ?? ""} first failure: ${outcomes.find((o) => !o.ok)?.reason ?? ""}`.trim();
+            writeSkillLedger({
+                runId, sessionId: ctx.sessionId, workspaceId: ctx.workspaceId, trigger: ctx.trigger,
+                decision, status: applied ? "applied" : "rejected",
+                files: applied ? files : [], warnings,
+            });
+            return { outcomes, warnings };
+        },
+        listSkillWorkspaces() {
+            return stmts.skillWorkspaces.all().map((row) => ({
+                workspaceId: row.workspace_id,
+                activeCount: row.n,
+                updatedAt: row.u,
+            }));
+        },
+        recordSkillUse(workspaceId, skillId, scope) {
+            try {
+                stmts.skillUseUpsert.run(workspaceId, skillId, scope, new Date().toISOString());
+            }
+            catch {
+                // Accounting never fails the read it rides on.
+            }
+        },
+        getSkillUse(workspaceId, skillId, scope) {
+            try {
+                const row = stmts.skillUseGet.get(workspaceId, skillId, scope);
+                if (row === undefined) {
+                    return undefined;
+                }
+                return { useCount: row.use_count, lastUsedAt: row.last_used_at };
+            }
+            catch {
+                return undefined;
+            }
+        },
+        reviewSummary(workspaceId, since) {
+            try {
+                const rows = stmts.reviewRows.all(workspaceId, since ?? "");
+                const summary = zeroReviewSummary();
+                const skips = new Map();
+                for (const row of rows) {
+                    if (row.status === "applied") {
+                        summary.applied += 1;
+                    }
+                    else if (row.status === "rejected") {
+                        summary.rejected += 1;
+                    }
+                    else if (row.status === "failed") {
+                        summary.failed += 1;
+                    }
+                    else {
+                        summary.skipped += 1;
+                    }
+                    if (row.status !== "applied" && row.status !== "rejected" && typeof row.skip_reason === "string" && row.skip_reason.length > 0) {
+                        skips.set(row.skip_reason, (skips.get(row.skip_reason) ?? 0) + 1);
+                    }
+                    if (typeof row.usage === "string" && row.usage.length > 0) {
+                        try {
+                            const normalized = normalizeUsage(JSON.parse(row.usage));
+                            if (normalized !== null) {
+                                summary.tokens = sumUsage(summary.tokens, normalized);
+                            }
+                        }
+                        catch {
+                            // One corrupt payload must not void the whole audit.
+                        }
+                    }
+                }
+                summary.topSkips = [...skips.entries()]
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 3)
+                    .map(([reason, count]) => ({
+                    reason: reason.length > 80 ? `${reason.slice(0, 80)}…` : reason,
+                    count,
+                }));
+                return summary;
+            }
+            catch {
+                return zeroReviewSummary();
+            }
+        },
     };
     return store;
 }