@sealant/mend 0.33.0 → 0.34.4

package/dist/main.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import {
+  GATEWAY_STATUSES,
   HARNESS_COMMANDS,
   LIVE_STATUSES,
+  MendRequestError,
   agentIsLive,
   agentOutcome,
+  captureLineOf,
   claudeGrantFacts,
   createSseParser,
   cwdFacts,
@@ -17,6 +20,7 @@ import {
   landingFactsFromWire,
   matchProjectByCwd,
   narrowCredential,
+  noAnswerError,
   normalizeGitAuthor,
   normalizeProjectName,
   normalizeRemoteUrl,
@@ -26,16 +30,17 @@ import {
   sameGrant,
   servicesHoldOf,
   sessionDisplayName,
+  spoken,
   trackBracketedPaste
-} from "./chunk-GJFMD7XF.js";
+} from "./chunk-AAAXHRWL.js";
 
 // src/main.ts
-import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
-import * as fs14 from "node:fs";
+import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
+import * as fs15 from "node:fs";
 import { createRequire } from "node:module";
 import * as net4 from "node:net";
-import * as os9 from "node:os";
-import * as path15 from "node:path";
+import * as os10 from "node:os";
+import * as path16 from "node:path";
 
 // src/agent-share.ts
 import * as net from "node:net";
@@ -1139,7 +1144,7 @@ var COMMANDS = [
     summary: "check this machine's setup, or bundle it for a bug report",
     synopsis: ["", "--bundle [--out <path>] [--tail <n>]"],
     description: [
-      "Read-only. One line per fact: the server, the sign-in, the platform connection, the provider accounts, the git key. Each unfinished line ends with the command that fixes it.",
+      "Read-only. One line per fact: the server, the sign-in, the platform connection, the provider accounts, the git key, and where docker is on PATH its daemon's shutdown-timeout against the capture grace. Each unfinished line ends with the command that fixes it.",
       "--bundle collects what a maintainer asks for one output at a time into one tar.gz: this CLI and its environment, the doctor lines, the server's health, the local server's configuration (its compose file and the names of its .env keys, never their values), docker version, info, contexts, the Mend and workspace containers with their inspect facts, the local server's container logs, the running workspace containers' logs, every session with its processes, exit codes and argv, the recorded terminal output of each, the connected accounts, and the versions and paths of claude, codex, gh, git and docker on this machine.",
       "Each part is collected on its own: one that fails leaves a <name>.error.txt in the bundle instead of stopping it. One redactor runs over every file before it is written: bearer and header values, Slack, OpenAI, GitHub and AWS token shapes, JWTs, passwords in URLs, and any password, secret or token value. The archive is written with mode 0600. It still contains logs and configuration; read it before you share it."
     ],
@@ -2505,8 +2510,333 @@ var doctorBundleCommand = async (args, deps) => {
 };
 
 // src/doctor.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+
+// src/docker-shutdown.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
 import * as fs5 from "node:fs";
+import * as os3 from "node:os";
 import * as path5 from "node:path";
+var DOCKER_CAPTURE_STOP_GRACE_SECONDS = 3600;
+var DOCKERD_DEFAULT_SHUTDOWN_TIMEOUT_SECONDS = 15;
+var flagValue = (argv, name) => {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    if (arg === name) return argv[index + 1] ?? "";
+  }
+  return null;
+};
+var seconds = (value) => {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(value.trim());
+  return null;
+};
+var daemonKindOf = (info) => {
+  if (/docker desktop/i.test(info.operatingSystem)) return "desktop";
+  if (/orbstack/i.test(info.operatingSystem)) return "orbstack";
+  if (info.securityOptions.some((option) => option.includes("name=rootless"))) return "rootless";
+  return "dockerd";
+};
+var defaultConfigPath = (facts, daemon) => {
+  switch (daemon) {
+    case "desktop":
+      return path5.join(facts.home, ".docker", "daemon.json");
+    case "orbstack":
+      return path5.join(facts.home, ".orbstack", "config", "docker.json");
+    case "rootless":
+      return path5.join(
+        facts.xdgConfigHome ?? path5.join(facts.home, ".config"),
+        "docker",
+        "daemon.json"
+      );
+    case "dockerd":
+      return "/etc/docker/daemon.json";
+  }
+};
+var readShutdownTimeout = (facts) => {
+  if (facts.info === null) return { kind: "unknown", why: "docker info did not answer" };
+  const daemon = daemonKindOf(facts.info);
+  const managed = daemon === "desktop" || daemon === "orbstack";
+  const argv = managed ? null : facts.dockerdArgv;
+  const unresolved = facts.dockerdUnresolved ?? null;
+  if (argv === null && !managed && unresolved !== null) return { kind: "unknown", why: unresolved };
+  const configPath = (argv === null ? null : flagValue(argv, "--config-file")) ?? defaultConfigPath(facts, daemon);
+  if (argv !== null) {
+    const flag = flagValue(argv, "--shutdown-timeout");
+    if (flag !== null) {
+      const value = seconds(flag);
+      return value === null ? { kind: "unknown", why: `dockerd --shutdown-timeout ${flag} unreadable` } : {
+        kind: "observed",
+        seconds: value,
+        source: "dockerd --shutdown-timeout",
+        daemon,
+        configPath,
+        fromFlag: true
+      };
+    }
+  }
+  const file = facts.readFile(configPath);
+  if (file.kind === "unreadable") return { kind: "unknown", why: `${configPath} unreadable` };
+  if (file.kind === "read") {
+    let parsed;
+    try {
+      parsed = JSON.parse(file.text);
+    } catch {
+      return { kind: "unknown", why: `${configPath} is not JSON` };
+    }
+    const configured = typeof parsed === "object" && parsed !== null && "shutdown-timeout" in parsed ? parsed["shutdown-timeout"] : void 0;
+    if (configured !== void 0) {
+      const value = seconds(configured);
+      return value === null ? { kind: "unknown", why: `shutdown-timeout in ${configPath} unreadable` } : {
+        kind: "observed",
+        seconds: value,
+        source: configPath,
+        daemon,
+        configPath,
+        fromFlag: false
+      };
+    }
+  }
+  if (argv === null && !managed) {
+    return {
+      kind: "unknown",
+      why: `no dockerd process observed here \xB7 not set in ${configPath}`
+    };
+  }
+  return {
+    kind: "observed",
+    seconds: DOCKERD_DEFAULT_SHUTDOWN_TIMEOUT_SECONDS,
+    source: `dockerd default \xB7 not set in ${configPath}`,
+    daemon,
+    configPath,
+    fromFlag: false
+  };
+};
+var restartWords = (daemon) => {
+  switch (daemon) {
+    case "desktop":
+      return "restart Docker Desktop";
+    case "orbstack":
+      return "restart OrbStack";
+    case "rootless":
+      return "systemctl --user restart docker";
+    case "dockerd":
+      return "restart dockerd";
+  }
+};
+var raiseShutdownTimeoutWords = (reading, grace) => reading.fromFlag ? `raise dockerd --shutdown-timeout to ${grace}, then ${restartWords(reading.daemon)}` : `set "shutdown-timeout": ${grace} in ${reading.configPath}, then ${restartWords(reading.daemon)}`;
+var dockerShutdownCheck = (reading, grace = DOCKER_CAPTURE_STOP_GRACE_SECONDS) => {
+  if (reading.kind === "unknown") {
+    return {
+      label: "docker",
+      state: "todo",
+      detail: `shutdown-timeout not observed \xB7 ${reading.why}`,
+      fix: null
+    };
+  }
+  if (reading.seconds >= grace) {
+    return {
+      label: "docker",
+      state: "ok",
+      detail: `shutdown-timeout ${reading.seconds} s \xB7 ${reading.source} \xB7 covers the ${grace} s capture grace`,
+      fix: null
+    };
+  }
+  return {
+    label: "docker",
+    state: "todo",
+    detail: `shutdown-timeout ${reading.seconds} s \xB7 ${reading.source} \xB7 below the ${grace} s capture grace`,
+    fix: raiseShutdownTimeoutWords(reading, grace)
+  };
+};
+var dockerShutdownSetupLine = (reading, grace = DOCKER_CAPTURE_STOP_GRACE_SECONDS) => {
+  if (reading.kind === "unknown") {
+    return `Docker shutdown-timeout not observed (${reading.why}); a daemon shutdown below ${grace} s kills capture workspaces before they save. See docs/SELF-HOSTING.md.`;
+  }
+  if (reading.seconds >= grace) return null;
+  return `Docker shutdown-timeout is ${reading.seconds} s (${reading.source}), below the ${grace} s capture grace: a host restart or daemon stop kills capture workspaces after ${reading.seconds} s, before they save. To raise it: ${raiseShutdownTimeoutWords(reading, grace)}.`;
+};
+var parseDockerInfo = (stdout) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("OperatingSystem" in parsed)) return null;
+  const operatingSystem = parsed.OperatingSystem;
+  if (typeof operatingSystem !== "string") return null;
+  const options = "SecurityOptions" in parsed ? parsed.SecurityOptions : [];
+  return {
+    operatingSystem,
+    securityOptions: Array.isArray(options) ? options.filter((option) => typeof option === "string") : []
+  };
+};
+var readHostFile = (file) => {
+  try {
+    return { kind: "read", text: fs5.readFileSync(file, "utf8") };
+  } catch (cause) {
+    return cause instanceof Error && "code" in cause && cause.code === "ENOENT" ? { kind: "absent" } : { kind: "unreadable" };
+  }
+};
+var hostProcView = {
+  list: (dir) => {
+    try {
+      return fs5.readdirSync(dir);
+    } catch {
+      return null;
+    }
+  },
+  read: (file) => {
+    try {
+      return fs5.readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  link: (file) => {
+    try {
+      return fs5.readlinkSync(file);
+    } catch {
+      return null;
+    }
+  }
+};
+var DOCKER_DEFAULT_HOST = "unix:///var/run/docker.sock";
+var socketPath = (file) => file.replace(/^\/var\/run\//, "/run/");
+var unixSocketOf = (host) => host.startsWith("unix://") && host.length > "unix://".length ? socketPath(host.slice("unix://".length)) : null;
+var hostFlags = (argv) => {
+  const hosts = [];
+  for (let index = 1; index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    for (const name of ["-H", "--host"]) {
+      if (arg === name) hosts.push(argv[index + 1] ?? "");
+      else if (arg.startsWith(`${name}=`)) hosts.push(arg.slice(name.length + 1));
+    }
+  }
+  return hosts;
+};
+var listeningInodes = (table, socket) => {
+  const inodes = /* @__PURE__ */ new Set();
+  for (const line of table.split("\n").slice(1)) {
+    const fields = line.trim().split(/\s+/);
+    const flags = fields[3];
+    const inode = fields[6];
+    const bound = fields.slice(7).join(" ");
+    if (flags === void 0 || inode === void 0 || bound === "") continue;
+    if ((Number.parseInt(flags, 16) & 65536) === 0) continue;
+    if (socketPath(bound) === socket) inodes.add(inode);
+  }
+  return inodes;
+};
+var observeDockerd = (proc, host) => {
+  const daemons = [];
+  for (const entry of proc.list("/proc") ?? []) {
+    if (!/^\d+$/.test(entry)) continue;
+    const cmdline = proc.read(`/proc/${entry}/cmdline`);
+    if (cmdline === null) continue;
+    const argv = cmdline.split("\0").filter((arg) => arg !== "");
+    if (path5.basename(argv[0] ?? "") === "dockerd") daemons.push({ pid: entry, argv });
+  }
+  if (daemons.length === 0) return { kind: "none" };
+  const socket = unixSocketOf(host);
+  if (socket === null) {
+    return {
+      kind: "unresolved",
+      why: `docker talks to ${host} \xB7 not a socket on this machine`
+    };
+  }
+  const selfTable = proc.read("/proc/self/net/unix");
+  const seenHere = selfTable === null ? /* @__PURE__ */ new Set() : listeningInodes(selfTable, socket);
+  const candidates = [];
+  for (const daemon of daemons) {
+    const hosts = hostFlags(daemon.argv);
+    const named = hosts.some((value) => unixSocketOf(value) === socket);
+    const activated = hosts.some((value) => value.startsWith("fd://"));
+    if (hosts.length > 0 && !named && !activated) continue;
+    const table = proc.read(`/proc/${daemon.pid}/net/unix`);
+    const listening = table === null ? null : listeningInodes(table, socket);
+    if (listening !== null) {
+      if (listening.size === 0) continue;
+      if (seenHere.size > 0 && ![...listening].some((inode) => seenHere.has(inode))) continue;
+    }
+    const fds = proc.list(`/proc/${daemon.pid}/fd`);
+    const held = fds === null || listening === null ? null : fds.some((fd) => {
+      const target = proc.link(`/proc/${daemon.pid}/fd/${fd}`);
+      const inode = target?.match(/^socket:\[(\d+)\]$/)?.[1];
+      return inode !== void 0 && listening.has(inode);
+    });
+    if (held === false) continue;
+    const nsPids = proc.read(`/proc/${daemon.pid}/status`)?.split("\n").find((line) => line.startsWith("NSpid:"))?.slice("NSpid:".length).trim().split(/\s+/);
+    candidates.push({
+      ...daemon,
+      owns: held === true,
+      named,
+      nested: nsPids !== void 0 && nsPids.length > 1
+    });
+  }
+  const narrowed = [
+    (candidate) => candidate.owns,
+    (candidate) => candidate.named,
+    (candidate) => !candidate.nested
+  ].reduce((left, prefer) => {
+    const preferred = left.filter(prefer);
+    return preferred.length > 0 ? preferred : left;
+  }, candidates);
+  const [only, ...others] = narrowed;
+  if (only !== void 0 && others.length === 0) {
+    return { kind: "observed", pid: only.pid, argv: only.argv };
+  }
+  const seen = `${daemons.length} dockerd process${daemons.length === 1 ? "" : "es"}`;
+  return {
+    kind: "unresolved",
+    why: only === void 0 ? `${seen} \xB7 none observed serving ${socket}` : `${seen} \xB7 could not tell which serves ${socket}`
+  };
+};
+var hostDockerEndpoint = () => {
+  const fromEnv = process.env["DOCKER_HOST"];
+  if (fromEnv !== void 0 && fromEnv.trim() !== "") return fromEnv.trim();
+  const context = spawnSync2(
+    "docker",
+    ["context", "inspect", "--format", "{{.Endpoints.docker.Host}}"],
+    {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }
+  );
+  const endpoint = context.status === 0 ? context.stdout.trim() : "";
+  return endpoint === "" ? DOCKER_DEFAULT_HOST : endpoint;
+};
+var dockerdFactsOf = (observation) => {
+  switch (observation.kind) {
+    case "observed":
+      return { dockerdArgv: observation.argv, dockerdUnresolved: null };
+    case "none":
+      return { dockerdArgv: null, dockerdUnresolved: null };
+    case "unresolved":
+      return { dockerdArgv: null, dockerdUnresolved: observation.why };
+  }
+};
+var hostDockerDaemonFacts = (infoStdout) => ({
+  info: infoStdout === null ? null : parseDockerInfo(infoStdout),
+  ...dockerdFactsOf(observeDockerd(hostProcView, hostDockerEndpoint())),
+  readFile: readHostFile,
+  home: os3.homedir(),
+  xdgConfigHome: process.env["XDG_CONFIG_HOME"] ?? null
+});
+var observeHostShutdownTimeout = () => {
+  const info = spawnSync2("docker", ["info", "--format", "{{json .}}"], {
+    encoding: "utf8",
+    timeout: 3e3,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return readShutdownTimeout(hostDockerDaemonFacts(info.status === 0 ? info.stdout : null));
+};
+
+// src/doctor.ts
 var TIMEOUT_MS = 3e3;
 var MARKS = { ok: "\u2713", todo: "\u25CB", failed: "\u2717" };
 var LABEL_WIDTH = 11;
@@ -2721,13 +3051,16 @@ var runChecks = async (config, probes) => {
   const machine = signedIn ? await getJson(config, "/machine") : null;
   const exposure = machine === null || machine.value === null ? void 0 : machine.value.exposure;
   checks.push(exposure === void 0 ? notChecked("exposure") : exposureCheck(exposure));
+  if (probes.dockerShutdown !== void 0 && probes.onPath("docker")) {
+    checks.push(dockerShutdownCheck(probes.dockerShutdown()));
+  }
   return checks;
 };
 var onPath = (command) => {
-  for (const directory of (process.env["PATH"] ?? "").split(path5.delimiter)) {
+  for (const directory of (process.env["PATH"] ?? "").split(path6.delimiter)) {
     if (directory === "") continue;
     try {
-      fs5.accessSync(path5.join(directory, command), fs5.constants.X_OK);
+      fs6.accessSync(path6.join(directory, command), fs6.constants.X_OK);
       return true;
     } catch {
     }
@@ -2740,15 +3073,20 @@ var paintMark = (state, mark) => {
   return `\x1B[${code}m${mark}\x1B[0m`;
 };
 var doctorCommand = async (config, localCredential2, claudeGrant2) => {
-  const checks = await runChecks(config, { localCredential: localCredential2, claudeGrant: claudeGrant2, onPath });
+  const checks = await runChecks(config, {
+    localCredential: localCredential2,
+    claudeGrant: claudeGrant2,
+    onPath,
+    dockerShutdown: observeHostShutdownTimeout
+  });
   for (const check of checks) process.stdout.write(`${formatCheck(check, paintMark)}
 `);
   if (checks.some((check) => check.state === "failed")) process.exitCode = 1;
 };
 
 // src/dotfiles.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 var DOTFILE_CANDIDATES = [
   {
     group: "shell",
@@ -2791,7 +3129,7 @@ var DOTFILE_CANDIDATES = [
 var MAX_FILE_BYTES = 1024 * 1024;
 var statFile = (home, relative4) => {
   try {
-    const stat = fs6.statSync(path6.join(home, relative4));
+    const stat = fs7.statSync(path7.join(home, relative4));
     return stat.isFile() ? stat : null;
   } catch {
     return null;
@@ -2804,9 +3142,9 @@ var scanDotfileCandidates = (home) => DOTFILE_CANDIDATES.flatMap(
   })
 );
 var homeRelativePath = (home, requested) => {
-  const relative4 = path6.relative(home, path6.resolve(home, requested));
-  const outside = relative4 === "" || relative4 === ".." || relative4.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative4);
-  return outside ? null : relative4.split(path6.sep).join("/");
+  const relative4 = path7.relative(home, path7.resolve(home, requested));
+  const outside = relative4 === "" || relative4 === ".." || relative4.startsWith(`..${path7.sep}`) || path7.isAbsolute(relative4);
+  return outside ? null : relative4.split(path7.sep).join("/");
 };
 var readSyncFiles = (home, paths_) => {
   const files = [];
@@ -2826,7 +3164,7 @@ var readSyncFiles = (home, paths_) => {
     }
     files.push({
       path: relative4,
-      contentsBase64: fs6.readFileSync(path6.join(home, relative4)).toString("base64"),
+      contentsBase64: fs7.readFileSync(path7.join(home, relative4)).toString("base64"),
       // eslint-disable-next-line no-bitwise -- permission bits are the point
       mode: (stat.mode & 511).toString(8)
     });
@@ -2925,10 +3263,10 @@ var parseGitAuthorArgs = (args) => {
 var gitAuthorLine = (author) => `${author.name} <${author.email}> \xB7 ${author.source === "setting" ? "your setting" : "your account's name and email"}`;
 
 // src/landing.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs7 from "node:fs";
-import * as os3 from "node:os";
-import * as path7 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import * as fs8 from "node:fs";
+import * as os4 from "node:os";
+import * as path8 from "node:path";
 var paint = (code) => (text) => process.stdout.isTTY === true ? `[${code}m${text}[0m` : text;
 var dim = paint("2");
 var green = paint("32");
@@ -3143,7 +3481,7 @@ var landCommand = async (api2, args) => {
   if (!landingSucceeded(report)) process.exitCode = 1;
 };
 var git = (cwd, args) => {
-  const result = spawnSync2("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync3("git", args, { cwd, encoding: "utf8" });
   return {
     status: result.status ?? 1,
     stdout: result.stdout ?? "",
@@ -3166,9 +3504,9 @@ var gitRemotes = (cwd) => {
 var remoteForOrigin = (remotes, originUrl, cwd) => {
   if (originUrl === null) return null;
   const origin = normalizeRemoteUrl(originUrl);
-  const originPath = origin === null ? path7.resolve(originUrl.replace(/^file:\/\//, "")) : null;
+  const originPath = origin === null ? path8.resolve(originUrl.replace(/^file:\/\//, "")) : null;
   return remotes.find(
-    (remote) => origin === null ? path7.resolve(cwd, remote.url.replace(/^file:\/\//, "")) === originPath : normalizeRemoteUrl(remote.url) === origin
+    (remote) => origin === null ? path8.resolve(cwd, remote.url.replace(/^file:\/\//, "")) === originPath : normalizeRemoteUrl(remote.url) === origin
   ) ?? null;
 };
 var LOG_LINES = 10;
@@ -3191,10 +3529,10 @@ var fetchBundle = (cwd, bundle) => {
   const before = git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
   const previous = before.status === 0 ? before.stdout.trim() : null;
   if (previous !== bundle.tip) {
-    const dir = fs7.mkdtempSync(path7.join(os3.tmpdir(), "mend-pull-"));
+    const dir = fs8.mkdtempSync(path8.join(os4.tmpdir(), "mend-pull-"));
     try {
-      const file = path7.join(dir, "change.bundle");
-      fs7.writeFileSync(file, bundle.bytes, { mode: 384 });
+      const file = path8.join(dir, "change.bundle");
+      fs8.writeFileSync(file, bundle.bytes, { mode: 384 });
       const fetched = git(cwd, [
         "fetch",
         "--no-tags",
@@ -3204,7 +3542,7 @@ var fetchBundle = (cwd, bundle) => {
       ]);
       if (fetched.status !== 0) return refusedWith(gitWords(fetched));
     } finally {
-      fs7.rmSync(dir, { recursive: true, force: true });
+      fs8.rmSync(dir, { recursive: true, force: true });
     }
   }
   const after = git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).stdout.trim();
@@ -3321,9 +3659,81 @@ 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 os4 from "node:os";
+import * as os5 from "node:os";
 
 // src/pair.ts
 var paint2 = (code) => (text) => process.stdout.isTTY === true ? `\x1B[${code}m${text}\x1B[0m` : text;
@@ -3492,8 +3902,8 @@ var post = async (url, body) => {
 };
 var retryAfterSecondsOf = (json2) => {
   if (typeof json2 === "object" && json2 !== null && "retryAfterSeconds" in json2) {
-    const seconds = Number(json2.retryAfterSeconds);
-    if (Number.isFinite(seconds) && seconds > 0) return seconds;
+    const seconds2 = Number(json2.retryAfterSeconds);
+    if (Number.isFinite(seconds2) && seconds2 > 0) return seconds2;
   }
   return 5;
 };
@@ -3515,7 +3925,7 @@ var resolveServerUrl = async (args, deps) => {
 };
 var loginCommand = async (args, deps) => {
   const base = await resolveServerUrl(args, deps);
-  const started = await post(`${base}/api/cli/auth`, { name: os4.hostname() });
+  const started = await post(`${base}/api/cli/auth`, { name: os5.hostname() });
   if (started.status === 429) {
     return fail3(
       `the server asked for a pause \u2014 try again in ${retryAfterSecondsOf(started.json)}s`
@@ -3566,8 +3976,8 @@ var loginCommand = async (args, deps) => {
 };
 
 // src/organization.ts
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
 var paint4 = (code) => (text) => process.stdout.isTTY === true ? `[${code}m${text}[0m` : text;
 var dim4 = paint4("2");
 var green4 = paint4("32");
@@ -3631,7 +4041,7 @@ var scanFolder = (dir) => {
   const files = [];
   const skipped = [];
   const walk = (relative4) => {
-    const entries = fs8.readdirSync(path8.join(dir, relative4), { withFileTypes: true }).toSorted((a, b) => a.name.localeCompare(b.name));
+    const entries = fs9.readdirSync(path9.join(dir, relative4), { withFileTypes: true }).toSorted((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const child = relative4 === "" ? entry.name : `${relative4}/${entry.name}`;
       if (entry.isSymbolicLink()) {
@@ -3640,7 +4050,7 @@ var scanFolder = (dir) => {
         if (SKIPPED_DIRECTORIES.has(entry.name)) skipped.push({ path: child, reason: "skipped" });
         else walk(child);
       } else if (entry.isFile()) {
-        const size = fs8.statSync(path8.join(dir, child)).size;
+        const size = fs9.statSync(path9.join(dir, child)).size;
         if (size > FOLDER_FILE_BYTES) skipped.push({ path: child, reason: "over 1 MiB" });
         else files.push({ path: child, size });
       }
@@ -3693,7 +4103,7 @@ var folderCommand = async (api2, args) => {
     }
     case "push": {
       if (dir === void 0) return fail4("usage: mend folder push <name> <dir> [--replace]");
-      if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) {
+      if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
         return fail4(`${dir} is not a directory`);
       }
       const folder = await folderNamed(api2, name);
@@ -3708,7 +4118,7 @@ var folderCommand = async (api2, args) => {
           files: batch.map((file) => ({
             path: file.path,
             // Read one batch at a time, so a large tree never sits in memory at once.
-            contentsBase64: fs8.readFileSync(path8.join(dir, file.path)).toString("base64")
+            contentsBase64: fs9.readFileSync(path9.join(dir, file.path)).toString("base64")
           })),
           // --replace empties the folder with the first batch; the rest add to it.
           merge: !(replace && index === 0)
@@ -3892,8 +4302,8 @@ var operatorCommand = async (api2, tryApi, baseUrl, args) => {
 import { createHmac, randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import * as net2 from "node:net";
-import * as os6 from "node:os";
-import * as path10 from "node:path";
+import * as os7 from "node:os";
+import * as path11 from "node:path";
 
 // src/server-docker-volumes.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -4111,9 +4521,9 @@ var verifyServerDockerVolumes = (runtime, input) => ownership(runtime, input, "v
 
 // src/server-store.ts
 import { randomUUID } from "node:crypto";
-import * as fs9 from "node:fs";
-import * as os5 from "node:os";
-import * as path9 from "node:path";
+import * as fs10 from "node:fs";
+import * as os6 from "node:os";
+import * as path10 from "node:path";
 var ServerStoreError = class extends Error {
   _tag = "ServerStoreError";
 };
@@ -4134,28 +4544,28 @@ var attempt = (operation) => {
 var hasCode = (cause, code) => cause instanceof Error && "code" in cause && cause.code === code;
 var readOptional = (file) => {
   try {
-    return fs9.readFileSync(file, "utf8");
+    return fs10.readFileSync(file, "utf8");
   } catch (cause) {
     if (hasCode(cause, "ENOENT")) return null;
     throw cause;
   }
 };
 var syncDirectory = (directory) => {
-  const fd = fs9.openSync(directory, "r");
+  const fd = fs10.openSync(directory, "r");
   try {
-    fs9.fsyncSync(fd);
+    fs10.fsyncSync(fd);
   } finally {
-    fs9.closeSync(fd);
+    fs10.closeSync(fd);
   }
 };
 var writeDurable = (file, content, mode = 384) => {
-  const fd = fs9.openSync(file, "wx", mode);
+  const fd = fs10.openSync(file, "wx", mode);
   try {
-    fs9.writeFileSync(fd, content, "utf8");
-    fs9.fchmodSync(fd, mode);
-    fs9.fsyncSync(fd);
+    fs10.writeFileSync(fd, content, "utf8");
+    fs10.fchmodSync(fd, mode);
+    fs10.fsyncSync(fd);
   } finally {
-    fs9.closeSync(fd);
+    fs10.closeSync(fd);
   }
 };
 var fileKeys = ["identity", "config", "env", "compose", "postgresInit"];
@@ -4175,11 +4585,11 @@ var parseLockOwner = (raw) => {
 };
 var describeOwner = (lockDir) => {
   try {
-    const raw = JSON.parse(fs9.readFileSync(path9.join(lockDir, "owner.json"), "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(path10.join(lockDir, "owner.json"), "utf8"));
     const owner = parseLockOwner(raw);
     if (owner === null) return "owner metadata is invalid";
     const label = `PID ${owner.pid} on ${owner.hostname}`;
-    if (owner.hostname !== os5.hostname()) return label;
+    if (owner.hostname !== os6.hostname()) return label;
     try {
       process.kill(owner.pid, 0);
       return `${label} is still live`;
@@ -4195,28 +4605,28 @@ var lockGuidance = (lockDir) => new ServerStoreError(
 );
 var acquireLock = (configDir, create) => {
   if (create) {
-    fs9.mkdirSync(configDir, { recursive: true, mode: 448 });
-    fs9.chmodSync(configDir, 448);
-  } else if (!fs9.existsSync(configDir)) {
+    fs10.mkdirSync(configDir, { recursive: true, mode: 448 });
+    fs10.chmodSync(configDir, 448);
+  } else if (!fs10.existsSync(configDir)) {
     throw new ServerStoreError(
       "No Mend server is configured. Run mend server setup explicitly to install one."
     );
   }
-  const lockDir = path9.join(configDir, "server.lock");
+  const lockDir = path10.join(configDir, "server.lock");
   try {
-    fs9.mkdirSync(lockDir, { mode: 448 });
+    fs10.mkdirSync(lockDir, { mode: 448 });
   } catch (cause) {
     if (hasCode(cause, "EEXIST")) throw lockGuidance(lockDir);
     throw cause;
   }
-  const owned = fs9.statSync(lockDir);
-  const ownerFile = path9.join(lockDir, "owner.json");
-  const owner = `${JSON.stringify({ pid: process.pid, hostname: os5.hostname(), token: randomUUID() })}
+  const owned = fs10.statSync(lockDir);
+  const ownerFile = path10.join(lockDir, "owner.json");
+  const owner = `${JSON.stringify({ pid: process.pid, hostname: os6.hostname(), token: randomUUID() })}
 `;
   let open = true;
   const assertOwned = () => {
-    const current = fs9.statSync(lockDir);
-    if (!open || current.dev !== owned.dev || current.ino !== owned.ino || fs9.readFileSync(ownerFile, "utf8") !== owner) {
+    const current = fs10.statSync(lockDir);
+    if (!open || current.dev !== owned.dev || current.ino !== owned.ino || fs10.readFileSync(ownerFile, "utf8") !== owner) {
       throw new ServerStoreError(
         "Server lock ownership was lost. Stop and check for another server command before retrying."
       );
@@ -4232,8 +4642,8 @@ var acquireLock = (configDir, create) => {
     release: () => {
       const result = attempt(() => {
         assertOwned();
-        fs9.unlinkSync(ownerFile);
-        fs9.rmdirSync(lockDir);
+        fs10.unlinkSync(ownerFile);
+        fs10.rmdirSync(lockDir);
       });
       open = false;
       return result;
@@ -4242,7 +4652,7 @@ var acquireLock = (configDir, create) => {
 };
 var readIdentity = (paths) => {
   const identity = readOptional(paths.identity);
-  if (identity === null && (fs9.existsSync(paths.active) || fs9.existsSync(paths.generations) && fs9.readdirSync(paths.generations).length > 0)) {
+  if (identity === null && (fs10.existsSync(paths.active) || fs10.existsSync(paths.generations) && fs10.readdirSync(paths.generations).length > 0)) {
     throw new ServerStoreError(
       "Server identity.env is missing. Restore it from a retained generation or backup; refusing to generate replacement credentials."
     );
@@ -4252,7 +4662,7 @@ var readIdentity = (paths) => {
 var readActive = (paths) => {
   let target;
   try {
-    target = fs9.readlinkSync(paths.active);
+    target = fs10.readlinkSync(paths.active);
   } catch (cause) {
     if (hasCode(cause, "ENOENT")) return null;
     throw cause;
@@ -4262,13 +4672,13 @@ var readActive = (paths) => {
       "Server active pointer is invalid. Restore the symlink to a retained generation before retrying."
     );
   }
-  const directory = path9.join(paths.configDir, target);
+  const directory = path10.join(paths.configDir, target);
   const files = {
-    identity: fs9.readFileSync(path9.join(directory, fileNames.identity), "utf8"),
-    config: fs9.readFileSync(path9.join(directory, fileNames.config), "utf8"),
-    env: fs9.readFileSync(path9.join(directory, fileNames.env), "utf8"),
-    compose: fs9.readFileSync(path9.join(directory, fileNames.compose), "utf8"),
-    postgresInit: fs9.readFileSync(path9.join(directory, fileNames.postgresInit), "utf8")
+    identity: fs10.readFileSync(path10.join(directory, fileNames.identity), "utf8"),
+    config: fs10.readFileSync(path10.join(directory, fileNames.config), "utf8"),
+    env: fs10.readFileSync(path10.join(directory, fileNames.env), "utf8"),
+    compose: fs10.readFileSync(path10.join(directory, fileNames.compose), "utf8"),
+    postgresInit: fs10.readFileSync(path10.join(directory, fileNames.postgresInit), "utf8")
   };
   if (readIdentity(paths) !== files.identity) {
     throw new ServerStoreError(
@@ -4278,20 +4688,20 @@ var readActive = (paths) => {
   return { directory, files };
 };
 var publishIdentity = (paths, identity) => {
-  const temporary = path9.join(paths.configDir, `.identity-${randomUUID()}`);
+  const temporary = path10.join(paths.configDir, `.identity-${randomUUID()}`);
   writeDurable(temporary, identity);
-  fs9.linkSync(temporary, paths.identity);
+  fs10.linkSync(temporary, paths.identity);
   syncDirectory(paths.configDir);
-  fs9.unlinkSync(temporary);
+  fs10.unlinkSync(temporary);
 };
 var prepareGeneration = (paths, files) => {
-  fs9.mkdirSync(paths.generations, { recursive: true, mode: 448 });
+  fs10.mkdirSync(paths.generations, { recursive: true, mode: 448 });
   const generationName = `gen-${randomUUID()}`;
-  const directory = path9.join(paths.generations, generationName);
-  fs9.mkdirSync(directory, { mode: 448 });
+  const directory = path10.join(paths.generations, generationName);
+  fs10.mkdirSync(directory, { mode: 448 });
   for (const key of fileKeys) {
     writeDurable(
-      path9.join(directory, fileNames[key]),
+      path10.join(directory, fileNames[key]),
       files[key],
       key === "postgresInit" ? 493 : 384
     );
@@ -4302,18 +4712,18 @@ var prepareGeneration = (paths, files) => {
   return { directory, files };
 };
 var activateGeneration = (paths, generation) => {
-  const relative4 = path9.relative(paths.configDir, generation.directory);
-  if (!/^generations\/gen-[0-9a-f-]{36}$/.test(relative4) || readIdentity(paths) !== fs9.readFileSync(path9.join(generation.directory, "identity.env"), "utf8")) {
+  const relative4 = path10.relative(paths.configDir, generation.directory);
+  if (!/^generations\/gen-[0-9a-f-]{36}$/.test(relative4) || readIdentity(paths) !== fs10.readFileSync(path10.join(generation.directory, "identity.env"), "utf8")) {
     throw new ServerStoreError("Cannot activate a generation outside this installation identity.");
   }
   for (const key of fileKeys) {
-    if (fs9.readFileSync(path9.join(generation.directory, fileNames[key]), "utf8") !== generation.files[key]) {
+    if (fs10.readFileSync(path10.join(generation.directory, fileNames[key]), "utf8") !== generation.files[key]) {
       throw new ServerStoreError("Cannot activate an incomplete or changed server generation.");
     }
   }
-  const pointer = path9.join(paths.configDir, `.active-${randomUUID()}`);
-  fs9.symlinkSync(relative4, pointer);
-  fs9.renameSync(pointer, paths.active);
+  const pointer = path10.join(paths.configDir, `.active-${randomUUID()}`);
+  fs10.symlinkSync(relative4, pointer);
+  fs10.renameSync(pointer, paths.active);
   syncDirectory(paths.configDir);
 };
 var prepareFiles = (paths, files) => {
@@ -4322,7 +4732,7 @@ var prepareFiles = (paths, files) => {
     throw new ServerStoreError("Server identity already exists; refusing to replace credentials.");
   }
   const active = readActive(paths);
-  if (active !== null && fileKeys.every((key) => files[key] === active.files[key]) && (fs9.statSync(path9.join(active.directory, fileNames.postgresInit)).mode & 4095) === 493)
+  if (active !== null && fileKeys.every((key) => files[key] === active.files[key]) && (fs10.statSync(path10.join(active.directory, fileNames.postgresInit)).mode & 4095) === 493)
     return active;
   if (identity === null) publishIdentity(paths, files.identity);
   return prepareGeneration(paths, files);
@@ -4335,9 +4745,9 @@ var commitGeneration = (paths, files) => {
 var createStore = (configDir, lock) => {
   const paths = {
     configDir,
-    identity: path9.join(configDir, "identity.env"),
-    generations: path9.join(configDir, "generations"),
-    active: path9.join(configDir, "active")
+    identity: path10.join(configDir, "identity.env"),
+    generations: path10.join(configDir, "generations"),
+    active: path10.join(configDir, "active")
   };
   const whileOwned = (operation) => attempt(() => {
     lock.assertOwned();
@@ -4350,13 +4760,13 @@ var createStore = (configDir, lock) => {
     prepare: (files) => whileOwned(() => prepareFiles(paths, files)),
     activate: (generation) => whileOwned(() => activateGeneration(paths, generation)),
     createBackup: (previous, target) => whileOwned(() => {
-      const backups = path9.join(configDir, "backups");
-      fs9.mkdirSync(backups, { recursive: true, mode: 448 });
-      fs9.chmodSync(backups, 448);
-      const directory = path9.join(backups, `upgrade-${randomUUID()}`);
-      fs9.mkdirSync(directory, { mode: 448 });
+      const backups = path10.join(configDir, "backups");
+      fs10.mkdirSync(backups, { recursive: true, mode: 448 });
+      fs10.chmodSync(backups, 448);
+      const directory = path10.join(backups, `upgrade-${randomUUID()}`);
+      fs10.mkdirSync(directory, { mode: 448 });
       writeDurable(
-        path9.join(directory, "recovery.json"),
+        path10.join(directory, "recovery.json"),
         `${JSON.stringify(
           {
             previousGeneration: previous.directory,
@@ -4372,21 +4782,21 @@ var createStore = (configDir, lock) => {
       syncDirectory(directory);
       syncDirectory(backups);
       syncDirectory(configDir);
-      const partialFile = path9.join(directory, "database.sql.partial");
+      const partialFile = path10.join(directory, "database.sql.partial");
       return {
         directory,
         partialFile,
         complete: () => whileOwned(() => {
-          if (fs9.statSync(partialFile).size === 0)
+          if (fs10.statSync(partialFile).size === 0)
             throw new ServerStoreError("Database backup is empty; refusing target startup.");
-          const fd = fs9.openSync(partialFile, "r");
+          const fd = fs10.openSync(partialFile, "r");
           try {
-            fs9.fchmodSync(fd, 384);
-            fs9.fsyncSync(fd);
+            fs10.fchmodSync(fd, 384);
+            fs10.fsyncSync(fd);
           } finally {
-            fs9.closeSync(fd);
+            fs10.closeSync(fd);
           }
-          fs9.renameSync(partialFile, path9.join(directory, "database.sql"));
+          fs10.renameSync(partialFile, path10.join(directory, "database.sql"));
           syncDirectory(directory);
         })
       };
@@ -4395,7 +4805,7 @@ var createStore = (configDir, lock) => {
 };
 var refuseFlatLayout = (configDir) => {
   if (["server.json", "server.env", "compose.yaml", "postgres-init.sh"].some(
-    (name) => fs9.existsSync(path9.join(configDir, name))
+    (name) => fs10.existsSync(path10.join(configDir, name))
   )) {
     throw new ServerStoreError(
       "Unreleased flat server configuration found. Preserve its credentials and volumes; migrate it to the generation layout before retrying. Setup will not replace this identity."
@@ -4403,7 +4813,7 @@ var refuseFlatLayout = (configDir) => {
   }
 };
 var withServerStore = async (directory, operation, options = {}) => {
-  const configDir = path9.resolve(directory);
+  const configDir = path10.resolve(directory);
   let lock;
   let result;
   try {
@@ -4420,9 +4830,9 @@ var withServerStore = async (directory, operation, options = {}) => {
 };
 
 // src/version.ts
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 var cliVersion = () => {
-  const raw = fs10.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  const raw = fs11.readFileSync(new URL("../package.json", import.meta.url), "utf8");
   const parsed = JSON.parse(raw);
   if (typeof parsed === "object" && parsed !== null && "version" in parsed) {
     const version = parsed.version;
@@ -4554,21 +4964,21 @@ var parseSetupOptions = (args) => {
     previous.push(value);
     values.set(flag, previous);
   }
-  const flagValue2 = (flag) => values.get(flag)?.[0];
-  const version = flagValue2("--version");
-  const appPort = flagValue2("--port");
-  const sshPort = flagValue2("--ssh-port");
+  const flagValue3 = (flag) => values.get(flag)?.[0];
+  const version = flagValue3("--version");
+  const appPort = flagValue3("--port");
+  const sshPort = flagValue3("--ssh-port");
   const origins = values.get("--origin");
   return {
-    context: flagValue2("--context"),
+    context: flagValue3("--context"),
     version: version === void 0 ? void 0 : parseVersion(version),
-    bind: flagValue2("--bind"),
-    url: flagValue2("--url"),
+    bind: flagValue3("--bind"),
+    url: flagValue3("--url"),
     origins: origins === void 0 ? void 0 : origins,
     appPort: appPort === void 0 ? void 0 : parsePort(appPort, "--port"),
     sshPort: sshPort === void 0 ? void 0 : parsePort(sshPort, "--ssh-port"),
-    dockerSocket: flagValue2("--docker-socket"),
-    assetsDir: flagValue2("--assets-dir"),
+    dockerSocket: flagValue3("--docker-socket"),
+    assetsDir: flagValue3("--assets-dir"),
     offline: values.has("--offline")
   };
 };
@@ -5125,7 +5535,7 @@ var resolveServerVersion = async (runtime, options, existing) => {
   return version;
 };
 var parseDockerSocketPath = (socket) => {
-  if (!path10.isAbsolute(socket) || /[\r\n$'"#:\\]/.test(socket)) {
+  if (!path11.isAbsolute(socket) || /[\r\n$'"#:\\]/.test(socket)) {
     throw setupError(
       "--docker-socket must be an absolute path without line breaks or Compose interpolation characters."
     );
@@ -5151,8 +5561,8 @@ var resolveAssets = async (runtime, serverVersion, existing, store, options) =>
   if (options.assetsDir !== void 0) {
     try {
       const [compose2, postgresInit2] = await Promise.all([
-        readFile(path10.join(options.assetsDir, COMPOSE_ASSET), "utf8"),
-        readFile(path10.join(options.assetsDir, POSTGRES_INIT_ASSET), "utf8")
+        readFile(path11.join(options.assetsDir, COMPOSE_ASSET), "utf8"),
+        readFile(path11.join(options.assetsDir, POSTGRES_INIT_ASSET), "utf8")
       ]);
       validateComposeAsset(compose2);
       validatePostgresAsset(postgresInit2);
@@ -5344,6 +5754,19 @@ var setupServer = async (args, runtime, store) => {
   };
   const assets = await resolveAssets(runtime, serverVersion, existing, store, options);
   const bucket = composeBucket(assets.compose);
+  if (bucket !== void 0 && runtime.dockerDaemonFacts !== void 0) {
+    const info = await runtime.run("docker", [
+      "--context",
+      selectedContext.name,
+      "info",
+      "--format",
+      "{{json .}}"
+    ]);
+    const line = dockerShutdownSetupLine(
+      readShutdownTimeout(runtime.dockerDaemonFacts(info.status === 0 ? info.stdout : null))
+    );
+    if (line !== null) runtime.writeLine(line);
+  }
   const config = {
     ...configWithoutBucket,
     ...bucket === void 0 ? {} : { bucket }
@@ -5665,10 +6088,10 @@ var manageServer = async (command, args, runtime, store) => {
 };
 var nodeServerRuntime = () => {
   const environment = { ...process.env };
-  const home = os6.homedir();
-  const configHome = environment["XDG_CONFIG_HOME"] ?? path10.join(home, ".config");
+  const home = os7.homedir();
+  const configHome = environment["XDG_CONFIG_HOME"] ?? path11.join(home, ".config");
   return {
-    configDir: path10.join(configHome, "mend"),
+    configDir: path11.join(configHome, "mend"),
     platform: process.platform,
     cliVersion: cliVersion(),
     run: (command, args, options) => runServerProcess(command, args, environment, options),
@@ -5687,7 +6110,8 @@ var nodeServerRuntime = () => {
     randomBytes,
     sleep: (milliseconds) => new Promise((resolve7) => setTimeout(resolve7, milliseconds)),
     writeLine: (line) => process.stdout.write(`${line}
-`)
+`),
+    dockerDaemonFacts: hostDockerDaemonFacts
   };
 };
 var serverCommand = async (args, runtime = nodeServerRuntime()) => {
@@ -6120,8 +6544,8 @@ var createServiceTunnels = (options) => {
 };
 
 // src/skills.ts
-import * as fs11 from "node:fs";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
 var DEFAULT_SKILLS_DIR = ".agents/skills";
 var MAX_SKILL_FILES = 64;
 var MAX_SKILL_FILE_BYTES = 512 * 1024;
@@ -6144,12 +6568,12 @@ var readFrontmatterDescription = (contents) => {
 var walkFiles = (root) => {
   const found = [];
   const visit = (dir) => {
-    for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const absolute = path11.join(dir, entry.name);
+      const absolute = path12.join(dir, entry.name);
       let stat;
       try {
-        stat = fs11.statSync(absolute);
+        stat = fs12.statSync(absolute);
       } catch {
         continue;
       }
@@ -6163,7 +6587,7 @@ var walkFiles = (root) => {
 var scanSkillLibrary = (root) => {
   let entries;
   try {
-    entries = fs11.readdirSync(root, { withFileTypes: true });
+    entries = fs12.readdirSync(root, { withFileTypes: true });
   } catch {
     return { error: `${root} is not a readable directory` };
   }
@@ -6171,23 +6595,23 @@ var scanSkillLibrary = (root) => {
   const notes = [];
   for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
     if (entry.name.startsWith(".")) continue;
-    const skillDir = path11.join(root, entry.name);
+    const skillDir = path12.join(root, entry.name);
     let stat;
     try {
-      stat = fs11.statSync(skillDir);
+      stat = fs12.statSync(skillDir);
     } catch {
       continue;
     }
     if (!stat.isDirectory()) continue;
-    if (!fs11.existsSync(path11.join(skillDir, "SKILL.md"))) {
+    if (!fs12.existsSync(path12.join(skillDir, "SKILL.md"))) {
       notes.push({ skill: entry.name, message: "no SKILL.md \u2014 skipped" });
       continue;
     }
     const files = [];
     let bytes = 0;
     for (const absolute of walkFiles(skillDir)) {
-      const relative4 = path11.relative(skillDir, absolute).split(path11.sep).join("/");
-      const buffer = fs11.readFileSync(absolute);
+      const relative4 = path12.relative(skillDir, absolute).split(path12.sep).join("/");
+      const buffer = fs12.readFileSync(absolute);
       if (buffer.byteLength > MAX_SKILL_FILE_BYTES) {
         notes.push({ skill: entry.name, message: `${relative4} is over 512KB \u2014 skipped` });
         continue;
@@ -6222,16 +6646,16 @@ var scanSkillLibrary = (root) => {
 };
 
 // src/ssh-setup.ts
-import * as os8 from "node:os";
-import * as path13 from "node:path";
+import * as os9 from "node:os";
+import * as path14 from "node:path";
 
 // ../../packages/workspace-ssh/src/index.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import { isIP as isIP2 } from "node:net";
-import * as os7 from "node:os";
-import * as path12 from "node:path";
+import * as os8 from "node:os";
+import * as path13 from "node:path";
 var LEGACY_BLOCK_BEGIN = "# >>> mend workspace ssh (managed by `mend ssh setup`) >>>";
 var LEGACY_BLOCK_END = "# <<< mend workspace ssh <<<";
 var WorkspaceSshError = class extends Error {
@@ -6318,8 +6742,8 @@ var blockBegin = (alias) => `# >>> mend workspace ssh ${alias} (managed) >>>`;
 var blockEnd = (alias) => `# <<< mend workspace ssh ${alias} <<<`;
 var hasControls = (value) => /[\p{Cc}\p{Zl}\p{Zp}]/u.test(value);
 var parseIdentityPath = (value) => {
-  const resolved = path12.resolve(
-    value.startsWith("~/") ? path12.join(os7.homedir(), value.slice(2)) : value
+  const resolved = path13.resolve(
+    value.startsWith("~/") ? path13.join(os8.homedir(), value.slice(2)) : value
   );
   if (value === "" || hasControls(value) || hasControls(resolved) || value.includes("${") || resolved.includes("${")) {
     return failure(
@@ -6465,7 +6889,7 @@ var workspaceSshPublicKeyFingerprint = (publicKey) => {
 var publicKeyIdentity = (publicKey) => publicKey.trim().split(/\s+/).slice(0, 2).join(" ");
 var agentKeys = () => {
   if (!process.env["SSH_AUTH_SOCK"]) return [];
-  const listed = spawnSync3("ssh-add", ["-L"], {
+  const listed = spawnSync4("ssh-add", ["-L"], {
     encoding: "utf8",
     timeout: 3e3,
     stdio: ["ignore", "pipe", "pipe"],
@@ -6475,7 +6899,7 @@ var agentKeys = () => {
 };
 var readText = (file) => {
   try {
-    return success(fs12.readFileSync(file, "utf8"));
+    return success(fs13.readFileSync(file, "utf8"));
   } catch (cause) {
     const error = cause instanceof Error && "code" in cause ? cause.code : void 0;
     return error === "ENOENT" ? success("") : failure(new WorkspaceSshError("key", `Could not read ${file}.`, cause));
@@ -6502,7 +6926,7 @@ var readRequiredKey = (keyPath, source) => {
   const privatePath = publicPath.slice(0, -".pub".length);
   const read = readText(publicPath);
   if (!read.ok) return read;
-  const derived = spawnSync3("ssh-keygen", ["-y", "-P", "", "-f", privatePath], {
+  const derived = spawnSync4("ssh-keygen", ["-y", "-P", "", "-f", privatePath], {
     encoding: "utf8",
     timeout: 3e3,
     stdio: ["ignore", "pipe", "pipe"],
@@ -6533,19 +6957,19 @@ var readRequiredKey = (keyPath, source) => {
 var readOptionalKey = (keyPath) => {
   const parsed = parseIdentityPath(keyPath);
   if (!parsed.ok) return parsed;
-  if (!fs12.existsSync(parsed.value) && !fs12.existsSync(publicKeyPath(parsed.value)))
+  if (!fs13.existsSync(parsed.value) && !fs13.existsSync(publicKeyPath(parsed.value)))
     return success(null);
   return readRequiredKey(parsed.value, "existing");
 };
 var pinAgentKey = (configHome, publicKey) => {
-  const identityFile = path12.resolve(
+  const identityFile = path13.resolve(
     configHome,
     "ssh",
     `agent-${hashIdentity(publicKeyIdentity(publicKey))}.pub`
   );
   try {
-    fs12.mkdirSync(path12.dirname(identityFile), { recursive: true, mode: 448 });
-    fs12.writeFileSync(identityFile, `${publicKey}
+    fs13.mkdirSync(path13.dirname(identityFile), { recursive: true, mode: 448 });
+    fs13.writeFileSync(identityFile, `${publicKey}
 `, { mode: 384 });
     return success({ publicKey, identityFile, source: "agent" });
   } catch (cause) {
@@ -6556,15 +6980,15 @@ var pinAgentKey = (configHome, publicKey) => {
 };
 var generateDedicatedKey = (privatePath) => {
   try {
-    fs12.mkdirSync(path12.dirname(privatePath), { recursive: true, mode: 448 });
+    fs13.mkdirSync(path13.dirname(privatePath), { recursive: true, mode: 448 });
   } catch (cause) {
     return failure(
-      new WorkspaceSshError("key", `Could not create ${path12.dirname(privatePath)}.`, cause)
+      new WorkspaceSshError("key", `Could not create ${path13.dirname(privatePath)}.`, cause)
     );
   }
-  const generated = spawnSync3(
+  const generated = spawnSync4(
     "ssh-keygen",
-    ["-t", "ed25519", "-f", privatePath, "-N", "", "-C", `mend-${os7.hostname()}`],
+    ["-t", "ed25519", "-f", privatePath, "-N", "", "-C", `mend-${os8.hostname()}`],
     { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "pipe"] }
   );
   if (generated.status !== 0) {
@@ -6588,7 +7012,7 @@ var generateDedicatedKey = (privatePath) => {
   return fresh;
 };
 var dedicatedKey = (configHome, create) => {
-  const privatePath = path12.join(configHome, "ssh", "id_ed25519");
+  const privatePath = path13.join(configHome, "ssh", "id_ed25519");
   const existing = readOptionalKey(privatePath);
   if (existing.ok === false) return failure(existing.error);
   if (existing.value !== null || !create) return existing;
@@ -6636,10 +7060,10 @@ var writeWorkspaceSshConfig = (configFile, target, identityFile) => {
   const reconciled = reconcileWorkspaceSshConfig(before.value, target, identityFile);
   if (reconciled.ok === false) return failure(reconciled.error);
   try {
-    fs12.mkdirSync(path12.dirname(configFile), { recursive: true, mode: 448 });
-    fs12.chmodSync(path12.dirname(configFile), 448);
-    fs12.writeFileSync(configFile, reconciled.value, { mode: 384 });
-    fs12.chmodSync(configFile, 384);
+    fs13.mkdirSync(path13.dirname(configFile), { recursive: true, mode: 448 });
+    fs13.chmodSync(path13.dirname(configFile), 448);
+    fs13.writeFileSync(configFile, reconciled.value, { mode: 384 });
+    fs13.chmodSync(configFile, 384);
     return success(void 0);
   } catch (cause) {
     return failure(new WorkspaceSshError("config", `Could not write ${configFile}.`, cause));
@@ -6652,8 +7076,8 @@ var dim5 = ansi("2");
 var green5 = ansi("32");
 var warn = ansi("33");
 var say5 = (line) => console.log(line);
-var sshConfigPath = () => path13.join(os8.homedir(), ".ssh", "config");
-var flagValue = (args, flag) => {
+var sshConfigPath = () => path14.join(os9.homedir(), ".ssh", "config");
+var flagValue2 = (args, flag) => {
   const index = args.indexOf(flag);
   return index === -1 || args[index + 1] === void 0 ? null : String(args[index + 1]);
 };
@@ -6670,7 +7094,7 @@ var showStatus = async (api2, cliHome, serverUrl, args) => {
   const parsedTarget = parseWorkspaceSshTarget({
     serverUrl,
     publishedPort: view.gateway.port,
-    hostnameOverride: flagValue(args, "--host")
+    hostnameOverride: flagValue2(args, "--host")
   });
   if (parsedTarget.ok === false) return showFailure(parsedTarget.error.message);
   const config = readWorkspaceSshConfig(sshConfigPath());
@@ -6707,14 +7131,14 @@ var setup = async (api2, cliHome, serverUrl, args) => {
   const parsedTarget = parseWorkspaceSshTarget({
     serverUrl,
     publishedPort: view.gateway.port,
-    hostnameOverride: flagValue(args, "--host")
+    hostnameOverride: flagValue2(args, "--host")
   });
   if (parsedTarget.ok === false) return showFailure(parsedTarget.error.message);
   const config = readWorkspaceSshConfig(sshConfigPath());
   if (config.ok === false) return showFailure(config.error.message);
   const picked = pickWorkspaceSshKey({
     configHome: cliHome,
-    explicitKeyPath: flagValue(args, "--key"),
+    explicitKeyPath: flagValue2(args, "--key"),
     configuredIdentityFile: configuredWorkspaceSshIdentityFile(config.value, parsedTarget.value),
     create: true
   });
@@ -6722,7 +7146,7 @@ var setup = async (api2, cliHome, serverUrl, args) => {
   if (picked.value === null) return showFailure("No workspace SSH key is available.");
   const registered = await api2("POST", "/workspace-ssh/keys", {
     publicKey: picked.value.publicKey,
-    name: os8.hostname()
+    name: os9.hostname()
   });
   const sourceLabel = {
     explicit: "from --key",
@@ -6764,8 +7188,8 @@ var sshCommand = async (args, api2, cliHome, serverUrl) => {
 };
 
 // src/uninstall.ts
-import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as fs14 from "node:fs";
+import * as path15 from "node:path";
 var UNINSTALL_USAGE = "usage: mend uninstall [--all | --server | --home] [--yes]";
 var parseUninstallArgs = (args) => {
   let scope = null;
@@ -6787,14 +7211,14 @@ var parseUninstallArgs = (args) => {
 var SERVER_FILES = ["identity.env", "active", "generations", "backups"];
 var countEntries = (directory) => {
   try {
-    return fs13.readdirSync(directory).length;
+    return fs14.readdirSync(directory).length;
   } catch {
     return 0;
   }
 };
 var exists = (file) => {
   try {
-    fs13.lstatSync(file);
+    fs14.lstatSync(file);
     return true;
   } catch {
     return false;
@@ -6803,7 +7227,7 @@ var exists = (file) => {
 var managedBlockCount = (sshConfigFile) => {
   let config;
   try {
-    config = fs13.readFileSync(sshConfigFile, "utf8");
+    config = fs14.readFileSync(sshConfigFile, "utf8");
   } catch {
     return 0;
   }
@@ -6827,27 +7251,27 @@ var describeUninstall = async (runtime, scope) => {
       if (!read.error.message.startsWith("No Mend server is configured")) throw read.error;
       server = "none";
     } else if (read.value === null) {
-      server = exists(path14.join(configDir, "identity.env")) ? {
+      server = exists(path15.join(configDir, "identity.env")) ? {
         version: "(no active generation)",
         appUrl: "",
         dockerContext: "",
-        generations: countEntries(path14.join(configDir, "generations")),
-        backups: countEntries(path14.join(configDir, "backups"))
+        generations: countEntries(path15.join(configDir, "generations")),
+        backups: countEntries(path15.join(configDir, "backups"))
       } : "none";
     } else {
       server = {
         version: read.value.config.serverVersion,
         appUrl: read.value.config.appUrl,
         dockerContext: read.value.config.dockerContext,
-        generations: countEntries(path14.join(configDir, "generations")),
-        backups: countEntries(path14.join(configDir, "backups"))
+        generations: countEntries(path15.join(configDir, "generations")),
+        backups: countEntries(path15.join(configDir, "backups"))
       };
     }
   }
   let home = null;
   if (scope !== "server") {
-    const cliConfig = path14.join(runtime.cliHome, "cli.json");
-    const sshDirectory = path14.join(runtime.cliHome, "ssh");
+    const cliConfig = path15.join(runtime.cliHome, "cli.json");
+    const sshDirectory = path15.join(runtime.cliHome, "ssh");
     home = {
       cliConfig: exists(cliConfig) ? cliConfig : null,
       sshDirectory: exists(sshDirectory) ? sshDirectory : null,
@@ -6979,7 +7403,7 @@ var removeServer = async (runtime, failures, leftovers) => {
         }
       }
       for (const name of SERVER_FILES) {
-        fs13.rmSync(path14.join(configDir, name), { recursive: true, force: true });
+        fs14.rmSync(path15.join(configDir, name), { recursive: true, force: true });
       }
       server.writeLine(`removed ${configDir}/{identity.env, active, generations, backups}`);
     },
@@ -6990,20 +7414,20 @@ var removeServer = async (runtime, failures, leftovers) => {
 var removeHome = async (runtime, plan, failures, leftovers) => {
   const { server } = runtime;
   if (plan.cliConfig !== null) {
-    fs13.rmSync(plan.cliConfig, { force: true });
+    fs14.rmSync(plan.cliConfig, { force: true });
     server.writeLine(`removed ${plan.cliConfig}`);
   }
   if (plan.sshDirectory !== null) {
-    fs13.rmSync(plan.sshDirectory, { recursive: true, force: true });
+    fs14.rmSync(plan.sshDirectory, { recursive: true, force: true });
     server.writeLine(`removed ${plan.sshDirectory}`);
   }
   if (plan.managedSshBlocks > 0) {
     try {
-      const before = fs13.readFileSync(runtime.sshConfigFile, "utf8");
+      const before = fs14.readFileSync(runtime.sshConfigFile, "utf8");
       const stripped = stripManagedWorkspaceSshBlocks(before);
       if (!stripped.ok) throw stripped.error;
       if (stripped.value.removed > 0) {
-        fs13.writeFileSync(runtime.sshConfigFile, stripped.value.config, { mode: 384 });
+        fs14.writeFileSync(runtime.sshConfigFile, stripped.value.config, { mode: 384 });
         server.writeLine(
           `removed ${plural(stripped.value.removed, "managed block")} from ${runtime.sshConfigFile}`
         );
@@ -7016,12 +7440,12 @@ var removeHome = async (runtime, plan, failures, leftovers) => {
   }
   let remaining = [];
   try {
-    remaining = fs13.readdirSync(runtime.cliHome);
+    remaining = fs14.readdirSync(runtime.cliHome);
   } catch {
     return;
   }
   if (remaining.length === 0) {
-    fs13.rmdirSync(runtime.cliHome);
+    fs14.rmdirSync(runtime.cliHome);
     server.writeLine(`removed ${runtime.cliHome}`);
   } else {
     leftovers.push(
@@ -7085,19 +7509,19 @@ var upgradeUrl = async (input) => {
 // src/main.ts
 var mendCliHome = () => {
   const xdg = process.env["XDG_CONFIG_HOME"];
-  const preferred = path15.join(
-    xdg === void 0 || xdg === "" ? path15.join(os9.homedir(), ".config") : xdg,
+  const preferred = path16.join(
+    xdg === void 0 || xdg === "" ? path16.join(os10.homedir(), ".config") : xdg,
     "mend"
   );
-  const legacy = path15.join(os9.homedir(), ".mend");
-  return !fs14.existsSync(preferred) && fs14.existsSync(legacy) ? legacy : preferred;
+  const legacy = path16.join(os10.homedir(), ".mend");
+  return !fs15.existsSync(preferred) && fs15.existsSync(legacy) ? legacy : preferred;
 };
-var CONFIG_PATH = path15.join(mendCliHome(), "cli.json");
+var CONFIG_PATH = path16.join(mendCliHome(), "cli.json");
 var loadConfig = () => {
   let fileConfig = {};
-  if (fs14.existsSync(CONFIG_PATH)) {
+  if (fs15.existsSync(CONFIG_PATH)) {
     try {
-      fileConfig = JSON.parse(fs14.readFileSync(CONFIG_PATH, "utf8"));
+      fileConfig = JSON.parse(fs15.readFileSync(CONFIG_PATH, "utf8"));
     } catch {
       fail6(`could not parse ${CONFIG_PATH}`);
     }
@@ -7135,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))"],
@@ -7163,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,
@@ -7170,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);
@@ -7205,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(
@@ -7219,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);
@@ -7243,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);
@@ -7258,8 +7694,11 @@ var withSpinner = async (label, work) => {
   const started = Date.now();
   let frame = 0;
   const timer = setInterval(() => {
-    const seconds = Math.round((Date.now() - started) / 1e3);
-    process.stdout.write(`\r  ${frames[frame % frames.length]} ${label} ${dim6(`${seconds}s`)} `);
+    const seconds2 = Math.round((Date.now() - started) / 1e3);
+    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 {
@@ -7269,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;
@@ -7288,7 +7773,7 @@ var adopt = async (config, args) => {
   }
   const sourceIssue = repositoryCloneUrlIssue(source);
   if (sourceIssue !== null) return fail6(sourceIssue);
-  const projectName = name ?? normalizeProjectName(path15.basename(source, ".git"));
+  const projectName = name ?? normalizeProjectName(path16.basename(source, ".git"));
   const auth = authFlagIndex !== -1 && args[authFlagIndex + 1] !== void 0 ? String(args[authFlagIndex + 1]) : null;
   if (auth !== null && auth !== "ambient" && auth !== "mend-key" && auth !== "bridge") {
     return fail6(`--auth takes "ambient", "mend-key", or "bridge", not "${auth}"`);
@@ -7337,7 +7822,7 @@ var findProject = async (config, explicit, adoptCwd = false) => {
   const sourceIssue = repositoryCloneUrlIssue(facts.originUrl);
   if (sourceIssue !== null) return fail6(sourceIssue);
   const adopted = await api(config, "POST", "/projects", {
-    name: normalizeProjectName(path15.basename(facts.repoRoot)),
+    name: normalizeProjectName(path16.basename(facts.repoRoot)),
     source: facts.originUrl
   });
   say6(`${green6("\u2713")} adopted \xB7 ${adopted.name} \xB7 ${dim6(adopted.storePath)}`);
@@ -7470,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`);
@@ -7494,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") {
@@ -7560,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;
@@ -7578,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) {
@@ -7599,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();
   }
 };
@@ -7656,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}`);
@@ -7722,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(
@@ -7734,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);
@@ -7805,6 +8371,10 @@ var stopSessions = async (config, targets, summarise) => {
     if (hold !== null) {
       say6(`${amber2("  " + hold)} \xB7 mend stop --services ${session.id.slice(0, 8)}`);
     }
+    const capture = after === null ? null : captureLineOf(after.session);
+    if (capture !== null) {
+      say6(`${amber2("  " + capture)} \xB7 the workspace stops once nothing is pending`);
+    }
     say6(`${cobalt2("  review")} \xB7 ${config.url}/sessions/${session.id}`);
   }
   if (summarise) {
@@ -7888,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);
@@ -8192,13 +8766,13 @@ var serviceRestart = async (config, args) => {
 };
 var serviceInit = async (args) => {
   const root = gitTopLevel(process.cwd()) ?? process.cwd();
-  const target = path15.join(root, "mend.toml");
-  if (fs14.existsSync(target)) {
+  const target = path16.join(root, "mend.toml");
+  if (fs15.existsSync(target)) {
     return fail6(`${target} already exists \u2014 edit it directly (init never merges)`);
   }
-  const rootFiles = fs14.readdirSync(root);
+  const rootFiles = fs15.readdirSync(root);
   const proposals = [];
-  const readRoot = (name) => fs14.readFileSync(path15.join(root, name), "utf8");
+  const readRoot = (name) => fs15.readFileSync(path16.join(root, name), "utf8");
   if (rootFiles.includes("package.json")) {
     proposals.push(...proposeFromPackageJson(readRoot("package.json"), rootFiles));
   }
@@ -8208,13 +8782,13 @@ var serviceInit = async (args) => {
   );
   for (const glob of globs) {
     const parent = glob.replace(/\/?\*+$/, "");
-    const dirs = glob.endsWith("*") ? fs14.existsSync(path15.join(root, parent)) ? fs14.readdirSync(path15.join(root, parent)).map((dir) => path15.join(parent, dir)) : [] : [glob];
+    const dirs = glob.endsWith("*") ? fs15.existsSync(path16.join(root, parent)) ? fs15.readdirSync(path16.join(root, parent)).map((dir) => path16.join(parent, dir)) : [] : [glob];
     for (const dir of dirs) {
-      const manifest = path15.join(root, dir, "package.json");
-      if (!fs14.existsSync(manifest)) continue;
+      const manifest = path16.join(root, dir, "package.json");
+      if (!fs15.existsSync(manifest)) continue;
       for (const proposal of proposeFromWorkspacePackage(
-        path15.basename(dir),
-        fs14.readFileSync(manifest, "utf8"),
+        path16.basename(dir),
+        fs15.readFileSync(manifest, "utf8"),
         rootFiles
       )) {
         if (!proposals.some((existing) => existing.name === proposal.name)) {
@@ -8258,7 +8832,7 @@ var serviceInit = async (args) => {
       return;
     }
   }
-  fs14.writeFileSync(target, toml);
+  fs15.writeFileSync(target, toml);
   say6(`${green6("\u2713")} wrote ${target} \u2014 commit it, then: mend service run ${proposals[0]?.name}`);
 };
 var tunnelServices = async (config, services, portOverride) => {
@@ -8362,23 +8936,23 @@ var serviceCommand = async (config, args) => {
   }
 };
 var isProvider = (value) => value === "claude" || value === "codex" || value === "github";
-var readIfExists = (file) => fs14.existsSync(file) ? fs14.readFileSync(file, "utf8") : null;
+var readIfExists = (file) => fs15.existsSync(file) ? fs15.readFileSync(file, "utf8") : null;
 var localCredential = (provider) => {
-  const home = os9.homedir();
+  const home = os10.homedir();
   switch (provider) {
     case "codex":
       return readIfExists(
-        path15.join(process.env["CODEX_HOME"] ?? path15.join(home, ".codex"), "auth.json")
+        path16.join(process.env["CODEX_HOME"] ?? path16.join(home, ".codex"), "auth.json")
       );
     case "claude":
       return readIfExists(
-        path15.join(
-          process.env["CLAUDE_CONFIG_DIR"] ?? path15.join(home, ".claude"),
+        path16.join(
+          process.env["CLAUDE_CONFIG_DIR"] ?? path16.join(home, ".claude"),
           ".credentials.json"
         )
       );
     case "github": {
-      const result = spawnSync4("gh", ["auth", "token"], { encoding: "utf8" });
+      const result = spawnSync5("gh", ["auth", "token"], { encoding: "utf8" });
       const token = result.status === 0 ? result.stdout.trim() : "";
       return token === "" ? null : token;
     }
@@ -8423,7 +8997,7 @@ var claudeGrantSecret = () => {
   return read.kind === "missing" ? null : read.secret;
 };
 var doctorBundle = (config, args) => doctorBundleCommand(args, {
-  defaultDir: path15.join(mendCliHome(), "bundles"),
+  defaultDir: path16.join(mendCliHome(), "bundles"),
   now: () => /* @__PURE__ */ new Date(),
   say: say6,
   warn: (line) => process.stderr.write(`${line}
@@ -8487,7 +9061,7 @@ var claudeGrant = async () => {
       return null;
     }
   }
-  if (status.configDirectory !== null && path15.resolve(status.configDirectory) !== path15.resolve(dir)) {
+  if (status.configDirectory !== null && path16.resolve(status.configDirectory) !== path16.resolve(dir)) {
     fail6(
       `claude: this Claude read ${status.configDirectory} instead of ${dir}, so a separate grant is not possible \u2014 connect the shared one deliberately with --use-my-login`
     );
@@ -8550,7 +9124,7 @@ var connectCommand = async (config, args) => {
   }
   let secret;
   if (flags.includes("--from-stdin")) {
-    secret = fs14.readFileSync(0, "utf8").trim();
+    secret = fs15.readFileSync(0, "utf8").trim();
     if (secret === "") return fail6("nothing on stdin");
   } else if (provider === "claude" && !flags.includes("--use-my-login")) {
     secret = await claudeGrant();
@@ -8596,14 +9170,14 @@ var takeFlagValue4 = (args, flag) => {
   return at !== -1 && args[at + 1] !== void 0 ? String(args[at + 1]) : null;
 };
 var saveCliConfig = (next) => {
-  fs14.mkdirSync(path15.dirname(CONFIG_PATH), { recursive: true, mode: 448 });
-  fs14.writeFileSync(
+  fs15.mkdirSync(path16.dirname(CONFIG_PATH), { recursive: true, mode: 448 });
+  fs15.writeFileSync(
     CONFIG_PATH,
     `${JSON.stringify({ url: next.url, token: next.token, deviceId: next.deviceId }, null, 2)}
 `,
     { mode: 384 }
   );
-  fs14.chmodSync(CONFIG_PATH, 384);
+  fs15.chmodSync(CONFIG_PATH, 384);
 };
 var login = async (config, args) => {
   await loginCommand(args, {
@@ -8616,7 +9190,7 @@ var login = async (config, args) => {
   });
 };
 var logout = async (config) => {
-  if (!fs14.existsSync(CONFIG_PATH) && config.token === null) {
+  if (!fs15.existsSync(CONFIG_PATH) && config.token === null) {
     say6(dim6("nothing saved \u2014 already signed out"));
     return;
   }
@@ -8669,8 +9243,8 @@ var uninstallCommand = async (config, args) => {
   const runtime = {
     server,
     cliHome: mendCliHome(),
-    sshConfigFile: path15.join(os9.homedir(), ".ssh", "config"),
-    signedIn: config.token === null || !fs14.existsSync(CONFIG_PATH) ? null : { url: config.url, deviceId: config.deviceId },
+    sshConfigFile: path16.join(os10.homedir(), ".ssh", "config"),
+    signedIn: config.token === null || !fs15.existsSync(CONFIG_PATH) ? null : { url: config.url, deviceId: config.deviceId },
     revokeDevice: async () => {
       if (config.deviceId === null) return "no device id saved";
       try {
@@ -8734,7 +9308,7 @@ var keysShare = async (config) => {
     return fail6("SSH_AUTH_SOCK is not set \u2014 start (or plug in) your ssh-agent first");
   }
   await shareAgent({
-    url: () => socketUrl(config, "keys-bridge", { host: os9.hostname() }),
+    url: () => socketUrl(config, "keys-bridge", { host: os10.hostname() }),
     agentSock,
     signal: new AbortController().signal,
     onEvent: (event) => {
@@ -8864,7 +9438,7 @@ ${usageOf("dotfiles repo")}`);
 var dotfilesSync = async (config, args) => {
   const all = args.includes("--all");
   const requestedPaths = args.filter((arg) => !arg.startsWith("--"));
-  const home = os9.homedir();
+  const home = os10.homedir();
   if (!all && requestedPaths.length === 0) {
     const found = scanDotfileCandidates(home);
     if (found.length === 0) {
@@ -8891,13 +9465,13 @@ var dotfilesSync = async (config, args) => {
   if ("error" in read) return fail6(read.error);
   const result = await api(config, "POST", "/dotfiles/snapshot", {
     files: read.files,
-    source: os9.hostname(),
+    source: os10.hostname(),
     merge: false
   });
   const snapshot = result.snapshot;
   if (snapshot === null) return fail6("the server accepted the sync but reports no snapshot");
   say6(
-    `${green6("synced")} ${snapshot.files.length} file${snapshot.files.length === 1 ? "" : "s"} from ${os9.hostname()} \xB7 ${dim6(snapshot.sha.slice(0, 7))} ${dim6("\u2014 applies from the next session launch")}`
+    `${green6("synced")} ${snapshot.files.length} file${snapshot.files.length === 1 ? "" : "s"} from ${os10.hostname()} \xB7 ${dim6(snapshot.sha.slice(0, 7))} ${dim6("\u2014 applies from the next session launch")}`
   );
 };
 var envLoad = async (config, args) => {
@@ -8911,10 +9485,10 @@ var envLoad = async (config, args) => {
   const positional = args.filter(
     (arg, i) => !arg.startsWith("--") && args[i - 1] !== "--project" && !consumed.has(i)
   );
-  const file = path15.resolve(positional[0] ?? ".env");
+  const file = path16.resolve(positional[0] ?? ".env");
   let contents;
   try {
-    contents = fs14.readFileSync(file, "utf8");
+    contents = fs15.readFileSync(file, "utf8");
   } catch {
     return fail6(`cannot read ${file} \u2014 pass a path: mend env load path/to/.env`);
   }
@@ -8930,10 +9504,10 @@ var envLoad = async (config, args) => {
     { contents, allSecret, secretNames }
   );
   if (report.loaded.length === 0 && report.rejected.length === 0 && report.malformedLines.length === 0) {
-    say6(dim6(`${path15.basename(file)} has no variables`));
+    say6(dim6(`${path16.basename(file)} has no variables`));
     return;
   }
-  say6(`${green6("\u2713")} loaded ${path15.basename(file)} into ${project2.name}`);
+  say6(`${green6("\u2713")} loaded ${path16.basename(file)} into ${project2.name}`);
   for (const line of formatLoadReport(report, { dim: dim6, warn: amber2 })) say6(line);
   const plaintextUrls = report.loaded.filter(
     (entry) => entry.lane === "configuration" && /_(URL|URI|DSN)$/.test(entry.name)
@@ -9124,7 +9698,7 @@ var skillsList = async (config, args) => {
 };
 var skillsPush = async (config, args) => {
   const dirFlag = takeFlagValue4(args, "--dir");
-  const root = dirFlag === null ? path15.join(os9.homedir(), DEFAULT_SKILLS_DIR) : path15.resolve(dirFlag);
+  const root = dirFlag === null ? path16.join(os10.homedir(), DEFAULT_SKILLS_DIR) : path16.resolve(dirFlag);
   const scanned = scanSkillLibrary(root);
   if ("error" in scanned) return fail6(scanned.error);
   for (const note of scanned.notes) say6(dim6(`  ${note.skill}: ${note.message}`));
@@ -9275,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`
@@ -9413,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("");
@@ -9423,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");
@@ -9464,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) {
@@ -9549,7 +10132,10 @@ var refreshCommand = async (config, args) => {
   }
   if (branches.length > 12) say6(dim6(`  \u2026 ${branches.length - 12} more`));
 };
-var rowHold = (row) => row.annotation === void 0 ? null : servicesHoldOf(row.session, row.annotation.currentAgent, row.annotation.liveServices ?? 0);
+var rowHold = (row) => (
+  // A workspace a stop is still saving (docs/adr/0002) reads what is left, first.
+  captureLineOf(row.session) ?? (row.annotation === void 0 ? null : servicesHoldOf(row.session, row.annotation.currentAgent, row.annotation.liveServices ?? 0))
+);
 var printSessionRow = (row) => {
   const { session, annotation } = row;
   const live = ACTIVE_STATUSES.has(session.status);
@@ -9647,6 +10233,14 @@ var sessionsCommand = async (config, args) => {
           openComments: annotation.openComments,
           totalComments: annotation.totalComments,
           pendingFollowUp: annotation.pendingFollowUp
+        },
+        capture: session.capturePending === void 0 ? null : {
+          pending: session.capturePending ?? null,
+          pendingBytes: session.capturePendingBytes ?? null,
+          refused: session.captureRefused ?? null,
+          drain: session.captureDrain ?? null,
+          notSaved: (session.captureNotSavedAt ?? null) !== null,
+          line: captureLineOf(session)
         }
       }))
     };
@@ -9779,14 +10373,14 @@ var dashboard = async (config, options = {}) => {
         `the dashboard needs Node >= 26 (node:ffi) \u2014 this is ${process.version}; every other command still works`
       );
     }
-    const rerun = spawnSync4(
+    const rerun = spawnSync5(
       process.execPath,
       ["--experimental-ffi", "--disable-warning=ExperimentalWarning", ...process.argv.slice(1)],
       { stdio: "inherit" }
     );
     process.exit(rerun.status ?? 0);
   }
-  const { runDashboard } = await import("./dashboard-NWHR7I5W.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),
@@ -9820,7 +10414,7 @@ var startShareIfBridge = async (config) => {
   }
   if (access.mode !== "bridge") return null;
   return startAgentShare({
-    url: () => socketUrl(config, "keys-bridge", { host: os9.hostname() }),
+    url: () => socketUrl(config, "keys-bridge", { host: os10.hostname() }),
     agentSock
   });
 };
@@ -9860,10 +10454,10 @@ var manCommand = (words) => {
   }
   const version = cliVersion();
   const page = doc === null ? renderManIndex(version) : renderManPage(doc, version);
-  const file = path15.join(os9.tmpdir(), `mend-man-${process.pid}-${manFileName(doc)}`);
-  fs14.writeFileSync(file, page);
-  const result = spawnSync4("man", ["-l", file], { stdio: "inherit" });
-  fs14.rmSync(file, { force: true });
+  const file = path16.join(os10.tmpdir(), `mend-man-${process.pid}-${manFileName(doc)}`);
+  fs15.writeFileSync(file, page);
+  const result = spawnSync5("man", ["-l", file], { stdio: "inherit" });
+  fs15.rmSync(file, { force: true });
   if (result.error !== void 0 || result.status !== 0) {
     say6(doc === null ? renderIndex() : renderCommand(doc));
   }