om-memory-system 4.34.0 → 5.0.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/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;
 })[]>;

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

@@ -1,34 +1,9 @@
-import { canUndoProposal } from "./apply.js";
-import { listProposals } from "./proposal-store.js";
-/** Added and removed line counts of a unified-style line diff. Hunk headers are skipped. */
-export function countDiffLines(diff) {
-    let added = 0;
-    let removed = 0;
-    for (const line of (diff ?? "").split("\n")) {
-        if (line.startsWith("@@"))
-            continue;
-        if (line.startsWith("+"))
-            added++;
-        else if (line.startsWith("-"))
-            removed++;
-    }
-    return { added, removed };
-}
-/** The newest saved version id for each proposal id. */
-async function latestVersionIds(deps, ids) {
-    const db = await deps.store.existingDb();
-    const found = new Map();
-    if (!db || ids.length === 0)
-        return found;
-    const rows = await db.all(`SELECT proposal_id, MAX(id) AS id FROM skill_versions
-     WHERE proposal_id IN (SELECT value FROM json_each(?)) GROUP BY proposal_id`, [JSON.stringify(ids)]);
-    for (const row of rows)
-        found.set(String(row.proposal_id), Number(row.id));
-    return found;
-}
+import { checkUndo } from "./apply.js";
+import { countDiffLines } from "./line-diff.js";
+import { listProposalRows, proposalLineCounts, } from "./proposal-summaries.js";
+export { countDiffLines };
 function entriesOf(proposal, versions) {
-    const counts = countDiffLines(proposal.diff);
-    const base = { proposalId: proposal.id, summary: proposal.summary ?? "", ...counts };
+    const base = { proposalId: proposal.id, summary: proposal.summary ?? "" };
     const entries = [
         {
             ...base,
@@ -48,7 +23,7 @@ function entriesOf(proposal, versions) {
             kind: proposal.state,
             at: proposal.updatedAt,
             appliedBy: applied ? proposal.appliedBy : null,
-            versionId: applied && version !== undefined ? String(version) : null,
+            versionId: applied && version !== undefined ? String(version.id) : null,
         });
     }
     return entries;
@@ -64,32 +39,78 @@ export async function skillHistory(deps, skill, limit, offset) {
     // A name without a path is a skill outside the watched folders. Its proposals
     // have no path, so a watched skill that shares the name stays out.
     const proposals = skill.path
-        ? await listProposals(deps.store, { skillPath: skill.path })
-        : (await listProposals(deps.store, { skillName: skill.name })).filter((p) => !p.skillPath);
-    const versions = await latestVersionIds(deps, proposals.filter((p) => p.state === "applied").map((p) => p.id));
+        ? await listProposalRows(deps.store, { skillPath: skill.path })
+        : (await listProposalRows(deps.store, { skillName: skill.name })).filter((p) => !p.skillPath);
+    const versions = await latestVersionFacts(deps, proposals.filter((p) => p.state === "applied").map((p) => p.id));
     const all = proposals.flatMap((p) => entriesOf(p, versions));
     // At the same time, the later step (applied, rejected) sorts above `created`.
     all.sort((a, b) => b.at - a.at || +(b.kind !== "created") - +(a.kind !== "created"));
-    const appliedVersionIds = [...versions.values()];
+    const appliedVersionIds = [...versions.values()].map((v) => v.id);
     const page = all.slice(offset, offset + limit);
-    const entries = await Promise.all(page.map(async (entry) => {
-        const version = entry.kind === "applied" ? Number(entry.versionId) : null;
+    // Diffs are read for the proposals on this page only.
+    const counts = await proposalLineCounts(deps.store, [...new Set(page.map((e) => e.proposalId))]);
+    const readOnly = deps.store.isReadOnly();
+    const entries = page.map((entry) => {
+        const version = entry.kind === "applied" ? (versions.get(entry.proposalId) ?? null) : null;
+        // A change with no diff, such as a new skill, keeps 0 and 0 here.
+        const lines = counts.get(entry.proposalId);
         return {
             ...entry,
-            canUndo: version !== null && (await canUndoProposal(entry.proposalId, deps)),
-            laterAppliedCount: version === null ? 0 : appliedVersionIds.filter((id) => id > version).length,
+            added: lines?.hasDiff ? lines.added : 0,
+            removed: lines?.hasDiff ? lines.removed : 0,
+            canUndo: entry.kind === "applied" &&
+                checkUndo({
+                    id: entry.proposalId,
+                    readOnly,
+                    state: "applied",
+                    version,
+                    folders: deps.folders,
+                }).ok,
+            laterAppliedCount: version === null ? 0 : appliedVersionIds.filter((id) => id > version.id).length,
         };
-    }));
+    });
     return { total: all.length, entries };
 }
+/**
+ * The id, path and hash of the newest saved version for each proposal id, in
+ * one query. It names its columns, so the saved previous content is not read.
+ */
+async function latestVersionFacts(deps, ids) {
+    const db = await deps.store.existingDb();
+    const found = new Map();
+    if (!db || ids.length === 0)
+        return found;
+    const rows = await db.all(`SELECT v.id, v.proposal_id, v.path, v.written_hash FROM skill_versions v
+     JOIN (SELECT MAX(id) AS id FROM skill_versions
+           WHERE proposal_id IN (SELECT value FROM json_each(?)) GROUP BY proposal_id) m
+       ON v.id = m.id`, [JSON.stringify(ids)]);
+    for (const row of rows) {
+        found.set(String(row.proposal_id), {
+            id: Number(row.id),
+            path: String(row.path),
+            writtenHash: String(row.written_hash),
+        });
+    }
+    return found;
+}
 /**
  * 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 async function withCanUndo(deps, proposals) {
-    return Promise.all(proposals.map(async (p) => ({
+    const versions = await latestVersionFacts(deps, proposals.filter((p) => p.state === "applied").map((p) => p.id));
+    const readOnly = deps.store.isReadOnly();
+    return proposals.map((p) => ({
         ...p,
-        canUndo: p.state === "applied" && (await canUndoProposal(p.id, deps)),
-    })));
+        canUndo: p.state === "applied" &&
+            checkUndo({
+                id: p.id,
+                readOnly,
+                state: p.state,
+                version: versions.get(p.id) ?? null,
+                folders: deps.folders,
+            }).ok,
+    }));
 }

package/dist/services/skill-learning/line-diff.d.ts

@@ -4,3 +4,8 @@
  * texts have the same lines. The web page renders it as text.
  */
 export declare function lineDiff(before: string, after: string): string;
+/** 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;
+};

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

@@ -92,3 +92,17 @@ export function lineDiff(before, after) {
     }
     return out.join("\n");
 }
+/** Added and removed line counts of a unified-style line diff. Hunk headers are skipped. */
+export function countDiffLines(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of (diff ?? "").split("\n")) {
+        if (line.startsWith("@@"))
+            continue;
+        if (line.startsWith("+"))
+            added++;
+        else if (line.startsWith("-"))
+            removed++;
+    }
+    return { added, removed };
+}

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

