om-memory-system 4.35.0-next.193 → 5.1.0

package/dist/core/skill-operations.js

@@ -1,6 +1,8 @@
 import { applyProposal } from "../services/skill-learning/apply.js";
 import { draftImprovement, draftNewSkill, findSkillIdeas, } from "../services/skill-learning/drafting.js";
-import { getProposal, listProposals, updateProposalState, } from "../services/skill-learning/proposal-store.js";
+import { withCanUndo } from "../services/skill-learning/history.js";
+import { getProposal, updateProposalState, } from "../services/skill-learning/proposal-store.js";
+import { listProposalSummaries, } from "../services/skill-learning/proposal-summaries.js";
 import { SKILL_ORDERS, rankSkills, } from "../services/skill-learning/ranking.js";
 import { getSkillIndex } from "../services/skill-learning/skill-index.js";
 import { evidence, propose, undo } from "./skill-agent-modes.js";
@@ -193,11 +195,13 @@ async function proposals(args, deps) {
     if (state && !PROPOSAL_STATES.includes(state)) {
         return reply("proposals", false, "invalid-args", `state must be one of: ${PROPOSAL_STATES.join(", ")}.`);
     }
-    const found = await listProposals(deps.store, state ? { state } : {});
+    // Summaries, not full proposals: the JSON goes into the agent's context. `show` gives the text.
+    const { proposals: found } = await listProposalSummaries(deps.store, state ? { state } : {});
     const text = found.length === 0
         ? `No ${state ? `${state} ` : ""}proposals.`
         : ["Proposals, newest first:", ...found.map(proposalLine)].join("\n");
-    return reply("proposals", true, "ok", text, { proposals: found });
+    const listed = await withCanUndo({ store: deps.store, folders: deps.folders }, found);
+    return reply("proposals", true, "ok", text, { proposals: listed });
 }
 /** The proposal for `args.id`, or the reply that explains why there is none. */
 async function findProposal(mode, args, deps) {

package/dist/core/skills-tool.js

@@ -23,7 +23,7 @@ export const SKILLS_TOOL_DESCRIPTION = [
     '"draft" (skill, or an idea from "ideas" {name, description, reason, evidenceTurnIds} with folder): the external API drafts a pending proposal; it changes no file.',
     'To fix a skill yourself: call "evidence" (skill, limit) for its SKILL.md and recorded turns, write the fixed SKILL.md, then call "propose" (skill, or idea with folder; content, summary, evidence turn ids). Show the user the diff.',
     "This path makes no external API call, but the recorded turn text enters this session.",
-    '"proposals" (state), "show" (id): review proposals and their diffs.',
+    '"proposals" (state): list proposals as summaries, with line counts and no content or diff. "show" (id): one proposal with its diff and content.',
     '"apply" (id): write a pending proposal to its SKILL.md, only when the user asks. "reject" (id), "undo" (id), "help".',
 ].join(" ");
 /** JSON Schema for the tool input; the V2 adapter passes it as is. */

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

@@ -42,8 +42,35 @@ export declare function hashSkillContent(content: string | Buffer): string;
  * previous content before the write. Expected outcomes return a result code.
  */
 export declare function applyProposal(id: string, by: SkillAppliedBy, deps: ApplyDeps): Promise<ApplyResult>;
-/** True when `undoProposal` would accept this proposal now. Writes nothing. */
-export declare function canUndoProposal(id: string, deps: ApplyDeps): Promise<boolean>;
+/** What `checkUndo` needs. A list can read these for many proposals in one query. */
+export interface UndoFacts {
+    id: string;
+    readOnly: boolean;
+    /** The proposal's state. */
+    state: string;
+    /** The newest saved version of the proposal, or null when it has none. */
+    version: {
+        path: string;
+        writtenHash: string;
+    } | null;
+    folders: readonly string[];
+}
+type UndoCheck = {
+    ok: true;
+    real: string;
+    folders: string[];
+} | {
+    ok: false;
+    code: "read-only" | "not-applied" | "no-version" | "outside-folder" | "changed";
+    message: string;
+};
+/**
+ * Every undo check that needs no database read: the store is writable, the
+ * proposal is applied, a version exists, its file is a `SKILL.md` inside a
+ * watched folder, and the file still holds what OMMS wrote. Reads one file.
+ * `planUndo` and the `canUndo` of a list both run it, so they cannot disagree.
+ */
+export declare function checkUndo(facts: UndoFacts): UndoCheck;
 /**
  * Restores the content saved before the last apply, or deletes the file the
  * apply created. Only when the file still matches what OMMS wrote; otherwise
@@ -51,3 +78,4 @@ export declare function canUndoProposal(id: string, deps: ApplyDeps): Promise<bo
  * later change has rewritten the file, until that later change is undone.
  */
 export declare function undoProposal(id: string, deps: ApplyDeps): Promise<UndoResult>;
+export {};

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

@@ -209,42 +209,57 @@ function removeEmptyFolder(folder, roots) {
         // The folder is gone or not empty; leave it.
     }
 }
