moshcode 0.36.0 → 0.38.0

package/README.md

@@ -183,13 +183,49 @@ moshcode herd ui
 │   ✕ stop   │                                   │
 │   ⊞ tile   │                                   │
 │   ← detach │                                   │
-└────────────┴───────────────────────────────────┘
+│            │                                   │
+│ enter ▸ …  │                                   │
+│ F12 ▸ …    │                                   │
+├────────────┴───────────────────────────────────┤
+│ mosh ▸ ps · start claude · show <n> · detach   │
+└────────────────────────────────────────────────┘
 ```
 
 Members and actions down the left, the selected member's **real terminal** on
 the right. Click a member to show it; click an action to start a shell, start an
 agent, or stop the selected one. `q` detaches and leaves everything running.
 
+Click the member that is already on screen — or press Enter — and the keyboard
+goes to it, so you are typing at the agent itself.
+
+### The mosh bar
+
+The row along the bottom is a mosh prompt, and it is always there. **F12** jumps
+to it from anywhere, including from inside an agent that has taken the keyboard,
+which makes it the way out of a session you cannot otherwise leave. Esc goes
+back to the session; `detach` leaves with everything still running.
+
+It takes any `moshcode herd` verb, so you can start a second agent without
+leaving the first:
+
+```
+mosh ▸ start claude          # another agent, now on screen
+mosh ▸ show api              # put a different member up
+mosh ▸ ps                    # the roster, over the session, then out of the way
+```
+
+`attach` means `show` here — in a workspace the word means "put it in the
+content pane", and the real attach would be a tmux client inside a tmux client.
+Output grows the bar over the content for as long as you are reading it, then it
+collapses back to one row.
+
+**`moshcode attach <name>` gets the bar too.** A session you attach to directly
+grows the same one-line prompt along the bottom for as long as you are there,
+and it is taken away again when you detach — so a member is a plain member when
+nobody is looking at it. `show <name>` from that bar switches you to another
+member (and gives that one a bar before you land in it). The bar is the bottom
+row either way, which is why one key finds it in both places.
+
 The right-hand pane is not a picture of a session — it *is* the session's pane,
 moved in. tmux's model is session → window → pane, so moving between *windows*
 cannot keep anything on screen; but `join-pane` moves a running pane into an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/cli-schema.mjs

@@ -115,10 +115,13 @@ export const CORE_CLI_COMMANDS = [
     name: "attach",
     group: "runtime",
     description: "attach this terminal to a herd session",
-    synopsis: [["moshcode attach <name>", "detach again with Ctrl-b d (or Ctrl-] without tmux)"]],
+    synopsis: [["moshcode attach <name>", "F12 for the mosh bar · Ctrl-b d detaches (Ctrl-] without tmux)"]],
     examples: [["moshcode attach api", ""]],
     seeAlso: ["ps", "herd", "kill"],
-    note: "detaching leaves the session running; ending it is `moshcode kill`. "
+    note: "under tmux the session gets a one-line mosh bar along the bottom for as long as you are "
+      + "attached, so the way out is on screen even when the agent has the keyboard: F12 reaches it, "
+      + "Esc goes back, `detach` leaves. it is taken away again when you detach. "
+      + "detaching leaves the session running; ending it is `moshcode kill`. "
       + "the whole herd shares one tmux server, so from inside any session Ctrl-b s picks another, "
       + "Ctrl-b ) and Ctrl-b ( step through them, and Ctrl-b L goes back to the last one — "
       + "no switcher under the no-tmux fallback, where Ctrl-] detaches instead.",
@@ -745,9 +748,17 @@ export const HERD_VERBS = [
   { name: "untile", description: "put tiled members back in their own sessions",
     synopsis: [["moshcode herd untile", ""]] },
   { name: "ui", description: "sidebar of members and actions, selected one beside it",
-    synopsis: [["moshcode herd ui", "click a member to show it · s shell · a agent · x stop · q detach"]],
+    synopsis: [["moshcode herd ui", "click a member to show it · click it again to type in it · F12 for the mosh bar"]],
     flags: [],
     examples: [["moshcode herd ui", "the workspace — start here"]] },
+  { name: "bar", description: "the one-line mosh prompt under the session (runs inside the workspace)",
+    synopsis: [["moshcode herd bar", "F12 reaches it from inside an agent · Esc goes back · detach leaves"]],
+    flags: [],
+    examples: [
+      ["F12", "jump to the bar from anywhere, even mid-agent"],
+      ["start claude", "another agent, without leaving this one"],
+      ["show api", "put a different member on screen"],
+    ] },
   { name: "run", description: "run ANY command in the herd — an agent moshcode does not ship, a build, a script",
     synopsis: [["moshcode herd run [--name <slug>] -- <command…>", "everything after -- is the command"]],
     flags: [

package/src/herd-bar.mjs

@@ -0,0 +1,321 @@
+// `moshcode herd bar` — a one-line mosh prompt pinned under the session.
+//
+// WHY THIS EXISTS. The workspace put a real agent in the content pane, which is
+// the point of it — but a real agent takes the keyboard. Click into claude and
+// every sidebar key stops working, and with tmux's status line off there is
+// nothing on screen that says how to get back out. You are looking at one agent
+// with no visible way to leave it, which is exactly the complaint.
+//
+// A status line would have been the small fix: one line of text that never goes
+// away. But a line you can only read answers "how do I get out" and nothing
+// else — you still cannot start a second agent without leaving first. So the
+// line takes input. It is the same surface as the CLI (every `moshcode herd`
+// verb works here) which means the escape hatch and the command line are one
+// thing rather than two.
+//
+// The bar is one row until it has something to say, then it grows over the
+// content, then it collapses again. Output has to go somewhere, and stealing
+// rows from the agent for a moment is cheaper than a pane that is mostly empty.
+import { spawnSync } from "node:child_process";
+
+import { tmux } from "./herd.mjs";
+import { acid, ash, bone } from "./ui.mjs";
+
+export const BAR_TITLE = "mosh-bar";
+export const SIDEBAR_TITLE = "herd";
+export const BAR_HEIGHT = 1;
+export const BAR_OPEN_HEIGHT = 14;
+
+/** The key that reaches the bar from anywhere, including from inside an agent. */
+export const BAR_KEY = "F12";
+
+export const HINT = "ps · start claude · show <n> · kill <n> · detach · help";
+
+/* ------------------------------------------------------------- pane geometry */
+
+/**
+ * Which pane is which, by title.
+ *
+ * Titles rather than indexes or ids: a pane keeps its title across `join-pane`,
+ * which is the whole reason the workspace can move panes around at all, and
+ * indexes shift every time one arrives or leaves.
+ */
+export function paneRoles(target, { runner = spawnSync } = {}) {
+  const roles = { sidebar: null, content: null, bar: null };
+  const r = tmux(["list-panes", "-t", target, "-F", "#{pane_id}\t#{pane_title}"], { runner });
+  if (!r.ok) return roles;
+  for (const line of r.stdout.split("\n")) {
+    const [paneId, title] = line.split("\t");
+    if (!paneId) continue;
+    if (title === BAR_TITLE) roles.bar = { paneId, title };
+    else if (title === SIDEBAR_TITLE) roles.sidebar = { paneId, title };
+    else roles.content = { paneId, title };
+  }
+  return roles;
+}
+
+/** How a bar pane starts itself. Separated so tests can run a stand-in. */
+export function barCommand(self = process.argv[1]) {
+  return `${process.execPath} ${self} herd bar`;
+}
+
+/** The window a pane lives in, as a target string. */
+export function ownTarget({ runner = spawnSync, me = process.env.TMUX_PANE } = {}) {
+  if (!me) return null;
+  const r = tmux(["display-message", "-p", "-t", me, "#{session_name}:#{window_index}"], { runner });
+  return r.ok ? r.stdout.trim() || null : null;
+}
+
+/**
+ * Put a bar at the bottom of `target`, or find the one already there.
+ *
+ * Idempotent, because both the workspace and every attach want one and neither
+ * should care which of them got there first.
+ */
+export function ensureBar(target, { runner = spawnSync, command = null } = {}) {
+  const existing = paneRoles(target, { runner }).bar;
+  if (existing) return { paneId: existing.paneId, created: false };
+  const made = tmux(
+    ["split-window", "-t", target, "-f", "-v", "-l", String(BAR_HEIGHT), "-P", "-F", "#{pane_id}", command],
+    { runner },
+  );
+  if (!made.ok) return { paneId: null, created: false };
+  const paneId = made.stdout.trim().split("\n")[0];
+  if (!paneId) return { paneId: null, created: false };
+  tmux(["select-pane", "-t", paneId, "-T", BAR_TITLE], { runner });
+  return { paneId, created: true };
+}
+
+/**
+ * Bind the key that reaches the bar.
+ *
+ * `{bottom-right}` rather than a pane id, so one binding serves the workspace
+ * and every attached session — in both, the bar is the bottom row. A pane id
+ * would have pinned the key to whichever bar happened to be built last.
+ *
+ * The root table is what makes it work at all: tmux claims the key before the
+ * pane's application ever sees it, which is the whole point when the pane holds
+ * an agent that has taken the keyboard.
+ */
+export function bindJumpKey({ runner = spawnSync } = {}) {
+  return tmux(["bind-key", "-n", BAR_KEY, "select-pane", "-t", "{bottom-right}"], { runner }).ok;
+}
+
+/** Drop the bar from a window, leaving whatever else is in it alone. */
+export function removeBar(target, { runner = spawnSync } = {}) {
+  const roles = paneRoles(target, { runner });
+  if (!roles.bar || !roles.content) return false;
+  return tmux(["kill-pane", "-t", roles.bar.paneId], { runner }).ok;
+}
+
+/**
+ * Take the bar back out of every session nobody is looking at.
+ *
+ * A bar left behind is not cosmetic: `kill` ends a member by killing its pane,
+ * so a session holding a leftover bar outlives the member it was named for and
+ * keeps showing up on the roster. Detaching cleans up after itself, but a
+ * crashed client cannot, so this also runs on the way in.
+ *
+ * Sessions with a client attached are skipped — someone else is using that bar.
+ */
+export function sweepBars({ runner = spawnSync, except = null } = {}) {
+  const r = tmux(["list-panes", "-a", "-F",
+    "#{session_name}\t#{window_index}\t#{pane_title}\t#{session_attached}"], { runner });
+  if (!r.ok) return 0;
+  const windows = new Map();
+  for (const line of r.stdout.split("\n")) {
+    const [session, window, title, attached] = line.split("\t");
+    if (!session || session === except || attached !== "0") continue;
+    const key = `${session}:${window}`;
+    const seen = windows.get(key) || { bars: 0, others: 0 };
+    if (title === BAR_TITLE) seen.bars += 1; else seen.others += 1;
+    windows.set(key, seen);
+  }
+  let removed = 0;
+  for (const [target, seen] of windows) {
+    if (seen.bars && seen.others && removeBar(target, { runner })) removed += 1;
+  }
+  return removed;
+}
+
+/* --------------------------------------------------------------- line editing */
+
+/**
+ * One keystroke against the current line. Pure, so the editor is testable
+ * without a terminal — the bar itself is then only plumbing.
+ */
+export function editLine(line, key) {
+  if (key === "\r" || key === "\n") return { line, action: "submit" };
+  if (key === "\x1b") return { line: "", action: "escape" };
+  if (key === "\x03") return { line: "", action: "escape" };          // Ctrl-C
+  if (key === "\x15") return { line: "", action: "edit" };             // Ctrl-U
+  if (key === "\x17") return { line: line.replace(/\S+\s*$/, ""), action: "edit" }; // Ctrl-W
+  if (key === "\x7f" || key === "\b") return { line: line.slice(0, -1), action: "edit" };
+  if (key.length === 1 && key >= " " && key !== "\x7f") return { line: line + key, action: "edit" };
+  return { line, action: "none" };
+}
+
+/**
+ * What a typed line means.
+ *
+ * `attach` deliberately becomes `show`. Running the real attach from in here
+ * would start a tmux client inside the client already showing this pane, which
+ * tmux refuses — and the thing the word means in a workspace is "put it in the
+ * content pane" anyway.
+ */
+export function resolveCommand(input) {
+  const argv = String(input || "").trim().split(/\s+/).filter(Boolean);
+  if (!argv.length) return { kind: "empty", argv: [] };
+  const [verb, ...rest] = argv;
+  if (verb === "detach" || verb === "exit" || verb === "quit") return { kind: "detach", argv: rest };
+  if (verb === "show" || verb === "attach" || verb === "fg") return { kind: "show", argv: rest };
+  if (verb === "help" || verb === "?") return { kind: "help", argv: rest };
+  if (verb === "clear") return { kind: "clear", argv: rest };
+  return { kind: "herd", argv };
+}
+
+/** The prompt line. The hint is what makes the way out discoverable at rest. */
+export function renderPrompt(line, { cols = 80, showHint = true } = {}) {
+  const prompt = `${acid("mosh")} ${bone("▸")} `;
+  if (!line && showHint) return `${prompt}${ash(HINT.slice(0, Math.max(0, cols - 8)))}`;
+  return `${prompt}${line}`;
+}
+
+export function helpLines() {
+  return [
+    "the bar takes any moshcode herd verb:",
+    "  ps                 the roster        start claude       new agent",
+    "  show <name>        put it on screen  shell              new shell",
+    "  kill <name>        end one           tile               all at once",
+    "  read <name>        its last screen   prompt <n> <text>  type into it",
+    "",
+    `${BAR_KEY} comes back here from anywhere · Esc returns to the session · detach leaves`,
+  ];
+}
+
+/* ----------------------------------------------------------------- the bar */
+
+/**
+ * Runs inside the one-line pane at the bottom of the workspace.
+ */
+export async function herdBar({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  runner = spawnSync,
+  target = null,
+  run = null,
+} = {}) {
+  const me = process.env.TMUX_PANE;
+  // The bar runs in the workspace AND under a plain attach, so it asks where it
+  // is rather than assuming. Everything below keys off that one answer.
+  const here = target || ownTarget({ runner, me }) || "herd:ui";
+  const inWorkspace = () => !!paneRoles(here, { runner }).sidebar;
+  const herdCommand = run || (async (argv, options) => (await import("./herd-cli.mjs")).herdCommand(argv, options));
+
+  let line = "";
+  let open = false;
+
+  const cols = () => stdout.columns || 80;
+  const collapse = () => {
+    if (!open) return;
+    open = false;
+    tmux(["resize-pane", "-t", me, "-y", String(BAR_HEIGHT)], { runner });
+  };
+  const expand = (rows) => {
+    open = true;
+    tmux(["resize-pane", "-t", me, "-y", String(Math.min(BAR_OPEN_HEIGHT, rows + 2))], { runner });
+  };
+  const draw = () => {
+    stdout.write(`\x1b[2J\x1b[H${renderPrompt(line, { cols: cols() })}`);
+  };
+  const show = (lines) => {
+    expand(lines.length);
+    stdout.write(`\x1b[2J\x1b[H${lines.join("\r\n")}\r\n${renderPrompt("", { cols: cols(), showHint: false })}`);
+  };
+  /** Give the keyboard back to whatever is on screen. */
+  const toContent = () => {
+    const roles = paneRoles(here, { runner });
+    if (roles.content) tmux(["select-pane", "-t", roles.content.paneId], { runner });
+  };
+
+  /**
+   * `show` means two different things and both are right.
+   *
+   * In the workspace it swaps the content pane. Under a plain attach there is
+   * no content pane to swap, so it switches the client to that member — and
+   * gives that member a bar first, or you would arrive somewhere with no way
+   * back out, which is the bug this whole thing exists to fix.
+   */
+  const showElsewhere = async (name) => {
+    const { paneIndex } = await import("./herd.mjs");
+    const found = paneIndex({ runner }).get(name);
+    if (!found) return false;
+    ensureBar(`${found.session}:${found.windowId}`, { runner, command: barCommand() });
+    return tmux(["switch-client", "-t", found.session], { runner }).ok;
+  };
+
+  const submit = async () => {
+    const typed = line;
+    line = "";
+    const command = resolveCommand(typed);
+    if (command.kind === "empty") { collapse(); draw(); toContent(); return true; }
+    if (command.kind === "clear") { collapse(); draw(); return true; }
+    if (command.kind === "help") { show(helpLines()); return true; }
+    if (command.kind === "detach") { tmux(["detach-client"], { runner }); return false; }
+    if (command.kind === "show") {
+      const [name] = command.argv;
+      let okShown = false;
+      if (name && inWorkspace()) {
+        const { showMember } = await import("./herd-workspace.mjs");
+        okShown = showMember(name, { runner, me });
+      } else if (name) {
+        okShown = await showElsewhere(name);
+      }
+      if (!okShown) { show([ash(`no session named ${JSON.stringify(name || "")} — try ps`)]); return true; }
+      collapse(); draw(); toContent();
+      return true;
+    }
+    const out = [];
+    await herdCommand(command.argv, { write: (s) => out.push(...String(s).split("\n")) });
+    if (out.length) show(out);
+    else { collapse(); draw(); }
+    return true;
+  };
+
+  /**
+   * Keep the bar one row.
+   *
+   * tmux scales panes proportionally when the window resizes, so a bar built
+   * before a client attached came back three rows tall once one did — the pane
+   * was created against an 80x24 window and stretched to fit 100x30. Nothing
+   * outside can predict when that happens, but the bar gets a resize event for
+   * it, so the bar is the thing that fixes it.
+   */
+  const keepThin = () => {
+    if (open) return;
+    tmux(["resize-pane", "-t", me, "-y", String(BAR_HEIGHT)], { runner });
+  };
+
+  try { stdin.setRawMode?.(true); } catch { /* not a tty */ }
+  stdin.resume();
+  stdout.on?.("resize", () => { keepThin(); draw(); });
+  keepThin();
+  draw();
+
+  await new Promise((resolve) => {
+    stdin.on("data", async (buf) => {
+      for (const key of String(buf)) {
+        const next = editLine(line, key);
+        line = next.line;
+        if (next.action === "submit") {
+          if (!(await submit())) { resolve(); return; }
+          continue;
+        }
+        if (next.action === "escape") { collapse(); draw(); toContent(); continue; }
+        if (next.action === "edit") { if (open) { collapse(); } draw(); }
+      }
+    });
+  });
+
+  return 0;
+}

package/src/herd-cli.mjs

@@ -10,7 +10,7 @@ import path from "node:path";
 
 import {
   attachSession, capture, defaultName, detectSubstrate, forgetSession, HERD_SOCKET,
-  herdDir, killSession, listSessions, readManifest, rememberSession, sendKeys, sendPrompt,
+  herdDir, killSession, listSessions, paneIndex, readManifest, rememberSession, sendKeys, sendPrompt,
   slugifyName, startSession, stopRuntime, substrateNote, validName, NAME_RE,
 } from "./herd.mjs";
 import { clearReport, reportState, STATES, withState } from "./herd-state.mjs";
@@ -178,7 +178,7 @@ export function herdStart(argv, { write = console.log } = {}) {
   }
   write(ok(`${bone(name)} — ${key} running in the herd. the prompt is yours.`));
   if (flags.agent) write(warn("agent mode: native approvals are bypassed or auto-approved."));
-  write(info(`attach: ${acid(`moshcode attach ${name}`)} · roster: ${acid("moshcode ps")}`));
+  write(info(`workspace: ${acid("moshcode herd ui")} · attach: ${acid(`moshcode attach ${name}`)} · roster: ${acid("moshcode ps")}`));
   const note = substrateNote(substrate);
   if (note) write(info(note));
   return EXIT.matched;
@@ -253,7 +253,7 @@ export function herdRun(argv, { write = console.log, shell = false } = {}) {
     return EXIT.matched;
   }
   write(ok(`${bone(name)} — ${label} running in the herd. the prompt is yours.`));
-  write(info(`attach: ${acid(`moshcode attach ${name}`)} · roster: ${acid("moshcode ps")}`));
+  write(info(`workspace: ${acid("moshcode herd ui")} · attach: ${acid(`moshcode attach ${name}`)} · roster: ${acid("moshcode ps")}`));
   return EXIT.matched;
 }
 
@@ -328,9 +328,32 @@ export async function herdAttach(argv, { write = console.log } = {}) {
   // this whole feature is someone quitting a session they meant to leave
   // running, and the only defence is telling them the key first.
   const substrate = detectSubstrate();
-  write(info(substrate === "tmux" ? "detach with Ctrl-b d — the session keeps running." : "detach with Ctrl-] — the session keeps running."));
+
+  // Give the session a mosh bar, so the way out is on screen the whole time
+  // rather than in a line that the agent's first repaint scrolls away. Only a
+  // member sitting in its own session: a tiled one shares a window with its
+  // neighbours and would be handing them a footer they did not ask for.
+  const bar = await import("./herd-bar.mjs");
+  let barTarget = null;
+  if (substrate === "tmux") {
+    bar.sweepBars({ runner: undefined, except: "herd" });
+    const found = paneIndex().get(name);
+    if (found && found.session === name) {
+      barTarget = `${found.session}:${found.windowId}`;
+      bar.ensureBar(barTarget, { command: bar.barCommand() });
+      bar.bindJumpKey({});
+    }
+  }
+
+  write(info(substrate === "tmux"
+    ? `detach with Ctrl-b d — the session keeps running.${barTarget ? ` ${bar.BAR_KEY} for the mosh bar.` : ""}`
+    : "detach with Ctrl-] — the session keeps running."));
 
   const result = await attachSession(name, { substrate });
+  // Take it back out on the way through, so a member is a member again: `kill`
+  // ends one by killing its pane, and a session still holding a bar would
+  // outlive the member and keep its name on the roster.
+  if (barTarget) bar.removeBar(barTarget, {});
   if (!result.ok) { write(err(String(result.error?.message || result.error))); return EXIT.usage; }
 
   const after = findSession(name);
@@ -729,6 +752,7 @@ const VERBS = {
   // inside it for machines with no tmux to swap panes on.
   ui: async (argv, options) => (await import("./herd-workspace.mjs")).herdUi(argv, options),
   sidebar: async (argv, options) => (await import("./herd-workspace.mjs")).herdSidebar(options),
+  bar: async (argv, options) => (await import("./herd-bar.mjs")).herdBar(options),
   tile: async (argv, options) => (await import("./herd-tile.mjs")).herdTile(argv, options),
   untile: async (argv, options) => (await import("./herd-tile.mjs")).herdUntile(argv, options),
   ps: herdPs, list: herdPs, status: herdStatus,

package/src/herd-workspace.mjs

@@ -21,6 +21,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { HERD_SOCKET, detectSubstrate, paneIndex, readManifest, tmux } from "./herd.mjs";
 import { roster } from "./herd-cli.mjs";
 import { groupByHerd, parseInput } from "./herd-ui.mjs";
+import { BAR_KEY, BAR_TITLE, SIDEBAR_TITLE, barCommand, bindJumpKey, ensureBar, paneRoles } from "./herd-bar.mjs";
 import { acid, amber, ash, bone, danger, dim, err, info, ok } from "./ui.mjs";
 
 export const WORKSPACE = "herd";
@@ -59,15 +60,12 @@ export async function herdUi(argv = [], { write = console.log, spawner = spawn,
     const sidebar = `${process.execPath} ${self} herd sidebar`;
     const made = tmux(["new-session", "-d", "-s", WORKSPACE, "-n", WINDOW, sidebar], { runner });
     if (!made.ok) { write(err(made.stderr.trim() || "could not open the workspace")); return 1; }
-    // The sidebar is the "main" pane of a main-vertical layout, which is what
-    // pins it to the left at a fixed width while the content pane takes the
-    // rest and follows the terminal when it resizes.
-    tmux(["set-option", "-t", WORKSPACE, "main-pane-width", String(SIDEBAR_WIDTH)], { runner });
     tmux(["set-option", "-t", WORKSPACE, "mouse", "on"], { runner });
     tmux(["set-option", "-t", WORKSPACE, "status", "off"], { runner });
     tmux(["set-option", "-t", WORKSPACE, "pane-border-status", "top"], { runner });
     tmux(["set-option", "-t", WORKSPACE, "pane-border-format", " #{pane_title} "], { runner });
-    tmux(["select-pane", "-t", `${TARGET}.0`, "-T", "herd"], { runner });
+    tmux(["select-pane", "-t", `${TARGET}.0`, "-T", SIDEBAR_TITLE], { runner });
+    buildBar({ runner });
   }
 
   return new Promise((resolve) => {
@@ -82,15 +80,33 @@ export async function herdUi(argv = [], { write = console.log, spawner = spawn,
   });
 }
 
+/* ------------------------------------------------------------------ the bar */
+
+/** Add the one-line mosh prompt under the content, and the key that reaches it. */
+export function buildBar({ runner = spawnSync, command = barCommand() } = {}) {
+  const { paneId } = ensureBar(TARGET, { runner, command });
+  if (!paneId) return null;
+  bindJumpKey({ runner });
+  tmux(["select-pane", "-t", `${TARGET}.0`], { runner });
+  return paneId;
+}
+
 /* ------------------------------------------------------------- the swapping */
 
-/** The content pane currently on the right, if there is one. */
+/**
+ * The content pane — the one that is neither the sidebar nor the bar.
+ *
+ * Excluding by title rather than "any pane that is not me": the bar made that
+ * shortcut wrong, and wrong here means a swap parks the bar into a session
+ * named after it and the prompt vanishes off the bottom of the screen.
+ */
 export function contentPane({ runner = spawnSync, me = process.env.TMUX_PANE } = {}) {
   const r = tmux(["list-panes", "-t", TARGET, "-F", "#{pane_id}\t#{pane_title}"], { runner });
   if (!r.ok) return null;
   for (const line of r.stdout.split("\n")) {
     const [paneId, title] = line.split("\t");
     if (!paneId || paneId === me) continue;
+    if (title === BAR_TITLE || title === SIDEBAR_TITLE) continue;
     return { paneId, title };
   }
   return null;
@@ -126,16 +142,34 @@ export function showMember(name, { runner = spawnSync, me = process.env.TMUX_PAN
   if (!wanted) return false;
 
   if (current) parkPane(current.paneId, current.title, { runner });
-  const joined = tmux(["join-pane", "-s", wanted.paneId, "-t", TARGET], { runner });
+
+  // Split the SIDEBAR rather than laying the window out.
+  //
+  // `select-layout main-vertical` was the obvious way to do this and it is the
+  // wrong one once a footer exists: it owns every pane in the window, so it
+  // dragged the bar into the right-hand column and gave it an equal share, and
+  // putting it back was a second fight every swap. Splitting the sidebar
+  // touches only the region above the footer, which leaves the bar a full-width
+  // row at the bottom and needs no correction afterwards.
+  const roles = paneRoles(TARGET, { runner });
+  const anchor = roles.sidebar?.paneId || me;
+  const joined = anchor
+    ? tmux(["join-pane", "-h", "-s", wanted.paneId, "-t", anchor], { runner })
+    : tmux(["join-pane", "-s", wanted.paneId, "-t", TARGET], { runner });
   if (!joined.ok) return false;
-  tmux(["select-layout", "-t", TARGET, "main-vertical"], { runner });
-  // main-vertical resets the main pane's width from the option, so re-assert it
-  // after every swap or the sidebar creeps wider each time.
-  tmux(["set-option", "-t", WORKSPACE, "main-pane-width", String(SIDEBAR_WIDTH)], { runner });
+  if (anchor) tmux(["resize-pane", "-t", anchor, "-x", String(SIDEBAR_WIDTH)], { runner });
   tmux(["select-pane", "-t", me], { runner });
   return true;
 }
 
+/** Hand the keyboard to the session on screen. */
+export function focusContent({ runner = spawnSync, me = process.env.TMUX_PANE } = {}) {
+  const current = contentPane({ runner, me });
+  if (!current) return false;
+  tmux(["select-pane", "-t", current.paneId], { runner });
+  return true;
+}
+
 /* --------------------------------------------------------------- the render */
 
 const MARK = { blocked: "!", working: "~", done: "✓", idle: "·", gone: "×", unknown: "?" };
@@ -159,6 +193,11 @@ export function sidebarRows(sessions) {
   }
   rows.push({ kind: "gap" }, { kind: "heading", text: "ACTIONS" });
   for (const action of ACTIONS) rows.push({ kind: "action", action });
+  // The two keys that stop the workspace being a one-way trip, on screen at all
+  // times. Everything else here is discoverable by looking; these are not.
+  rows.push({ kind: "gap" });
+  rows.push({ kind: "hint", text: "enter ▸ type in it" });
+  rows.push({ kind: "hint", text: `${BAR_KEY} ▸ mosh bar` });
   return rows.map((row, i) => ({ ...row, line: i + 1 }));
 }
 
@@ -168,6 +207,7 @@ export function renderSidebar(rows, { selected, showing, width = SIDEBAR_WIDTH }
     if (row.kind === "title") { out.push(` ${bone("herd")}`); continue; }
     if (row.kind === "gap") { out.push(""); continue; }
     if (row.kind === "heading") { out.push(` ${ash(row.text)}`); continue; }
+    if (row.kind === "hint") { out.push(` ${dim(row.text)}`); continue; }
     if (row.kind === "herd") { out.push(` ${ash(row.herd.toUpperCase())}`); continue; }
     if (row.kind === "session") {
       const s = row.session;
@@ -262,9 +302,14 @@ export async function herdSidebar({
           const hit = rows.find((r) => r.line === event.row && (r.kind === "session" || r.kind === "action"));
           if (!hit) continue;
           if (hit.kind === "session") {
+            // First click browses. Clicking the one already on screen hands it
+            // the keyboard — the same second-click-opens idiom as the list, and
+            // the only way to reach an agent without using the mouse on it.
+            const already = hit.session.name === showing;
             selected = hit.session.name;
             if (hit.session.alive) { showMember(hit.session.name, { runner, me }); showing = hit.session.name; }
             draw();
+            if (already) focusContent({ runner, me });
           } else {
             selected = hit.action.key;
             draw();
@@ -280,7 +325,13 @@ export async function herdSidebar({
         const at = names.indexOf(selected);
         if (event.key === "\x1b[A" || event.key === "k") selected = names[Math.max(0, at - 1)] || selected;
         if (event.key === "\x1b[B" || event.key === "j") selected = names[Math.min(names.length - 1, at + 1)] || selected;
-        if (event.key === "\r" || event.key === "\n") { showMember(selected, { runner, me }); showing = selected; }
+        if (event.key === "\r" || event.key === "\n") {
+          showMember(selected, { runner, me });
+          showing = selected;
+          draw();
+          focusContent({ runner, me });
+          continue;
+        }
         draw();
       }
     });

package/src/herd.mjs

@@ -629,7 +629,19 @@ export function killSession(name, { substrate = detectSubstrate(), runner = spaw
   if (substrate === "tmux") {
     // kill-pane, not kill-session: a tiled member shares its session with
     // every other tiled member, and killing that would take the lot.
+    const found = paneIndex({ runner }).get(name);
     const r = tmux(["kill-pane", "-t", target(name, { runner })], { runner });
+    // A member being attached to has a mosh bar under it, and the bar would
+    // hold the session open after its member is gone — an empty room still
+    // answering to the dead member's name on the roster. If that is all that is
+    // left, take the room too.
+    if (r.ok && found) {
+      const left = tmux(["list-panes", "-t", found.session, "-F", "#{pane_title}"], { runner });
+      const titles = left.ok ? left.stdout.split("\n").filter(Boolean) : [];
+      if (titles.length && titles.every((t) => t === "mosh-bar")) {
+        tmux(["kill-session", "-t", found.session], { runner });
+      }
+    }
     forgetSession(name);
     return r.ok ? { ok: true } : { ok: false, error: new Error(r.stderr.trim() || "no such session") };
   }