@@ -55,6 +55,8 @@ export interface SkillSettings {
     lastReviewAt: number | null;
     usesAtLastReview: number;
 }
+/** The turn ids in an `evidence_turn_ids` column. A damaged list reads as no evidence. */
+export declare function parseEvidenceIds(raw: unknown): 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>;
@@ -63,8 +65,13 @@ export interface ProposalFilter {
     skillName?: string;
     skillPath?: string;
 }
-/** Proposals, newest first. */
-export declare function listProposals(store: SkillStore, filter?: ProposalFilter): Promise<SkillProposal[]>;
+/** The shared order of every proposal list: newest first, ties by insertion. */
+export declare const PROPOSAL_ORDER = "ORDER BY created_at DESC, rowid DESC";
+/** The `WHERE` clause and its arguments for a filter. Empty when the filter is empty. */
+export declare function proposalFilterClause(filter: ProposalFilter): {
+    clause: string;
+    args: string[];
+};
 /**
  * Sets the state and the update time. `appliedBy` is written when given and
  * kept otherwise. Returns false when no proposal has this id.

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

@@ -9,16 +9,20 @@ async function writableDb(store) {
 function text(value) {
     return value === null || value === undefined ? null : String(value);
 }
-function toProposal(row) {
-    let evidence = [];
+/** The turn ids in an `evidence_turn_ids` column. A damaged list reads as no evidence. */
+export function parseEvidenceIds(raw) {
     try {
-        const parsed = JSON.parse(String(row.evidence_turn_ids));
+        const parsed = JSON.parse(String(raw));
         if (Array.isArray(parsed))
-            evidence = parsed.map(Number);
+            return parsed.map(Number);
     }
     catch {
         // A damaged list reads as no evidence.
     }
+    return [];
+}
+function toProposal(row) {
+    const evidence = parseEvidenceIds(row.evidence_turn_ids);
     return {
         id: String(row.id),
         kind: String(row.kind),
@@ -76,11 +80,10 @@ export async function getProposal(store, id) {
     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 [];
+/** The shared order of every proposal list: newest first, ties by insertion. */
+export const PROPOSAL_ORDER = "ORDER BY created_at DESC, rowid DESC";
+/** The `WHERE` clause and its arguments for a filter. Empty when the filter is empty. */
+export function proposalFilterClause(filter) {
     const where = [];
     const args = [];
     if (filter.state) {
@@ -95,9 +98,7 @@ export async function listProposals(store, filter = {}) {
         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);
+    return { clause: where.length > 0 ? `WHERE ${where.join(" AND ")}` : "", args };
 }
 /**
  * Sets the state and the update time. `appliedBy` is written when given and

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

@@ -0,0 +1,52 @@
+import { type ProposalFilter, type SkillAppliedBy, type SkillDraftedBy, type SkillProposalKind, type SkillProposalState } from "./proposal-store.js";
+import type { SkillStore } from "./store.js";
+/**
+ * Proposal lists without the proposed content or the diff (TDR-059). Those two
+ * columns are the bulk of a proposal, so a list names its columns and reads
+ * them only to count lines, and only for the proposals it returns. Nothing
+ * here reads `CONFIG`.
+ */
+/** A proposal as a list shows it, before line counts. */
+export interface SkillProposalRow {
+    id: string;
+    kind: SkillProposalKind;
+    skillName: string;
+    skillPath: string | null;
+    state: SkillProposalState;
+    appliedBy: SkillAppliedBy | null;
+    draftedBy: SkillDraftedBy;
+    summary: string | null;
+    evidenceTurnIds: number[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface LineCounts {
+    added: number;
+    removed: number;
+    /** False for a proposal with no diff, such as a new skill. */
+    hasDiff: boolean;
+}
+/** A listed proposal: the row and its line counts. `withCanUndo` adds `canUndo`. */
+export interface SkillProposalSummary extends SkillProposalRow, LineCounts {
+}
+export interface ProposalPage {
+    limit: number;
+    offset: number;
+}
+/** Proposals without content or diff, newest first. */
+export declare function listProposalRows(store: SkillStore, filter?: ProposalFilter): Promise<SkillProposalRow[]>;
+/**
+ * Added and removed lines for the given proposal ids. Reads the diff, and the
+ * content only where there is no diff. A proposal with no diff counts every
+ * content line as added. Unknown ids are left out.
+ */
+export declare function proposalLineCounts(store: SkillStore, ids: readonly string[]): Promise<Map<string, LineCounts>>;
+/**
+ * Summaries of the proposals that match the filter, newest first, with line
+ * counts for the returned page only. `total` counts every match. Without a
+ * page the whole list comes back.
+ */
+export declare function listProposalSummaries(store: SkillStore, filter?: ProposalFilter, page?: ProposalPage): Promise<{
+    proposals: SkillProposalSummary[];
+    total: number;
+}>;

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

@@ -0,0 +1,73 @@
+import { countDiffLines } from "./line-diff.js";
+import { PROPOSAL_ORDER, parseEvidenceIds, proposalFilterClause, } from "./proposal-store.js";
+const LIST_COLUMNS = "id, kind, skill_name, skill_path, state, applied_by, drafted_by, summary, evidence_turn_ids, created_at, updated_at";
+function text(value) {
+    return value === null || value === undefined ? null : String(value);
+}
+function toRow(row) {
+    return {
+        id: String(row.id),
+        kind: String(row.kind),
+        skillName: String(row.skill_name),
+        skillPath: text(row.skill_path),
+        state: String(row.state),
+        appliedBy: text(row.applied_by),
+        draftedBy: row.drafted_by === "agent" ? "agent" : "model",
+        summary: text(row.summary),
+        evidenceTurnIds: parseEvidenceIds(row.evidence_turn_ids),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+    };
+}
+/** Proposals without content or diff, newest first. */
+export async function listProposalRows(store, filter = {}) {
+    const db = await store.existingDb();
+    if (!db)
+        return [];
+    const { clause, args } = proposalFilterClause(filter);
+    const rows = await db.all(`SELECT ${LIST_COLUMNS} FROM skill_proposals ${clause} ${PROPOSAL_ORDER}`, args);
+    return rows.map(toRow);
+}
+/** Lines of a new skill's content. A blank body has none, as on the Skills page. */
+function contentLines(content) {
+    return content.trim() ? content.split("\n").length : 0;
+}
+/**
+ * Added and removed lines for the given proposal ids. Reads the diff, and the
+ * content only where there is no diff. A proposal with no diff counts every
+ * content line as added. Unknown ids are left out.
+ */
+export async function proposalLineCounts(store, ids) {
+    const counts = new Map();
+    const db = await store.existingDb();
+    if (!db || ids.length === 0)
+        return counts;
+    // The diff text is read here and counted in JavaScript. Counting inside SQLite was
+    // measured 20 ms slower at 5,000 proposals, because `replace()` copies each diff.
+    const rows = await db.all(`SELECT id, diff, CASE WHEN diff IS NULL THEN proposed_content END AS content
+     FROM skill_proposals WHERE id IN (SELECT value FROM json_each(?))`, [JSON.stringify(ids)]);
+    for (const row of rows) {
+        const diff = text(row.diff);
+        counts.set(String(row.id), diff === null
+            ? { added: contentLines(String(row.content ?? "")), removed: 0, hasDiff: false }
+            : { ...countDiffLines(diff), hasDiff: true });
+    }
+    return counts;
+}
+/**
+ * Summaries of the proposals that match the filter, newest first, with line
+ * counts for the returned page only. `total` counts every match. Without a
+ * page the whole list comes back.
+ */
+export async function listProposalSummaries(store, filter = {}, page) {
+    const all = await listProposalRows(store, filter);
+    const shown = page ? all.slice(page.offset, page.offset + page.limit) : all;
+    const counts = await proposalLineCounts(store, shown.map((p) => p.id));
+    return {
+        proposals: shown.map((p) => ({
+            ...p,
+            ...(counts.get(p.id) ?? { added: 0, removed: 0, hasDiff: false }),
+        })),
+        total: all.length,
+    };
+}

package/dist/services/skill-routes.js

@@ -6,7 +6,8 @@ import { parseActivityQuery, topParam } from "./skill-learning/activity-range.js
 import { undoProposal } from "./skill-learning/apply.js";
 import { skillHistory, withCanUndo } from "./skill-learning/history.js";
 import { skillOperationsDeps } from "./skill-learning/operations-deps.js";
-import { getProposal, listProposals, setSkillMode, } from "./skill-learning/proposal-store.js";
+import { getProposal, setSkillMode, } from "./skill-learning/proposal-store.js";
+import { listProposalSummaries } from "./skill-learning/proposal-summaries.js";
 import { intParam } from "./skill-learning/query-params.js";
 import { SKILL_ORDERS, rankSkills } from "./skill-learning/ranking.js";
 import { skillTurnSettingsFor } from "./skill-learning/settings-for.js";
@@ -200,7 +201,7 @@ async function showSkill(url, deps, index, now) {
         turnTotal: await countSkillTurns(store, skill, index),
         daily: await skillDaily(store, index, skill, now),
         proposals: skill.path
-            ? await withCanUndo(deps, await listProposals(store, { skillPath: skill.path }))
+            ? await withCanUndo(deps, (await listProposalSummaries(store, { skillPath: skill.path })).proposals)
             : [],
     });
 }
@@ -218,13 +219,13 @@ async function proposals(url, store, folders) {
         filter.skillPath = skill;
     else if (skill)
         filter.skillName = skill;
-    const all = await listProposals(store, filter);
-    // Without limit or offset the whole list comes back, as before.
+    // Without limit or offset the whole list comes back, as before. Summaries only: the
+    // content and diff come from the detail route.
     const offset = intParam(url, "offset", 0, Number.MAX_SAFE_INTEGER, 0);
-    const limit = intParam(url, "limit", 1, MAX_PAGE, all.length || 1);
+    const limit = intParam(url, "limit", 1, MAX_PAGE, Number.MAX_SAFE_INTEGER);
     const paged = url.searchParams.has("limit") || url.searchParams.has("offset");
-    const shown = paged ? all.slice(offset, offset + limit) : all;
-    return ok("ok", { proposals: await withCanUndo({ store, folders }, shown), total: all.length });
+    const { proposals: shown, total } = await listProposalSummaries(store, filter, paged ? { limit, offset } : undefined);
+    return ok("ok", { proposals: await withCanUndo({ store, folders }, shown), total });
 }
 async function history(url, store, folders) {
     const path = text(url.searchParams.get("path"));