-/** Every check undo makes before it writes. Reads only; changes nothing. */
-async function planUndo(id, deps) {
-    const { store } = deps;
-    if (store.isReadOnly()) {
-        return {
-            ok: false,
-            code: "read-only",
-            message: "skills.db is from a newer OMMS and is read-only",
-        };
-    }
-    const proposal = await getProposal(store, id);
-    if (!proposal)
-        return { ok: false, code: "not-found", message: `No proposal ${id}` };
-    if (proposal.state !== "applied") {
-        return { ok: false, code: "not-applied", message: `Proposal ${id} is ${proposal.state}` };
+const READ_ONLY_MESSAGE = "skills.db is from a newer OMMS and is read-only";
+/**
+ * Every undo check that needs no database read: the store is writable, the
+ * proposal is applied, a version exists, its file is a `SKILL.md` inside a
+ * watched folder, and the file still holds what OMMS wrote. Reads one file.
+ * `planUndo` and the `canUndo` of a list both run it, so they cannot disagree.
+ */
+export function checkUndo(facts) {
+    const { id, state, version } = facts;
+    if (facts.readOnly)
+        return { ok: false, code: "read-only", message: READ_ONLY_MESSAGE };
+    if (state !== "applied") {
+        return { ok: false, code: "not-applied", message: `Proposal ${id} is ${state}` };
     }
-    const version = await getLatestVersion(store, id);
     if (!version)
         return { ok: false, code: "no-version", message: `No saved version for ${id}` };
-    const target = checkTarget(version.path, deps.folders);
+    const target = checkTarget(version.path, facts.folders);
     if (!target.ok)
         return { ok: false, code: "outside-folder", message: target.message };
-    const { real, folders } = target;
-    if (readHash(real) !== version.writtenHash) {
+    if (readHash(target.real) !== version.writtenHash) {
         return {
             ok: false,
             code: "changed",
             message: "The file changed since OMMS wrote it, so undo would lose that change",
-            savedContent: version.previousContent,
         };
     }
-    return { ok: true, proposal, version, real, folders };
+    return { ok: true, real: target.real, folders: target.folders };
 }
-/** True when `undoProposal` would accept this proposal now. Writes nothing. */
-export async function canUndoProposal(id, deps) {
-    return (await planUndo(id, deps)).ok;
+/** Every check undo makes before it writes. Reads only; changes nothing. */
+async function planUndo(id, deps) {
+    const { store } = deps;
+    // A read-only store refuses before it looks the proposal up.
+    if (store.isReadOnly())
+        return { ok: false, code: "read-only", message: READ_ONLY_MESSAGE };
+    const proposal = await getProposal(store, id);
+    if (!proposal)
+        return { ok: false, code: "not-found", message: `No proposal ${id}` };
+    const version = await getLatestVersion(store, id);
+    const check = checkUndo({
+        id,
+        readOnly: false,
+        state: proposal.state,
+        version,
+        folders: deps.folders,
+    });
+    if (!check.ok) {
+        return check.code === "changed"
+            ? { ...check, savedContent: version?.previousContent ?? null }
+            : check;
+    }
+    return { ok: true, proposal, version: version, real: check.real, folders: check.folders };
 }
 /**
  * Restores the content saved before the last apply, or deletes the file the

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

@@ -50,6 +50,19 @@ export type IdeasResult = {
     ok: true;
     ideas: SkillIdea[];
 } | DraftFailure;
+declare function tool(name: string, description: string, properties: Record<string, unknown>): {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: Record<string, unknown>;
+            required: string[];
+        };
+    };
+};
+export { tool };
 export declare function withFinalNewline(text: string): string;
 export declare function sameText(a: string, b: string): boolean;
 export declare const READ_ONLY: DraftFailure;

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

@@ -37,6 +37,7 @@ function tool(name, description, properties) {
         },
     };
 }
+export { tool };
 const evidenceField = {
     type: "array",
     items: { type: "string" },

package/dist/services/skill-learning/failure-explain.d.ts

@@ -0,0 +1,52 @@
+import { type ProfileFailureCode } from "../../core/profile-failure.js";
+import { type SkillModel } from "./drafting.js";
+import { type FailureGroup } from "./failures.js";
+import type { SkillIndex } from "./skill-index.js";
+import type { SkillStore } from "./store.js";
+/** At most this many groups go to the model, most calls first. */
+export declare const MAX_EXPLAIN_GROUPS = 10;
+/** One input excerpt per group, cut to this many characters. */
+export declare const EXPLAIN_EXCERPT_CHARS = 500;
+/** What a cause is blamed on; the panel shows the label as a lead. */
+export type ExplainCauseKind = "skill" | "harness" | "environment" | "unknown";
+export interface ExplainCause {
+    kind: ExplainCauseKind;
+    explanation: string;
+    actions: string[];
+}
+/** The model's reply: a summary and labelled causes. Shown, never saved. */
+export interface FailureExplanation {
+    summary: string;
+    causes: ExplainCause[];
+}
+export type ExplainFailureCode = ProfileFailureCode | "not-found" | "invalid-args";
+export type ExplainResult = {
+    ok: true;
+    explanation: FailureExplanation;
+} | {
+    ok: false;
+    code: ExplainFailureCode;
+    message: string;
+};
+export interface ExplainDeps {
+    store: SkillStore;
+    index: SkillIndex;
+    model: SkillModel;
+}
+/**
+ * Builds the request the test asserts on: the skill name, its `SKILL.md` when
+ * a watched folder holds it, and the top groups. No prompts, no replies.
+ */
+export declare function explainUserPrompt(skill: {
+    name: string;
+    path: string | null;
+}, skillFile: string | null, groups: readonly FailureGroup[]): string;
+/**
+ * Asks the external API model to explain one skill's failure groups (design
+ * §9). The reply is returned, never saved. Reuses the drafting model path and
+ * its failure codes, including `not-configured`.
+ */
+export declare function explainFailures(skill: {
+    name: string;
+    path: string | null;
+}, deps: ExplainDeps): Promise<ExplainResult>;

package/dist/services/skill-learning/failure-explain.js

@@ -0,0 +1,131 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { profileFailureCode, profileResultCode, } from "../../core/profile-failure.js";
+import { log } from "../logger.js";
+import { tool } from "./drafting.js";
+import { skillFailureGroups } from "./failures.js";
+/** At most this many groups go to the model, most calls first. */
+export const MAX_EXPLAIN_GROUPS = 10;
+/** One input excerpt per group, cut to this many characters. */
+export const EXPLAIN_EXCERPT_CHARS = 500;
+const ExplainReply = z.object({
+    summary: z.string(),
+    causes: z
+        .array(z.object({
+        kind: z.enum(["skill", "harness", "environment", "unknown"]),
+        explanation: z.string(),
+        actions: z.array(z.string()).default([]),
+    }))
+        .default([]),
+});
+const EXPLAIN_TOOL = tool("explain_skill_failures", "Explain a skill's failed tool calls", {
+    summary: { type: "string", description: "One or two plain sentences on what fails and why" },
+    causes: {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                kind: {
+                    type: "string",
+                    enum: ["skill", "harness", "environment", "unknown"],
+                    description: "skill: the SKILL.md should change; harness: a host or harness bug; environment: machine, setup or credentials; unknown",
+                },
+                explanation: { type: "string", description: "What the error text shows" },
+                actions: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Suggested actions, as leads from the error text only",
+                },
+            },
+            required: ["kind", "explanation", "actions"],
+        },
+    },
+});
+const EXPLAIN_SYSTEM = [
+    "You explain why a coding agent's tool calls failed while it used one skill (SKILL.md).",
+    "You see the skill file and its failure groups: tool name, first error line, counts, the last time seen and one short input excerpt. You cannot see the host's code.",
+    "Label each cause skill, harness, environment or unknown. Treat your labels and suggested actions as leads from error text only, not conclusions.",
+    "Write plain British English. Call the explain_skill_failures tool.",
+].join(" ");
+const FAILURE_TEXT = {
+    "not-configured": "The external API is not set up. Set it up in the External API card.",
+    "invalid-args": "This skill has no failed tool calls to explain.",
+    "invalid-reply": "The model reply was not valid, so nothing is shown. Try again.",
+    timeout: "The model did not reply in time",
+};
+/** Log one metadata record with the reason code only, and return the failure. */
+function fail(step, code) {
+    log(`Skill ${step} failed`, { host: null, reason: code }, "error");
+    return { ok: false, code, message: FAILURE_TEXT[code] ?? `Explaining failed: ${code}` };
+}
+function groupLine(group) {
+    const parts = [
+        `- Tool: ${group.name}`,
+        `Error: ${group.errorLine ?? "(no error text)"}`,
+        `Calls: ${group.calls} over ${group.turns} turns`,
+        `Last seen: ${new Date(group.lastSeenAt).toISOString()}`,
+    ];
+    const call = group.latest[0];
+    if (call) {
+        parts.push(`Input excerpt: "${call.input.slice(0, EXPLAIN_EXCERPT_CHARS)}"`);
+    }
+    return parts.join("; ");
+}
+/**
+ * Builds the request the test asserts on: the skill name, its `SKILL.md` when
+ * a watched folder holds it, and the top groups. No prompts, no replies.
+ */
+export function explainUserPrompt(skill, skillFile, groups) {
+    const file = skillFile === null ? "(not in a watched folder; no SKILL.md)" : `<<<\n${skillFile}\n>>>`;
+    return [
+        `Skill: ${skill.name}`,
+        `SKILL.md:\n${file}`,
+        `Failure groups, most calls first:`,
+        groups.map(groupLine).join("\n") || "(none)",
+    ].join("\n\n");
+}
+/**
+ * Asks the external API model to explain one skill's failure groups (design
+ * §9). The reply is returned, never saved. Reuses the drafting model path and
+ * its failure codes, including `not-configured`.
+ */
+export async function explainFailures(skill, deps) {
+    if (!deps.model.ready)
+        return fail("explain failures", "not-configured");
+    const groups = (await skillFailureGroups(deps.store, skill, deps.index)).slice(0, MAX_EXPLAIN_GROUPS);
+    if (groups.length === 0)
+        return fail("explain failures", "invalid-args");
+    let skillFile = null;
+    if (skill.path) {
+        try {
+            skillFile = readFileSync(skill.path, "utf8");
+        }
+        catch {
+            skillFile = null;
+        }
+    }
+    const user = explainUserPrompt(skill, skillFile, groups);
+    let result;
+    try {
+        result = await deps.model.callTool(EXPLAIN_SYSTEM, user, EXPLAIN_TOOL);
+    }
+    catch (error) {
+        return fail("explain failures", profileFailureCode(error));
+    }
+    if (!result.success)
+        return fail("explain failures", profileResultCode(result));
+    const parsed = ExplainReply.safeParse(result.data);
+    if (!parsed.success)
+        return fail("explain failures", "invalid-reply");
+    return {
+        ok: true,
+        explanation: {
+            summary: parsed.data.summary.trim(),
+            causes: parsed.data.causes.map((cause) => ({
+                kind: cause.kind,
+                explanation: cause.explanation.trim(),
+                actions: cause.actions.map((action) => action.trim()).filter(Boolean),
+            })),
+        },
+    };
+}

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

@@ -0,0 +1,57 @@
+import type { SkillIndex } from "./skill-index.js";
+import type { SkillStore } from "./store.js";
+/** The server sends at most this many characters of one call's input (design §3). */
+export declare const FAILURE_INPUT_CAP = 20000;
+/** A group key is the first line of the error text, cut to this length (design §4). */
+export declare const FAILURE_LINE_CHARS = 200;
+/** How many of a group's latest calls the reply carries. */
+export declare const FAILURE_SAMPLE = 5;
+/** How many groups the reply carries, most calls first. */
+export declare const FAILURE_GROUP_LIMIT = 50;
+/** One failed tool call of a turn, as the dialog shows it. */
+export interface TurnFailure {
+    position: number;
+    name: string;
+    input: string;
+    /** True when the stored input was longer than `FAILURE_INPUT_CAP`. */
+    inputCut: boolean;
+    /** Null when the host reported no error text. */
+    error: string | null;
+}
+/** One failed call of a group: the call fields plus its turn's time and project. */
+export interface FailureGroupCall extends TurnFailure {
+    turnId: number;
+    createdAt: number;
+    projectName: string | null;
+}
+/** The failed calls of one skill that count against it, grouped by tool and first error line. */
+export interface FailureGroup {
+    /** The tool name. */
+    name: string;
+    /** The first line of the error text, cut to `FAILURE_LINE_CHARS`; null when no error text. */
+    errorLine: string | null;
+    /** Calls in the group. */
+    calls: number;
+    /** Turns the calls span. */
+    turns: number;
+    /** When the newest call of the group happened. */
+    lastSeenAt: number;
+    /** The latest `FAILURE_SAMPLE` calls, newest first. */
+    latest: FailureGroupCall[];
+}
+/**
+ * Every failed call of one turn, ordered by position. Null when the turn does
+ * not exist; an empty list when it has no failed call. A missing `skills.db`
+ * gives an empty list and stays missing.
+ */
+export declare function turnFailures(store: SkillStore, turnId: number): Promise<TurnFailure[] | null>;
+/**
+ * The failed calls of one skill that count against it by the ranking rule,
+ * grouped by tool name and the first line of the error text, most calls first.
+ * At most `FAILURE_GROUP_LIMIT` groups come back, each with its latest calls.
+ * A missing `skills.db` gives an empty list and stays missing.
+ */
+export declare function skillFailureGroups(store: SkillStore, skill: {
+    name: string;
+    path: string | null;
+}, index: SkillIndex): Promise<FailureGroup[]>;

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

@@ -0,0 +1,103 @@
+import { skillUsesFor } from "./turn-summaries.js";
+/** The server sends at most this many characters of one call's input (design §3). */
+export const FAILURE_INPUT_CAP = 20_000;
+/** A group key is the first line of the error text, cut to this length (design §4). */
+export const FAILURE_LINE_CHARS = 200;
+/** How many of a group's latest calls the reply carries. */
+export const FAILURE_SAMPLE = 5;
+/** How many groups the reply carries, most calls first. */
+export const FAILURE_GROUP_LIMIT = 50;
+// An empty error text is no error text, as a null one is: both show as
+// "No error text recorded". The first line of the error is the group key; a
+// trailing carriage return from CRLF text is not part of the key.
+const NO_ERROR = "tc.error IS NULL OR tc.error = ''";
+const LINE = `CASE WHEN ${NO_ERROR} THEN NULL
+  ELSE rtrim(substr(substr(tc.error, 1, instr(tc.error || char(10), char(10)) - 1), 1, ${FAILURE_LINE_CHARS}), char(13)) END`;
+const CALL_FIELDS = `
+  tc.position, tc.name,
+  substr(tc.input, 1, ${FAILURE_INPUT_CAP}) AS input,
+  length(tc.input) > ${FAILURE_INPUT_CAP} AS input_cut,
+  CASE WHEN ${NO_ERROR} THEN NULL ELSE tc.error END AS error`;
+function callRow(row) {
+    return {
+        position: Number(row.position),
+        name: String(row.name),
+        input: String(row.input),
+        inputCut: Number(row.input_cut) === 1,
+        error: row.error == null ? null : String(row.error),
+    };
+}
+/**
+ * Every failed call of one turn, ordered by position. Null when the turn does
+ * not exist; an empty list when it has no failed call. A missing `skills.db`
+ * gives an empty list and stays missing.
+ */
+export async function turnFailures(store, turnId) {
+    const db = await store.existingDb();
+    if (!db)
+        return [];
+    const turn = await db.get("SELECT id FROM turns WHERE id = ?", [turnId]);
+    if (!turn)
+        return null;
+    const rows = await db.all(`SELECT ${CALL_FIELDS} FROM tool_calls tc
+     WHERE tc.turn_id = ? AND tc.outcome = 'error' ORDER BY tc.position, tc.id`, [turnId]);
+    return rows.map(callRow);
+}
+/**
+ * The failed calls of one skill that count against it by the ranking rule,
+ * grouped by tool name and the first line of the error text, most calls first.
+ * At most `FAILURE_GROUP_LIMIT` groups come back, each with its latest calls.
+ * A missing `skills.db` gives an empty list and stays missing.
+ */
+export async function skillFailureGroups(store, skill, index) {
+    const db = await store.existingDb();
+    if (!db)
+        return [];
+    const uses = skillUsesFor(skill, index);
+    // The earliest use of this skill only, as the ranking measures it; another
+    // skill used earlier in the same turn does not move the line.
+    const firstUse = `SELECT u.turn_id, MIN(COALESCE(u.position, -1)) AS position
+    FROM (${uses.sql}) u GROUP BY u.turn_id`;
+    const failed = `SELECT tc.id, tc.turn_id, tc.position, tc.name, t.created_at, t.project_name, ${LINE} AS line,
+      substr(tc.input, 1, ${FAILURE_INPUT_CAP}) AS input,
+      length(tc.input) > ${FAILURE_INPUT_CAP} AS input_cut,
+      CASE WHEN ${NO_ERROR} THEN NULL ELSE tc.error END AS error
+    FROM tool_calls tc
+    JOIN turns t ON t.id = tc.turn_id
+    JOIN (${firstUse}) f ON f.turn_id = tc.turn_id
+    WHERE tc.outcome = 'error' AND tc.position > f.position`;
+    const top = `SELECT name, line, COUNT(*) AS calls, COUNT(DISTINCT turn_id) AS turn_count,
+       MAX(created_at) AS last_seen
+     FROM (${failed}) GROUP BY name, line
+     ORDER BY calls DESC, last_seen DESC, name, line LIMIT ${FAILURE_GROUP_LIMIT}`;
+    const groups = await db.all(top, uses.args);
+    if (groups.length === 0)
+        return [];
+    // The latest calls of the returned groups in one query: window functions work in the
+    // store's libSQL (checked for this change), so no JavaScript fallback is needed.
+    const latest = await db.all(`SELECT turn_id, created_at, project_name, position, name, line, input, input_cut, error
+     FROM (SELECT g.*, ROW_NUMBER() OVER (PARTITION BY g.name, g.line ORDER BY g.created_at DESC, g.id DESC) AS rn
+       FROM (${failed}) g
+       JOIN (${top}) k ON k.name = g.name AND k.line IS g.line)
+     WHERE rn <= ${FAILURE_SAMPLE} ORDER BY name, line, rn`, [...uses.args, ...uses.args]);
+    const byGroup = new Map();
+    for (const row of latest) {
+        const key = JSON.stringify([String(row.name), row.line == null ? null : String(row.line)]);
+        const list = byGroup.get(key) ?? [];
+        list.push({
+            ...callRow(row),
+            turnId: Number(row.turn_id),
+            createdAt: Number(row.created_at),
+            projectName: row.project_name == null ? null : String(row.project_name),
+        });
+        byGroup.set(key, list);
+    }
+    return groups.map((group) => ({
+        name: String(group.name),
+        errorLine: group.line == null ? null : String(group.line),
+        calls: Number(group.calls),
+        turns: Number(group.turn_count),
+        lastSeenAt: Number(group.last_seen),
+        latest: byGroup.get(JSON.stringify([String(group.name), group.line == null ? null : String(group.line)])) ?? [],
+    }));
+}

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

@@ -1,5 +1,5 @@
 import { type ApplyDeps } from "./apply.js";
-import { type SkillProposal } from "./proposal-store.js";
+import { countDiffLines } from "./line-diff.js";
 export type SkillHistoryKind = "created" | "applied" | "rejected" | "undone" | "stale";
 export interface SkillHistoryEntry {
     /** `<proposal id>:created` or `<proposal id>:<state>`. */
@@ -19,11 +19,7 @@ export interface SkillHistoryEntry {
     added: number;
     removed: number;
 }
-/** Added and removed line counts of a unified-style line diff. Hunk headers are skipped. */
-export declare function countDiffLines(diff: string | null): {
-    added: number;
-    removed: number;
-};
+export { countDiffLines };
 /**
  * The change history of one skill, newest first: a `created` entry for each
  * proposal and a second entry once it was applied, rejected, undone or found
@@ -40,9 +36,13 @@ export declare function skillHistory(deps: ApplyDeps, skill: {
 }>;
 /**
  * Each proposal with `canUndo`: true only for an applied proposal that undo
- * would accept now, so false once a later change rewrote the file. Reads one
- * saved version and one file hash per applied proposal, and nothing for the rest.
+ * would accept now, so false once a later change rewrote the file. Reads the
+ * newest saved versions of all applied proposals in one query, then one file
+ * hash per applied proposal, and nothing for the rest.
  */
-export declare function withCanUndo(deps: ApplyDeps, proposals: readonly SkillProposal[]): Promise<(SkillProposal & {
+export declare function withCanUndo<T extends {
+    id: string;
+    state: string;
+}>(deps: ApplyDeps, proposals: readonly T[]): Promise<(T & {
     canUndo: boolean;
 })[]>;