@sealant/mend 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,44 @@
+# mend
+
+The CLI for [Mend](https://github.com/sealant-sh/Mend) — a local-first workbench for developers who
+use coding agents heavily. Adopt a repository into Mend's central store, run your agent (Claude
+Code, Codex, or any command) in a recorded per-session git worktree, detach, and reattach from any
+terminal.
+
+```sh
+npm install -g @sealant/mend
+```
+
+Requires Node 22+ and a running Mend server.
+
+## Commands
+
+```
+mend adopt [source] [--name <name>]   adopt a repository into the store (default: cwd)
+mend codex|claude|opencode            new session worktree + launch the harness in it
+mend run -- <command...>              same, with an arbitrary command
+mend attach <session-id-prefix>       reattach this terminal to a running session
+mend continue [session-id]            resume a session with its pending review follow-up
+mend resume [session-id] [--with h]   rejoin a settled session (state restored; --with switches harness)
+mend status                           active sessions
+```
+
+## Configuration
+
+| Source             | What                                              |
+| ------------------ | ------------------------------------------------- |
+| `MEND_URL`         | The Mend server (default `http://localhost:3105`) |
+| `MEND_TOKEN`       | Bearer token for that server                      |
+| `~/.mend/cli.json` | `{ "url": ..., "token": ... }` — env vars win     |
+
+## How it works
+
+Every session runs in its own git worktree over the adopted repository, inside a recorded workspace.
+The terminal you see is a held WebSocket to that workspace's PTY: `Ctrl+]` detaches and the session
+keeps running; `mend attach` reconnects with full scrollback — from this machine or any other that
+can reach the server. When a session settles, Mend harvests the harness's own state into the store,
+so `mend resume` restores it natively (a Claude session resumes with its memory intact, even across
+machines), and `--with` carries the conversation into a different harness.
+
+The reviewable object is the session's accumulated local change — worktree versus base — in the Mend
+web app, with the session record beside it. No issue tracker or pull request required.

