@sealant/mend 0.34.2 → 0.34.4

package/dist/main.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import {
+  GATEWAY_STATUSES,
   HARNESS_COMMANDS,
   LIVE_STATUSES,
+  MendRequestError,
   agentIsLive,
   agentOutcome,
   captureLineOf,
@@ -18,6 +20,7 @@ import {
   landingFactsFromWire,
   matchProjectByCwd,
   narrowCredential,
+  noAnswerError,
   normalizeGitAuthor,
   normalizeProjectName,
   normalizeRemoteUrl,
@@ -27,8 +30,9 @@ import {
   sameGrant,
   servicesHoldOf,
   sessionDisplayName,
+  spoken,
   trackBracketedPaste
-} from "./chunk-JJ66V76Y.js";
+} from "./chunk-AAAXHRWL.js";
 
 // src/main.ts
 import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
@@ -3655,6 +3659,78 @@ var pullCommand = async (api2, download2, args, cwd = process.cwd()) => {
   for (const line of fetchedLines(fetched)) say(line);
 };
 
+// src/launch-follow.ts
+var SETTLED = /* @__PURE__ */ new Set(["completed", "failed", "stopped", "stopping"]);
+var agentRuns = (agent) => agent !== null && agent.kind !== "agent-protocol" && agent.exitedAt === null && agent.status === "running" && agent.sealantSessionId !== null;
+var startingLineOf = (session) => {
+  const summary = session.summary?.trim() ?? "";
+  if (summary === "") return session.status;
+  if (/^[a-z][a-z -]*·/u.test(summary)) return summary;
+  return `${session.status} \xB7 ${summary}`;
+};
+var refusalOf = (error) => error instanceof MendRequestError && error.kind === "http" && (error.status === null || !GATEWAY_STATUSES.has(error.status)) ? error.message : null;
+var followStart = async (options) => {
+  const pollMs = options.pollMs ?? 2e3;
+  const unreachableAfterMs = options.unreachableAfterMs ?? 6e4;
+  const launch2 = {
+    state: options.start === null ? { kind: "no-answer" } : { kind: "pending" }
+  };
+  const start = options.start;
+  const launched = (async () => {
+    if (start === null) return;
+    try {
+      launch2.state = { kind: "answered", session: await start };
+    } catch (error) {
+      const refusal = refusalOf(error);
+      launch2.state = refusal === null ? { kind: "no-answer" } : { kind: "refused", message: refusal };
+    }
+  })();
+  let lastLine = null;
+  let failingSince = null;
+  let seenStarting = false;
+  for (; ; ) {
+    if (launch2.state.kind === "pending") await Promise.race([launched, options.sleep(pollMs)]);
+    const state = launch2.state;
+    if (state.kind === "refused") return { kind: "refused", message: state.message };
+    if (state.kind === "answered" && state.session.status === "running") {
+      return { kind: "live", session: state.session };
+    }
+    let detail;
+    try {
+      detail = await options.read();
+    } catch (error) {
+      const refusal = refusalOf(error);
+      if (refusal !== null) return { kind: "refused", message: refusal };
+      failingSince ??= options.now();
+      if (state.kind !== "pending" && options.now() - failingSince >= unreachableAfterMs) {
+        return {
+          kind: "unreachable",
+          message: error instanceof Error ? error.message : String(error)
+        };
+      }
+      if (state.kind !== "pending") await options.sleep(pollMs);
+      continue;
+    }
+    failingSince = null;
+    const { session, currentAgent } = detail;
+    if (agentRuns(currentAgent)) return { kind: "live", session };
+    if (SETTLED.has(session.status)) {
+      if (seenStarting || state.kind !== "pending") return { kind: "settled", session };
+    } else {
+      seenStarting = true;
+    }
+    if (currentAgent === null && state.kind === "answered" && state.session.status === "running" && session.status === "running") {
+      return { kind: "live", session };
+    }
+    const line = startingLineOf(session);
+    if (line !== lastLine) {
+      lastLine = line;
+      options.onLine(line);
+    }
+    if (state.kind !== "pending") await options.sleep(pollMs);
+  }
+};
+
 // src/login.ts
 import { spawn as spawn2 } from "node:child_process";
 import * as os5 from "node:os";
@@ -7483,9 +7559,10 @@ var herdrAgentOf = (harness) => {
   if (harness === "codex" || harness === "claude" || harness === "opencode") return harness;
   return null;
 };
+var noHerdrHint = () => void 0;
 var hintHerdrAttachment = (harness) => {
   const agent = herdrAgentOf(harness);
-  if (process.env["HERDR_ENV"] !== "1" || agent === null) return () => void 0;
+  if (process.env["HERDR_ENV"] !== "1" || agent === null) return noHerdrHint;
   const carrier = spawn3(
     process.execPath,
     ["-e", "process.stdin.resume();process.stdin.once('end',()=>process.exit(0))"],
@@ -7511,6 +7588,8 @@ var request = async (config, method, route, body) => {
   const headers = { "content-type": "application/json" };
   if (config.token !== null) headers["authorization"] = `Bearer ${config.token}`;
   let response;
+  const started = Date.now();
+  const call = `${method} ${route}`;
   try {
     response = await fetch(`${config.url}/api${route}`, {
       method,
@@ -7518,23 +7597,30 @@ var request = async (config, method, route, body) => {
       // Spread, not `body: null` — fresh oxlint rejects a body key on GETs.
       ...body === void 0 ? {} : { body: JSON.stringify(body) }
     });
-  } catch {
-    throw new Error(`cannot reach the Mend server at ${config.url} \u2014 is it running?`);
+  } catch (error) {
+    throw noAnswerError(error, config.url, call, Date.now() - started);
   }
   if (response.status === 401) {
-    throw new Error(
-      config.token === null ? `not signed in to ${config.url} \u2014 run: mend login` : `unauthorized at ${config.url} \u2014 the saved token was rejected; run: mend login`
+    throw new MendRequestError(
+      "http",
+      config.token === null ? `not signed in to ${config.url} \u2014 run: mend login` : `unauthorized at ${config.url} \u2014 the saved token was rejected; run: mend login`,
+      401
     );
   }
-  const text = await response.text();
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    throw noAnswerError(error, config.url, call, Date.now() - started);
+  }
   if (!response.ok) {
-    let message = `${method} ${route} \u2192 ${response.status}`;
+    let message = `${call} \u2192 ${response.status}`;
     try {
       const parsed = JSON.parse(text);
       message = parsed.message ?? message;
     } catch {
     }
-    throw new Error(message);
+    throw new MendRequestError("http", message, response.status);
   }
   try {
     return JSON.parse(text);
@@ -7553,10 +7639,11 @@ var download = (config) => async (route) => {
   const headers = {};
   if (config.token !== null) headers["authorization"] = `Bearer ${config.token}`;
   let response;
+  const started = Date.now();
   try {
     response = await fetch(`${config.url}/api${route}`, { headers });
-  } catch {
-    return fail6(`cannot reach the Mend server at ${config.url} \u2014 is it running?`);
+  } catch (error) {
+    return fail6(noAnswerError(error, config.url, `GET ${route}`, Date.now() - started).message);
   }
   if (response.status === 401) {
     return fail6(
@@ -7567,13 +7654,14 @@ var download = (config) => async (route) => {
   return { status: response.status, header: (name) => response.headers.get(name), bytes };
 };
 var warnedLegacyBearer = false;
-var mintTicket = (config) => async (target, params) => {
+var mintTicket = (config, signal) => async (target, params) => {
   const headers = { "content-type": "application/json" };
   if (config.token !== null) headers["authorization"] = `Bearer ${config.token}`;
   const response = await fetch(`${config.url}/api/upgrade-tickets`, {
     method: "POST",
     headers,
-    body: JSON.stringify({ target, ...params })
+    body: JSON.stringify({ target, ...params }),
+    ...signal === void 0 ? {} : { signal }
   });
   if (response.status === 404) {
     if (await mintRefusedInTransit(config.url)) throw new Error(MINT_REFUSED_IN_TRANSIT);
@@ -7591,12 +7679,12 @@ var mintTicket = (config) => async (target, params) => {
     throw new Error("upgrade ticket missing from the answer");
   return { kind: "ticket", ticket: minted.ticket };
 };
-var socketUrl = (config, target, params, extra) => upgradeUrl({
+var socketUrl = (config, target, params, extra, signal) => upgradeUrl({
   serverUrl: parseMendUrl(config.url).toString(),
   target,
   params,
   ...extra === void 0 ? {} : { extra },
-  mint: mintTicket(config),
+  mint: mintTicket(config, signal),
   legacyToken: config.token
 });
 var boundApi = (config) => (method, route, body) => api(config, method, route, body);
@@ -7607,7 +7695,10 @@ var withSpinner = async (label, work) => {
   let frame = 0;
   const timer = setInterval(() => {
     const seconds2 = Math.round((Date.now() - started) / 1e3);
-    process.stdout.write(`\r  ${frames[frame % frames.length]} ${label} ${dim6(`${seconds2}s`)} `);
+    const text = typeof label === "string" ? label : label();
+    process.stdout.write(
+      `\r\x1B[2K  ${frames[frame % frames.length]} ${text} ${dim6(`${seconds2}s`)} `
+    );
     frame += 1;
   }, 120);
   try {
@@ -7617,6 +7708,52 @@ var withSpinner = async (label, work) => {
     process.stdout.write("\r\x1B[2K");
   }
 };
+var followStarting = async (config, sessionId, label, start) => {
+  let line = label;
+  const timers = /* @__PURE__ */ new Set();
+  const sleep3 = (ms) => new Promise((resolve7) => {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      resolve7();
+    }, ms);
+    timers.add(timer);
+  });
+  try {
+    return await withSpinner(
+      () => line,
+      followStart({
+        start,
+        read: () => request(config, "GET", `/sessions/${sessionId}`),
+        onLine: (next) => {
+          line = next === "starting" ? label : next;
+          if (process.stdout.isTTY !== true) say6(dim6(`  ${next}`));
+        },
+        sleep: sleep3,
+        now: Date.now
+      })
+    );
+  } finally {
+    for (const timer of timers) clearTimeout(timer);
+  }
+};
+var startedOrExit = (config, sessionId, outcome) => {
+  const id8 = sessionId.slice(0, 8);
+  switch (outcome.kind) {
+    case "live":
+      return outcome.session;
+    case "refused":
+      return fail6(outcome.message);
+    case "settled":
+      return fail6(
+        `session ${id8} \xB7 ${startingLineOf(outcome.session)} before its agent ran \xB7 ${config.url}/sessions/${sessionId}`
+      );
+    case "unreachable":
+      return fail6(
+        `${outcome.message} \xB7 the session may still be starting \xB7 follow it: mend attach ${id8}`
+      );
+  }
+};
+var startAndFollow = async (config, sessionId, label, start) => startedOrExit(config, sessionId, await followStarting(config, sessionId, label, start));
 var adopt = async (config, args) => {
   const nameFlag = args.indexOf("--name");
   const name = nameFlag !== -1 && args[nameFlag + 1] !== void 0 ? String(args[nameFlag + 1]) : null;
@@ -7818,9 +7955,11 @@ var launch = async (config, harness, args) => {
     ...parsed.ask ? { permissionMode: "ask" } : {},
     ...parsed.fast ? { speed: "fast" } : {}
   } : { argv };
-  await withSpinner(
+  await startAndFollow(
+    config,
+    session.id,
     "provisioning workspace \u2014 a first launch builds the harness image (can take minutes)\u2026",
-    api(config, "POST", `/sessions/${session.id}/launch`, launchBody)
+    request(config, "POST", `/sessions/${session.id}/launch`, launchBody)
   );
   if (lifecycle === "detach") {
     say6(`${green6("\u2713 recording")} \xB7 running detached`);
@@ -7842,58 +7981,67 @@ var autoLandLine = (override, project2) => {
   }
   return `${green6("\u2713")} automatic landing \xB7 ${override ? "on" : "off"} for this session ${dim6("\xB7 from this terminal, land with mend land")}`;
 };
-var attachTty = async (config, sessionId, harness, from, processId, options) => {
-  let url;
-  try {
-    url = await socketUrl(
-      config,
-      "tty",
-      processId === void 0 ? { session: sessionId } : { process: processId },
-      { from: from.toString() }
+var ATTACH_CONNECT_TIMEOUT_MS = (() => {
+  const configured = Number(process.env["MEND_ATTACH_TIMEOUT_MS"]);
+  return Number.isFinite(configured) && configured > 0 ? configured : 3e4;
+})();
+var connectingLine = (sessionId, elapsedMs) => `\r\x1B[2K  connecting to ${sessionId.slice(0, 8)} \xB7 ${Math.round(elapsedMs / 1e3)}s \xB7 ${detachKeyEnabled ? "Ctrl+] or " : ""}Ctrl+C cancels`;
+var takeTerminal = () => {
+  if (process.stdin.isTTY !== true) {
+    console.error(
+      "mend: stdin is not a terminal, so it cannot be put in raw mode \u2014 keys reach the session a line at a time and echo here"
     );
-  } catch {
-    return "unavailable";
+    return { raw: false };
   }
-  const ws = new WebSocket(url);
-  ws.binaryType = "arraybuffer";
   try {
-    await new Promise((resolve7, reject) => {
-      ws.addEventListener("open", () => resolve7(), { once: true });
-      ws.addEventListener("error", () => reject(new Error("could not connect")), { once: true });
-    });
-  } catch {
-    return "unavailable";
+    process.stdin.setRawMode(true);
+  } catch (error) {
+    console.error(
+      `mend: could not put this terminal in raw mode (${error instanceof Error ? error.message : String(error)}) \u2014 keys reach the session a line at a time and echo here`
+    );
+    return { raw: false };
   }
-  const stopHerdrHint = hintHerdrAttachment(harness);
-  let finishAttachment;
-  const finished = new Promise((resolve7) => {
-    finishAttachment = resolve7;
-  });
-  const onClose = () => finishAttachment?.();
-  if (ws.readyState === WebSocket.CLOSED) finishAttachment?.();
-  else ws.addEventListener("close", onClose, { once: true });
-  const sendResize = () => {
-    if (ws.readyState !== WebSocket.OPEN) return;
-    ws.send(
-      JSON.stringify({
-        t: "resize",
-        cols: process.stdout.columns ?? 80,
-        rows: process.stdout.rows ?? 24
-      })
+  if (!process.stdin.isRaw) {
+    console.error(
+      "mend: this terminal did not accept raw mode \u2014 keys reach the session a line at a time and echo here"
     );
+    return { raw: false };
+  }
+  return { raw: true };
+};
+var terminalSize = () => ({
+  cols: process.stdout.columns || 80,
+  rows: process.stdout.rows || 24
+});
+var attachTty = async (config, sessionId, harness, from, processId, options) => {
+  const interactive = options?.readOnly !== true;
+  const rawModeEnabled = interactive ? takeTerminal().raw : false;
+  const connecting = new AbortController();
+  let abortReason = null;
+  const abort = (reason) => {
+    abortReason ??= reason;
+    connecting.abort();
   };
-  const onWinch = () => sendResize();
-  const rawTty = process.stdin.isTTY === true;
-  let rawModeEnabled = false;
+  let ws = null;
   let detached = false;
   let sawEnd = false;
   let interrupted = false;
+  let finishAttachment;
+  const finished = new Promise((resolve7) => {
+    finishAttachment = resolve7;
+  });
   const onSignal = () => {
     interrupted = true;
-    ws.close();
+    abort("interrupted");
+    ws?.close();
     finishAttachment?.();
   };
   const signals = ["SIGHUP", "SIGINT", "SIGTERM"];
+  const sendResize = (size = terminalSize()) => {
+    if (ws === null || ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify({ t: "resize", cols: size.cols, rows: size.rows }));
+  };
+  const onWinch = () => sendResize();
   let bracketedPaste = false;
   const onTtyFrame = (event) => {
     if (typeof event.data !== "string") {
@@ -7908,15 +8056,24 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
         return;
       }
       sawEnd = true;
-      ws.close();
+      ws?.close();
       finishAttachment?.();
     } catch {
     }
   };
+  const forward = (bytes) => {
+    if (ws !== null && ws.readyState === WebSocket.OPEN) ws.send(new Uint8Array(bytes).buffer);
+  };
   const onKeys = (data) => {
+    if (ws === null) {
+      if (detachKeyEnabled && isDetachChunk(data)) abort("detached");
+      else if (data.includes(3)) abort("interrupted");
+      return;
+    }
     if (detachKeyEnabled && isDetachChunk(data)) {
       detached = true;
       ws.close();
+      finishAttachment?.();
       return;
     }
     if (ws.readyState !== WebSocket.OPEN) return;
@@ -7926,9 +8083,6 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
     }
     ws.send(new Uint8Array(data).buffer);
   };
-  const forward = (bytes) => {
-    if (ws.readyState === WebSocket.OPEN) ws.send(new Uint8Array(bytes).buffer);
-  };
   const pasteClipboardImage = async (keystroke) => {
     const image = await readClipboardImage();
     if (image === null) {
@@ -7947,36 +8101,88 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
       process.stdout.write("\x07");
     }
   };
+  const connect2 = async () => {
+    let url;
+    try {
+      url = await socketUrl(
+        config,
+        "tty",
+        processId === void 0 ? { session: sessionId } : { process: processId },
+        { from: from.toString() },
+        connecting.signal
+      );
+    } catch {
+      return connecting.signal.aborted ? "aborted" : "unavailable";
+    }
+    if (connecting.signal.aborted) return "aborted";
+    const socket = new WebSocket(url);
+    socket.binaryType = "arraybuffer";
+    const opened = await new Promise((resolve7) => {
+      const onAbort = () => resolve7(false);
+      connecting.signal.addEventListener("abort", onAbort, { once: true });
+      const settle = (value) => {
+        connecting.signal.removeEventListener("abort", onAbort);
+        resolve7(value);
+      };
+      socket.addEventListener("open", () => settle(true), { once: true });
+      socket.addEventListener("error", () => settle(false), { once: true });
+    });
+    if (opened && !connecting.signal.aborted) return socket;
+    socket.close();
+    return connecting.signal.aborted ? "aborted" : "unavailable";
+  };
+  const started = Date.now();
+  let connectingShown = false;
+  const connectingTimer = setInterval(() => {
+    if (process.stdout.isTTY !== true) return;
+    connectingShown = true;
+    process.stdout.write(connectingLine(sessionId, Date.now() - started));
+  }, 1e3);
+  const deadline = setTimeout(() => abort("no-answer"), ATTACH_CONNECT_TIMEOUT_MS);
+  const stopConnecting = () => {
+    for (const timer of [connectingTimer, deadline]) clearTimeout(timer);
+    if (connectingShown) process.stdout.write("\r\x1B[2K");
+    connectingShown = false;
+  };
+  let stopHerdrHint = noHerdrHint;
   try {
-    sendResize();
-    process.stdout.on("resize", onWinch);
     if (options?.handleSignals === true) for (const signal of signals) process.on(signal, onSignal);
-    if (options?.readOnly !== true) {
-      if (rawTty) {
-        process.stdin.setRawMode(true);
-        rawModeEnabled = true;
-      }
-      process.stdin.resume();
+    if (interactive) {
       process.stdin.on("data", onKeys);
+      process.stdin.resume();
     }
+    const connected = await connect2();
+    stopConnecting();
+    if (connected === "unavailable") return "unavailable";
+    if (connected === "aborted") return abortReason ?? "interrupted";
+    ws = connected;
+    stopHerdrHint = hintHerdrAttachment(harness);
+    const onClose = () => finishAttachment?.();
+    if (ws.readyState === WebSocket.CLOSED) finishAttachment?.();
+    else ws.addEventListener("close", onClose, { once: true });
     ws.addEventListener("message", onTtyFrame);
+    const size = terminalSize();
+    if (size.rows > 1) sendResize({ cols: size.cols, rows: size.rows - 1 });
+    setTimeout(() => sendResize(), 80);
+    process.stdout.on("resize", onWinch);
     await finished;
     return detached ? "detached" : interrupted ? "interrupted" : sawEnd ? "ended" : "dropped";
   } finally {
+    stopConnecting();
     for (const signal of signals) process.off(signal, onSignal);
     process.stdin.off("data", onKeys);
     process.stdout.off("resize", onWinch);
-    ws.removeEventListener("message", onTtyFrame);
-    ws.removeEventListener("close", onClose);
+    ws?.removeEventListener("message", onTtyFrame);
     if (rawModeEnabled) process.stdin.setRawMode(false);
-    if (options?.readOnly !== true && process.stdout.isTTY === true) {
+    if (interactive && ws !== null && process.stdout.isTTY === true) {
       process.stdout.write(
         "\x1B[<u\x1B[=0;1u\x1B[?2004l\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?1049l\x1B[?25h"
         // show the cursor
       );
     }
     process.stdin.pause();
-    if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close();
+    if (ws !== null && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING))
+      ws.close();
     stopHerdrHint();
   }
 };
@@ -8004,11 +8210,18 @@ var stopAndExit = async (config, sessionId) => {
   say6(`${amber2("could not stop")} \u2014 the session may still run \xB7 mend stop ${id8}`);
   process.exit(1);
 };
+var noAnswerLine = (config, id8) => `${amber2("no answer")} \u2014 ${config.url} did not open the terminal within ${spoken(ATTACH_CONNECT_TIMEOUT_MS)}; the session keeps running \xB7 try again: mend attach ${id8} \xB7 check the server: mend doctor`;
 var finishAttach = async (config, sessionId, outcome, mode = "background") => {
   const id8 = sessionId.slice(0, 8);
   if (outcome === "unavailable") {
     return fail6(`tty attach unavailable: could not connect to ${config.url}`);
   }
+  if (outcome === "no-answer") {
+    say6("");
+    say6(noAnswerLine(config, id8));
+    if (mode === "foreground") return stopAndExit(config, sessionId);
+    process.exit(1);
+  }
   if (outcome === "detached") {
     say6("");
     say6(`${amber2("detached")} \u2014 the session keeps running; reattach: mend attach ${id8}`);
@@ -8070,6 +8283,9 @@ var attachPicked = async (config, session, tunnels) => {
   say6(
     `${green6("\u2713")} attaching to ${sessionDisplayName(session)} \xB7 ${session.harness} ${dim6(session.id.slice(0, 8))}${detachHint()}`
   );
+  if (session.status === "starting") {
+    await startAndFollow(config, session.id, "starting \u2014 attaching once the agent runs\u2026", null);
+  }
   await tunnels?.start(session.id);
   say6("");
   const outcome = await attachWithTunnels(
@@ -8082,9 +8298,11 @@ var attachPicked = async (config, session, tunnels) => {
     const detail = await api(config, "GET", `/sessions/${session.id}`);
     if (detail.currentAgent?.kind === "agent-protocol" && agentIsLive(detail.session, detail.currentAgent)) {
       say6(`${amber2("taking over")} from the protocol session`);
-      await withSpinner(
+      await startAndFollow(
+        config,
+        session.id,
         "reopening as a terminal \u2014 same conversation\u2026",
-        api(config, "POST", `/sessions/${session.id}/handoff`, { to: "pty" })
+        request(config, "POST", `/sessions/${session.id}/handoff`, { to: "pty" })
       );
       say6("");
       await attachOrExit(config, session.id, session.harness, "background", tunnels);
@@ -8240,6 +8458,10 @@ var shellCommand = async (config, args) => {
     return fail6(`tty attach unavailable: could not connect to ${config.url}`);
   }
   say6("");
+  if (outcome === "no-answer") {
+    say6(noAnswerLine(config, session.id.slice(0, 8)));
+    process.exit(1);
+  }
   if (outcome === "detached" || outcome === "interrupted" || outcome === "dropped") {
     say6(`${amber2("detached")} \u2014 the shell keeps running and holds the workspace open`);
     process.exit(0);
@@ -9627,9 +9849,11 @@ var completionsCommand = (args) => {
   }
 };
 var supervisedRun = async (config, session, argv) => {
-  const launched = await withSpinner(
+  const launched = await startAndFollow(
+    config,
+    session.id,
     "provisioning workspace \u2014 a first launch builds the harness image (can take minutes)\u2026",
-    api(config, "POST", `/sessions/${session.id}/launch`, { argv })
+    request(config, "POST", `/sessions/${session.id}/launch`, { argv })
   );
   say6(
     `${green6("\u2713 recording")} \xB7 run ${dim6(launched.id.slice(0, 8))} \xB7 workspace mounts the worktree`
@@ -9765,9 +9989,13 @@ var resumeCommand = async (config, args) => {
   say6(`${cobalt2("  watch")} \xB7 ${config.url}/sessions/${match.id}`);
   const priorAgent = detail.annotations.find((annotation) => annotation.sessionId === match.id)?.currentAgent ?? null;
   const protocolPrior = priorAgent?.kind === "agent-protocol" && withHarness === null;
-  await withSpinner(
+  await startAndFollow(
+    config,
+    match.id,
     protocolPrior ? "reopening as a terminal \u2014 same conversation\u2026" : "resuming \u2014 a fresh workspace restores the saved session state\u2026",
-    protocolPrior ? api(config, "POST", `/sessions/${match.id}/handoff`, { to: "pty" }) : api(config, "POST", `/sessions/${match.id}/resume`, { harness: withHarness })
+    protocolPrior ? request(config, "POST", `/sessions/${match.id}/handoff`, { to: "pty" }) : request(config, "POST", `/sessions/${match.id}/resume`, {
+      harness: withHarness
+    })
   );
   say6(`${green6("\u2713 recording")} \xB7 same worktree, conversation restored${detachHint()}`);
   say6("");
@@ -9775,17 +10003,18 @@ var resumeCommand = async (config, args) => {
   exitAfterSessionEnd(config, match.id);
 };
 var resumeForRejoin = async (config, sessionId, label) => {
-  try {
-    await withSpinner(
-      label,
-      request(config, "POST", `/sessions/${sessionId}/resume`, { harness: null })
-    );
-    return true;
-  } catch (error) {
+  const outcome = await followStarting(
+    config,
+    sessionId,
+    label,
+    request(config, "POST", `/sessions/${sessionId}/resume`, { harness: null })
+  );
+  if (outcome.kind === "refused") {
     const refreshed = await api(config, "GET", `/sessions/${sessionId}`);
     if (agentIsLive(refreshed.session, refreshed.currentAgent)) return false;
-    return fail6(error instanceof Error ? error.message : String(error));
   }
+  startedOrExit(config, sessionId, outcome);
+  return true;
 };
 var rejoinCommand = async (config, args) => {
   const harnessFlag = args.indexOf("--harness");
@@ -9816,9 +10045,11 @@ var rejoinCommand = async (config, args) => {
   let restored = false;
   const currentAgent = detail.annotations.find((annotation) => annotation.sessionId === session.id)?.currentAgent ?? null;
   if (currentAgent?.kind === "agent-protocol") {
-    await withSpinner(
+    await startAndFollow(
+      config,
+      session.id,
       alreadyLive ? "taking over from the protocol session \u2014 same conversation\u2026" : "reopening as a terminal \u2014 same conversation\u2026",
-      api(config, "POST", `/sessions/${session.id}/handoff`, { to: "pty" })
+      request(config, "POST", `/sessions/${session.id}/handoff`, { to: "pty" })
     );
     restored = true;
   } else if (!alreadyLive) {
@@ -10149,7 +10380,7 @@ var dashboard = async (config, options = {}) => {
     );
     process.exit(rerun.status ?? 0);
   }
-  const { runDashboard } = await import("./dashboard-OADX3PHI.js");
+  const { runDashboard } = await import("./dashboard-DWXXYFPE.js");
   const agentShare = await startShareIfBridge(config);
   const tunnels = options.noTunnel === true || serverIsLocal(config) ? null : createServiceTunnels({
     listServices: () => fetchServices(config),

package/man/mend-accounts.1

@@ -1,4 +1,4 @@
-.TH MEND-ACCOUNTS 1 "" "mend 0.34.2" "mend manual"
+.TH MEND-ACCOUNTS 1 "" "mend 0.34.4" "mend manual"
 .SH NAME
 mend\-accounts \- your connected accounts on the platform
 .SH SYNOPSIS

package/man/mend-adopt.1

@@ -1,4 +1,4 @@
-.TH MEND-ADOPT 1 "" "mend 0.34.2" "mend manual"
+.TH MEND-ADOPT 1 "" "mend 0.34.4" "mend manual"
 .SH NAME
 mend\-adopt \- adopt a repository into the store
 .SH SYNOPSIS

package/man/mend-attach.1

@@ -1,4 +1,4 @@
-.TH MEND-ATTACH 1 "" "mend 0.34.2" "mend manual"
+.TH MEND-ATTACH 1 "" "mend 0.34.4" "mend manual"
 .SH NAME
 mend\-attach \- reattach this terminal to a running session
 .SH SYNOPSIS