om-memory-system 4.30.1 → 4.31.2

package/dist/services/skill-learning/line-diff.js

@@ -0,0 +1,94 @@
+/** Unchanged lines shown around each change. */
+const CONTEXT_LINES = 3;
+/** Lines of a text. A final newline does not add an empty line. */
+function splitLines(text) {
+    if (text === "")
+        return [];
+    const lines = text.split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+/** Keep, remove and add steps from `before` to `after`, by longest common subsequence. */
+function diffOps(before, after) {
+    // The shared start and end need no table; skill edits are usually local.
+    let start = 0;
+    while (start < before.length && start < after.length && before[start] === after[start])
+        start++;
+    let endA = before.length;
+    let endB = after.length;
+    while (endA > start && endB > start && before[endA - 1] === after[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const a = before.slice(start, endA);
+    const b = after.slice(start, endB);
+    const table = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            table[i][j] =
+                a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+        }
+    }
+    const ops = before.slice(0, start).map((line) => ({ kind: " ", line }));
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            ops.push({ kind: " ", line: a[i++] });
+            j++;
+        }
+        else if (table[i + 1][j] >= table[i][j + 1]) {
+            ops.push({ kind: "-", line: a[i++] });
+        }
+        else {
+            ops.push({ kind: "+", line: b[j++] });
+        }
+    }
+    while (i < a.length)
+        ops.push({ kind: "-", line: a[i++] });
+    while (j < b.length)
+        ops.push({ kind: "+", line: b[j++] });
+    for (const line of before.slice(endA))
+        ops.push({ kind: " ", line });
+    return ops;
+}
+/**
+ * A unified-style line diff: `@@ -start,count +start,count @@` hunks with
+ * three lines of context, then lines marked ` `, `-` or `+`. Empty when the
+ * texts have the same lines. The web page renders it as text.
+ */
+export function lineDiff(before, after) {
+    const ops = diffOps(splitLines(before), splitLines(after));
+    const oldAt = [];
+    const newAt = [];
+    let oldLine = 1;
+    let newLine = 1;
+    for (const op of ops) {
+        oldAt.push(oldLine);
+        newAt.push(newLine);
+        if (op.kind !== "+")
+            oldLine++;
+        if (op.kind !== "-")
+            newLine++;
+    }
+    const changed = ops.flatMap((op, index) => (op.kind === " " ? [] : [index]));
+    const out = [];
+    for (let h = 0; h < changed.length; h++) {
+        const first = changed[h];
+        while (h + 1 < changed.length && changed[h + 1] - changed[h] <= 2 * CONTEXT_LINES)
+            h++;
+        const from = Math.max(0, first - CONTEXT_LINES);
+        const to = Math.min(ops.length - 1, changed[h] + CONTEXT_LINES);
+        const hunk = ops.slice(from, to + 1);
+        const oldCount = hunk.filter((op) => op.kind !== "+").length;
+        const newCount = hunk.filter((op) => op.kind !== "-").length;
+        // A side with no lines names the line before the hunk, as unified diffs do.
+        const oldStart = oldCount > 0 ? oldAt[from] : oldAt[from] - 1;
+        const newStart = newCount > 0 ? newAt[from] : newAt[from] - 1;
+        out.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+        for (const op of hunk)
+            out.push(op.kind + op.line);
+    }
+    return out.join("\n");
+}

package/dist/services/skill-learning/operations-deps.d.ts

@@ -0,0 +1,7 @@
+import type { SkillOperationsDeps } from "../../core/skill-operations.js";
+/**
+ * The wiring point between `CONFIG` and the `skills` operations. The terminal
+ * command passes `person` and the host tools pass `agent`. The store is not
+ * opened here; reads never create `skills.db`.
+ */
+export declare function skillOperationsDeps(directory: string, appliedBy: SkillOperationsDeps["appliedBy"]): SkillOperationsDeps;

package/dist/services/skill-learning/operations-deps.js