package/dist/main.js

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const CONFIG_PATH = path.join(os.homedir(), ".mend", "cli.json");
+const loadConfig = () => {
+    let fileConfig = {};
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            fileConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+        }
+        catch {
+            fail(`could not parse ${CONFIG_PATH}`);
+        }
+    }
+    return {
+        url: process.env["MEND_URL"] ?? fileConfig.url ?? "http://localhost:3105",
+        token: process.env["MEND_TOKEN"] ?? fileConfig.token ?? null,
+    };
+};
+const fail = (message) => {
+    process.stderr.write(`mend: ${message}\n`);
+    process.exit(1);
+};
+const paint = (code) => (text) => process.stdout.isTTY ? `[${code}m${text}` : text;
+const dim = paint("2");
+const green = paint("32");
+const amber = paint("33");
+const cobalt = paint("34");
+const say = (line) => process.stdout.write(`${line}\n`);
+const api = async (config, method, route, body) => {
+    const headers = { "content-type": "application/json" };
+    if (config.token !== null)
+        headers["authorization"] = `Bearer ${config.token}`;
+    let response;
+    try {
+        response = await fetch(`${config.url}/api${route}`, {
+            method,
+            headers,
+            // Spread, not `body: null` — fresh oxlint rejects a body key on GETs.
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+    }
+    catch {
+        return fail(`cannot reach the Mend server at ${config.url} — is it running?`);
+    }
+    if (response.status === 401) {
+        return fail(`unauthorized — set MEND_TOKEN (or "token" in ${CONFIG_PATH}) to a bearer token for ${config.url}`);
+    }
+    const text = await response.text();
+    if (!response.ok) {
+        try {
+            const parsed = JSON.parse(text);
+            return fail(parsed.message ?? `${method} ${route} → ${response.status}`);
+        }
+        catch {
+            return fail(`${method} ${route} → ${response.status}`);
+        }
+    }
+    return JSON.parse(text);
+};
+const worktreePathOf = (storePath, worktree) => path.join(path.dirname(storePath), "worktrees", worktree);
+/** A live elapsed-time spinner around a slow await — provisioning is not a hang. */
+const withSpinner = async (label, work) => {
+    if (process.stdout.isTTY !== true)
+        return work;
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    const started = Date.now();
+    let frame = 0;
+    const timer = setInterval(() => {
+        const seconds = Math.round((Date.now() - started) / 1000);
+        process.stdout.write(`\r  ${frames[frame % frames.length]} ${label} ${dim(`${seconds}s`)} `);
+        frame += 1;
+    }, 120);
+    try {
+        return await work;
+    }
+    finally {
+        clearInterval(timer);
+        process.stdout.write("\r");
+    }
+};
+// ─── adopt ──────────────────────────────────────────────────────────────────
+const adopt = async (config, args) => {
+    const nameFlag = args.indexOf("--name");
+    const name = nameFlag !== -1 && args[nameFlag + 1] !== undefined ? String(args[nameFlag + 1]) : null;
+    const positional = args.filter((a, i) => !a.startsWith("--") && (nameFlag === -1 || i !== nameFlag + 1));
+    const rawSource = positional[0] ?? ".";
+    const source = /^(https?|git|ssh):|^git@/.test(rawSource) ? rawSource : path.resolve(rawSource);
+    const projectName = name ?? path.basename(source, ".git");
+    const project = await api(config, "POST", "/projects", {
+        name: projectName,
+        source,
+    });
+    say(`${green("✓")} adopted · ${project.name} · ${dim(project.storePath)}`);
+    say(`${dim("  default branch")} ${project.defaultBranch}`);
+    say(`${dim("  sessions start with:")} mend codex ${dim("(from anywhere —")} --project ${project.name}${dim(")")}`);
+};
+// ─── session launch ─────────────────────────────────────────────────────────
+const findProject = async (config, explicit) => {
+    const projects = await api(config, "GET", "/projects");
+    if (explicit !== null) {
+        const named = projects.find((p) => p.name === explicit);
+        if (named === undefined)
+            return fail(`no adopted project named "${explicit}"`);
+        return named;
+    }
+    const cwd = process.cwd();
+    const byOrigin = projects.find((p) => p.originUrl !== null && cwd.startsWith(p.originUrl));
+    const byName = projects.find((p) => p.name === path.basename(cwd));
+    const project = byOrigin ?? byName;
+    if (project === undefined) {
+        return fail(`no adopted project matches ${cwd} — run "mend adopt" here first, or name one with --project`);
+    }
+    return project;
+};
+const HARNESS_COMMANDS = {
+    codex: ["codex"],
+    claude: ["claude"],
+    opencode: ["opencode"],
+};
+const launch = async (config, harness, args) => {
+    const projectFlag = args.indexOf("--project");
+    const explicit = projectFlag !== -1 && args[projectFlag + 1] !== undefined
+        ? String(args[projectFlag + 1])
+        : null;
+    const dashdash = args.indexOf("--");
+    const custom = dashdash !== -1 ? args.slice(dashdash + 1) : [];
+    const argv = harness === "run" ? custom : (HARNESS_COMMANDS[harness] ?? []);
+    if (argv.length === 0) {
+        return fail(harness === "run" ? "usage: mend run -- <command...>" : `unknown harness ${harness}`);
+    }
+    const project = await findProject(config, explicit);
+    const session = await api(config, "POST", `/projects/${project.id}/sessions`, {
+        harness,
+        label: null,
+        base: null,
+    });
+    say(`${green("✓")} worktree ${session.worktree} ${dim(`· branch ${session.branch}`)}`);
+    say(`${green("✓")} base ${dim(session.baseSha.slice(0, 12))} · session ${dim(session.id.slice(0, 8))}`);
+    say(`${cobalt("  watch")} · ${config.url}/sessions/${session.id}`);
+    // Everything runs SUPERVISED (SDK 0.7.0): a workspace mounts the worktree,
+    // a platform PTY runs argv, the record begins. Commands tail the record;
+    // interactive harnesses get the full terminal bridge.
+    if (harness === "run") {
+        return supervisedRun(config, session, argv);
+    }
+    await withSpinner("provisioning workspace — a first launch builds the harness image (can take minutes)…", api(config, "POST", `/sessions/${session.id}/launch`, { argv }));
+    say(`${green("✓ recording")} · workspace mounts the worktree · detach: ${dim("Ctrl+]")}`);
+    say("");
+    await attachTty(config, session.id, 0n);
+    const settled = await api(config, "GET", `/sessions/${session.id}`);
+    say("");
+    say(`${green("✓")} session ${settled.session.status} · recorded`);
+    say(`${cobalt("  review")} · ${config.url}/sessions/${session.id}`);
+    process.exit(0);
+};
+// ─── the terminal bridge: raw stdin/stdout against the platform PTY ─────────
+/**
+ * Attach this terminal to the session's PTY through the Mend server over ONE
+ * WebSocket: binary frames are PTY bytes both ways, text frames carry control
+ * JSON (resize up, end down). Auth happens once at connect (?token=); after
+ * that a keystroke is a frame on an open socket — nothing else on the path.
+ * Ctrl+] detaches — the session keeps running and can be reattached from
+ * anywhere. Resolves when the session settles or the user detaches.
+ */
+const attachTty = async (config, sessionId, from) => {
+    const url = new URL(`${config.url}/api/tty`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("session", sessionId);
+    url.searchParams.set("from", from.toString());
+    if (config.token !== null)
+        url.searchParams.set("token", config.token);
+    const ws = new WebSocket(url);
+    ws.binaryType = "arraybuffer";
+    try {
+        await new Promise((resolve, reject) => {
+            ws.addEventListener("open", () => resolve(), { once: true });
+            ws.addEventListener("error", () => reject(new Error("could not connect")), { once: true });
+        });
+    }
+    catch {
+        return fail(`tty attach unavailable: could not connect to ${url.host}`);
+    }
+    const sendResize = () => ws.send(JSON.stringify({
+        t: "resize",
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    }));
+    sendResize();
+    const onWinch = () => sendResize();
+    process.stdout.on("resize", onWinch);
+    const rawTty = process.stdin.isTTY === true;
+    if (rawTty)
+        process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let detached = false;
+    const onKeys = (data) => {
+        if (data.includes(0x1d)) {
+            // Ctrl+] — detach, leave the session running.
+            detached = true;
+            ws.close();
+            return;
+        }
+        // Copy into a plain ArrayBuffer (WebSocket.send rejects pooled Buffer views).
+        ws.send(new Uint8Array(data).buffer);
+    };
+    process.stdin.on("data", onKeys);
+    ws.addEventListener("message", (event) => {
+        if (typeof event.data === "string")
+            return; // control frames ({"t":"end"}) — close follows
+        process.stdout.write(Buffer.from(event.data));
+    });
+    await new Promise((resolve) => {
+        ws.addEventListener("close", () => resolve(), { once: true });
+    });
+    process.stdin.off("data", onKeys);
+    process.stdout.off("resize", onWinch);
+    if (rawTty)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
+    if (detached) {
+        say("");
+        say(`${amber("detached")} — the session keeps running; reattach: mend attach ${sessionId.slice(0, 8)}`);
+        process.exit(0);
+    }
+};
+/** 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>");
+    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 ${match.harness} · ${dim(match.id.slice(0, 8))} · detach: ${dim("Ctrl+]")}`);
+    say("");
+    await attachTty(config, match.id, 0n);
+    say("");
+    say(`${green("✓")} session settled`);
+    process.exit(0);
+};
+// ─── supervised run: platform workspace + PTY + record ──────────────────────
+const supervisedRun = async (config, session, argv) => {
+    const launched = await withSpinner("provisioning workspace — a first launch builds the harness image (can take minutes)…", api(config, "POST", `/sessions/${session.id}/launch`, { argv }));
+    say(`${green("✓ recording")} · run ${dim(launched.id.slice(0, 8))} · workspace mounts the worktree`);
+    say(dim(`  ${argv.join(" ")} — live record:`));
+    say("");
+    // Tail the record through the server's event stream until the session settles.
+    const headers = {};
+    if (config.token !== null)
+        headers["authorization"] = `Bearer ${config.token}`;
+    const response = await fetch(`${config.url}/api/events`, { headers });
+    if (response.body === null)
+        return fail("event stream unavailable");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let settled = null;
+    while (settled === null) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+            const data = part
+                .split("\n")
+                .filter((line) => line.startsWith("data: "))
+                .map((line) => line.slice(6))
+                .join("");
+            if (data === "")
+                continue;
+            let event;
+            try {
+                event = JSON.parse(data);
+            }
+            catch {
+                continue;
+            }
+            if (event.sessionId !== session.id)
+                continue;
+            if (event.type === "session-progress" && event.line !== undefined) {
+                say(dim(`  ${event.line}`));
+            }
+            if (event.type === "session") {
+                const detail = await api(config, "GET", `/sessions/${session.id}`);
+                if (["completed", "failed", "stopped"].includes(detail.session.status)) {
+                    settled = detail.session.status;
+                }
+            }
+        }
+    }
+    await reader.cancel().catch(() => undefined);
+    say("");
+    say(`${green("✓")} session ${settled ?? "settled"} · recorded · checkpoint taken`);
+    say(`${cobalt("  review")} · ${config.url}/sessions/${session.id}`);
+    process.exit(settled === "failed" ? 1 : 0);
+};
+/** How each harness takes an instruction as its opening prompt. */
+const CONTINUE_COMMANDS = {
+    codex: (instruction) => ["codex", instruction],
+    claude: (instruction) => ["claude", instruction],
+    opencode: (instruction) => ["opencode", "run", instruction],
+};
+/**
+ * The second half of the review loop (plan §7.3): find the session with a
+ * pending follow-up, deliver it (which reopens the session), and relaunch the
+ * harness in the same worktree with the instruction as its prompt.
+ */
+const continueSession = async (config, args) => {
+    const explicitSession = args.find((a) => !a.startsWith("--")) ?? null;
+    let sessionId = explicitSession;
+    let followUp = null;
+    if (sessionId !== null) {
+        followUp = await api(config, "GET", `/sessions/${sessionId}/follow-up`);
+        if (followUp === null)
+            return fail(`session ${sessionId} has no pending follow-up`);
+    }
+    else {
+        // Search the cwd's project, newest sessions first.
+        const project = await findProject(config, null);
+        const detail = await api(config, "GET", `/projects/${project.id}`);
+        for (const candidate of detail.sessions) {
+            const pending = await api(config, "GET", `/sessions/${candidate.id}/follow-up`);
+            if (pending !== null) {
+                sessionId = candidate.id;
+                followUp = pending;
+                break;
+            }
+        }
+        if (sessionId === null || followUp === null) {
+            return fail("no session with a pending follow-up — send one from the review first");
+        }
+    }
+    const detail = await api(config, "GET", `/sessions/${sessionId}`);
+    const session = detail.session;
+    const projects = await api(config, "GET", "/projects");
+    const project = projects.find((p) => p.id === session.projectId);
+    if (project === undefined)
+        return fail(`project ${session.projectId} not found`);
+    const worktree = worktreePathOf(project.storePath, session.worktree);
+    const build = CONTINUE_COMMANDS[session.harness];
+    say(`${green("✓")} follow-up for session ${dim(session.id.slice(0, 8))} · ${session.branch}`);
+    say(dim("  instruction:"));
+    for (const line of followUp.instruction.split("\n").slice(0, 6))
+        say(dim(`  │ ${line}`));
+    if (followUp.instruction.split("\n").length > 6)
+        say(dim("  │ …"));
+    if (build === undefined) {
+        say("");
+        say(`${amber("  cannot relaunch")} ${dim(`— harness "${session.harness}" has no known resume command.`)}`);
+        say(dim(`  run it yourself in ${worktree}; the follow-up stays pending.`));
+        process.exit(1);
+    }
+    await api(config, "POST", `/sessions/${session.id}/follow-up/deliver`);
+    say(`${green("✓")} delivered · session reopened`);
+    say(`${cobalt("  watch")} · ${config.url}/sessions/${session.id}`);
+    // Relaunch SUPERVISED, exactly like a fresh `mend <harness>`: a new
+    // workspace mounts the SAME worktree, the platform PTY runs the harness
+    // with the instruction as its opening prompt, and the record continues —
+    // the web session page shows the live terminal throughout.
+    const argv = build(followUp.instruction);
+    await withSpinner("provisioning workspace — the resumed run records like any other…", api(config, "POST", `/sessions/${session.id}/launch`, { argv }));
+    say(`${green("✓ recording")} · workspace mounts the worktree · detach: ${dim("Ctrl+]")}`);
+    say("");
+    await attachTty(config, session.id, 0n);
+    const settled = await api(config, "GET", `/sessions/${session.id}`);
+    say("");
+    say(`${green("✓")} session ${settled.session.status} · recorded`);
+    say(`${cobalt("  review")} · ${config.url}/sessions/${session.id}`);
+    process.exit(0);
+};
+// ─── resume: rejoin a session — same worktree, restored harness state ───────
+const ACTIVE_STATUSES = new Set(["starting", "running", "waiting", "idle"]);
+/**
+ * Sessions are continuous work, not runs: `mend resume` rejoins one on a
+ * fresh workspace — saved harness state restored, a claude resume is native
+ * (conversation intact). `--with <harness>` re-opens the same work in a
+ * DIFFERENT harness: the conversation crosses as a distilled opening prompt.
+ */
+const resumeCommand = async (config, args) => {
+    const withFlag = args.indexOf("--with");
+    const withHarness = withFlag !== -1 && args[withFlag + 1] !== undefined ? String(args[withFlag + 1]) : null;
+    const prefix = args.find((a, i) => !a.startsWith("--") && i !== withFlag + 1);
+    const project = await findProject(config, null);
+    const detail = await api(config, "GET", `/projects/${project.id}`);
+    const match = prefix !== undefined
+        ? detail.sessions.find((s) => s.id.startsWith(prefix))
+        : detail.sessions.find((s) => !ACTIVE_STATUSES.has(s.status));
+    if (match === undefined) {
+        return fail(prefix !== undefined
+            ? `no session matches "${prefix}"`
+            : "no settled session to resume — mend status lists sessions");
+    }
+    if (ACTIVE_STATUSES.has(match.status)) {
+        return fail(`session ${match.id.slice(0, 8)} is live — attach: mend attach ${match.id.slice(0, 8)}`);
+    }
+    say(`${green("✓")} resuming ${match.harness} · ${dim(match.id.slice(0, 8))}${withHarness === null ? "" : ` ${dim("as")} ${withHarness}`}`);
+    say(`${cobalt("  watch")} · ${config.url}/sessions/${match.id}`);
+    await withSpinner("resuming — a fresh workspace restores the saved session state…", api(config, "POST", `/sessions/${match.id}/resume`, { harness: withHarness }));
+    say(`${green("✓ recording")} · same worktree, conversation restored · detach: ${dim("Ctrl+]")}`);
+    say("");
+    await attachTty(config, match.id, 0n);
+    const settled = await api(config, "GET", `/sessions/${match.id}`);
+    say("");
+    say(`${green("✓")} session ${settled.session.status} · recorded`);
+    say(`${cobalt("  review")} · ${config.url}/sessions/${match.id}`);
+    process.exit(0);
+};
+// ─── status ─────────────────────────────────────────────────────────────────
+const status = async (config) => {
+    const sessions = await api(config, "GET", "/sessions");
+    if (sessions.length === 0) {
+        say(dim("no active sessions"));
+        return;
+    }
+    for (const session of sessions) {
+        say(`${session.harness}  ${dim(session.id.slice(0, 8))}  ${session.status}  ${dim(session.branch)}`);
+    }
+};
+// ─── entry ──────────────────────────────────────────────────────────────────
+const HELP = `mend — the agent workbench
+
+  mend adopt [source] [--name <name>]   adopt a repository into the store (default: cwd)
+  mend codex|claude|opencode            new session worktree + launch the harness in it
+  mend run -- <command...>              same, with an arbitrary command
+  mend attach <session-id-prefix>       reattach this terminal to a running session
+  mend continue [session-id]            resume a session with its pending review follow-up
+  mend resume [session-id] [--with h]   rejoin a settled session (state restored; --with switches harness)
+  mend status                           active sessions
+
+  server: MEND_URL (default http://localhost:3105) · auth: MEND_TOKEN
+  config file: ~/.mend/cli.json { "url": ..., "token": ... }
+`;
+const main = async () => {
+    const [command, ...rest] = process.argv.slice(2);
+    const config = loadConfig();
+    switch (command) {
+        case "adopt":
+            return adopt(config, rest);
+        case "codex":
+        case "claude":
+        case "opencode":
+        case "run":
+            return launch(config, command, rest);
+        case "attach":
+            return attach(config, rest);
+        case "continue":
+            return continueSession(config, rest);
+        case "resume":
+            return resumeCommand(config, rest);
+        case "status":
+            return status(config);
+        case undefined:
+        case "help":
+        case "--help":
+            say(HELP);
+            return;
+        default:
+            return fail(`unknown command "${command}" — try: mend help`);
+    }
+};
+await main();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sealant/mend",
+  "version": "0.1.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",
+    "codex",
+    "coding-agent",
+    "mend",
+    "sealant",
+    "session",
+    "worktree"
+  ],
+  "homepage": "https://github.com/sealant-sh/Mend",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sealant-sh/Mend.git",
+    "directory": "apps/cli"
+  },
+  "bin": {
+    "mend": "./dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^4.0.0-beta.85",
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2",
+    "vitest": "^3.0.5",
+    "@mend/typescript": "0.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc src/main.ts --outDir dist --module nodenext --target es2022 --types node --skipLibCheck",
+    "lint": "oxlint . --no-error-on-unmatched-pattern",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsgo -p tsconfig.json --noEmit"
+  }
+}