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

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-learning/turn-summaries.d.ts

@@ -12,6 +12,14 @@ export interface SkillTurnSummary {
     promptPreview: string;
     failedToolCalls: number;
 }
+/** The SQL that selects a skill's uses (turn id and position), and its parameters. */
+export declare function skillUsesFor(skill: {
+    name: string;
+    path: string | null;
+}, index: SkillIndex): {
+    sql: string;
+    args: (string | number)[];
+};
 /**
  * Turns that used one skill, newest first, `limit` of them after skipping
  * `offset`. `path` is null for a skill that no watched folder holds. A missing

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

@@ -17,16 +17,16 @@ function toSummary(row) {
 // The same use-to-skill rule as the ranking: a recorded path counts while the
 // index lists it; a use with no path belongs to the one watched skill with its name.
 const BY_PATH = `
-SELECT su.turn_id FROM skill_uses su
+SELECT su.turn_id, su.position FROM skill_uses su
 WHERE su.skill_path = ? OR (su.skill_path IS NULL AND su.skill_name = ? AND ? = 1)`;
 const BY_NAME = `
-SELECT su.turn_id FROM skill_uses su
+SELECT su.turn_id, su.position FROM skill_uses su
 WHERE su.skill_name = ? AND (
   (su.skill_path IS NOT NULL AND su.skill_path NOT IN (SELECT value FROM json_each(?)))
   OR (su.skill_path IS NULL AND ? = 0)
 )`;
-/** The SQL that selects a skill's turn ids, and its parameters. */
-function turnIdsFor(skill, index) {
+/** The SQL that selects a skill's uses (turn id and position), and its parameters. */
+export function skillUsesFor(skill, index) {
     const named = index.entries.filter((e) => e.name === skill.name);
     return skill.path
         ? {
@@ -42,6 +42,11 @@ function turnIdsFor(skill, index) {
             ],
         };
 }
+/** The SQL that selects a skill's turn ids, and its parameters. */
+function turnIdsFor(skill, index) {
+    const uses = skillUsesFor(skill, index);
+    return { sql: `SELECT turn_id FROM (${uses.sql})`, args: uses.args };
+}
 /**
  * Turns that used one skill, newest first, `limit` of them after skipping
  * `offset`. `path` is null for a skill that no watched folder holds. A missing

package/dist/services/skill-routes.js

@@ -1,15 +1,20 @@
 import { existsSync } from "node:fs";
+import { CONFIG } from "../config.js";
 import { RECORDING_OFF_TEXT, runSkillOperation, } from "../core/skill-operations.js";
 import { log } from "./logger.js";
 import { skillActivity, skillDaily } from "./skill-learning/activity.js";
 import { parseActivityQuery, topParam } from "./skill-learning/activity-range.js";
 import { undoProposal } from "./skill-learning/apply.js";
+import { turnFailures, skillFailureGroups } from "./skill-learning/failures.js";
+import { explainFailures } from "./skill-learning/failure-explain.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";
+import { skillModel } from "./skill-learning/skill-model.js";
 import { getSkillIndex } from "./skill-learning/skill-index.js";
 import { SkillStore, SkillStoreError, skillsDbPath } from "./skill-learning/store.js";
 import { RECENT_TURN_LIMIT, countSkillTurns, recentSkillTurns, skillTurnsByIds, } from "./skill-learning/turn-summaries.js";
@@ -132,6 +137,25 @@ async function dispatch(path, method, url, readBody, ctx) {
         if (path === "/api/skills/skill") {
             return showSkill(url, { store, folders: settings.folders }, index(), now);
         }
+        if (path === "/api/skills/failures") {
+            return showFailureGroups(url, store, index(), now);
+        }
+        const turnFailuresMatch = /^\/api\/skills\/turns\/([^/]+)\/failures$/.exec(path);
+        if (turnFailuresMatch) {
+            let id = "";
+            try {
+                id = decodeURIComponent(turnFailuresMatch[1]);
+            }
+            catch {
+                // A malformed percent sequence is not a number; the check below rejects "".
+            }
+            if (!/^\d+$/.test(id))
+                return fail("invalid-args", "The turn id must be a number");
+            const failures = await turnFailures(store, Number(id));
+            if (failures === null)
+                return fail("not-found", "No such turn");
+            return ok("ok", { failures });
+        }
         if (path === "/api/skills/activity") {
             const query = parseActivityQuery(url, now);
             if ("error" in query)
@@ -178,6 +202,11 @@ async function dispatch(path, method, url, readBody, ctx) {
             return setMode(await readBody(), store, index());
         case "/api/skills/delete-turns":
             return deleteTurns(await readBody(), store);
+        case "/api/skills/explain-failures":
+            // Stored text goes to the external model, so recording must be on.
+            if (!settings.enabled)
+                return fail("recording-off", RECORDING_OFF_TEXT);
+            return explainFailureGroups(await readBody(), store, index(), now);
         case "/api/skills/record-past":
             return recordPast(settings.enabled, ctx);
     }
@@ -200,10 +229,34 @@ 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)
             : [],
     });
 }
+async function showFailureGroups(url, store, index, now) {
+    const path = text(url.searchParams.get("path"));
+    const name = text(url.searchParams.get("name"));
+    if (!path && !name)
+        return fail("invalid-args", "Give path or name");
+    const skill = (await rankSkills(store, index, now)).find((s) => path ? s.path === path : s.path === null && s.name === name);
+    if (!skill)
+        return fail("not-found", "No such skill");
+    return ok("ok", { groups: await skillFailureGroups(store, skill, index) });
+}
+/** Explains one skill's failure groups through the drafting model path. The reply is shown, never saved. */
+async function explainFailureGroups(body, store, index, now) {
+    const path = text(body.path);
+    const name = text(body.name);
+    if (!path && !name)
+        return fail("invalid-args", "Give path or name");
+    const skill = (await rankSkills(store, index, now)).find((s) => path ? s.path === path : s.path === null && s.name === name);
+    if (!skill)
+        return fail("not-found", "No such skill");
+    const result = await explainFailures(skill, { store, index, model: skillModel(CONFIG) });
+    if (!result.ok)
+        return fail(result.code, result.message);
+    return ok("explained", { explanation: result.explanation });
+}
 async function proposals(url, store, folders) {
     const state = text(url.searchParams.get("state"));
     const skill = text(url.searchParams.get("skill"));
@@ -218,13 +271,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"));