@@ -0,0 +1,19 @@
+import { CONFIG } from "../../config.js";
+import { skillTurnSettingsFor } from "./settings-for.js";
+import { skillModel } from "./skill-model.js";
+import { SkillStore, skillsDbPath } from "./store.js";
+/**
+ * The wiring point between `CONFIG` and the `skills` operations. The terminal
+ * command passes `person` and the host tools pass `agent`. The store is not
+ * opened here; reads never create `skills.db`.
+ */
+export function skillOperationsDeps(directory, appliedBy) {
+    const settings = skillTurnSettingsFor(directory);
+    return {
+        enabled: settings.enabled,
+        store: new SkillStore(skillsDbPath(settings.storagePath)),
+        folders: settings.folders,
+        model: skillModel(CONFIG),
+        appliedBy,
+    };
+}

package/dist/services/skill-learning/proposal-store.d.ts

@@ -0,0 +1,82 @@
+import { type SkillStore } from "./store.js";
+/**
+ * Proposals, saved versions and per-skill settings in `skills.db`. Built on the
+ * `SkillStore` connection. Call `store.init()` before a write. Reads on a
+ * missing file return empty values and do not create it.
+ */
+export type SkillProposalKind = "improve" | "new";
+export type SkillProposalState = "pending" | "applied" | "stale" | "rejected" | "undone";
+export type SkillAppliedBy = "person" | "agent" | "automatic";
+/** `model`: the external API drafted it. `agent`: the coding agent wrote it through `propose`. */
+export type SkillDraftedBy = "model" | "agent";
+export type SkillMode = "manual" | "automatic";
+export interface SkillProposal {
+    id: string;
+    kind: SkillProposalKind;
+    skillName: string;
+    /** Full path of the `SKILL.md` the proposal writes. */
+    skillPath: string | null;
+    /** sha256 of the file the draft started from; null for a new skill. */
+    baseHash: string | null;
+    content: string;
+    diff: string | null;
+    summary: string | null;
+    evidenceTurnIds: number[];
+    state: SkillProposalState;
+    appliedBy: SkillAppliedBy | null;
+    draftedBy: SkillDraftedBy;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface NewSkillProposal {
+    kind: SkillProposalKind;
+    skillName: string;
+    skillPath: string | null;
+    baseHash: string | null;
+    content: string;
+    diff: string | null;
+    summary: string | null;
+    evidenceTurnIds: number[];
+    /** Defaults to `model`. */
+    draftedBy?: SkillDraftedBy;
+}
+export interface SkillVersion {
+    id: number;
+    proposalId: string;
+    path: string;
+    /** The file before the apply, or null when the apply created it. */
+    previousContent: string | null;
+    writtenHash: string;
+    savedAt: number;
+}
+export interface SkillSettings {
+    skillPath: string;
+    mode: SkillMode;
+    lastReviewAt: number | null;
+    usesAtLastReview: number;
+}
+/** Saves a pending proposal with a new id. */
+export declare function createProposal(store: SkillStore, input: NewSkillProposal, now: number): Promise<SkillProposal>;
+export declare function getProposal(store: SkillStore, id: string): Promise<SkillProposal | null>;
+export interface ProposalFilter {
+    state?: SkillProposalState;
+    skillName?: string;
+    skillPath?: string;
+}
+/** Proposals, newest first. */
+export declare function listProposals(store: SkillStore, filter?: ProposalFilter): Promise<SkillProposal[]>;
+/**
+ * Sets the state and the update time. `appliedBy` is written when given and
+ * kept otherwise. Returns false when no proposal has this id.
+ */
+export declare function updateProposalState(store: SkillStore, id: string, state: SkillProposalState, now: number, appliedBy?: SkillAppliedBy): Promise<boolean>;
+/** Saves the content a write replaces. Returns the version id. */
+export declare function saveSkillVersion(store: SkillStore, version: Pick<SkillVersion, "proposalId" | "path" | "previousContent" | "writtenHash">, now: number): Promise<number>;
+/** Removes a version whose write did not happen. */
+export declare function deleteSkillVersion(store: SkillStore, id: number): Promise<void>;
+export declare function getLatestVersion(store: SkillStore, proposalId: string): Promise<SkillVersion | null>;
+/** The settings for one skill. A skill with no row is in manual mode and never reviewed. */
+export declare function getSkillSettings(store: SkillStore, skillPath: string): Promise<SkillSettings>;
+export declare function setSkillMode(store: SkillStore, skillPath: string, mode: SkillMode): Promise<void>;
+/** Records a review: its time and the use count at that time. */
+export declare function setSkillReview(store: SkillStore, skillPath: string, reviewedAt: number, uses: number): Promise<void>;

package/dist/services/skill-learning/proposal-store.js

@@ -0,0 +1,164 @@
+import { randomUUID } from "node:crypto";
+import { SkillStoreError } from "./store.js";
+async function writableDb(store) {
+    if (store.isReadOnly()) {
+        throw new SkillStoreError("skills.db is from a newer OMMS and is read-only", "read_only");
+    }
+    return store.db();
+}
+function text(value) {
+    return value === null || value === undefined ? null : String(value);
+}
+function toProposal(row) {
+    let evidence = [];
+    try {
+        const parsed = JSON.parse(String(row.evidence_turn_ids));
+        if (Array.isArray(parsed))
+            evidence = parsed.map(Number);
+    }
+    catch {
+        // A damaged list reads as no evidence.
+    }
+    return {
+        id: String(row.id),
+        kind: String(row.kind),
+        skillName: String(row.skill_name),
+        skillPath: text(row.skill_path),
+        baseHash: text(row.base_hash),
+        content: String(row.proposed_content),
+        diff: text(row.diff),
+        summary: text(row.summary),
+        evidenceTurnIds: evidence,
+        state: String(row.state),
+        appliedBy: text(row.applied_by),
+        draftedBy: row.drafted_by === "agent" ? "agent" : "model",
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+    };
+}
+/** Saves a pending proposal with a new id. */
+export async function createProposal(store, input, now) {
+    const db = await writableDb(store);
+    const proposal = {
+        id: randomUUID(),
+        ...input,
+        draftedBy: input.draftedBy ?? "model",
+        state: "pending",
+        appliedBy: null,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await db.run(`INSERT INTO skill_proposals
+      (id, kind, skill_name, skill_path, base_hash, proposed_content, diff, summary,
+       evidence_turn_ids, state, applied_by, drafted_by, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        proposal.id,
+        proposal.kind,
+        proposal.skillName,
+        proposal.skillPath,
+        proposal.baseHash,
+        proposal.content,
+        proposal.diff,
+        proposal.summary,
+        JSON.stringify(proposal.evidenceTurnIds),
+        proposal.state,
+        proposal.appliedBy,
+        proposal.draftedBy,
+        proposal.createdAt,
+        proposal.updatedAt,
+    ]);
+    return proposal;
+}
+export async function getProposal(store, id) {
+    const db = await store.existingDb();
+    if (!db)
+        return null;
+    const row = await db.get("SELECT * FROM skill_proposals WHERE id = ?", [id]);
+    return row ? toProposal(row) : null;
+}
+/** Proposals, newest first. */
+export async function listProposals(store, filter = {}) {
+    const db = await store.existingDb();
+    if (!db)
+        return [];
+    const where = [];
+    const args = [];
+    if (filter.state) {
+        where.push("state = ?");
+        args.push(filter.state);
+    }
+    if (filter.skillName) {
+        where.push("skill_name = ?");
+        args.push(filter.skillName);
+    }
+    if (filter.skillPath) {
+        where.push("skill_path = ?");
+        args.push(filter.skillPath);
+    }
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    const rows = await db.all(`SELECT * FROM skill_proposals ${clause} ORDER BY created_at DESC, rowid DESC`, args);
+    return rows.map(toProposal);
+}
+/**
+ * Sets the state and the update time. `appliedBy` is written when given and
+ * kept otherwise. Returns false when no proposal has this id.
+ */
+export async function updateProposalState(store, id, state, now, appliedBy) {
+    const db = await writableDb(store);
+    const changed = await db.run("UPDATE skill_proposals SET state = ?, applied_by = COALESCE(?, applied_by), updated_at = ? WHERE id = ?", [state, appliedBy ?? null, now, id]);
+    return changed > 0;
+}
+/** Saves the content a write replaces. Returns the version id. */
+export async function saveSkillVersion(store, version, now) {
+    const db = await writableDb(store);
+    const result = await db.execute("INSERT INTO skill_versions (proposal_id, path, previous_content, written_hash, saved_at) VALUES (?, ?, ?, ?, ?)", [version.proposalId, version.path, version.previousContent, version.writtenHash, now]);
+    return Number(result.lastInsertRowid);
+}
+/** Removes a version whose write did not happen. */
+export async function deleteSkillVersion(store, id) {
+    const db = await writableDb(store);
+    await db.run("DELETE FROM skill_versions WHERE id = ?", [id]);
+}
+export async function getLatestVersion(store, proposalId) {
+    const db = await store.existingDb();
+    if (!db)
+        return null;
+    const row = await db.get("SELECT * FROM skill_versions WHERE proposal_id = ? ORDER BY id DESC LIMIT 1", [proposalId]);
+    if (!row)
+        return null;
+    return {
+        id: Number(row.id),
+        proposalId: String(row.proposal_id),
+        path: String(row.path),
+        previousContent: text(row.previous_content),
+        writtenHash: String(row.written_hash),
+        savedAt: Number(row.saved_at),
+    };
+}
+/** The settings for one skill. A skill with no row is in manual mode and never reviewed. */
+export async function getSkillSettings(store, skillPath) {
+    const db = await store.existingDb();
+    const row = db
+        ? await db.get("SELECT * FROM skill_settings WHERE skill_path = ?", [skillPath])
+        : null;
+    return {
+        skillPath,
+        mode: row?.mode === "automatic" ? "automatic" : "manual",
+        lastReviewAt: row?.last_review_at == null ? null : Number(row.last_review_at),
+        usesAtLastReview: Number(row?.uses_at_last_review ?? 0),
+    };
+}
+export async function setSkillMode(store, skillPath, mode) {
+    const db = await writableDb(store);
+    await db.run(`INSERT INTO skill_settings (skill_path, mode) VALUES (?, ?)
+     ON CONFLICT(skill_path) DO UPDATE SET mode = excluded.mode`, [skillPath, mode]);
+}
+/** Records a review: its time and the use count at that time. */
+export async function setSkillReview(store, skillPath, reviewedAt, uses) {
+    const db = await writableDb(store);
+    await db.run(`INSERT INTO skill_settings (skill_path, mode, last_review_at, uses_at_last_review)
+     VALUES (?, 'manual', ?, ?)
+     ON CONFLICT(skill_path) DO UPDATE SET
+       last_review_at = excluded.last_review_at,
+       uses_at_last_review = excluded.uses_at_last_review`, [skillPath, reviewedAt, uses]);
+}

package/dist/services/skill-learning/ranking.d.ts

@@ -0,0 +1,36 @@
+import type { SkillMode } from "./proposal-store.js";
+import type { SkillIndex } from "./skill-index.js";
+import type { SkillStore } from "./store.js";
+export declare const RANKING_WINDOW_MS: number;
+/** A skill needs this many uses in the window before it can be Suggested. */
+export declare const SUGGEST_MIN_USES = 5;
+/** A skill also needs this attention score before it can be Suggested. */
+export declare const SUGGEST_MIN_ATTENTION = 0.3;
+export declare const SKILL_ORDERS: readonly ["uses", "attention"];
+export type SkillOrder = (typeof SKILL_ORDERS)[number];
+export interface SkillRanking {
+    name: string;
+    /** Full path of its `SKILL.md`, or null when no watched folder holds it. */
+    path: string | null;
+    /** Shown as **Not in a watched folder**; such a skill gets no draft. */
+    notInWatchedFolder: boolean;
+    /** Turns in the last 30 days that used the skill. */
+    uses: number;
+    /** Of those turns, the ones with a failed tool call after the skill was used. */
+    failedTurns: number;
+    /** (failed turns + 1) / (uses + 2), rounded to 2 decimals. 0 to 1; higher needs more care. */
+    attention: number;
+    lastUsedAt: number | null;
+    mode: SkillMode;
+    /** 5 uses, attention of 0.3, and a failed turn since the skill's last proposal or review. */
+    suggested: boolean;
+}
+/** (failed + 1) / (uses + 2): a skill with little evidence stays near the middle. */
+export declare function attentionScore(failedTurns: number, uses: number): number;
+/**
+ * Every watched skill and every recorded skill, with its 30-day counts.
+ * Sorted by use count, highest first, then name; order `attention` sorts by
+ * attention first, then uses, then name. Watched skills with no use are
+ * listed with zero counts. Counting happens in SQL.
+ */
+export declare function rankSkills(store: SkillStore, index: SkillIndex, now: number, order?: SkillOrder): Promise<SkillRanking[]>;

package/dist/services/skill-learning/ranking.js

@@ -0,0 +1,140 @@
+export const RANKING_WINDOW_MS = 30 * 86_400_000;
+/** A skill needs this many uses in the window before it can be Suggested. */
+export const SUGGEST_MIN_USES = 5;
+/** A skill also needs this attention score before it can be Suggested. */
+export const SUGGEST_MIN_ATTENTION = 0.3;
+export const SKILL_ORDERS = ["uses", "attention"];
+// A recorded path counts only while the index still lists it. A use with no
+// path takes the index path when exactly one watched skill has that name.
+// Each turn counts once per skill, even when it used the skill twice.
+// A failed tool call counts only when it came after the skill was used: its
+// order is above the earliest use position in that turn. A NULL position (a
+// row from before the column) and -1 (a slash command) count every failure.
+// A review (a draft with no change, or an automatic review) counts as a proposal.
+const RANKING_SQL = `
+WITH idx AS (
+  SELECT json_extract(value, '$.name') AS name, json_extract(value, '$.path') AS path
+  FROM json_each(?)
+),
+resolved AS (
+  SELECT
+    su.turn_id,
+    su.skill_name AS name,
+    CASE
+      WHEN su.skill_path IS NOT NULL AND EXISTS (SELECT 1 FROM idx WHERE idx.path = su.skill_path)
+        THEN su.skill_path
+      WHEN su.skill_path IS NULL AND (SELECT COUNT(*) FROM idx WHERE idx.name = su.skill_name) = 1
+        THEN (SELECT idx.path FROM idx WHERE idx.name = su.skill_name)
+      ELSE NULL
+    END AS path,
+    t.created_at,
+    COALESCE(su.position, -1) AS position
+  FROM skill_uses su
+  JOIN turns t ON t.id = su.turn_id
+  WHERE t.created_at >= ?
+),
+first_use AS (
+  SELECT turn_id, name, path, created_at, MIN(position) AS position
+  FROM resolved
+  GROUP BY turn_id, name, path
+),
+uses AS (
+  SELECT
+    f.turn_id,
+    f.name,
+    f.path,
+    f.created_at,
+    EXISTS (
+      SELECT 1 FROM tool_calls tc
+      WHERE tc.turn_id = f.turn_id AND tc.outcome = 'error' AND tc.position > f.position
+    ) AS failed
+  FROM first_use f
+),
+last_proposal AS (
+  SELECT path, MAX(at) AS at FROM (
+    SELECT skill_path AS path, created_at AS at FROM skill_proposals WHERE skill_path IS NOT NULL
+    UNION ALL
+    SELECT skill_path, last_review_at FROM skill_settings WHERE last_review_at IS NOT NULL
+  )
+  GROUP BY path
+)
+SELECT
+  u.name,
+  u.path,
+  COUNT(DISTINCT u.turn_id) AS uses,
+  COUNT(DISTINCT CASE WHEN u.failed THEN u.turn_id END) AS failed_turns,
+  COUNT(DISTINCT CASE WHEN u.failed AND (lp.at IS NULL OR u.created_at > lp.at) THEN u.turn_id END)
+    AS failed_since_proposal,
+  MAX(u.created_at) AS last_used_at,
+  s.mode
+FROM uses u
+LEFT JOIN last_proposal lp ON lp.path = u.path
+LEFT JOIN skill_settings s ON s.skill_path = u.path
+GROUP BY u.name, u.path
+`;
+function modeOf(value) {
+    return value === "automatic" ? "automatic" : "manual";
+}
+/** (failed + 1) / (uses + 2): a skill with little evidence stays near the middle. */
+export function attentionScore(failedTurns, uses) {
+    return Math.round(((failedTurns + 1) / (uses + 2)) * 100) / 100;
+}
+/**
+ * Every watched skill and every recorded skill, with its 30-day counts.
+ * Sorted by use count, highest first, then name; order `attention` sorts by
+ * attention first, then uses, then name. Watched skills with no use are
+ * listed with zero counts. Counting happens in SQL.
+ */
+export async function rankSkills(store, index, now, order = "uses") {
+    const db = await store.existingDb();
+    const entries = index.entries.map((e) => ({ name: e.name, path: e.path }));
+    const rankings = [];
+    const seen = new Set();
+    if (db) {
+        const rows = await db.all(RANKING_SQL, [JSON.stringify(entries), now - RANKING_WINDOW_MS]);
+        for (const row of rows) {
+            const path = row.path == null ? null : String(row.path);
+            const uses = Number(row.uses);
+            const failedTurns = Number(row.failed_turns);
+            const attention = attentionScore(failedTurns, uses);
+            if (path)
+                seen.add(path);
+            rankings.push({
+                name: String(row.name),
+                path,
+                notInWatchedFolder: path === null,
+                uses,
+                failedTurns,
+                attention,
+                lastUsedAt: row.last_used_at == null ? null : Number(row.last_used_at),
+                mode: modeOf(row.mode),
+                suggested: path !== null &&
+                    uses >= SUGGEST_MIN_USES &&
+                    attention >= SUGGEST_MIN_ATTENTION &&
+                    Number(row.failed_since_proposal) > 0,
+            });
+        }
+    }
+    const unused = index.entries.filter((e) => !seen.has(e.path));
+    const modes = new Map();
+    if (db && unused.length > 0) {
+        const rows = await db.all("SELECT s.skill_path, s.mode FROM skill_settings s WHERE s.skill_path IN (SELECT value FROM json_each(?))", [JSON.stringify(unused.map((e) => e.path))]);
+        for (const row of rows)
+            modes.set(String(row.skill_path), modeOf(row.mode));
+    }
+    for (const entry of unused) {
+        rankings.push({
+            name: entry.name,
+            path: entry.path,
+            notInWatchedFolder: false,
+            uses: 0,
+            failedTurns: 0,
+            attention: attentionScore(0, 0),
+            lastUsedAt: null,
+            mode: modes.get(entry.path) ?? "manual",
+            suggested: false,
+        });
+    }
+    const byUses = (a, b) => b.uses - a.uses || a.name.localeCompare(b.name);
+    return rankings.sort(order === "attention" ? (a, b) => b.attention - a.attention || byUses(a, b) : byUses);
+}

package/dist/services/skill-learning/settings-for.d.ts

@@ -0,0 +1,11 @@
+import type { CaptureWorkUnit } from "../../core/capture.js";
+import { type SkillTurnSettings, type SkillTurnStatus } from "./turn-output.js";
+/**
+ * The wiring point between `CONFIG` and the pure skill-turn output. The live
+ * capture sites call it; `turn-output.ts` takes the settings as an argument.
+ */
+export type SkillTurnRecorder = (unit: CaptureWorkUnit) => Promise<SkillTurnStatus>;
+/** The skill-turn settings for a project folder, with its project override applied. */
+export declare function skillTurnSettingsFor(directory: string): SkillTurnSettings;
+/** A recorder for turns in this folder, or undefined when skill learning is off there. */
+export declare function skillTurnRecorder(directory: string): SkillTurnRecorder | undefined;

package/dist/services/skill-learning/settings-for.js

@@ -0,0 +1,21 @@
+import { CONFIG, refreshConfigIfChanged } from "../../config.js";
+import { skillStoragePath, watchedSkillFolders } from "./skill-folders.js";
+import { recordSkillTurn } from "./turn-output.js";
+/** The skill-turn settings for a project folder, with its project override applied. */
+export function skillTurnSettingsFor(directory) {
+    refreshConfigIfChanged(directory);
+    return {
+        enabled: CONFIG.skillLearning === true,
+        redact: CONFIG.skillLearningRedact !== false,
+        folders: watchedSkillFolders(CONFIG),
+        storagePath: skillStoragePath(CONFIG),
+        secrets: CONFIG,
+    };
+}
+/** A recorder for turns in this folder, or undefined when skill learning is off there. */
+export function skillTurnRecorder(directory) {
+    const settings = skillTurnSettingsFor(directory);
+    if (!settings.enabled)
+        return undefined;
+    return (unit) => recordSkillTurn(unit, settings);
+}

package/dist/services/skill-learning/skill-config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Skill learning settings (ADR-036), kept out of `src/config.ts` to save its
+ * lines. Pure on purpose: callers pass the file config, and the loaded
+ * `CONFIG` is never imported here, because many tests stub `src/config.js`.
+ */
+/** The raw keys as they appear in a config file, before any check. */
+export interface SkillFileConfig {
+    skillLearning?: unknown;
+    skillLearningRedact?: unknown;
+    skillFolders?: unknown;
+}
+export interface SkillConfig {
+    /** Record full turns into `skills.db`. Off by default. */
+    skillLearning: boolean;
+    /** Remove `<private>` text and secrets before a turn is stored. On by default. Global only. */
+    skillLearningRedact: boolean;
+    /** Folders OMMS reads skills from. Unset means `defaultSkillFolders`. Global only. */
+    skillFolders: string[] | undefined;
+}
+/** The three settings from a merged file config, with defaults applied. */
+export declare function normaliseSkillConfig(fileConfig: SkillFileConfig, homeDir?: string): SkillConfig;
+/**
+ * The first `skillFolders` entry, as written, that is not an existing folder,
+ * or null when every entry is one. The Settings save refuses a missing folder
+ * and names it. `isFolder` is passed in so the caller owns the file system access.
+ */
+export declare function missingSkillFolder(folders: readonly string[], isFolder: (path: string) => boolean, homeDir?: string): string | null;
+/**
+ * What a project config may change. A checked-in project file must not start
+ * recording conversations, so it can only turn `skillLearning` off. Its
+ * `skillLearningRedact` and `skillFolders` are always ignored.
+ * `ignoredTurnOn` tells the caller to log a project value of `true`.
+ */
+export declare function projectSkillOverride(project: SkillFileConfig): {
+    override: {
+        skillLearning?: false;
+    };
+    ignoredTurnOn: boolean;
+};
+/**
+ * The folders to watch when `skillFolders` is unset: `~/.agents/skills` and
+ * `<Claude Code folder>/skills`, each only when it exists. `exists` is passed
+ * in so the caller owns the file system access.
+ */
+export declare function defaultSkillFolders(homeDir: string, claudeFolder: string, exists: (path: string) => boolean): string[];