@sealant/mend 0.15.2 → 0.17.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

@@ -208,6 +208,14 @@ export const foldGroupStatus = (group) => {
  * 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 session's live protocol agent — a phone pickup driving the same
+ * conversation over stream-json. It holds the workspace with no PTY behind it,
+ * so a terminal "get me in" must take it over (hand back to a TUI) rather than
+ * report the attach unavailable or open a bare shell. Null = no pickup to take.
+ */
+export const liveProtocolOf = (processes) => processes.find((process) => process.kind === "agent-protocol" && 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.

package/dist/dashboard.js

@@ -3,7 +3,7 @@ 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, advanceFromBase, deriveRows, deriveWorktrees, filterBranches, foldGroupStatus, labelIsIdentity, rowKeyOf, worktreeDisplayName, fetchWorkbench, liveShellOf, mapWorkbenchSessions, markSessionStopped, removeWorktreeGroup, prependSession, removeSession, replaceSession, WORKBENCH_KEY, } from "./dashboard-model.js";
+import { deriveHarnesses, deriveProjects, advanceFromBase, deriveRows, deriveWorktrees, filterBranches, foldGroupStatus, labelIsIdentity, rowKeyOf, worktreeDisplayName, fetchWorkbench, liveProtocolOf, 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";
@@ -261,8 +261,17 @@ const App = ({ ctx, onQuit }) => {
                 // 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 liveProtocol = liveProtocolOf(detail.processes);
                 const existing = liveShellOf(detail.processes);
-                if (existing !== null) {
+                if (liveProtocol !== null) {
+                    // A phone pickup holds the session in protocol mode — no PTY behind
+                    // it. Take it over: end the protocol agent, resume the same
+                    // conversation as a TUI, then attach to that.
+                    process.stdout.write(`taking over from the protocol session — same conversation…\n\n`);
+                    await ctx.api("POST", `/sessions/${session.id}/handoff`, { to: "pty" });
+                    outcome = await ctx.attachTty(session.id, session.harness);
+                }
+                else if (existing !== null) {
                     process.stdout.write(`no live terminal — rejoining the open shell\n\n`);
                     outcome = await ctx.attachTty(session.id, "shell", existing.id);
                 }
@@ -997,7 +1006,7 @@ const App = ({ ctx, onQuit }) => {
                     ? " ↑↓ 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";
+                        : " ↑↓ move · enter attach/resume · n new worktree · s session here · ⇧K kill · ⇧D remove · v review · e rename · o web · q quit";
     const loadFailure = data === undefined && failureReason !== null
         ? failureReason instanceof Error
             ? failureReason.message

package/dist/main.js

@@ -12,6 +12,7 @@ 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, 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).
@@ -617,16 +618,41 @@ const exitAfterSessionEnd = (config, sessionId) => {
 /** Reattach a terminal to a running session (full scrollback replay, then live). */
 const attach = async (config, args) => {
     const prefix = args.find((a) => !a.startsWith("--"));
-    if (prefix === undefined)
-        return fail("usage: mend attach <session-id-prefix>");
+    // No id: the picker IS the selection surface (the resolution `mend shell`
+    // already uses), so attaching never demands an id the user must go look up.
+    if (prefix === undefined) {
+        const picked = await resolveLiveSession(config, undefined, "attach");
+        return attachPicked(config, picked);
+    }
     const sessions = await api(config, "GET", "/sessions");
     const match = sessions.find((s) => s.id.startsWith(prefix));
     if (match === undefined)
         return fail(`no active session matches "${prefix}"`);
-    say(`${green("✓")} attaching to ${sessionDisplayName(match)} · ${match.harness} ${dim(match.id.slice(0, 8))}${detachHint()}`);
+    return attachPicked(config, match);
+};
+/** Attach to one resolved session — the tail both `mend attach` paths share. */
+const attachPicked = async (config, session) => {
+    say(`${green("✓")} attaching to ${sessionDisplayName(session)} · ${session.harness} ${dim(session.id.slice(0, 8))}${detachHint()}`);
     say("");
-    await attachOrExit(config, match.id, match.harness);
-    exitAfterSessionEnd(config, match.id);
+    const outcome = await attachTty(config, session.id, session.harness, 0n, undefined, {
+        handleSignals: true,
+    });
+    // A live protocol agent (a phone pickup) has no PTY behind it — the attach
+    // reports "unavailable" with nothing wrong. Take the session over: end the
+    // protocol agent, resume the same conversation as a TUI, then attach to it.
+    if (outcome === "unavailable") {
+        const detail = await api(config, "GET", `/sessions/${session.id}`);
+        if (detail.currentAgent?.kind === "agent-protocol" &&
+            agentIsLive(detail.session, detail.currentAgent)) {
+            say(`${amber("taking over")} from the protocol session`);
+            await withSpinner("reopening as a terminal — same conversation…", api(config, "POST", `/sessions/${session.id}/handoff`, { to: "pty" }));
+            say("");
+            await attachOrExit(config, session.id, session.harness);
+            return exitAfterSessionEnd(config, session.id);
+        }
+    }
+    await finishAttach(config, session.id, outcome);
+    return exitAfterSessionEnd(config, session.id);
 };
 /**
  * Explicit stop — the one intent detaching never carries. Ends the agent; the
@@ -639,8 +665,15 @@ const stopCommand = async (config, args) => {
         ? String(args[projectFlag + 1])
         : null;
     const prefix = args.find((arg, index) => !arg.startsWith("--") && index !== projectFlag + 1);
+    // Neither an id nor --all: pick the session to close, the same resolution
+    // `mend attach` uses. --all and --project keep their bulk meaning.
+    if (!all && prefix === undefined && projectName === null) {
+        const picked = await resolveLiveSession(config, undefined, "stop");
+        await stopSessions(config, [picked], false);
+        return;
+    }
     if (!all && prefix === undefined) {
-        return fail("usage: mend stop <session-id-prefix> | --all [--project <p>]");
+        return fail("usage: mend stop [session-id-prefix] | --all [--project <p>]");
     }
     const [sessions, projects] = await Promise.all([
         api(config, "GET", "/sessions"),
@@ -670,19 +703,24 @@ const stopCommand = async (config, args) => {
         }
         targets = matches;
     }
+    await stopSessions(config, targets, all);
+};
+/** Stop each target and print its record link — the tail every stop path shares. */
+const stopSessions = async (config, targets, summarise) => {
     for (const session of targets) {
         await api(config, "POST", `/sessions/${session.id}/stop`);
         say(`${green("✓")} stopped · ${session.harness} · ${dim(session.id.slice(0, 8))} · ${session.branch}`);
         say(`${cobalt("  review")} · ${config.url}/sessions/${session.id}`);
     }
-    if (all)
+    if (summarise) {
         say(`${green("✓")} stopped ${targets.length} session${targets.length === 1 ? "" : "s"}`);
+    }
 };
 /** Compact picker: numbered live sessions, one keystroke of typing. */
 const pickSessionInteractively = async (rows) => {
     say(dim("more than one live session — pick one:"));
     rows.forEach((row, index) => {
-        say(`  ${index + 1}. ${row.session.harness.padEnd(8)} ${dim(row.session.id.slice(0, 8))}  ${row.projectName}  ${dim(row.session.branch)}`);
+        say(`  ${index + 1}. ${row.session.harness.padEnd(8)} ${dim(row.session.id.slice(0, 8))}  ${row.projectName}  ${dim(row.session.branch)}  ${dim(row.session.status)}`);
     });
     const readline = await import("node:readline/promises");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -698,7 +736,7 @@ const pickSessionInteractively = async (rows) => {
  * the cwd's project narrows, one candidate is taken, several go to the
  * picker, and a non-interactive caller never gets a silent guess.
  */
-const resolveLiveSession = async (config, prefix) => {
+const resolveLiveSession = async (config, prefix, command) => {
     const sessions = await api(config, "GET", "/sessions?retained=1");
     if (prefix !== undefined) {
         const matches = sessions.filter((s) => s.id.startsWith(prefix));
@@ -720,7 +758,7 @@ const resolveLiveSession = async (config, prefix) => {
     if (candidates.length === 1)
         return only;
     if (process.stdin.isTTY !== true) {
-        return fail("several live sessions — name one: mend shell <session-id-prefix>");
+        return fail(`several live sessions — name one: mend ${command} <session-id-prefix>`);
     }
     const nameById = new Map(projects.map((p) => [p.id, p.name]));
     return pickSessionInteractively(candidates.map((session) => ({
@@ -736,7 +774,7 @@ const resolveLiveSession = async (config, prefix) => {
  */
 const shellCommand = async (config, args) => {
     const prefix = args.find((a) => !a.startsWith("--"));
-    const session = await resolveLiveSession(config, prefix);
+    const session = await resolveLiveSession(config, prefix, "shell");
     say(`${green("✓")} shell in ${session.harness} session ${dim(session.id.slice(0, 8))} · ${dim(session.branch)}${detachHint()}`);
     const shellProcess = await withSpinner("opening a shell in the session workspace…", api(config, "POST", `/sessions/${session.id}/shell`));
     say("");
@@ -871,7 +909,7 @@ const serviceAdd = async (config, args) => {
         return fail(`"${portRaw}" is not a port`);
     }
     const prefix = positional.find((a) => a !== portRaw);
-    const session = await resolveLiveSession(config, prefix);
+    const session = await resolveLiveSession(config, prefix, "service add");
     const service = await mutateService(config, "POST", `/sessions/${session.id}/services`, {
         port,
         name,
@@ -952,7 +990,7 @@ const serviceRun = async (config, args) => {
         if (name === undefined)
             return fail(usage);
         const prefix = positionals.length > 1 ? positionals[0] : undefined;
-        const session = await resolveLiveSession(config, prefix);
+        const session = await resolveLiveSession(config, prefix, "service run");
         const recipes = await api(config, "GET", `/sessions/${session.id}/recipes`);
         const recipe = recipes.find((entry) => entry.name === name);
         if (recipe === undefined) {
@@ -995,7 +1033,7 @@ const serviceRun = async (config, args) => {
     if (protocol === "udp" && browserScheme !== null)
         return fail(usage);
     const prefix = head.find((a, i) => !a.startsWith("--") && i !== portFlag + 1 && i !== nameFlag + 1);
-    const session = await resolveLiveSession(config, prefix);
+    const session = await resolveLiveSession(config, prefix, "service run");
     const service = await withSpinner(protocol === "udp"
         ? `starting ${name ?? argv[0]} (udp :${port})…`
         : `starting ${name ?? argv[0]} — waiting for :${port} to answer…`, mutateService(config, "POST", `/sessions/${session.id}/services/run`, {
@@ -1789,6 +1827,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 +1931,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 +1957,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
@@ -2475,14 +2583,19 @@ 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
   mend worktrees [--project <p>] [--json]
                                         every worktree and the sessions inside it (mend sessions
                                         --json stays the v1 flat list; --json=v2 groups like this)
-  mend attach <session-id-prefix>       reattach this terminal to a running session
-  mend stop <session-id-prefix> | --all [--project <p>]
+  mend attach [session-id-prefix]       reattach this terminal to a running session
+                                        (no id: pick one from the live sessions)
+  mend stop [session-id-prefix] | --all [--project <p>]
                                         stop the agent — the workspace harvests and closes; the
                                         record and review remain
   mend shell [session-id-prefix]        open a shell in a live session's workspace
@@ -2545,6 +2658,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/mend",
-  "version": "0.15.2",
+  "version": "0.17.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",