@martintrojer/murmur 0.2.1 → 0.2.2

package/dist/cli.js

@@ -915,6 +915,8 @@ function parseSnapshot(input) {
 // src/collector.ts
 var MAX_CONCURRENT_PEERS = 8;
 var COLLECT_DEADLINE_MS = 4e3;
+var COLLECT_FLOOR_MS = 3e4;
+var COLLECT_JITTER_MS = 2e4;
 async function mapSettled(items, limit, task, deadline) {
   const results = new Array(items.length);
   let cursor = 0;
@@ -936,6 +938,14 @@ async function mapSettled(items, limit, task, deadline) {
   await (stop ? Promise.race([pool, stop]) : pool);
   return results;
 }
+function duePeers(peers, now, floorMs, random) {
+  if (floorMs <= 0) return [...peers];
+  return peers.filter((peer) => {
+    if (peer.last_attempt_at === null) return true;
+    const jitter = (random() - 0.5) * COLLECT_JITTER_MS;
+    return now - peer.last_attempt_at >= floorMs + jitter;
+  });
+}
 function isUnreachable(message) {
   return /Host is down|No route to host|Connection refused|Connection timed out|Connection closed|Operation timed out|Network is unreachable|Name or service not known|Could not resolve hostname|timed out after/i.test(
     message
@@ -959,11 +969,12 @@ function describeFailure(peer, message) {
   const detail = collapsed.length > 160 ? `${collapsed.slice(0, 157)}...` : collapsed;
   return `${peer}: ${detail}`;
 }
-async function collect(store, channel, now = Date.now(), deadline, mux = tmux) {
+async function collect(store, channel, now = Date.now(), options = {}) {
+  const { deadline, mux = tmux, floorMs = 0, random = Math.random } = options;
   const results = [];
   let timer;
   try {
-    const peers = store.peers();
+    const peers = duePeers(store.peers(), now, floorMs, random);
     const bounded = deadline ?? new Promise((resolve) => {
       timer = setTimeout(resolve, COLLECT_DEADLINE_MS);
       timer.unref?.();
@@ -1054,23 +1065,785 @@ function requireIdentity() {
   process.exitCode = 1;
   return null;
 }
-
-// src/cli/collect.ts
-function registerCollect(program2) {
-  program2.command("collect").description("Fetch each peer's snapshot").option("-q, --quiet", "report nothing, not even unreachable peers").action(async (options) => {
-    if (!requireIdentity()) return;
+
+// src/cli/collect.ts
+function registerCollect(program2) {
+  program2.command("collect").description("Fetch each peer's snapshot").option("-q, --quiet", "report nothing, not even unreachable peers").action(async (options) => {
+    if (!requireIdentity()) return;
+    const store = openStore();
+    try {
+      const results = await collect(store, ssh);
+      if (options.quiet) return;
+      for (const result of results) {
+        if (result.ok || !result.error) continue;
+        process.stderr.write(`murmur: ${describeFailure(result.peer, result.error)}
+`);
+      }
+      if (results.some((result) => !result.ok && !result.unreachable)) {
+        process.exitCode = 1;
+      }
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/cli/peer.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var SNAPSHOT_VERSION = 1;
+function parseSshHosts(config) {
+  const hosts = [];
+  for (const line of config.split("\n")) {
+    const tokens = line.replace(/#.*$/, "").trim().split(/\s+/);
+    if (tokens[0]?.toLowerCase() !== "host") continue;
+    for (const host of tokens.slice(1)) {
+      if (!/[*?!]/.test(host)) hosts.push(host);
+    }
+  }
+  return hosts;
+}
+function sshHosts() {
+  try {
+    return parseSshHosts(readFileSync2(join3(homedir2(), ".ssh", "config"), "utf8"));
+  } catch {
+    return [];
+  }
+}
+function lastSeen(fetchedAt, now) {
+  if (fetchedAt === null) return "never";
+  if (freshness(fetchedAt, now, STALENESS_MS) === "fresh") return "just now";
+  return `${age(now - fetchedAt)} ago`;
+}
+function versionCell(peer, ours = SNAPSHOT_VERSION) {
+  if (peer.murmur_version === null && peer.snapshot_version === null) {
+    return { text: "unknown", incompatible: false };
+  }
+  const version = peer.murmur_version ?? "unreported";
+  const incompatible = peer.snapshot_version !== null && peer.snapshot_version !== ours;
+  return {
+    text: incompatible ? `${version} (snapshot ${peer.snapshot_version} \u2260 ${ours})` : version,
+    incompatible
+  };
+}
+function formatTable(rows) {
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, index) => {
+      widths[index] = Math.max(widths[index] ?? 0, cell.length);
+    });
+  }
+  return rows.map(
+    (row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd()
+  ).map((line) => `${line}
+`).join("");
+}
+function peerAddDecision(input) {
+  const { name, target, snapshot, selfHostId, peers } = input;
+  if (!snapshot) return null;
+  if (snapshot.host_id === selfHostId) {
+    return `${target} is this node; not adding it as a peer
+`;
+  }
+  const existing = peers.find(
+    (candidate) => candidate.host_id === snapshot.host_id && candidate.name !== name
+  );
+  if (existing) {
+    return `${target} is already configured as peer "${existing.name}" (${snapshot.display_name}); remove it first to rename
+`;
+  }
+  return null;
+}
+function registerPeer(program2) {
+  const peer = program2.command("peer").description("Manage peers");
+  peer.command("add").description("Add a peer and discover its identity").argument("<name>").argument("[target]").action(async (name, target = name) => {
+    const store = openStore();
+    try {
+      let snapshot = null;
+      try {
+        snapshot = parseSnapshot(await ssh.exec(target, ["murmur", "export"]));
+      } catch {
+        snapshot = null;
+      }
+      const refusal = peerAddDecision({
+        name,
+        target,
+        snapshot,
+        selfHostId: loadIdentity()?.host_id ?? null,
+        peers: store.peers()
+      });
+      if (refusal) {
+        process.stderr.write(refusal);
+        process.exitCode = 1;
+        return;
+      }
+      store.addPeer(name, target);
+      if (snapshot) {
+        store.replacePeerSnapshot(name, { ok: true, snapshot, at: Date.now() });
+      }
+      process.stdout.write(
+        snapshot ? `Added ${name} (${snapshot.display_name})
+` : `Added ${name} (identity pending)
+`
+      );
+    } finally {
+      store.close();
+    }
+  });
+  peer.command("remove").description("Remove a peer").argument("<name>", "peer to remove").action((name) => {
+    const store = openStore();
+    try {
+      if (store.removePeer(name)) process.stdout.write(`Removed ${name}
+`);
+      else {
+        process.stderr.write(`no such peer: ${name}
+`);
+        process.exitCode = 1;
+      }
+    } finally {
+      store.close();
+    }
+  });
+  peer.command("list").description("List peers; --all adds SSH hosts that could become peers").option("--json", "print JSON").option("-a, --all", "also show SSH hosts that are not peers yet").action((options) => {
+    const store = openStore();
+    try {
+      const peers = store.peers();
+      const configured = new Map(peers.map((entry) => [entry.target, entry]));
+      const discovered = options.all ? sshHosts().filter((host) => !configured.has(host)) : [];
+      const now = Date.now();
+      const rows = [...configured.keys(), ...discovered].map((target) => {
+        const entry = configured.get(target);
+        return {
+          // The handle other commands take: a peer's name, or for a host that
+          // is not one yet, the ssh host `peer add` wants.
+          name: entry?.name ?? target,
+          target,
+          peer: entry !== void 0,
+          // What the node called itself. Shown, never typed: it can be a
+          // container id.
+          hostname: entry?.display_name ?? null,
+          // Being a peer is not the same as being reachable, and the old
+          // output said only the first. A node asleep for twelve hours read
+          // exactly like one polled a second ago.
+          last_seen: entry === void 0 ? null : lastSeen(entry.fetched_at, now),
+          // A warm ControlMaster socket makes a collect ~10ms instead of
+          // ~170ms, and is the only path that works on a host demanding a
+          // hardware-token touch per connection. A speed hint, never a
+          // requirement -- which is why the old bare `[x]` / `[ ]` was
+          // unreadable: it never said what was being checked.
+          //
+          // Safe for every row: `ssh -O check` talks to a local socket and
+          // never dials, so a host that is down or does not exist answers in
+          // ~16ms. Measured.
+          ssh: hasWarmSocket(target) ? "warm" : "cold",
+          // What it is running, or undefined when nothing is known -- either
+          // because the host is not a peer yet, or because it is a peer that
+          // has never answered. Undefined is what drops the column, so the
+          // test is "has anything told us", not "is this configured": a fleet
+          // of asleep peers must not buy a column of "unknown".
+          version: entry === void 0 || entry.murmur_version === null && entry.snapshot_version === null ? void 0 : versionCell(entry),
+          // Named where it can be acted on: a peer that answered with a bad
+          // document is reachable but broken, which is an operator task and
+          // reads nothing like a sleeping laptop.
+          error: entry?.last_error ?? null
+        };
+      });
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(rows)}
+`);
+        return;
+      }
+      if (rows.length === 0) {
+        process.stdout.write(
+          options.all ? "no peers configured, and no hosts in ~/.ssh/config\n" : "no peers configured. See what could be added with: murmur peer list --all\n"
+        );
+        return;
+      }
+      const showPeerColumn = rows.some((row) => !row.peer);
+      const showVersionColumn = rows.some((row) => row.version !== void 0);
+      process.stdout.write(
+        formatTable([
+          [
+            "NAME",
+            "TARGET",
+            ...showPeerColumn ? ["PEER"] : [],
+            "HOSTNAME",
+            ...showVersionColumn ? ["VERSION"] : [],
+            "LAST SEEN",
+            "SSH"
+          ],
+          ...rows.map((row) => [
+            row.name,
+            row.target,
+            ...showPeerColumn ? [row.peer ? "yes" : "-"] : [],
+            row.hostname ?? "unknown",
+            ...showVersionColumn ? [row.version?.text ?? "-"] : [],
+            row.last_seen ?? "-",
+            row.ssh
+          ])
+        ])
+      );
+      const incompatible = rows.filter((row) => row.version?.incompatible);
+      if (incompatible.length > 0) {
+        process.stdout.write(
+          `
+${incompatible.length} peer${incompatible.length === 1 ? "" : "s"} speak an incompatible snapshot version; state will not sync until murmur versions match: ${incompatible.map((row) => row.name).join(", ")}
+`
+        );
+      }
+      const broken = rows.filter((row) => row.error);
+      for (const row of broken) {
+        process.stdout.write(`
+${row.name}: last attempt failed -- ${row.error}
+`);
+      }
+      const addable = rows.filter((row) => !row.peer).length;
+      if (addable > 0) {
+        process.stdout.write(
+          `
+${addable} host${addable === 1 ? "" : "s"} not yet a peer. Add one with: murmur peer add <name>
+`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/doctor.ts
+var DOCTOR_DEADLINE_MS = 15e3;
+var OUTDATED = /\berror: unknown (?:option|command)\b/i;
+function failure(target, reason, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return { ok: false, target, reason, detail: describeFailure(target, message) };
+}
+function parseRoster(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    throw new Error("peer list did not answer with JSON");
+  }
+  if (!Array.isArray(parsed)) throw new Error("peer list: expected an array of peers");
+  return parsed.map((row, index) => {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error(`peer list[${index}]: expected an object`);
+    }
+    const record = row;
+    const { name, target, hostname: hostname2 } = record;
+    if (typeof name !== "string" || name === "") {
+      throw new Error(`peer list[${index}]: expected a non-empty name`);
+    }
+    if (typeof target !== "string" || target === "") {
+      throw new Error(`peer list[${index}]: expected a non-empty target`);
+    }
+    return { name, target, hostname: typeof hostname2 === "string" ? hostname2 : null };
+  });
+}
+async function surveyPeer(channel, target) {
+  let host_id;
+  let display_name;
+  let murmur_version;
+  try {
+    const snapshot = parseSnapshot(await channel.exec(target, ["murmur", "export"]));
+    ({ host_id, display_name, murmur_version } = snapshot);
+  } catch (error) {
+    return failure(target, "identity-unavailable", error);
+  }
+  let output;
+  try {
+    output = await channel.exec(target, ["murmur", "peer", "list", "--json"]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return failure(
+      target,
+      OUTDATED.test(message) ? "roster-unsupported" : "roster-unavailable",
+      error
+    );
+  }
+  try {
+    return { ok: true, target, host_id, display_name, murmur_version, roster: parseRoster(output) };
+  } catch (error) {
+    return failure(target, "roster-invalid", error);
+  }
+}
+function withoutTargetPrefix(target, detail) {
+  return detail.startsWith(`${target}: `) ? detail.slice(target.length + 2) : detail;
+}
+function rowIsAbout(row, host) {
+  if (host.display_name === null) return false;
+  if (row.hostname !== null) return row.hostname === host.display_name;
+  return row.name === host.display_name || row.target === host.display_name;
+}
+function diagnose(local, surveys) {
+  const findings = [];
+  const answered = surveys.filter((survey) => survey.ok);
+  const byTarget = new Map(answered.map((survey) => [survey.target, survey]));
+  const nameOf = (target) => local.peers.find((peer) => peer.target === target)?.name ?? target;
+  const self = {
+    host_id: local.host_id,
+    display_name: local.display_name,
+    localName: null,
+    target: null
+  };
+  const hosts = [self];
+  for (const peer of local.peers) {
+    const survey = byTarget.get(peer.target);
+    const host_id = survey?.host_id ?? peer.host_id;
+    if (host_id === null) continue;
+    hosts.push({
+      host_id,
+      display_name: survey?.display_name ?? peer.display_name,
+      localName: peer.name,
+      target: peer.target
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const host of hosts) {
+    if (host.localName === null) continue;
+    const first = seen.get(host.host_id);
+    if (first === void 0) {
+      seen.set(host.host_id, host);
+      continue;
+    }
+    const label = host.display_name ?? host.host_id;
+    findings.push({
+      kind: "duplicate-host-id",
+      severity: "problem",
+      subject: host.localName,
+      message: `${first.localName} and ${host.localName} are the same machine (${label}), so every command reaches it twice`,
+      detail: `same machine as ${first.localName} (${label}); every command reaches it twice`,
+      remedy: `murmur peer remove ${host.localName}`
+    });
+  }
+  for (const peer of local.peers) {
+    const cell = versionCell(peer);
+    if (!cell.incompatible) continue;
+    findings.push({
+      kind: "snapshot-skew",
+      severity: "problem",
+      subject: peer.name,
+      message: `${peer.name} speaks an incompatible snapshot version (${cell.text}); state will not sync until murmur versions match`,
+      detail: `incompatible snapshot version (${cell.text}); state will not sync`,
+      remedy: `ssh ${peer.target} npm i -g @martintrojer/murmur`
+    });
+  }
+  const peersThisNode = answered.filter(
+    (survey) => survey.roster.some((row) => rowIsAbout(row, self))
+  );
+  for (const survey of answered) {
+    if (peersThisNode.includes(survey)) continue;
+    const name = nameOf(survey.target);
+    findings.push({
+      kind: "asymmetry",
+      severity: "observation",
+      subject: name,
+      message: `${name} does not peer this node (${local.display_name}), so its picker cannot see this node's agents`,
+      // The consequence is identical on every asymmetric row, so it belongs in
+      // the column header once rather than in each cell N times.
+      detail: `does not peer ${local.display_name}`,
+      // display_name is what the operator would type, but it is not guaranteed
+      // to resolve from THAT host's ssh config, which murmur cannot see. So it
+      // is a command to check, and `peer add` tolerates a target that does not
+      // answer.
+      remedy: `ssh ${survey.target} murmur peer add ${local.display_name}`
+    });
+  }
+  if (answered.length > 0 && peersThisNode.length === 0) {
+    findings.push({
+      kind: "island",
+      severity: "observation",
+      subject: local.display_name,
+      message: `no peer that this node surveyed peers this host (${local.display_name}); ${answered.length} of ${answered.length} surveyed peers cannot see this node's agents`,
+      // "surveyed" is load-bearing and survives the shortening: this is a
+      // one-hop claim, and dropping the word would turn it into a statement
+      // about machines never contacted.
+      detail: `none of the ${answered.length} surveyed peers can see this node`,
+      remedy: null
+    });
+  }
+  for (const host of hosts) {
+    const names = /* @__PURE__ */ new Map();
+    const record = (name, where) => {
+      const nodes = names.get(name);
+      if (nodes) nodes.push(where);
+      else names.set(name, [where]);
+    };
+    if (host.localName !== null) record(host.localName, "here");
+    for (const survey of answered) {
+      if (survey.host_id === host.host_id) continue;
+      for (const row of survey.roster) {
+        if (rowIsAbout(row, host)) record(row.name, nameOf(survey.target));
+      }
+    }
+    if (names.size < 2) continue;
+    const label = host.display_name ?? host.host_id;
+    const spelled = [...names].map(([name, nodes]) => `"${name}" on ${nodes.join(", ")}`).join("; ");
+    findings.push({
+      kind: "naming-drift",
+      severity: "observation",
+      subject: host.localName ?? local.display_name,
+      message: `one machine (${label}) is configured under different names: ${spelled}`,
+      detail: `one machine (${label}) under different names: ${spelled}`,
+      remedy: null
+    });
+  }
+  for (const survey of surveys) {
+    if (survey.ok) continue;
+    const name = nameOf(survey.target);
+    const detail = withoutTargetPrefix(survey.target, survey.detail);
+    findings.push({
+      kind: "unsurveyable",
+      severity: "observation",
+      subject: name,
+      message: survey.reason === "roster-unsupported" ? `${name} runs a murmur too old to report its roster, so it could not be checked -- upgrade that host` : `${name} could not be surveyed -- ${detail}`,
+      detail: survey.reason === "roster-unsupported" ? "murmur too old to report its roster" : detail,
+      remedy: survey.reason === "roster-unsupported" ? `ssh ${survey.target} npm i -g @martintrojer/murmur` : null
+    });
+  }
+  return findings;
+}
+var TOPOLOGY_DEADLINE_MS = 3e4;
+var UNRESOLVED = /could not resolve hostname|name or service not known|nodename nor servname/i;
+function isNameResolutionFailure(detail) {
+  return detail !== null && UNRESOLVED.test(detail);
+}
+async function probeReach(channel, from, to) {
+  const inner = ["ssh", "-o", "BatchMode=yes", `-o`, "ConnectTimeout=1", to.target, "true"];
+  try {
+    await channel.exec(from.self ? to.target : from.target, from.self ? ["true"] : inner);
+    return { ok: true, detail: null };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, detail: describeFailure(to.name, message) };
+  }
+}
+function reachableFromHere(surveys) {
+  return new Set(surveys.filter((survey) => survey.ok).map((survey) => survey.target));
+}
+async function buildTopology(channel, nodes, upFromHere, deadline) {
+  const isUp = (node) => node.self || upFromHere.has(node.target);
+  const pairs = [];
+  for (const from of nodes) {
+    for (const to of nodes) {
+      if (from.name !== to.name) pairs.push({ from, to });
+    }
+  }
+  const dialled = pairs.filter((pair) => isUp(pair.from));
+  let timer;
+  try {
+    const bounded = deadline ?? new Promise((resolve) => {
+      timer = setTimeout(resolve, TOPOLOGY_DEADLINE_MS);
+      timer.unref?.();
+    });
+    const settled = await mapSettled(
+      dialled,
+      MAX_CONCURRENT_PEERS,
+      async (pair) => probeReach(channel, pair.from, pair.to),
+      bounded
+    );
+    const outcomes = /* @__PURE__ */ new Map();
+    let probes = 0;
+    for (const [index, pair] of dialled.entries()) {
+      const result = settled[index];
+      if (result !== void 0) probes += 1;
+      outcomes.set(
+        `${pair.from.name}\0${pair.to.name}`,
+        result?.status === "fulfilled" ? result.value : void 0
+      );
+    }
+    const edges = pairs.map(({ from, to }) => {
+      const outcome = outcomes.get(`${from.name}\0${to.name}`);
+      if (outcome === void 0) {
+        return {
+          from: from.name,
+          to: to.name,
+          reach: "unknown",
+          detail: isUp(from) ? "not probed within the deadline" : `${from.name} did not answer`
+        };
+      }
+      if (outcome.ok) return { from: from.name, to: to.name, reach: "reaches", detail: null };
+      return {
+        from: from.name,
+        to: to.name,
+        reach: isUp(to) ? "unreachable" : "unknown",
+        detail: outcome.detail
+      };
+    });
+    return { nodes, edges, probes };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function hubCandidates(topology) {
+  const { nodes, edges } = topology;
+  const lookup = new Map(edges.map((edge) => [`${edge.from}\0${edge.to}`, edge.reach]));
+  const reachOf = (from, to) => from === to ? "reaches" : lookup.get(`${from}\0${to}`) ?? "unknown";
+  return nodes.map((hub) => {
+    const others = nodes.filter((node) => node.name !== hub.name);
+    const reaches = others.filter((node) => reachOf(hub.name, node.name) === "reaches");
+    return {
+      node: hub.name,
+      reaches: reaches.map((node) => node.name),
+      cannotReach: others.filter((node) => reachOf(hub.name, node.name) === "unreachable").map((node) => node.name),
+      unknown: others.filter((node) => reachOf(hub.name, node.name) === "unknown").map((node) => node.name),
+      // Proven in both directions, and `unknown` never counts as proven: a star
+      // built on a guess is the thing that cannot be allowed to look computed.
+      star: [
+        hub.name,
+        ...reaches.filter((node) => reachOf(node.name, hub.name) === "reaches").map((node) => node.name)
+      ]
+    };
+  });
+}
+function bestHub(candidates) {
+  let best = null;
+  for (const candidate of candidates) {
+    if (candidate.star.length < 2) continue;
+    if (best === null || candidate.star.length > best.star.length) best = candidate;
+  }
+  return best;
+}
+
+// src/cli/doctor.ts
+async function surveyFleet(channel, peers, deadline) {
+  let timer;
+  try {
+    const bounded = deadline ?? new Promise((resolve) => {
+      timer = setTimeout(resolve, DOCTOR_DEADLINE_MS);
+      timer.unref?.();
+    });
+    const settled = await mapSettled(
+      peers,
+      MAX_CONCURRENT_PEERS,
+      async (peer) => surveyPeer(channel, peer.target),
+      bounded
+    );
+    return peers.map((peer, index) => {
+      const result = settled[index];
+      if (result?.status === "fulfilled") return result.value;
+      const detail = result === void 0 ? `not surveyed within ${DOCTOR_DEADLINE_MS / 1e3}s` : result.reason instanceof Error ? result.reason.message : String(result.reason);
+      return { ok: false, target: peer.target, reason: "identity-unavailable", detail };
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function indent(block) {
+  return block.split("\n").map((line) => line ? `  ${line}` : line).join("\n");
+}
+var GROUP = {
+  "duplicate-host-id": {
+    heading: "Duplicate peers",
+    because: "One machine configured twice. Every command reaches it twice."
+  },
+  "snapshot-skew": {
+    heading: "Incompatible versions",
+    because: "State will not sync with these until murmur versions match."
+  },
+  asymmetry: {
+    heading: "One-way peering",
+    because: "These do not peer this node, so their pickers cannot see its agents."
+  },
+  island: {
+    heading: "Not visible to the fleet",
+    because: null
+  },
+  "naming-drift": {
+    heading: "Naming drift",
+    because: "Harmless to murmur, confusing to read: one machine, several names."
+  },
+  unsurveyable: {
+    heading: "Could not be surveyed",
+    because: "Normal for a sleeping laptop or a box switched off."
+  }
+};
+var GROUP_ORDER = [
+  "duplicate-host-id",
+  "snapshot-skew",
+  "island",
+  "asymmetry",
+  "naming-drift",
+  "unsurveyable"
+];
+function render(local, surveys, findings) {
+  const answered = surveys.filter((survey) => survey.ok).length;
+  const out = [];
+  if (surveys.length === 0) return "No peers configured, so there is nothing to survey.\n";
+  out.push(
+    `Surveyed ${surveys.length} peer${surveys.length === 1 ? "" : "s"}, ${answered} answered.
+`
+  );
+  if (findings.length === 0) {
+    out.push("\nNo problems found.\n");
+    return out.join("");
+  }
+  const problems = findings.filter((finding) => finding.severity === "problem").length;
+  const counts = [
+    problems > 0 ? `${problems} problem${problems === 1 ? "" : "s"}` : "",
+    findings.length - problems > 0 ? `${findings.length - problems} observation${findings.length - problems === 1 ? "" : "s"}` : ""
+  ].filter(Boolean);
+  out.push(
+    problems > 0 ? `${counts.join(", ")}. See "Do this" below.
+` : `${counts.join(", ")}, nothing broken.
+`
+  );
+  for (const kind of GROUP_ORDER) {
+    const group = findings.filter((finding) => finding.kind === kind);
+    if (group.length === 0) continue;
+    const { heading, because } = GROUP[kind] ?? { heading: kind, because: null };
+    const marked = group.some((finding) => finding.severity === "problem");
+    const rows = group.map(
+      (finding) => marked ? [finding.severity === "problem" ? "!" : " ", finding.subject, finding.detail] : [finding.subject, finding.detail]
+    );
+    out.push(`
+${heading}
+`);
+    if (because) out.push(`  ${DIM}${because}${RESET}
+`);
+    out.push(indent(formatTable(rows)));
+  }
+  const remedies = findings.filter(
+    (finding) => finding.remedy !== null
+  );
+  if (remedies.length > 0) {
+    out.push("\nDo this\n");
+    const seen = /* @__PURE__ */ new Set();
+    for (const finding of remedies) {
+      if (seen.has(finding.remedy)) continue;
+      seen.add(finding.remedy);
+      out.push(`  ${finding.remedy}
+`);
+    }
+    if (remedies.some((f) => f.remedy.includes(`murmur peer add ${local.display_name}`))) {
+      out.push(
+        `
+  ${DIM}These name this node "${local.display_name}". Whether a peer resolves that
+  depends on its own ssh config, which murmur cannot see -- so check, do not
+  trust. \`peer add\` accepts a target that does not answer yet.${RESET}
+`
+      );
+    }
+  }
+  return out.join("");
+}
+function renderTopology(topology) {
+  const candidates = hubCandidates(topology);
+  const hub = bestHub(candidates);
+  const out = [];
+  const all = topology.nodes.length - 1;
+  out.push(
+    `
+Reachability  ${DIM}${topology.probes} ordered pair${topology.probes === 1 ? "" : "s"} probed across ${topology.nodes.length} nodes${RESET}
+`
+  );
+  const anyUnknown = candidates.some((candidate) => candidate.unknown.length > 0);
+  const rows = [["", "REACHES", "CANNOT REACH", ...anyUnknown ? ["UNKNOWN"] : []]];
+  for (const candidate of candidates) {
+    rows.push([
+      candidate.node,
+      candidate.reaches.length === all && all > 0 ? `all ${all}` : candidate.reaches.length > 0 ? candidate.reaches.join(" ") : "-",
+      candidate.cannotReach.length > 0 ? candidate.cannotReach.join(" ") : "-",
+      ...anyUnknown ? [candidate.unknown.length > 0 ? candidate.unknown.join(" ") : "-"] : []
+    ]);
+  }
+  out.push(indent(formatTable(rows)));
+  const unresolved = topology.edges.filter((edge) => isNameResolutionFailure(edge.detail));
+  if (unresolved.length > 0) {
+    const targets = [...new Set(unresolved.map((edge) => edge.to))];
+    const from = [...new Set(unresolved.map((edge) => edge.from))];
+    out.push(
+      `
+  ${DIM}${targets.join(", ")} is not resolvable by name from ${from.join(", ")} -- a naming
+  problem, not a network one. It may be reachable under another address.${RESET}
+`
+    );
+  }
+  if (hub === null) {
+    out.push(
+      `
+Hub  ${DIM}none possible${RESET}
+  A hub must reach every spoke and be reachable from each in turn.
+  No node here does both, so none is recommended.
+`
+    );
+    return out.join("");
+  }
+  const spokes = hub.star.filter((name) => name !== hub.node);
+  const excluded = topology.nodes.map((node) => node.name).filter((name) => !hub.star.includes(name));
+  out.push(
+    excluded.length === 0 ? `
+Hub  ${hub.node}  ${DIM}serves the whole fleet${RESET}
+` : `
+Hub  ${hub.node}  ${DIM}serves {${hub.star.join(", ")}}, leaves out ${excluded.join(", ")}${RESET}
+`
+  );
+  out.push(`
+To build that star
+`);
+  for (const spoke of spokes) out.push(`  ssh ${spoke} murmur peer add ${hub.node}
+`);
+  out.push(
+    `
+  ${DIM}Cost: spokes would see ${hub.node}'s agents and it would see theirs, but
+  SPOKES WOULD NOT SEE EACH OTHER. \`murmur export\` publishes a node's own
+  panes only, so a hub cannot re-serve what it learned. A star is not a mesh.${RESET}
+`
+  );
+  return out.join("");
+}
+function jsonReport(surveys, findings) {
+  return {
+    surveyed: surveys.length,
+    answered: surveys.filter((survey) => survey.ok).length,
+    findings
+  };
+}
+function exitCodeFor(findings) {
+  return findings.some((finding) => finding.severity === "problem") ? 1 : 0;
+}
+function registerDoctor(program2) {
+  program2.command("doctor").description("Survey peers over ssh and report what only a fleet-wide view can see").option("--json", "print the finding list").option("--topology", "also probe who can reach whom, and compute hub options").action(async (options) => {
+    const identity = requireIdentity();
+    if (!identity) return;
     const store = openStore();
     try {
-      const results = await collect(store, ssh);
-      if (options.quiet) return;
-      for (const result of results) {
-        if (result.ok || !result.error) continue;
-        process.stderr.write(`murmur: ${describeFailure(result.peer, result.error)}
-`);
+      const peers = store.peers();
+      const surveys = await surveyFleet(ssh, peers);
+      const local = {
+        host_id: identity.host_id,
+        display_name: identity.display_name,
+        peers
+      };
+      const findings = diagnose(local, surveys);
+      let topology = null;
+      if (options.topology) {
+        const nodes = [
+          { name: identity.display_name, target: identity.display_name, self: true },
+          ...peers.map((peer) => ({ name: peer.name, target: peer.target, self: false }))
+        ];
+        topology = await buildTopology(ssh, nodes, reachableFromHere(surveys));
       }
-      if (results.some((result) => !result.ok && !result.unreachable)) {
-        process.exitCode = 1;
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify({
+            ...jsonReport(surveys, findings),
+            // Omitted entirely rather than null when the phase did not run: a
+            // consumer must not have to tell "no topology" apart from "a
+            // topology with nothing in it".
+            ...topology ? { topology, hubs: hubCandidates(topology) } : {}
+          })}
+`
+        );
+      } else {
+        process.stdout.write(render(local, surveys, findings));
+        if (topology) process.stdout.write(renderTopology(topology));
       }
+      process.exitCode = exitCodeFor(findings);
     } finally {
       store.close();
     }
@@ -1104,9 +1877,9 @@ function registerInit(program2) {
 }
 
 // src/cli/link.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath } from "url";
 var SHIM_MARKER = "// murmur:shim";
 function shim(entry, storePath) {
@@ -1137,8 +1910,8 @@ function registerLink(program2) {
     "inline the extension instead of re-exporting it (pins to this version; needs re-linking after an upgrade)"
   ).action((target, options) => {
     if (target !== "pi") throw new Error(`unsupported link target: ${target}`);
-    const destination = join3(
-      process.env.MURMUR_PI_HOME ?? homedir2(),
+    const destination = join4(
+      process.env.MURMUR_PI_HOME ?? homedir3(),
       ".pi",
       "agent",
       "extensions",
@@ -1151,7 +1924,7 @@ function registerLink(program2) {
     if (!options.copy) {
       let replacedCopy = false;
       try {
-        const existing = readFileSync2(destination, "utf8");
+        const existing = readFileSync3(destination, "utf8");
         replacedCopy = !existing.includes(SHIM_MARKER);
       } catch {
       }
@@ -1169,7 +1942,7 @@ function registerLink(program2) {
       }
       return;
     }
-    const source = readFileSync2(entry, "utf8");
+    const source = readFileSync3(entry, "utf8");
     const pinned = source.replace(
       /"@martintrojer\/murmur\/extension-store"/,
       JSON.stringify(storePath)
@@ -1283,237 +2056,17 @@ async function readStdin() {
   });
 }
 
-// src/cli/peer.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-var SNAPSHOT_VERSION = 1;
-function parseSshHosts(config) {
-  const hosts = [];
-  for (const line of config.split("\n")) {
-    const tokens = line.replace(/#.*$/, "").trim().split(/\s+/);
-    if (tokens[0]?.toLowerCase() !== "host") continue;
-    for (const host of tokens.slice(1)) {
-      if (!/[*?!]/.test(host)) hosts.push(host);
-    }
-  }
-  return hosts;
-}
-function sshHosts() {
-  try {
-    return parseSshHosts(readFileSync3(join4(homedir3(), ".ssh", "config"), "utf8"));
-  } catch {
-    return [];
-  }
-}
-function lastSeen(fetchedAt, now) {
-  if (fetchedAt === null) return "never";
-  if (freshness(fetchedAt, now, STALENESS_MS) === "fresh") return "just now";
-  return `${age(now - fetchedAt)} ago`;
-}
-function versionCell(peer, ours = SNAPSHOT_VERSION) {
-  if (peer.murmur_version === null && peer.snapshot_version === null) {
-    return { text: "unknown", incompatible: false };
-  }
-  const version = peer.murmur_version ?? "unreported";
-  const incompatible = peer.snapshot_version !== null && peer.snapshot_version !== ours;
-  return {
-    text: incompatible ? `${version} (snapshot ${peer.snapshot_version} \u2260 ${ours})` : version,
-    incompatible
-  };
-}
-function formatTable(rows) {
-  const widths = [];
-  for (const row of rows) {
-    row.forEach((cell, index) => {
-      widths[index] = Math.max(widths[index] ?? 0, cell.length);
-    });
-  }
-  return rows.map(
-    (row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd()
-  ).map((line) => `${line}
-`).join("");
-}
-function peerAddDecision(input) {
-  const { name, target, snapshot, selfHostId, peers } = input;
-  if (!snapshot) return null;
-  if (snapshot.host_id === selfHostId) {
-    return `${target} is this node; not adding it as a peer
-`;
-  }
-  const existing = peers.find(
-    (candidate) => candidate.host_id === snapshot.host_id && candidate.name !== name
-  );
-  if (existing) {
-    return `${target} is already configured as peer "${existing.name}" (${snapshot.display_name}); remove it first to rename
-`;
-  }
-  return null;
-}
-function registerPeer(program2) {
-  const peer = program2.command("peer").description("Manage peers");
-  peer.command("add").description("Add a peer and discover its identity").argument("<name>").argument("[target]").action(async (name, target = name) => {
-    const store = openStore();
-    try {
-      let snapshot = null;
-      try {
-        snapshot = parseSnapshot(await ssh.exec(target, ["murmur", "export"]));
-      } catch {
-        snapshot = null;
-      }
-      const refusal = peerAddDecision({
-        name,
-        target,
-        snapshot,
-        selfHostId: loadIdentity()?.host_id ?? null,
-        peers: store.peers()
-      });
-      if (refusal) {
-        process.stderr.write(refusal);
-        process.exitCode = 1;
-        return;
-      }
-      store.addPeer(name, target);
-      if (snapshot) {
-        store.replacePeerSnapshot(name, { ok: true, snapshot, at: Date.now() });
-      }
-      process.stdout.write(
-        snapshot ? `Added ${name} (${snapshot.display_name})
-` : `Added ${name} (identity pending)
-`
-      );
-    } finally {
-      store.close();
-    }
-  });
-  peer.command("remove").description("Remove a peer").argument("<name>", "peer to remove").action((name) => {
-    const store = openStore();
-    try {
-      if (store.removePeer(name)) process.stdout.write(`Removed ${name}
-`);
-      else {
-        process.stderr.write(`no such peer: ${name}
-`);
-        process.exitCode = 1;
-      }
-    } finally {
-      store.close();
-    }
-  });
-  peer.command("list").description("List peers; --all adds SSH hosts that could become peers").option("--json", "print JSON").option("-a, --all", "also show SSH hosts that are not peers yet").action((options) => {
-    const store = openStore();
-    try {
-      const peers = store.peers();
-      const configured = new Map(peers.map((entry) => [entry.target, entry]));
-      const discovered = options.all ? sshHosts().filter((host) => !configured.has(host)) : [];
-      const now = Date.now();
-      const rows = [...configured.keys(), ...discovered].map((target) => {
-        const entry = configured.get(target);
-        return {
-          // The handle other commands take: a peer's name, or for a host that
-          // is not one yet, the ssh host `peer add` wants.
-          name: entry?.name ?? target,
-          target,
-          peer: entry !== void 0,
-          // What the node called itself. Shown, never typed: it can be a
-          // container id.
-          hostname: entry?.display_name ?? null,
-          // Being a peer is not the same as being reachable, and the old
-          // output said only the first. A node asleep for twelve hours read
-          // exactly like one polled a second ago.
-          last_seen: entry === void 0 ? null : lastSeen(entry.fetched_at, now),
-          // A warm ControlMaster socket makes a collect ~10ms instead of
-          // ~170ms, and is the only path that works on a host demanding a
-          // hardware-token touch per connection. A speed hint, never a
-          // requirement -- which is why the old bare `[x]` / `[ ]` was
-          // unreadable: it never said what was being checked.
-          //
-          // Safe for every row: `ssh -O check` talks to a local socket and
-          // never dials, so a host that is down or does not exist answers in
-          // ~16ms. Measured.
-          ssh: hasWarmSocket(target) ? "warm" : "cold",
-          // What it is running, or undefined when nothing is known -- either
-          // because the host is not a peer yet, or because it is a peer that
-          // has never answered. Undefined is what drops the column, so the
-          // test is "has anything told us", not "is this configured": a fleet
-          // of asleep peers must not buy a column of "unknown".
-          version: entry === void 0 || entry.murmur_version === null && entry.snapshot_version === null ? void 0 : versionCell(entry),
-          // Named where it can be acted on: a peer that answered with a bad
-          // document is reachable but broken, which is an operator task and
-          // reads nothing like a sleeping laptop.
-          error: entry?.last_error ?? null
-        };
-      });
-      if (options.json) {
-        process.stdout.write(`${JSON.stringify(rows)}
-`);
-        return;
-      }
-      if (rows.length === 0) {
-        process.stdout.write(
-          options.all ? "no peers configured, and no hosts in ~/.ssh/config\n" : "no peers configured. See what could be added with: murmur peer list --all\n"
-        );
-        return;
-      }
-      const showPeerColumn = rows.some((row) => !row.peer);
-      const showVersionColumn = rows.some((row) => row.version !== void 0);
-      process.stdout.write(
-        formatTable([
-          [
-            "NAME",
-            "TARGET",
-            ...showPeerColumn ? ["PEER"] : [],
-            "HOSTNAME",
-            ...showVersionColumn ? ["VERSION"] : [],
-            "LAST SEEN",
-            "SSH"
-          ],
-          ...rows.map((row) => [
-            row.name,
-            row.target,
-            ...showPeerColumn ? [row.peer ? "yes" : "-"] : [],
-            row.hostname ?? "unknown",
-            ...showVersionColumn ? [row.version?.text ?? "-"] : [],
-            row.last_seen ?? "-",
-            row.ssh
-          ])
-        ])
-      );
-      const incompatible = rows.filter((row) => row.version?.incompatible);
-      if (incompatible.length > 0) {
-        process.stdout.write(
-          `
-${incompatible.length} peer${incompatible.length === 1 ? "" : "s"} speak an incompatible snapshot version; state will not sync until murmur versions match: ${incompatible.map((row) => row.name).join(", ")}
-`
-        );
-      }
-      const broken = rows.filter((row) => row.error);
-      for (const row of broken) {
-        process.stdout.write(`
-${row.name}: last attempt failed -- ${row.error}
-`);
-      }
-      const addable = rows.filter((row) => !row.peer).length;
-      if (addable > 0) {
-        process.stdout.write(
-          `
-${addable} host${addable === 1 ? "" : "s"} not yet a peer. Add one with: murmur peer add <name>
-`
-        );
-      }
-    } finally {
-      store.close();
-    }
-  });
-}
-
 // src/cli/pick.ts
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/agents.ts
 import { spawnSync } from "child_process";
+function sessionLeaf(session) {
+  const leaf = session.split("/").filter(Boolean).at(-1);
+  return leaf ?? session;
+}
 function agentLabel(agent) {
-  const name = agent.agent_name ?? agent.pi_session ?? agent.window_name ?? agent.session_name;
+  const name = agent.agent_name ?? agent.pi_session ?? agent.window_name ?? (agent.session_name === null ? null : sessionLeaf(agent.session_name));
   return terminalText(name ?? agent.window);
 }
 function agentLocation(agent) {
@@ -1712,9 +2265,9 @@ function status(store, identity, now = Date.now()) {
     }))
   };
 }
-async function statusWithCollect(store, identity, now = Date.now(), channel = ssh, mux = tmux) {
+async function statusWithCollect(store, identity, now = Date.now(), channel = ssh, options = {}) {
   try {
-    await collect(store, channel, now, void 0, mux);
+    await collect(store, channel, now, options);
   } catch {
   }
   return status(store, identity, now);
@@ -1752,8 +2305,8 @@ var ANSI_AT_START = new RegExp(`^${ANSI_PATTERN}`);
 var ANSI_AT_END = new RegExp(`(?:${ANSI_PATTERN})+$`);
 var REMOTE = "\x1B[36m";
 var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
 var CREW_MARK = "crew ";
 function isVisible(agent) {
   return agent.driver === "human" || NEEDS_HUMAN.some((kind) => agent.attention.includes(kind));
@@ -1824,11 +2377,11 @@ function pickerRow(agent, showHost, current, local = agent.local) {
   const state = renderState(agent);
   const colour = COLOUR[state] ?? "";
   const glyph = GLYPH[state] ?? "?";
-  const marker = current ? `${BOLD}\u25C6${RESET}` : " ";
-  const name = agent.agent_name ?? agent.pi_session ?? agentLabel(agent);
-  const host = showHost ? local ? `${DIM}  here${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}` : "";
+  const marker = current ? `${BOLD}\u25C6${RESET2}` : " ";
+  const name = agentLabel(agent);
+  const host = showHost ? local ? `${DIM2}  here${RESET2}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET2}` : "";
   const group = agent.workstream ?? agent.session_name;
-  const workstream = group && group !== name ? `${DIM}${terminalText(group)}${RESET}` : "";
+  const workstream = group && group !== name ? `${DIM2}${terminalText(group)}${RESET2}` : "";
   const extra = agent.attention.filter((kind) => kind !== state);
   const flags = [
     agent.driver === "orchestrated" ? "crew" : "",
@@ -1841,12 +2394,14 @@ function pickerRow(agent, showHost, current, local = agent.local) {
     age(agent.updated_at === null ? null : Date.now() - agent.updated_at)
   ].filter(Boolean).join(" ");
   const label = [
-    `${marker} ${colour}${glyph}${RESET}`,
-    `${colour}${pad(state, COLUMNS.state)}${RESET}`,
-    pad(`${BOLD}${terminalText(name)}${RESET}`, COLUMNS.name),
+    `${marker} ${colour}${glyph}${RESET2}`,
+    `${colour}${pad(state, COLUMNS.state)}${RESET2}`,
+    // No `terminalText` here: `agentLabel` already sanitised it, and wrapping it
+    // again implied this value was raw.
+    pad(`${BOLD}${name}${RESET2}`, COLUMNS.name),
     pad(workstream, showHost ? COLUMNS.stream : COLUMNS.streamWide),
     showHost ? pad(host, COLUMNS.host) : "",
-    flags ? `${DIM}${flags}${RESET}` : ""
+    flags ? `${DIM2}${flags}${RESET2}` : ""
   ].filter(Boolean).join(" ");
   return `${agent.host_id}	${agent.pane}	${label}`;
 }
@@ -1854,11 +2409,16 @@ function previewText(store, agent) {
   const state = renderState(agent);
   const colour = COLOUR[state] ?? "";
   const head = [
-    `${colour}${GLYPH[state] ?? "?"} ${state}${RESET}  ${BOLD}${agent.agent_name ? terminalText(agent.agent_name) : agentLabel(agent)}${RESET}`,
+    // Same one chain the row uses. This was
+    // `agent.agent_name ? terminalText(agent.agent_name) : agentLabel(agent)`,
+    // whose true branch is exactly what `agentLabel` does first anyway, down to
+    // the `terminalText` -- a no-op fork that existed only to fall out of step
+    // with the row above it.
+    `${colour}${GLYPH[state] ?? "?"} ${state}${RESET2}  ${BOLD}${agentLabel(agent)}${RESET2}`,
     // Says where, and whether "where" is this machine. The glance below is a
     // local capture-pane or an ssh depending on this one fact, so it belongs in
     // the header rather than being inferred from a hostname.
-    agent.local ? `${DIM}here  ${agentLocation(agent)}${RESET}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET}  ${DIM}${agentLocation(agent)}${RESET}`
+    agent.local ? `${DIM2}here  ${agentLocation(agent)}${RESET2}` : `${REMOTE}\u2192 ${terminalText(agent.host)}${RESET2}  ${DIM2}${agentLocation(agent)}${RESET2}`
   ];
   const facts = [
     `activity ${agent.activity ?? "none (attention only)"}`,
@@ -1872,15 +2432,15 @@ function previewText(store, agent) {
     // three-hour-old fact, and collapsing them is how that read as fresh.
     agent.updated_at === null ? "" : `said     ${timestamp2(agent.updated_at)}`,
     agent.local ? "" : `fetched  ${agent.fetched_at === null ? "never" : timestamp2(agent.fetched_at)}`,
-    agent.freshness === "stale" ? `${DIM}host is stale: fields below are last-known${RESET}` : ""
+    agent.freshness === "stale" ? `${DIM2}host is stale: fields below are last-known${RESET2}` : ""
   ].filter(Boolean);
   const pane = glance(store, agent);
   const live = pane?.trimEnd() ? [
-    `${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`,
+    `${DIM2}\u2500\u2500 pane \u2500\u2500${RESET2}`,
     pane.trimEnd().slice(-PREVIEW_MESSAGE_MAX * 20)
   ] : [
-    `${DIM}\u2500\u2500 pane \u2500\u2500${RESET}`,
-    `${DIM}unavailable (host unreachable, or pane gone)${RESET}`
+    `${DIM2}\u2500\u2500 pane \u2500\u2500${RESET2}`,
+    `${DIM2}unavailable (host unreachable, or pane gone)${RESET2}`
   ];
   return [...head, "", ...facts, "", ...live].join("\n");
 }
@@ -1892,7 +2452,7 @@ function runPreview(store, paneId, hostId) {
   );
   process.stdout.write(
     agent ? `${previewText(store, agent)}
-` : `${DIM}${paneId} is no longer here.${RESET}
+` : `${DIM2}${paneId} is no longer here.${RESET2}
 `
   );
 }
@@ -1901,7 +2461,9 @@ async function runPick(store, options = {}, deps = {}) {
   const jumpTo = deps.jump ?? jumpToAgent;
   const identity = requireIdentity();
   if (!identity) return;
-  const view = await statusWithCollect(store, identity, Date.now(), ssh, deps.mux ?? tmux);
+  const view = await statusWithCollect(store, identity, Date.now(), ssh, {
+    mux: deps.mux ?? tmux
+  });
   const agents = view.panes.filter((agent2) => options.all || isVisible(agent2));
   const hidden = view.panes.length - agents.length;
   if (agents.length === 0) {
@@ -1919,7 +2481,7 @@ async function runPick(store, options = {}, deps = {}) {
     const state = renderState(agent2);
     counts.set(state, (counts.get(state) ?? 0) + 1);
   }
-  const prompt = RENDER_PRIORITY.filter((state) => counts.get(state)).map((state) => `${COLOUR[state]}${GLYPH[state]}${counts.get(state)}${RESET}`).join(" ");
+  const prompt = RENDER_PRIORITY.filter((state) => counts.get(state)).map((state) => `${COLOUR[state]}${GLYPH[state]}${counts.get(state)}${RESET2}`).join(" ");
   const basePrompt = `${prompt}${prompt ? "  " : ""}`;
   const self = process.argv[1] ?? "murmur";
   const allFlag = options.all ? " --all" : "";
@@ -2079,7 +2641,9 @@ function registerStatus(program2) {
     if (!identity) return;
     const store = openStore();
     try {
-      const view = await statusWithCollect(store, identity);
+      const view = await statusWithCollect(store, identity, Date.now(), ssh, {
+        floorMs: COLLECT_FLOOR_MS
+      });
       process.stdout.write(
         options.json ? `${JSON.stringify(view, null, 2)}
 ` : tmuxStatus(view)
@@ -2100,6 +2664,7 @@ registerCollect(program);
 registerClear(program);
 registerNotify(program);
 registerPeer(program);
+registerDoctor(program);
 registerStatus(program);
 registerPick(program);
 program.parse();