@sealant/mend 0.15.0 → 0.16.0

package/README.md

@@ -83,6 +83,10 @@ mend sessions [--all] [--project p] [--json]
 mend status                           active sessions (alias of mend sessions)
 mend pair [--url <base url>]          pair a phone or a second machine: QR + code + URL
 mend doctor                           read-only checklist of this machine's setup
+mend skills [--project [p]]           your skill library on the server (or a project's)
+mend skills push [--project [p]] [--prune] [--dir <path>]
+                                      upload ~/.agents/skills bundles; sessions receive
+                                      them at launch (--prune removes what's gone)
 ```
 
 ## Signing in

package/dist/dashboard-model.js

@@ -200,3 +200,98 @@ export const foldGroupStatus = (group) => {
         return "idle";
     return statuses[0] ?? "idle";
 };
+// ─── attach + verb helpers ──────────────────────────────────────────────────
+/**
+ * Where "get me in" should land when the session has no live agent terminal:
+ * the newest LIVE shell, so repeated attaches rejoin the same one instead of
+ * stacking a fresh bash per attempt (the five-orphan-shells failure mode).
+ * Null = nothing attachable; opening a new shell is then honest.
+ */
+export const liveShellOf = (processes) => processes.findLast((process) => process.kind === "shell" && process.exitedAt === null) ?? null;
+/**
+ * The optimistic stop: the row settles AND its live process/service fact
+ * lines drop in the same paint — the server's refetch only confirms.
+ */
+export const markSessionStopped = (data, sessionId) => {
+    const processesBySession = new Map(data.processesBySession);
+    processesBySession.delete(sessionId);
+    const servicesBySession = new Map(data.servicesBySession);
+    servicesBySession.delete(sessionId);
+    return {
+        ...mapWorkbenchSessions(data, (session) => session.id === sessionId ? { ...session, status: "stopped" } : session),
+        processesBySession,
+        servicesBySession,
+    };
+};
+/** The optimistic removal: the whole group leaves the list before the server answers. */
+export const removeWorktreeGroup = (data, projectId, group) => {
+    const memberIds = new Set(group.sessions.map((item) => item.session.id));
+    const detail = data.details.get(projectId);
+    if (detail === undefined)
+        return data;
+    const details = new Map(data.details);
+    details.set(projectId, {
+        ...detail,
+        sessions: detail.sessions.filter((session) => !memberIds.has(session.id)),
+        ...(detail.worktrees === undefined
+            ? {}
+            : { worktrees: detail.worktrees.filter((worktree) => worktree.id !== group.id) }),
+    });
+    return { ...data, details };
+};
+/**
+ * Subsequence fuzzy score, fzf-flavored: every query character must appear in
+ * order; consecutive hits and segment starts (after `/`, `-`, `_`, `.`) score
+ * higher; earlier matches beat later ones. Null = no match. Case-insensitive.
+ */
+export const fuzzyScore = (query, candidate) => {
+    if (query === "")
+        return 0;
+    const q = query.toLowerCase();
+    const c = candidate.toLowerCase();
+    let score = 0;
+    let last = -1;
+    for (const char of q) {
+        const at = c.indexOf(char, last + 1);
+        if (at === -1)
+            return null;
+        if (at === last + 1)
+            score += 3;
+        else if (at === 0 || "/-_.".includes(c[at - 1] ?? ""))
+            score += 2;
+        else
+            score += 1;
+        score -= (at - last - 1) * 0.01;
+        last = at;
+    }
+    return score;
+};
+/**
+ * The picker's rows for one query: fuzzy-filtered, best score first, ties by
+ * most recent commit; an empty query lists everything, default branch on top.
+ */
+export const filterBranches = (branches, query) => {
+    const scored = branches.flatMap((branch) => {
+        const score = fuzzyScore(query, branch.name);
+        return score === null ? [] : [{ branch, score }];
+    });
+    return scored
+        .toSorted((a, b) => {
+        if (query === "" && a.branch.isDefault !== b.branch.isDefault) {
+            return a.branch.isDefault ? -1 : 1;
+        }
+        if (a.score !== b.score)
+            return b.score - a.score;
+        return b.branch.committedAt.localeCompare(a.branch.committedAt);
+    })
+        .map((entry) => entry.branch);
+};
+/** Commit the base step: the highlighted branch (default branch = null base). */
+export const advanceFromBase = (current) => {
+    const chosen = filterBranches(current.branches ?? [], current.query)[current.baseIndex];
+    return {
+        ...current,
+        base: chosen === undefined || chosen.isDefault ? null : chosen.name,
+        step: "harness",
+    };
+};

package/dist/dashboard.js

@@ -3,12 +3,12 @@ import { CliRenderEvents, createCliRenderer } from "@opentui/core";
 import { createRoot, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react";
 import { QueryClient, QueryClientProvider, useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
 import { useEffect, useRef, useState } from "react";
-import { deriveHarnesses, deriveProjects, deriveRows, deriveWorktrees, foldGroupStatus, labelIsIdentity, rowKeyOf, worktreeDisplayName, fetchWorkbench, mapWorkbenchSessions, prependSession, removeSession, replaceSession, WORKBENCH_KEY, } from "./dashboard-model.js";
+import { deriveHarnesses, deriveProjects, advanceFromBase, deriveRows, deriveWorktrees, filterBranches, foldGroupStatus, labelIsIdentity, rowKeyOf, worktreeDisplayName, fetchWorkbench, liveShellOf, mapWorkbenchSessions, markSessionStopped, removeWorktreeGroup, prependSession, removeSession, replaceSession, WORKBENCH_KEY, } from "./dashboard-model.js";
 import { reviewTargetForSession } from "./review-workflow.js";
 import { ReviewScreen } from "./review.js";
 import { cwdFacts, HARNESS_COMMANDS, isPendingId, LIVE_STATUSES, matchProjectByCwd, normalizeProjectName, pendingId, } from "./shared.js";
 import { openUrl } from "./terminal.js";
-import { COBALT, FAINT, INK, INK_2, MUTED, RED, RULE, WASH } from "./tui-theme.js";
+import { COBALT, FAINT, INK, INK_2, MUTED, RED, RULE, SURFACE, WASH } from "./tui-theme.js";
 // Near-mono on purpose: a status is a word, and only an observed failure
 // earns color. Live states read at full ink; settled ones recede.
 const STATUS_COLOR = {
@@ -155,15 +155,24 @@ const App = ({ ctx, onQuit }) => {
     const [editing, setEditing] = useState(null);
     /** Session id a stop is armed against; the second press fires it. */
     const [stopArmed, setStopArmed] = useState(null);
-    /** The new-session flow asks the worktree's name FIRST, then the harness. */
-    const [naming, setNaming] = useState(null);
-    const [pendingName, setPendingName] = useState(null);
+    /**
+     * The whole worktree creation is ONE modal: name, base (fuzzy over the
+     * project's branches), harness — every step visible, the active one
+     * expanded. Enter advances, esc steps back (cancels from the name).
+     */
+    const [creating, setCreating] = useState(null);
+    /**
+     * The cwd is a git repo the store doesn't know: offer to adopt it, once
+     * per dashboard run. Enter adopts, esc declines and stays quiet.
+     */
+    const [adoptOffer, setAdoptOffer] = useState(null);
+    const adoptOfferDecided = useRef(false);
     const [reviewing, setReviewing] = useState(null);
     /** Set synchronously around attach/launch so keystrokes can't double-fire. */
     const lockRef = useRef(false);
     /** Latest modal state for mutation callbacks — closures there go stale. */
     const modalRef = useRef(false);
-    modalRef.current = editing !== null || reviewing !== null || picker !== null;
+    modalRef.current = editing !== null || reviewing !== null || picker !== null || creating !== null;
     const { width: terminalCols, height: terminalRows } = useTerminalDimensions();
     const showProjectsPane = terminalCols >= 72;
     const showDetail = terminalRows >= 18;
@@ -197,6 +206,26 @@ const App = ({ ctx, onQuit }) => {
     const selectSession = (id) => setSessionKey(`s:${id}`);
     const say = (text) => setStatus({ text, at: Date.now() });
     const refetch = () => void queryClient.invalidateQueries({ queryKey: WORKBENCH_KEY });
+    // A repo underfoot that the store has never met: raise the adopt offer the
+    // first time the workbench answers and no project matches the cwd.
+    useEffect(() => {
+        if (data === undefined || adoptOfferDecided.current)
+            return;
+        if (homeProject !== undefined)
+            return;
+        const facts = cwdFacts(ctx.cwd);
+        if (facts.repoRoot === null)
+            return;
+        adoptOfferDecided.current = true;
+        setAdoptOffer({
+            root: facts.repoRoot,
+            source: facts.originUrl ?? facts.repoRoot,
+            name: normalizeProjectName(facts.repoRoot.split("/").at(-1) ?? "project"),
+            modeIndex: 0,
+        });
+        // homeProject/data identity is enough; ctx.cwd never changes in a run.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [data, homeProject]);
     // Keep each pane's selection on screen — the one imperative escape hatch.
     const projectScrollRef = useRef(null);
     const sessionScrollRef = useRef(null);
@@ -227,11 +256,21 @@ const App = ({ ctx, onQuit }) => {
             outcome = await ctx.attachTty(session.id, session.harness);
             if (outcome === "unavailable") {
                 // A live session whose terminal ended (idle: a workspace held open,
-                // no PTY behind it). Enter still means "get me in" — open a fresh
-                // shell in the same workspace and attach to that.
-                const shell = await ctx.api("POST", `/sessions/${session.id}/shell`);
-                process.stdout.write(`no live terminal — opened a shell in the workspace\n\n`);
-                outcome = await ctx.attachTty(session.id, "shell", shell.id);
+                // no PTY behind it). Enter still means "get me in" — REJOIN the shell
+                // already holding the workspace when one is live; only open a fresh
+                // one when nothing is attachable (stacking a new bash per attempt is
+                // how a session ends up held open by orphan shells).
+                const detail = await ctx.api("GET", `/sessions/${session.id}`);
+                const existing = liveShellOf(detail.processes);
+                if (existing !== null) {
+                    process.stdout.write(`no live terminal — rejoining the open shell\n\n`);
+                    outcome = await ctx.attachTty(session.id, "shell", existing.id);
+                }
+                else {
+                    const shell = await ctx.api("POST", `/sessions/${session.id}/shell`);
+                    process.stdout.write(`no live terminal — opened a shell in the workspace\n\n`);
+                    outcome = await ctx.attachTty(session.id, "shell", shell.id);
+                }
             }
         }
         catch (error) {
@@ -283,7 +322,7 @@ const App = ({ ctx, onQuit }) => {
                 harness: vars.harness,
                 label: null,
                 name: vars.name,
-                base: null,
+                base: vars.base,
             });
             await ctx.api("POST", `/sessions/${session.id}/launch`, { argv });
             return session;
@@ -296,7 +335,7 @@ const App = ({ ctx, onQuit }) => {
                 label: null,
                 branch: vars.name === null ? "provisioning…" : `mend/${vars.name}`,
                 baseSha: "",
-                baseRef: null,
+                baseRef: vars.base,
                 status: "starting",
                 summary: null,
                 createdAt: new Date().toISOString(),
@@ -342,6 +381,46 @@ const App = ({ ctx, onQuit }) => {
         },
         onSettled: settleRefetch,
     });
+    const ADOPT_AUTH_MODES = [
+        {
+            mode: "ambient",
+            label: "ambient",
+            hint: "the server machine's own git/ssh setup",
+        },
+        {
+            mode: "mend-key",
+            label: "mend-key",
+            hint: "the machine's Mend deploy key — add its public half on the git host",
+        },
+        {
+            mode: "bridge",
+            label: "bridge",
+            hint: "your OWN ssh-agent, relayed while `mend keys share` runs here",
+        },
+    ];
+    const adoptMutation = useMutation({
+        mutationFn: (offer) => ctx.api("POST", "/projects", {
+            name: offer.name,
+            source: offer.source,
+            gitAuthMode: ADOPT_AUTH_MODES[offer.modeIndex]?.mode ?? "ambient",
+        }),
+        onMutate: (offer) => {
+            setAdoptOffer(null);
+            setBusy(`adopting ${offer.name} — cloning into the store ·`);
+            setBusyStarted(Date.now());
+        },
+        onError: (error) => {
+            setBusy(null);
+            say(errorText(error));
+        },
+        onSuccess: (project) => {
+            setBusy(null);
+            say(`adopted · ${project.name} — n starts a worktree`);
+            setProjectKey(project.id);
+            setSessionKey(null);
+        },
+        onSettled: settleRefetch,
+    });
     // The label lands in the row before the server answers; an error puts the
     // truth back on the next refetch.
     const renameMutation = useMutation({
@@ -365,7 +444,8 @@ const App = ({ ctx, onQuit }) => {
         mutationFn: (session) => ctx.api("POST", `/sessions/${session.id}/stop`),
         onMutate: async (session) => {
             await queryClient.cancelQueries({ queryKey: WORKBENCH_KEY });
-            patchWorkbench((current) => mapWorkbenchSessions(current, (row) => row.id === session.id ? { ...row, status: "stopped" } : row));
+            // The row settles and its live process/service facts drop in one paint.
+            patchWorkbench((current) => markSessionStopped(current, session.id));
             say(`stopped · ${worktreeDisplayName(session)} — the record and review remain`);
         },
         onError: (error) => {
@@ -424,7 +504,13 @@ const App = ({ ctx, onQuit }) => {
         mutationFn: (group) => group.id !== null
             ? ctx.api("DELETE", `/worktrees/${group.id}`)
             : ctx.api("DELETE", `/sessions/${group.sessions[0]?.session.id ?? ""}`),
-        onMutate: (group) => {
+        onMutate: async (group) => {
+            await queryClient.cancelQueries({ queryKey: WORKBENCH_KEY });
+            const projectId = selectedProject?.project.id;
+            // The group leaves the list before the server answers; an error refetches truth.
+            if (projectId !== undefined) {
+                patchWorkbench((current) => removeWorktreeGroup(current, projectId, group));
+            }
             say(`removing worktree · ${group.name}`);
         },
         onError: (error) => {
@@ -492,17 +578,79 @@ const App = ({ ctx, onQuit }) => {
         setStopArmed(item.session.id);
         say(`press again to stop · ${worktreeDisplayName(item.session)}`);
     };
-    const startSession = (projectId, harness) => {
-        setFocus("sessions");
-        launchMutation.mutate({ projectId, harness, name: pendingName, pendingKey: pendingId() });
-        setPendingName(null);
+    /** Open the creation modal; the branch list starts loading immediately. */
+    const openCreateModal = (projectId) => {
+        setCreating({
+            projectId,
+            step: "name",
+            name: "",
+            branches: null,
+            query: "",
+            baseIndex: 0,
+            base: null,
+            joins: false,
+            harnessIndex: 0,
+        });
+        // The checkout mend ran in names its branch; creating in THAT project
+        // prefills the base with it — the list highlights it once loaded.
+        const prefill = projectId === homeProject?.id ? ctx.cwdBranch : null;
+        void ctx.api("GET", `/projects/${projectId}/branches`).then((branches) => setCreating((current) => {
+            if (current === null)
+                return current;
+            const match = prefill === null ? undefined : branches.find((candidate) => candidate.name === prefill);
+            const ordered = filterBranches(branches, "");
+            return {
+                ...current,
+                branches,
+                base: match === undefined || match.isDefault ? null : match.name,
+                baseIndex: match === undefined
+                    ? 0
+                    : Math.max(0, ordered.findIndex((candidate) => candidate.name === match.name)),
+            };
+        }), () => 
+        // An unreadable list falls back to the default base; the base step
+        // then shows only the default and enter moves on.
+        setCreating((current) => (current === null ? current : { ...current, branches: [] })));
+    };
+    /** Commit the name: an existing name JOINS its worktree — base is fixed. */
+    const advanceFromName = (current, raw) => {
+        const slug = normalizeProjectName(raw.trim());
+        const name = raw.trim() === "" ? "" : slug;
+        const joins = name !== "" &&
+            (workbench()?.details.get(current.projectId)?.worktrees ?? []).some((candidate) => candidate.name === name);
+        // A join fixes the base; otherwise whatever is chosen (the checkout
+        // prefill included) rides along untouched.
+        return {
+            ...current,
+            name,
+            joins,
+            ...(joins ? { base: null } : {}),
+            step: joins ? "harness" : "base",
+        };
+    };
+    const submitCreateName = (value) => {
+        setCreating((current) => (current === null ? current : advanceFromName(current, value)));
     };
-    /** Name first, then the harness: the worktree is the identity being created. */
-    const submitWorktreeName = (value) => {
-        setNaming(null);
-        const slug = normalizeProjectName(value.trim());
-        setPendingName(value.trim() === "" ? null : slug);
-        openPicker(null);
+    const submitCreateBase = () => {
+        setCreating((current) => (current === null ? current : advanceFromBase(current)));
+    };
+    /** Enter on the harness: everything is chosen — launch. */
+    const submitCreateHarness = () => {
+        const current = creating;
+        if (current === null)
+            return;
+        const choice = deriveHarnesses(null)[current.harnessIndex];
+        if (choice?.harness == null)
+            return;
+        setCreating(null);
+        setFocus("sessions");
+        launchMutation.mutate({
+            projectId: current.projectId,
+            harness: choice.harness,
+            name: current.name === "" ? null : current.name,
+            base: current.base,
+            pendingKey: pendingId(),
+        });
     };
     const resumeSession = (projectId, session, harness) => {
         setFocus("sessions");
@@ -558,11 +706,7 @@ const App = ({ ctx, onQuit }) => {
                     });
                 }
             }
-            else if (picker.session === null) {
-                if (choice.harness !== null)
-                    startSession(projectId, choice.harness);
-            }
-            else {
+            else if (picker.session !== null) {
                 resumeSession(projectId, picker.session, choice.harness);
             }
             return;
@@ -603,15 +747,109 @@ const App = ({ ctx, onQuit }) => {
             return;
         if (key.ctrl && key.name === "c")
             return onQuit();
+        if (adoptOffer !== null) {
+            if (key.name === "return" || key.name === "linefeed" || key.name === "y") {
+                adoptMutation.mutate(adoptOffer);
+            }
+            else if (key.name === "escape" || key.name === "q") {
+                setAdoptOffer(null);
+                say("not adopted — mend adopt does it any time");
+            }
+            else if (key.name === "right" ||
+                key.name === "l" ||
+                key.name === "tab" ||
+                key.name === "left" ||
+                key.name === "h") {
+                const delta = key.name === "left" || key.name === "h" ? -1 : 1;
+                setAdoptOffer((current) => current === null
+                    ? current
+                    : {
+                        ...current,
+                        modeIndex: (current.modeIndex + delta + ADOPT_AUTH_MODES.length) % ADOPT_AUTH_MODES.length,
+                    });
+            }
+            return;
+        }
         if (editing !== null) {
             // The input owns the keyboard; only escape leaves without saving.
             if (key.name === "escape")
                 setEditing(null);
             return;
         }
-        if (naming !== null) {
-            if (key.name === "escape")
-                setNaming(null);
+        if (creating !== null) {
+            // Inputs own the characters (name text, base filter); this handler owns
+            // the arrows, esc (a step back; cancel from the name), and the harness
+            // step's enter. The name and base enters land through their input's
+            // submit so typed-but-unflushed text never races.
+            if (key.name === "escape") {
+                setCreating((current) => {
+                    if (current === null)
+                        return current;
+                    if (current.step === "harness") {
+                        return { ...current, step: current.joins ? "name" : "base" };
+                    }
+                    if (current.step === "base")
+                        return { ...current, step: "name" };
+                    say("new worktree cancelled");
+                    return null;
+                });
+                return;
+            }
+            // Tab walks the steps without the enter ceremony: forward commits the
+            // active field (the mirrored name, the highlighted branch), shift+tab
+            // steps back, and from the harness it wraps around to the name.
+            if (key.name === "tab" || key.name === "backtab") {
+                const backward = key.name === "backtab" || key.shift === true;
+                setCreating((current) => {
+                    if (current === null)
+                        return current;
+                    if (backward) {
+                        if (current.step === "harness") {
+                            return { ...current, step: current.joins ? "name" : "base" };
+                        }
+                        if (current.step === "base")
+                            return { ...current, step: "name" };
+                        return current;
+                    }
+                    if (current.step === "name")
+                        return advanceFromName(current, current.name);
+                    if (current.step === "base")
+                        return advanceFromBase(current);
+                    return { ...current, step: "name" };
+                });
+                return;
+            }
+            const delta = key.name === "down" || (key.ctrl === true && key.name === "n")
+                ? 1
+                : key.name === "up" || (key.ctrl === true && key.name === "p")
+                    ? -1
+                    : 0;
+            if (delta !== 0) {
+                setCreating((current) => {
+                    if (current === null)
+                        return current;
+                    if (current.step === "base") {
+                        const matches = filterBranches(current.branches ?? [], current.query).length;
+                        return {
+                            ...current,
+                            baseIndex: Math.max(0, Math.min(matches - 1, current.baseIndex + delta)),
+                        };
+                    }
+                    if (current.step === "harness") {
+                        const count = deriveHarnesses(null).length;
+                        return {
+                            ...current,
+                            harnessIndex: Math.max(0, Math.min(count - 1, current.harnessIndex + delta)),
+                        };
+                    }
+                    return current;
+                });
+                return;
+            }
+            if (creating.step === "harness" &&
+                (key.name === "return" || key.name === "linefeed" || key.name === "l")) {
+                submitCreateHarness();
+            }
             return;
         }
         if (picker !== null) {
@@ -672,9 +910,9 @@ const App = ({ ctx, onQuit }) => {
                     setFocus(focus === "projects" ? "sessions" : "projects");
                 return;
             case "n":
-                // The worktree's name comes first; the harness picker follows.
+                // The whole creation is one modal: name, base, harness.
                 if (selectedProject !== null)
-                    setNaming({ projectId: selectedProject.project.id });
+                    openCreateModal(selectedProject.project.id);
                 return;
             case "s": {
                 // A new conversation inside the selected worktree.
@@ -742,15 +980,24 @@ const App = ({ ctx, onQuit }) => {
             : picker.session === null
                 ? "new session — pick a harness"
                 : `resume ${picker.session.id.slice(0, 8)} — pick a harness`;
-    const footerText = editing !== null
-        ? " enter save · esc cancel"
-        : naming !== null
-            ? " enter continue — the harness picker follows · esc cancel"
-            : picker !== null
-                ? " ↑↓ move · enter start · esc cancel"
-                : focus === "projects"
-                    ? " ↑↓ move · enter/l sessions · ⇥ panes · r refresh · q quit"
-                    : " ↑↓ move · enter attach/resume · n new worktree · s session here · x stop · ⇧D remove · v review · e rename · o web · q quit";
+    // One big fixed-size modal: every step visible at once, nothing shifts as
+    // focus moves through name → base → harness.
+    const creatingHeight = 2 + 1 + 1 + 6 + 1 + deriveHarnesses(null).length;
+    const footerText = adoptOffer !== null
+        ? " enter adopt · ←→ auth mode · esc not now"
+        : editing !== null
+            ? " enter save · esc cancel"
+            : creating !== null
+                ? creating.step === "name"
+                    ? " enter continue · esc cancel"
+                    : creating.step === "base"
+                        ? " type to filter · ↑↓ move · enter choose base · esc back"
+                        : " ↑↓ move · enter launch · esc back"
+                : picker !== null
+                    ? " ↑↓ move · enter start · esc cancel"
+                    : focus === "projects"
+                        ? " ↑↓ move · enter/l sessions · ⇥ panes · r refresh · q quit"
+                        : " ↑↓ move · enter attach/resume · n new worktree · s session here · x stop · ⇧D remove · v review · e rename · o web · q quit";
     const loadFailure = data === undefined && failureReason !== null
         ? failureReason instanceof Error
             ? failureReason.message
@@ -762,13 +1009,39 @@ const App = ({ ctx, onQuit }) => {
                 refetch();
             }, onQuit: onQuit }));
     }
-    return (_jsxs("box", { flexGrow: 1, flexDirection: "column", backgroundColor: "transparent", children: [_jsxs("box", { height: 1, flexDirection: "row", justifyContent: "space-between", children: [_jsxs("text", { height: 1, bg: "transparent", children: [_jsx("span", { fg: INK, children: " mend" }), _jsxs("span", { fg: MUTED, children: ["  ", projectItems.length, " project", projectItems.length === 1 ? "" : "s"] }), _jsx("span", { fg: FAINT, children: " \u00B7 " }), _jsxs("span", { fg: liveTotal > 0 ? MUTED : FAINT, children: [liveTotal, " live"] })] }), _jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: `${ctx.config.url}  ` })] }), _jsxs("box", { flexGrow: 1, flexShrink: 1, minHeight: 0, flexDirection: "row", children: [showProjectsPane ? (_jsx(Pane, { title: "projects", focused: focus === "projects", width: PROJECTS_PANE_WIDTH, children: _jsxs("scrollbox", { ref: projectScrollRef, flexGrow: 1, flexShrink: 1, minHeight: 0, style: paneScrollStyle, children: [projectItems.map((item, index) => (_jsx(ProjectRow, { item: item, selected: index === projectIndex, nameWidth: nameWidth }, item.project.id))), data !== undefined && projectItems.length === 0 ? (_jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: "  none adopted yet" })) : null] }) })) : null, _jsx(Pane, { title: sessionsTitle, focused: focus === "sessions", grow: true, children: _jsxs("scrollbox", { ref: sessionScrollRef, flexGrow: 1, flexShrink: 1, minHeight: 0, style: paneScrollStyle, children: [rows.map((row, index) => row.kind === "worktree" ? (_jsx(WorktreeHeaderRow, { group: row.group, selected: index === rowIndex }, rowKeyOf(row))) : row.group.sessions.length === 1 ? (_jsx(CombinedRow, { group: row.group, item: row.item, selected: index === rowIndex }, rowKeyOf(row))) : (_jsx(SessionChildRow, { item: row.item, selected: index === rowIndex }, rowKeyOf(row)))), data !== undefined && rows.length === 0 ? (_jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: "  no sessions yet — n starts one" })) : null, loadFailure !== null ? (_jsx("text", { height: 1, fg: INK_2, bg: "transparent", children: `  ${loadFailure} — retrying` })) : null] }) })] }), picker !== null ? (_jsx(Pane, { title: pickerTitle, focused: true, height: 2 + pickerItems.length, children: pickerItems.map((item, index) => (_jsx(HarnessRow, { item: item, selected: index === pickerIndex }, String(item.harness)))) })) : naming !== null ? (_jsx("box", { border: true, borderStyle: "rounded", borderColor: COBALT, title: " new worktree \u2014 name ", titleAlignment: "left", backgroundColor: "transparent", height: 3, flexShrink: 0, children: _jsx("input", { focused: true, value: "", placeholder: "name the worktree, e.g. fix-auth (empty = auto)", backgroundColor: "transparent", focusedBackgroundColor: "transparent", textColor: INK, focusedTextColor: INK, placeholderColor: FAINT, cursorColor: INK, flexGrow: 1, onSubmit: (value) => {
-                        if (typeof value === "string")
-                            submitWorktreeName(value);
-                    } }) })) : editing !== null ? (_jsx("box", { border: true, borderStyle: "rounded", borderColor: COBALT, title: ` label — ${editing.harness} ${editing.id.slice(0, 8)} `, titleAlignment: "left", backgroundColor: "transparent", height: 3, flexShrink: 0, children: _jsx("input", { focused: true, value: editing.label ?? "", placeholder: "a few words for what this session is doing (empty clears)", backgroundColor: "transparent", focusedBackgroundColor: "transparent", textColor: INK, focusedTextColor: INK, placeholderColor: FAINT, cursorColor: INK, flexGrow: 1, onSubmit: (value) => {
+    return (_jsxs("box", { flexGrow: 1, flexDirection: "column", backgroundColor: "transparent", children: [_jsxs("box", { height: 1, flexDirection: "row", justifyContent: "space-between", children: [_jsxs("text", { height: 1, bg: "transparent", children: [_jsx("span", { fg: INK, children: " mend" }), _jsxs("span", { fg: MUTED, children: ["  ", projectItems.length, " project", projectItems.length === 1 ? "" : "s"] }), _jsx("span", { fg: FAINT, children: " \u00B7 " }), _jsxs("span", { fg: liveTotal > 0 ? MUTED : FAINT, children: [liveTotal, " live"] })] }), _jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: `${ctx.config.url}  ` })] }), _jsxs("box", { flexGrow: 1, flexShrink: 1, minHeight: 0, flexDirection: "row", children: [showProjectsPane ? (_jsx(Pane, { title: "projects", focused: focus === "projects", width: PROJECTS_PANE_WIDTH, children: _jsxs("scrollbox", { ref: projectScrollRef, flexGrow: 1, flexShrink: 1, minHeight: 0, style: paneScrollStyle, children: [projectItems.map((item, index) => (_jsx(ProjectRow, { item: item, selected: index === projectIndex, nameWidth: nameWidth }, item.project.id))), data !== undefined && projectItems.length === 0 ? (_jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: "  none adopted yet" })) : null] }) })) : null, _jsx(Pane, { title: sessionsTitle, focused: focus === "sessions", grow: true, children: _jsxs("scrollbox", { ref: sessionScrollRef, flexGrow: 1, flexShrink: 1, minHeight: 0, style: paneScrollStyle, children: [rows.map((row, index) => row.kind === "worktree" ? (_jsx(WorktreeHeaderRow, { group: row.group, selected: index === rowIndex }, rowKeyOf(row))) : row.group.sessions.length === 1 ? (_jsx(CombinedRow, { group: row.group, item: row.item, selected: index === rowIndex }, rowKeyOf(row))) : (_jsx(SessionChildRow, { item: row.item, selected: index === rowIndex }, rowKeyOf(row)))), data !== undefined && rows.length === 0 ? (_jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: "  no sessions yet — n starts one" })) : null, loadFailure !== null ? (_jsx("text", { height: 1, fg: INK_2, bg: "transparent", children: `  ${loadFailure} — retrying` })) : null] }) })] }), picker !== null ? (_jsx(Pane, { title: pickerTitle, focused: true, height: 2 + pickerItems.length, children: pickerItems.map((item, index) => (_jsx(HarnessRow, { item: item, selected: index === pickerIndex }, String(item.harness)))) })) : editing !== null ? (_jsx("box", { border: true, borderStyle: "rounded", borderColor: COBALT, title: ` label — ${editing.harness} ${editing.id.slice(0, 8)} `, titleAlignment: "left", backgroundColor: "transparent", height: 3, flexShrink: 0, children: _jsx("input", { focused: true, value: editing.label ?? "", placeholder: "a few words for what this session is doing (empty clears)", backgroundColor: "transparent", focusedBackgroundColor: "transparent", textColor: INK, focusedTextColor: INK, placeholderColor: FAINT, cursorColor: INK, flexGrow: 1, onSubmit: (value) => {
                         if (typeof value === "string")
                             submitRename(editing, value);
-                    } }) })) : showDetail ? (_jsx(Pane, { title: detailTitle, focused: false, height: 6, children: _jsx(SessionDetail, { item: selectedSession }) })) : null, _jsx(StatusLine, { busy: busy, busyStarted: busyStarted, status: status }), _jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: footerText })] }));
+                    } }) })) : showDetail ? (_jsx(Pane, { title: detailTitle, focused: false, height: 6, children: _jsx(SessionDetail, { item: selectedSession }) })) : null, adoptOffer !== null ? (_jsxs("box", { position: "absolute", zIndex: 11, left: Math.max(1, Math.floor((terminalCols - Math.min(70, terminalCols - 4)) / 2)), top: Math.max(1, Math.floor((terminalRows - 7) / 2)), width: Math.min(70, terminalCols - 4), height: 7, border: true, borderStyle: "rounded", borderColor: COBALT, title: " adopt this repository? ", titleAlignment: "left", backgroundColor: SURFACE, flexDirection: "column", children: [_jsxs("text", { height: 1, bg: SURFACE, children: [_jsx("span", { children: "  " }), _jsx("span", { fg: INK, children: adoptOffer.name }), _jsx("span", { fg: FAINT, children: " · not in the store yet" })] }), _jsx("text", { height: 1, bg: SURFACE, fg: MUTED, children: `  ${adoptOffer.source}` }), _jsxs("text", { height: 1, bg: SURFACE, children: [_jsx("span", { fg: FAINT, children: "  auth  " }), ADOPT_AUTH_MODES.map((candidate, index) => (_jsxs("span", { children: [index > 0 ? _jsx("span", { fg: FAINT, children: " · " }) : null, _jsx("span", { fg: index === adoptOffer.modeIndex ? COBALT : FAINT, children: index === adoptOffer.modeIndex ? `▸ ${candidate.label}` : candidate.label })] }, candidate.mode)))] }), _jsx("text", { height: 1, bg: SURFACE, fg: FAINT, children: `        ${ADOPT_AUTH_MODES[adoptOffer.modeIndex]?.hint ?? ""}` }), _jsx("text", { height: 1, bg: SURFACE, fg: FAINT, children: adoptOffer.source === adoptOffer.root
+                            ? "  enter adopt from this path — needs the server on THIS machine · esc not now"
+                            : "  enter adopt · ←→ auth mode · esc not now" })] })) : null, creating !== null ? (_jsxs("box", { position: "absolute", zIndex: 10, left: Math.max(1, Math.floor((terminalCols - Math.min(74, terminalCols - 4)) / 2)), top: Math.max(1, Math.floor((terminalRows - creatingHeight) / 2)), width: Math.min(74, terminalCols - 4), height: creatingHeight, border: true, borderStyle: "rounded", borderColor: COBALT, title: ` new worktree — ${selectedProject?.project.name ?? "project"} `, titleAlignment: "left", backgroundColor: SURFACE, flexDirection: "column", children: [_jsxs("box", { height: 1, flexShrink: 0, flexDirection: "row", backgroundColor: SURFACE, children: [_jsxs("text", { height: 1, bg: SURFACE, children: [_jsx(Gutter, { selected: creating.step === "name" }), _jsx("span", { fg: FAINT, children: "name     " }), creating.step !== "name" ? (_jsx("span", { fg: INK, children: creating.name === "" ? "auto" : creating.name })) : null, creating.joins ? _jsx("span", { fg: FAINT, children: "  · joins the existing worktree" }) : null] }), creating.step === "name" ? (_jsx("input", { focused: true, value: creating.name, placeholder: "e.g. fix-auth (empty = auto \u00B7 an existing name joins it)", backgroundColor: SURFACE, focusedBackgroundColor: SURFACE, textColor: INK, focusedTextColor: INK, placeholderColor: FAINT, cursorColor: INK, flexGrow: 1, onInput: (value) => {
+                                    const clean = value.replace(/\t/g, "");
+                                    setCreating((current) => current === null ? current : { ...current, name: clean });
+                                }, onSubmit: (value) => {
+                                    if (typeof value === "string")
+                                        submitCreateName(value);
+                                } })) : null] }), _jsxs("box", { height: 1, flexShrink: 0, flexDirection: "row", backgroundColor: SURFACE, children: [_jsxs("text", { height: 1, bg: SURFACE, children: [_jsx(Gutter, { selected: creating.step === "base" }), _jsx("span", { fg: FAINT, children: "base     " }), creating.step !== "base" ? (_jsx("span", { fg: creating.step === "name" && !creating.joins ? FAINT : INK, children: creating.joins
+                                            ? "fixed by the existing worktree"
+                                            : (creating.base ?? "default branch") })) : null] }), creating.step === "base" ? (creating.branches === null ? (_jsx("text", { height: 1, bg: SURFACE, fg: FAINT, children: "reading branches\u2026" })) : (_jsx("input", { focused: true, value: "", placeholder: "type to filter (enter = highlighted; empty = default)", backgroundColor: SURFACE, focusedBackgroundColor: SURFACE, textColor: INK, focusedTextColor: INK, placeholderColor: FAINT, cursorColor: INK, flexGrow: 1, onInput: (value) => {
+                                    const clean = value.replace(/\t/g, "");
+                                    setCreating((current) => current === null ? current : { ...current, query: clean, baseIndex: 0 });
+                                }, onSubmit: () => submitCreateBase() }))) : null] }), Array.from({ length: 6 }, (_, index) => {
+                        const branch = creating.joins || creating.branches === null
+                            ? undefined
+                            : filterBranches(creating.branches, creating.query)[index];
+                        const active = creating.step === "base";
+                        if (branch === undefined) {
+                            return (_jsx("text", { height: 1, bg: SURFACE, fg: FAINT, children: index === 0 && active && creating.branches !== null
+                                    ? "     no branch matches — enter uses the default"
+                                    : " " }, `slot-${index}`));
+                        }
+                        const highlighted = active && index === creating.baseIndex;
+                        return (_jsx("box", { height: 1, flexShrink: 0, backgroundColor: highlighted ? WASH : SURFACE, children: _jsxs("text", { height: 1, bg: highlighted ? WASH : SURFACE, children: [_jsx("span", { fg: FAINT, children: "   " }), _jsx(Gutter, { selected: highlighted }), _jsx("span", { fg: active ? INK : FAINT, children: branch.name.slice(0, 40).padEnd(41) }), _jsx("span", { fg: FAINT, children: branch.sha.slice(0, 8).padEnd(10) }), _jsx("span", { fg: active ? MUTED : FAINT, children: timeAgo(branch.committedAt).replace(" ago", "").padEnd(6) }), branch.isDefault ? _jsx("span", { fg: FAINT, children: "default" }) : null] }) }, branch.name));
+                    }), _jsxs("text", { height: 1, bg: SURFACE, children: [_jsx(Gutter, { selected: creating.step === "harness" }), _jsx("span", { fg: FAINT, children: "harness" })] }), deriveHarnesses(null).map((item, index) => {
+                        const active = creating.step === "harness";
+                        const highlighted = active && index === creating.harnessIndex;
+                        return (_jsx("box", { height: 1, flexShrink: 0, backgroundColor: highlighted ? WASH : SURFACE, children: _jsxs("text", { height: 1, bg: highlighted ? WASH : SURFACE, children: [_jsx("span", { fg: FAINT, children: "   " }), _jsx(Gutter, { selected: highlighted }), _jsx("span", { fg: active ? INK : FAINT, children: item.label.padEnd(12) }), _jsx("span", { fg: FAINT, children: active ? item.hint : "" })] }) }, String(item.harness)));
+                    })] })) : null, _jsx(StatusLine, { busy: busy, busyStarted: busyStarted, status: status }), _jsx("text", { height: 1, fg: FAINT, bg: "transparent", children: footerText })] }));
 };
 // ─── entry ──────────────────────────────────────────────────────────────────
 export const runDashboard = async (ctx) => {

package/dist/main.js

@@ -11,7 +11,8 @@ import { formatLoadReport } from "./env.js";
 import { loginCommand } from "./login.js";
 import { pairCommand, qrCommand } from "./pair.js";
 import { isComposeFile, proposeFromCompose, proposeFromPackageJson, proposeFromWorkspacePackage, renderMendToml, workspaceGlobs, } from "./service-init.js";
-import { agentIsLive, agentOutcome, cwdFacts, gitTopLevel, HARNESS_COMMANDS, isDetachChunk, LIVE_STATUSES, sessionDisplayName, matchProjectByCwd, normalizeProjectName, parseLaunchArgs, } from "./shared.js";
+import { agentIsLive, agentOutcome, cwdFacts, gitTopLevel, HARNESS_COMMANDS, isDetachChunk, LIVE_STATUSES, sessionDisplayName, matchProjectByCwd, normalizeProjectName, gitCurrentBranch, parseLaunchArgs, } from "./shared.js";
+import { DEFAULT_SKILLS_DIR, scanSkillLibrary } from "./skills.js";
 import { sshCommand } from "./ssh-setup.js";
 // `$XDG_CONFIG_HOME/mend`, default `~/.config/mend`; a pre-XDG `~/.mend` stays authoritative
 // when it is the only one present (mirrors @mend/store's resolver — the CLI stays dependency-light).
@@ -1789,6 +1790,75 @@ const dotfilesCommand = async (config, args) => {
             return fail(`unknown dotfiles command "${verb}" — try: mend dotfiles sync | show`);
     }
 };
+/** With `--project` the project's library; bare, your own. */
+const skillsList = async (config, args) => {
+    const forProject = args.includes("--project");
+    const project = forProject ? await findProject(config, takeFlagValue(args, "--project")) : null;
+    const skills = await api(config, "GET", project === null ? "/skills" : `/projects/${project.id}/skills`);
+    const library = project === null ? "your library" : project.name;
+    if (skills.length === 0) {
+        say(dim(`no skills in ${library} — push a local one: mend skills push`));
+        return;
+    }
+    for (const skill of skills) {
+        say(`  ${skill.name.padEnd(28)} ${dim(`${skill.fileCount} file${skill.fileCount === 1 ? "" : "s"} · ${formatDotfileBytes(skill.bytes)}`)}`);
+        if (skill.description !== "")
+            say(`    ${dim(skill.description)}`);
+    }
+};
+/**
+ * Scan the shared agent-skills directory (`~/.agents/skills` by convention)
+ * and upload every bundle. The upload is the intent: same-named skills are
+ * replaced, and `--prune` removes what the directory no longer carries.
+ */
+const skillsPush = async (config, args) => {
+    const dirFlag = takeFlagValue(args, "--dir");
+    const root = dirFlag === null ? path.join(os.homedir(), DEFAULT_SKILLS_DIR) : path.resolve(dirFlag);
+    const scanned = scanSkillLibrary(root);
+    if ("error" in scanned)
+        return fail(scanned.error);
+    for (const note of scanned.notes)
+        say(dim(`  ${note.skill}: ${note.message}`));
+    if (scanned.skills.length === 0)
+        return fail(`no skills found under ${root}`);
+    const forProject = args.includes("--project");
+    const project = forProject ? await findProject(config, takeFlagValue(args, "--project")) : null;
+    const report = await api(config, "POST", "/skills/sync", {
+        scope: project === null ? "user" : "project",
+        projectId: project?.id ?? null,
+        skills: scanned.skills.map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+            files: skill.files,
+        })),
+        prune: args.includes("--prune"),
+    });
+    const library = project === null ? "your library" : project.name;
+    const counts = [
+        `${report.created.length} new`,
+        `${report.updated.length} updated`,
+        `${report.unchanged.length} unchanged`,
+        ...(report.removed.length > 0 ? [`${report.removed.length} removed`] : []),
+    ].join(" · ");
+    say(`${green("pushed")} ${scanned.skills.length} skill${scanned.skills.length === 1 ? "" : "s"} from ${root} to ${library} · ${dim(counts)}`);
+    say(dim("sessions receive them from the next launch"));
+};
+const skillsCommand = async (config, args) => {
+    const [verb, ...rest] = args;
+    switch (verb) {
+        case "push":
+            return skillsPush(config, rest);
+        case "list":
+            return skillsList(config, rest);
+        case undefined:
+            return skillsList(config, args);
+        default:
+            // Bare flags (`mend skills --project web`) read as the list.
+            if (verb.startsWith("--"))
+                return skillsList(config, args);
+            return fail(`unknown skills command "${verb}" — try: mend skills push | list`);
+    }
+};
 // ─── completions: live sessions under TAB ───────────────────────────────────
 /**
  * The data half of shell completion: one live session per line as
@@ -1824,6 +1894,7 @@ _mend() {
     'shell:open a shell in a live session workspace'
     'service:reachable ports — add, list, stop'
     'keys:the machine Mend deploy key — init, show, share'
+    'skills:skill libraries — list, push'
     'accounts:your connected accounts on the platform'
     'pair:pair a phone or a second machine' 'doctor:read-only checklist of this setup'
     'connect:send this machine'"'"'s claude/codex/github credential to the platform'
@@ -1849,7 +1920,7 @@ _mend "$@"
 const BASH_COMPLETIONS = `_mend() {
   local cur=\${COMP_WORDS[COMP_CWORD]}
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "adopt codex claude opencode run attach stop shell service keys pair doctor continue resume rejoin refresh projects sessions status ui help" -- "$cur") )
+    COMPREPLY=( $(compgen -W "adopt codex claude opencode run attach stop shell service keys skills pair doctor continue resume rejoin refresh projects sessions status ui help" -- "$cur") )
     return
   fi
   case \${COMP_WORDS[1]} in
@@ -2426,6 +2497,7 @@ const dashboard = async (config) => {
     await runDashboard({
         config,
         cwd: process.cwd(),
+        cwdBranch: gitCurrentBranch(process.cwd()),
         api: (method, route, body) => request(config, method, route, body),
         attachTty: (sessionId, harness, processId) => attachTty(config, sessionId, harness, 0n, processId),
     });
@@ -2474,6 +2546,10 @@ everything else
   mend accounts                         your connected accounts on the platform (claude, codex, github)
   mend dotfiles                         your dotfiles on the server: repo + synced home files
   mend dotfiles sync [--all | paths…]   capture config files from THIS machine into your store
+  mend skills [--project [p]]           your skill library on the server (or a project's)
+  mend skills push [--project [p]] [--prune] [--dir <path>]
+                                        upload ~/.agents/skills bundles into the library; sessions
+                                        receive them at launch (--prune removes what's gone)
   mend keys share                       relay THIS machine's ssh-agent to the server (bridge mode:
                                         hardware keys sign here; Ctrl-C stops sharing)
   mend run -- <command...>              same, with an arbitrary command
@@ -2544,6 +2620,8 @@ const main = async () => {
             return keysCommand(config, rest);
         case "dotfiles":
             return dotfilesCommand(config, rest);
+        case "skills":
+            return skillsCommand(config, rest);
         case "accounts":
             return accountsCommand(config);
         case "connect":

package/dist/shared.js

@@ -263,6 +263,12 @@ export const cwdFacts = (cwd) => ({
     repoRoot: gitTopLevel(cwd),
     originUrl: gitOriginUrl(cwd),
 });
+/** The branch checked out at `cwd`, or null outside a repo or on a detached HEAD. */
+export const gitCurrentBranch = (cwd) => {
+    const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8" });
+    const out = result.status === 0 ? result.stdout.trim() : "";
+    return out === "" || out === "HEAD" ? null : out;
+};
 /** The cwd repo's origin remote, or null when there is no repo or no origin. */
 export const gitOriginUrl = (cwd) => {
     const result = spawnSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });

package/dist/skills.js

@@ -0,0 +1,134 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Local skill-library scanning for `mend skills push`. Runs on the machine
+ * that HAS the skills: the shared agent-skills convention keeps them under
+ * `~/.agents/skills/<name>/SKILL.md` (plus support files), and the CLI
+ * captures the bundles here and streams them to the server's library. The
+ * CLI stays dependency-light by design, so the frontmatter peek below is a
+ * few lines of string handling, not a YAML parser — the server re-validates
+ * everything.
+ */
+/** Where the shared convention keeps user skills, relative to `$HOME`. */
+export const DEFAULT_SKILLS_DIR = ".agents/skills";
+/** The servers' caps, checked here so a mistake fails before the upload. */
+export const MAX_SKILL_FILES = 64;
+export const MAX_SKILL_FILE_BYTES = 512 * 1024;
+const IGNORED_DIRS = new Set([".git", "node_modules", "__pycache__"]);
+const isTextBuffer = (buffer) => !buffer.subarray(0, 8192).includes(0);
+/**
+ * Pull `description:` out of a SKILL.md frontmatter block. Single-line plain
+ * or quoted scalars only — the common case by far; anything else reads as
+ * absent and the server keeps an empty description.
+ */
+export const readFrontmatterDescription = (contents) => {
+    if (!contents.startsWith("---\n") && !contents.startsWith("---\r\n"))
+        return "";
+    const end = contents.indexOf("\n---", 3);
+    if (end === -1)
+        return "";
+    for (const line of contents.slice(0, end).split("\n")) {
+        const match = /^description:\s*(.*)$/.exec(line);
+        if (match === null)
+            continue;
+        const raw = (match[1] ?? "").trim();
+        if (raw === "" || raw === "|" || raw === ">" || raw === "|-" || raw === ">-")
+            return "";
+        const quoted = /^(['"])(.*)\1$/.exec(raw);
+        return quoted?.[2] ?? raw;
+    }
+    return "";
+};
+const walkFiles = (root) => {
+    const found = [];
+    const visit = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const absolute = path.join(dir, entry.name);
+            // stat (not the dirent) so symlinked files and directories both count.
+            let stat;
+            try {
+                stat = fs.statSync(absolute);
+            }
+            catch {
+                continue; // dangling symlink
+            }
+            if (stat.isDirectory())
+                visit(absolute);
+            else if (stat.isFile())
+                found.push(absolute);
+        }
+    };
+    visit(root);
+    return found.toSorted();
+};
+/**
+ * Scan a skill library directory: every immediate subdirectory carrying a
+ * `SKILL.md` becomes one bundle. Oversized and binary files are skipped with
+ * a note; a directory without a SKILL.md is noted and left out entirely.
+ */
+export const scanSkillLibrary = (root) => {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return { error: `${root} is not a readable directory` };
+    }
+    const skills = [];
+    const notes = [];
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.name.startsWith("."))
+            continue;
+        const skillDir = path.join(root, entry.name);
+        let stat;
+        try {
+            stat = fs.statSync(skillDir);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        if (!fs.existsSync(path.join(skillDir, "SKILL.md"))) {
+            notes.push({ skill: entry.name, message: "no SKILL.md — skipped" });
+            continue;
+        }
+        const files = [];
+        let bytes = 0;
+        for (const absolute of walkFiles(skillDir)) {
+            const relative = path.relative(skillDir, absolute).split(path.sep).join("/");
+            const buffer = fs.readFileSync(absolute);
+            if (buffer.byteLength > MAX_SKILL_FILE_BYTES) {
+                notes.push({ skill: entry.name, message: `${relative} is over 512KB — skipped` });
+                continue;
+            }
+            if (!isTextBuffer(buffer)) {
+                notes.push({ skill: entry.name, message: `${relative} is binary — skipped` });
+                continue;
+            }
+            files.push({ path: relative, contents: buffer.toString("utf8") });
+            bytes += buffer.byteLength;
+        }
+        if (files.length > MAX_SKILL_FILES) {
+            notes.push({
+                skill: entry.name,
+                message: `${files.length} files is over the ${MAX_SKILL_FILES}-file cap — skipped`,
+            });
+            continue;
+        }
+        const entryFile = files.find((file) => file.path === "SKILL.md");
+        if (entryFile === undefined) {
+            notes.push({ skill: entry.name, message: "SKILL.md was unreadable — skipped" });
+            continue;
+        }
+        skills.push({
+            name: entry.name.toLowerCase(),
+            description: readFrontmatterDescription(entryFile.contents),
+            files,
+            bytes,
+        });
+    }
+    return { skills, notes };
+};

package/dist/tui-theme.js

@@ -23,6 +23,11 @@ export const RULE = "#37374a";
 export const COBALT = "#6f96f5";
 /** The selection wash: a neutral lifted row — visible, not colorful. */
 export const WASH = "#2c2c35";
+/**
+ * The one exception to the no-painted-background rule: a floating modal
+ * must occlude the content beneath it, so it owns its ground.
+ */
+export const SURFACE = "#17171d";
 export const AMBER = "#e2ab42";
 export const GREEN = "#69c189";
 export const RED = "#e87f76";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/mend",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "The mend CLI: adopt a repository into Mend's store, launch your coding agent in a recorded session worktree, detach and reattach from any terminal",
   "keywords": [
     "claude-code",