super-dsh 0.1.0 → 0.1.2

package/agent-omp/dist/models.js

@@ -0,0 +1,299 @@
+/**
+ * OMP model catalog for the Dash model selector.
+ *
+ * The browser model selector is a pure RPC round-trip through the apiproxy:
+ * `session.models` reads `ctx.llm.listProviders/listModels/resolveModelInfo`,
+ * so the OMP provider registers an `LlmAdapter` whose catalog is OMP's real
+ * AVAILABLE model set. This module owns the source of that catalog.
+ *
+ * Source: `omp models --json` (first-party CLI, `omp-cli.ts`) — OMP's own
+ * credential-resolved availability verdict. The documented selectability
+ * rule (provider not in `disabledProviders` and keyless or with a
+ * resolvable credential) runs through a 7-level credential precedence that
+ * includes OAuth/login keys stored in agent.db — a state NO config file
+ * reveals, which is why the catalog must come from OMP itself.
+ *
+ * The authoritative RPC `get_available_models` would serve the same set but
+ * exceeds the 1 MiB transport frame limit for this install; the CLI returns
+ * the compact form (~50 models / 5 providers, 15 KB, ~1.7s). The on-disk
+ * `models.db` ∪ `models.yml` pair remains ONLY as the subprocess-failure
+ * fallback (registry-cache noise included) — never the primary.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { ompAvailableModels, ompAvailableModelsSync, ompModelRolesSync } from "./omp-cli.js";
+import { OMP_NATIVE_HOME } from "./knobs.js";
+import { readOmpModelRolesFromConfig } from "./omp-store.js";
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+const OMP_AGENT_DIR = join(OMP_NATIVE_HOME, "agent");
+/**
+ * Providers named by config.yml `modelRoles` lead the selector: they are the
+ * roles the operator actually wired (the TUI default-model semantics).
+ */
+let cached = null;
+/**
+ * Read the AVAILABLE OMP model catalog, memoized. First call prefers the CLI
+ * (`omp models --json`, synchronous — the boot route list must be known
+ * before `registerAdapter` returns); a CLI failure falls back to the on-disk
+ * registry cache with a stderr note. Later refreshes go through
+ * `refreshOmpModelsCli` (async, per reconcile tick).
+ */
+export function loadOmpModels() {
+    if (cached === null) {
+        const cli = ompAvailableModelsSync();
+        if (cli !== undefined) {
+            cached = cli.map((model) => normalizeModel(model)).filter((model) => model !== null);
+        }
+        else {
+            process.stderr.write("[omp-provider] omp models --json unavailable; falling back to the on-disk model cache\n");
+            cached = mergeModels(loadModelsDb(), loadModelsYml());
+        }
+    }
+    return cached;
+}
+/**
+ * Re-run the CLI catalog and swap the memo on success.
+ * @returns whether the refresh produced a fresh catalog.
+ */
+export async function refreshOmpModelsCli() {
+    const cli = await ompAvailableModels();
+    if (cli === undefined)
+        return false;
+    cached = cli.map((model) => normalizeModel(model)).filter((model) => model !== null);
+    return true;
+}
+/** The distinct provider ids across the catalog, modelRoles roles first. */
+export function ompProviderIds(models = loadOmpModels()) {
+    const seen = new Set();
+    for (const model of models)
+        seen.add(model.provider);
+    const ordered = [];
+    // Providers the operator wired into modelRoles lead the selector (TUI
+    // semantics: the roles actually in use); everything else follows
+    // alphabetically. Roles come from config.yml ON DISK — never a sidecar
+    // warm (sidecar-decoupling); the memo is only a fallback for a sidecar
+    // that is already live.
+    const roles = readOmpModelRolesFromConfig() ?? ompModelRolesSync();
+    for (const selector of Object.values(roles ?? {})) {
+        const slash = selector.indexOf("/");
+        const provider = slash > 0 ? selector.slice(0, slash) : "";
+        if (provider !== "" && seen.has(provider) && !ordered.includes(provider))
+            ordered.push(provider);
+    }
+    for (const provider of [...seen].sort((a, b) => a.localeCompare(b))) {
+        if (!ordered.includes(provider))
+            ordered.push(provider);
+    }
+    return ordered;
+}
+/** Human-readable provider name for `LlmProviderInfo.name`. */
+export function providerDisplayName(provider) {
+    const titles = { zai: "Z.AI", xai: "xAI", openrouter: "OpenRouter" };
+    return titles[provider] ?? (provider.charAt(0).toUpperCase() + provider.slice(1));
+}
+/** Merge the registry cache under the user overlay (later models win per provider+id). */
+function mergeModels(cache, overlay) {
+    if (overlay.length === 0)
+        return cache;
+    const byKey = new Map();
+    for (const model of cache)
+        byKey.set(model.provider + "/" + model.id, model);
+    for (const model of overlay)
+        byKey.set(model.provider + "/" + model.id, model);
+    return [...byKey.values()];
+}
+/**
+ * Read `~/.omp/agent/models.db` (`model_cache.models` JSON column). This is
+ * the on-disk form of the registry `get_available_models` serves. Read-only
+ * and tolerant of a missing/empty file (OMP may not have refreshed it yet).
+ */
+function loadModelsDb() {
+    const out = [];
+    try {
+        const db = new DatabaseSync(join(OMP_AGENT_DIR, "models.db"), { readOnly: true });
+        try {
+            const rows = db.prepare("SELECT models FROM model_cache").all();
+            for (const row of rows) {
+                try {
+                    const models = JSON.parse(row.models);
+                    if (!Array.isArray(models))
+                        continue;
+                    for (const model of models) {
+                        const parsed = normalizeModel(model);
+                        if (parsed !== null)
+                            out.push(parsed);
+                    }
+                }
+                catch {
+                    // one malformed provider row must not sink the whole catalog
+                }
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        // absent db / schema drift → fall through to the overlay alone
+    }
+    return out;
+}
+/**
+ * Parse `~/.omp/agent/models.yml` — a `providers: <id>: { models: [ ... ] }`
+ * overlay OMP writes. A focused indentation scan is enough for this fixed
+ * shape and avoids pulling `js-yaml` into the provider's dependency surface.
+ * Any parse failure degrades to an empty overlay.
+ */
+function loadModelsYml() {
+    const out = [];
+    let text;
+    try {
+        text = readFileSync(join(OMP_AGENT_DIR, "models.yml"), "utf8");
+    }
+    catch {
+        return out;
+    }
+    let provider = "";
+    let inModels = false;
+    let model = null;
+    const push = () => {
+        if (model !== null) {
+            const parsed = normalizeModel({ ...model, provider });
+            if (parsed !== null)
+                out.push(parsed);
+            model = null;
+        }
+    };
+    for (const raw of text.split("\n")) {
+        const line = raw.replace(/\r$/, "");
+        if (line.trim() === "" || line.trimStart().startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        const trimmed = line.trim();
+        if (indent === 0) {
+            if (trimmed === "providers:") {
+                provider = "";
+                inModels = false;
+                model = null;
+            }
+            else {
+                provider = "";
+                inModels = false;
+                model = null;
+            }
+            continue;
+        }
+        if (indent === 2 && trimmed.endsWith(":")) {
+            push();
+            provider = trimmed.slice(0, -1).trim();
+            inModels = false;
+            continue;
+        }
+        if (indent === 4 && trimmed === "models:") {
+            inModels = true;
+            continue;
+        }
+        if (inModels && indent >= 6 && trimmed.startsWith("- ")) {
+            push();
+            model = {};
+            const entry = trimmed.slice(2).trim();
+            const colon = entry.indexOf(":");
+            if (colon > 0)
+                model[entry.slice(0, colon).trim()] = entry.slice(colon + 1).trim();
+            continue;
+        }
+        if (inModels && model !== null && indent >= 8) {
+            const colon = trimmed.indexOf(":");
+            if (colon > 0) {
+                const key = trimmed.slice(0, colon).trim();
+                model[key] = trimmed.slice(colon + 1).trim();
+            }
+            continue;
+        }
+        // Any other shape is outside the models list we care about.
+    }
+    push();
+    return out;
+}
+/** Coerce one raw model record into an {@link OmpModel}, or null when unusable. */
+function normalizeModel(raw) {
+    if (raw === null || typeof raw !== "object")
+        return null;
+    const record = raw;
+    const id = typeof record.id === "string" ? record.id : "";
+    const provider = typeof record.provider === "string" ? record.provider : "";
+    const name = typeof record.name === "string" && record.name !== "" ? record.name : id;
+    if (id === "" || provider === "" || name === "")
+        return null;
+    const thinking = normalizeThinking(record.thinking);
+    return {
+        id,
+        provider,
+        name,
+        ...(typeof record.api === "string" ? { api: record.api } : {}),
+        ...(typeof record.baseUrl === "string" ? { baseUrl: record.baseUrl } : {}),
+        ...(typeof record.reasoning === "boolean" ? { reasoning: record.reasoning } : {}),
+        ...(Array.isArray(record.input) ? { input: record.input.filter((m) => typeof m === "string") } : {}),
+        ...(typeof record.contextWindow === "number" ? { contextWindow: record.contextWindow } : {}),
+        ...(typeof record.maxTokens === "number" ? { maxTokens: record.maxTokens } : {}),
+        ...(thinking === undefined ? {} : { thinking }),
+    };
+}
+/** Map OMP's declared input modalities to the harness vocabulary. */
+function inputModalities(model) {
+    if (model.input === undefined)
+        return undefined;
+    const modalities = model.input.filter((m) => m === "text" || m === "image");
+    return modalities.length === 0 ? undefined : modalities;
+}
+/** Extract OMP's `thinking` sub-object, checking each field at the boundary. */
+function normalizeThinking(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const t = raw;
+    return {
+        ...(typeof t.mode === "string" ? { mode: t.mode } : {}),
+        ...(Array.isArray(t.efforts) ? { efforts: t.efforts.filter((e) => typeof e === "string") } : {}),
+        ...(typeof t.defaultLevel === "string" ? { defaultLevel: t.defaultLevel } : {}),
+    };
+}
+/** Map OMP `thinking.efforts` into the adapter reasoning-effort vocabulary. */
+function reasoningInfo(model) {
+    const efforts = model.thinking?.efforts ?? [];
+    if (efforts.length === 0)
+        return undefined;
+    const ids = new Set();
+    const mapped = efforts
+        .filter((effort) => effort !== "" && !ids.has(effort) && (ids.add(effort), true))
+        .map((effort) => ({ id: ReasoningEffortId(effort), name: effort }));
+    if (mapped.length === 0)
+        return undefined;
+    const defaultEffort = model.thinking?.defaultLevel;
+    return {
+        efforts: mapped,
+        ...(defaultEffort !== undefined && ids.has(defaultEffort) ? { defaultEffort: ReasoningEffortId(defaultEffort) } : {}),
+    };
+}
+/** One catalog row: {@link LlmModelInfo} for `listModels`. */
+export function toModelInfo(model) {
+    return {
+        provider: model.provider,
+        id: model.id,
+        name: model.name,
+        ...(inputModalities(model) === undefined ? {} : { inputModalities: inputModalities(model) }),
+    };
+}
+/** One exact-model resolution: {@link LlmResolvedModelInfo} for `resolveModel`. */
+export function toResolvedModelInfo(model) {
+    const info = toModelInfo(model);
+    const contextWindow = typeof model.contextWindow === "number" && model.contextWindow > 0 ? model.contextWindow : undefined;
+    const defaultMaxTokens = typeof model.maxTokens === "number" && model.maxTokens > 0 ? model.maxTokens : undefined;
+    const reasoning = reasoningInfo(model);
+    return {
+        ...info,
+        ...(contextWindow === undefined ? {} : { context: { contextWindow } }),
+        ...(defaultMaxTokens === undefined ? {} : { defaultMaxTokens }),
+        ...(reasoning === undefined ? {} : { reasoning }),
+    };
+}

package/agent-omp/dist/omp-cli.js

@@ -0,0 +1,147 @@
+/**
+ * OMP model catalog + modelRoles data plane, served by the shared bun sidecar
+ * (which embeds the OMP core via @oh-my-pi/pi-coding-agent) instead of
+ * spawning `omp` CLI subprocesses.
+ *
+ * Two data planes are bridged:
+ *   - `models.list`             → the credential-resolved AVAILABLE model
+ *     catalog (the same set `omp models --json` returned: ~50 models / 5
+ *     providers), keyed the way `models.ts` normalizes them (id/provider/name/
+ *     api/baseUrl/reasoning/input/contextWindow/maxTokens/thinking).
+ *   - `settings.modelRoles.get/set` → the role→"provider/model[:effort]" map,
+ *     including the persisted `default` selector (TUI semantics: the default
+ *     model IS config state, surviving sessions). `set` is a whole-object
+ *     roundtrip write, matching `omp config set modelRoles` (dotted keys are
+ *     rejected; the entire modelRoles object is the unit).
+ *
+ * The sidecar is a SHARED SINGLETON (src/sdk-client.ts acquire/release) — this
+ * module goes through the same instance via `callShared`, never spawning a
+ * second sidecar process.
+ *
+ * Sync variants (`*Sync`) cannot block on sidecar IPC, so they return the last
+ * cache and warm it asynchronously: the first boot-time call returns
+ * `undefined` (the caller's on-disk fallback engages) and a later background
+ * fetch repopulates the cache. The async variants always fetch fresh.
+ *
+ * Fail-soft: any sidecar failure (not started / crashed) yields `undefined`
+ * (reads) or `false` (write), so the provider never fails to boot on a down
+ * sidecar.
+ *
+ * @module omp-web/omp-cli
+ */
+import { callShared, callSharedIfLive } from "./sdk-client.js";
+// ---------------------------------------------------------------------------
+// Sidecar plumbing (fail-soft: any failure → undefined/false)
+// ---------------------------------------------------------------------------
+/** `models.list` over the shared sidecar → validated OmpCliModel[], undefined on failure. */
+async function sidecarModelsList() {
+    // LIVE-GATED: resolves only when the shared sidecar already exists (a live
+    // session or an on-demand op). Cold → undefined → the disk fallback engages;
+    // the reconcile tick can never spawn a sidecar (sidecar-decoupling ruling).
+    try {
+        const data = await callSharedIfLive("models.list", { refresh: true });
+        if (data === null || typeof data !== "object")
+            return undefined;
+        const models = data.models;
+        if (!Array.isArray(models))
+            return undefined;
+        const out = [];
+        for (const model of models) {
+            if (model !== null &&
+                typeof model === "object" &&
+                typeof model.provider === "string" &&
+                typeof model.id === "string") {
+                out.push(model);
+            }
+        }
+        return out.length > 0 ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `settings.modelRoles.get` over the shared sidecar → validated OmpModelRoles, undefined on failure. */
+async function sidecarModelRolesGet() {
+    try {
+        const data = await callShared("settings.modelRoles.get", {});
+        const value = data?.modelRoles;
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        const out = {};
+        for (const [role, selector] of Object.entries(value)) {
+            if (typeof selector === "string" && selector !== "")
+                out[role] = selector;
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `settings.modelRoles.set` over the shared sidecar → true only on a durable write. */
+async function sidecarModelRolesSet(roles) {
+    try {
+        const data = await callShared("settings.modelRoles.set", { modelRoles: roles });
+        return data?.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Model catalog
+// ---------------------------------------------------------------------------
+let modelsCache;
+/**
+ * Synchronous catalog read — MEMO-ONLY by design (sidecar-decoupling): no boot
+ * warm, no sidecar touch. `undefined` until something live swaps the cache in
+ * ({@link ompAvailableModels} on an already-live sidecar), so the boot path in
+ * `models.ts` falls back to the on-disk registry without spawning anything.
+ */
+export function ompAvailableModelsSync() {
+    return modelsCache;
+}
+/**
+ * `models.list` — the credential-resolved catalog, LIVE-GATED: fetched only
+ * when the shared sidecar already exists (a live session); `undefined` and the
+ * cache untouched when cold. Callers fall back to the on-disk sources.
+ */
+export async function ompAvailableModels() {
+    const models = await sidecarModelsList();
+    if (models !== undefined)
+        modelsCache = models;
+    return models;
+}
+// ---------------------------------------------------------------------------
+// modelRoles
+// ---------------------------------------------------------------------------
+let rolesCache;
+/**
+ * Synchronous roles read — memo-only, same contract as
+ * {@link ompAvailableModelsSync}. The boot path reads modelRoles from
+ * `config.yml` on disk (omp-store); this cache only ever reflects what a live
+ * sidecar reported. The write path (`ompModelRoles`/`ompSetModelRoles`) may
+ * spawn on real need — a default-model change is a user action, not a tick.
+ */
+export function ompModelRolesSync() {
+    return rolesCache;
+}
+/**
+ * `settings.modelRoles.get` — the current modelRoles object, fetched fresh
+ * from the sidecar on every call (the OMP TUI may have rewritten config.yml).
+ * `undefined` when unset or the sidecar fails.
+ */
+export async function ompModelRoles() {
+    const roles = await sidecarModelRolesGet();
+    if (roles !== undefined)
+        rolesCache = roles;
+    return roles;
+}
+/**
+ * `settings.modelRoles.set` — the TUI-grade default-model write: the sidecar
+ * replaces the whole modelRoles object (matching `omp config set modelRoles`
+ * whole-object semantics) and confirms the write landed before returning true.
+ */
+export async function ompSetModelRoles(roles) {
+    return sidecarModelRolesSet(roles);
+}

package/agent-omp/dist/omp-disk-discovery.js

@@ -0,0 +1,178 @@
+/**
+ * Host-side disk readers for OMP slash commands and skills.
+ *
+ * Replaces the sidecar round-trips (`slashCommands.list` / `skills.list`) that
+ * used to spawn the whole bun/OMP core just to walk a few directories. The
+ * upstream discovery (pi-coding-agent src/discovery/*) is a 10+ provider
+ * capability web we deliberately do NOT port; v1 scans the practical roots:
+ *
+ *   commands: <OMP_NATIVE_HOME>/agent/commands/*.md      (native user)
+ *             <cwd>/.omp/commands/*.md                   (native project)
+ *             ~/.claude/commands/*.md                    (claude user)
+ *             <cwd>/.claude/commands/*.md                (claude project)
+ *   skills:   the same four roots' `skills/` sibling, each entry either
+ *             `<root>/<name>/SKILL.md` (Agent Skills standard) or a lenient
+ *             flat `<root>/*.md`.
+ *
+ * Known divergences from the SDK path (accepted, see plan §3): no embedded
+ * bundled commands, no codex/opencode/cursor/gemini providers, no capability
+ * semantics (at-imports, managed skills, extensionRoots reload). Dedupe order
+ * is scan order with FIRST occurrence winning: omp user → claude user →
+ * omp project → claude project. All readers are fail-soft: missing roots or
+ * unreadable files are skipped, never thrown.
+ *
+ * @module omp-web/omp-disk-discovery
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveOmpNativeHome } from "./knobs.js";
+function discoveryRoots(cwd, kind) {
+    const home = homedir();
+    const roots = [
+        { base: resolveOmpNativeHome(), subdir: join("agent", kind), label: `omp:user` },
+        { base: home, subdir: join(".claude", kind), label: `claude:user` },
+    ];
+    if (cwd !== undefined && cwd !== "") {
+        roots.push({ base: cwd, subdir: join(".omp", kind), label: `omp:project` }, { base: cwd, subdir: join(".claude", kind), label: `claude:project` });
+    }
+    return roots;
+}
+/**
+ * Split an optional YAML-ish frontmatter from a markdown body and derive the
+ * display description the way the SDK's parseCommandTemplate does: the
+ * frontmatter `description` when present, else the first non-empty body line
+ * trimmed to 60 chars. Unknown keys are ignored; a malformed block degrades to
+ * "whole file is body".
+ */
+function parseMarkdownTemplate(raw) {
+    const text = raw.replace(/\r\n/g, "\n");
+    if (!text.startsWith("---\n")) {
+        return { description: fallbackDescription(text), content: text };
+    }
+    const end = text.indexOf("\n---", 4);
+    if (end === -1) {
+        return { description: fallbackDescription(text), content: text };
+    }
+    const frontmatter = text.slice(4, end);
+    const bodyStart = text.indexOf("\n", end + 1);
+    const body = bodyStart === -1 ? "" : text.slice(bodyStart + 1).replace(/^\n+/, "");
+    let description;
+    for (const line of frontmatter.split("\n")) {
+        const match = /^(description|argument-hint):\s*(.*)$/.exec(line);
+        if (match !== null && match[2] !== "") {
+            description = match[2].trim().replace(/^["']|["']$/g, "");
+            break;
+        }
+    }
+    return { description: description ?? fallbackDescription(body), content: body };
+}
+function fallbackDescription(body) {
+    const line = body.split("\n").find((candidate) => candidate.trim() !== "") ?? "";
+    return line.trim().slice(0, 60);
+}
+function listMarkdownFiles(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function readFileSoft(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read every file-based slash command from the discovery roots.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export function readSlashCommands(cwd) {
+    const byName = new Map();
+    for (const root of discoveryRoots(cwd, "commands")) {
+        const dir = join(root.base, root.subdir);
+        for (const file of listMarkdownFiles(dir)) {
+            const name = file.replace(/\.md$/i, "");
+            if (name === "" || byName.has(name))
+                continue;
+            const raw = readFileSoft(join(dir, file));
+            if (raw === undefined)
+                continue;
+            const parsed = parseMarkdownTemplate(raw);
+            byName.set(name, {
+                name,
+                description: parsed.description,
+                content: parsed.content,
+                source: root.label,
+                filePath: join(dir, file),
+            });
+        }
+    }
+    return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function readSkillFile(path, label) {
+    const raw = readFileSoft(path);
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseMarkdownTemplate(raw);
+    // Frontmatter `name:` may rename the skill; default to the directory/file name.
+    let name = "";
+    const frontmatterName = /^---\n[\s\S]*?^name:\s*(\S+)/m.exec(raw);
+    if (frontmatterName !== null)
+        name = frontmatterName[1];
+    if (name === "") {
+        const base = path.split("/").pop() ?? "";
+        name = base.toLowerCase() === "skill.md" ? (path.split("/").at(-2) ?? base) : base.replace(/\.md$/i, "");
+    }
+    return {
+        name,
+        description: parsed.description,
+        filePath: path,
+        baseDir: path.slice(0, path.lastIndexOf("/")) || path,
+        source: label,
+    };
+}
+/**
+ * Read every discovered skill from the discovery roots: the Agent Skills
+ * standard `<root>/<name>/SKILL.md` layout, plus a lenient flat `<root>/*.md`.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export function readSkills(cwd) {
+    const byName = new Map();
+    for (const root of discoveryRoots(cwd, "skills")) {
+        const dir = join(root.base, root.subdir);
+        if (!existsSync(dir))
+            continue;
+        let entries = [];
+        try {
+            entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({
+                name: entry.name,
+                isDirectory: entry.isDirectory(),
+            }));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const path = entry.isDirectory
+                ? join(dir, entry.name, "SKILL.md")
+                : join(dir, entry.name);
+            if (!entry.isDirectory && !entry.name.toLowerCase().endsWith(".md"))
+                continue;
+            if (entry.isDirectory && byName.has(entry.name))
+                continue;
+            const skill = readSkillFile(path, root.label);
+            if (skill === undefined || byName.has(skill.name))
+                continue;
+            byName.set(skill.name, skill);
+        }
+    }
+    return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}