@rind-ai/cli 0.6.1 → 0.7.0

package/lib/components/assistant-message.js

@@ -1,11 +1,12 @@
 import { wrapTextWithAnsi } from "../text-width.js";
 import {
   codeOpenLabel,
+  consumeTableLine,
+  createTableState,
+  finishTableState,
   dim,
   isPlainLine,
-  isTableLine,
-  parseTableRow,
-  renderInline,
+  renderTableBlock,
   renderMarkdownishLine,
   styled,
 } from "../markdown-lines.js";
@@ -18,6 +19,7 @@ export class AssistantMessage {
     this.finalized = [];
     this.pending = "";
     this.inCodeBlock = false;
+    this.tableState = createTableState();
     this.cacheWidth = -1;
     this.cacheItems = [];
     this.cacheLines = null;
@@ -32,7 +34,9 @@ export class AssistantMessage {
       }
       const line = this.pending.slice(0, newlineIndex);
       this.pending = this.pending.slice(newlineIndex + 1);
-      this.classifyFinalize(line);
+      if (this.classifyFinalize(line)) {
+        this.cacheItems.length = 0;
+      }
     }
     this.cacheLines = null;
   }
@@ -43,18 +47,48 @@ export class AssistantMessage {
       this.pending = "";
       this.classifyFinalize(line);
     }
+    this.flushTableState();
+    this.cacheItems.length = 0;
     this.cacheLines = null;
   }
 
   get isEmpty() {
-    return !this.finalized.length && !this.pending;
+    return !this.finalized.length && !this.pending && !this.tableState.candidate.length && !this.tableState.rows;
   }
 
   classifyFinalize(line) {
-    if (isTableLine(line, this.inCodeBlock)) {
-      this.finalizeTable(line);
-      return;
+    const result = consumeTableLine(this.tableState, line, this.inCodeBlock);
+    if (result.type === "hold") {
+      return false;
+    }
+    if (result.type === "start") {
+      for (const line of result.lines || []) {
+        this.classifyNonTable(line);
+      }
+      this.pushItem({ kind: "table", rows: this.tableState.rows });
+      return true;
+    }
+    if (result.type === "append") {
+      return true;
+    }
+    if (result.type === "flush") {
+      this.classifyNonTable(result.line);
+      return true;
     }
+    if (result.type === "flush_candidate") {
+      for (const candidate of result.lines) {
+        this.classifyNonTable(candidate);
+      }
+      if (result.line !== undefined) {
+        this.classifyNonTable(result.line);
+      }
+      return false;
+    }
+    this.classifyNonTable(line);
+    return false;
+  }
+
+  classifyNonTable(line) {
     if (line.trim().startsWith("```")) {
       this.finalizeCodeFence(line);
       return;
@@ -74,12 +108,16 @@ export class AssistantMessage {
     this.pushItem({ kind: "markdown", raw: line });
   }
 
-  finalizeTable(line) {
-    const cells = parseTableRow(line);
-    if (!cells.length || cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()))) {
+  flushTableState() {
+    const result = finishTableState(this.tableState);
+    if (!result) {
       return;
     }
-    this.pushItem({ kind: "table", raw: line });
+    if (result.type === "flush_candidate") {
+      for (const line of result.lines) {
+        this.classifyNonTable(line);
+      }
+    }
   }
 
   finalizeCodeFence(line) {
@@ -95,15 +133,10 @@ export class AssistantMessage {
     this.finalized.push(item);
   }
 
-  styleItem(item) {
+  styleItem(item, width) {
     switch (item.kind) {
-      case "table": {
-        const cells = parseTableRow(item.raw);
-        const rendered = cells.map((cell, index) =>
-          renderInline(cell, this.color, index === 0 ? "tableHeader" : "")
-        );
-        return rendered.join(dim(" | ", this.color));
-      }
+      case "table":
+        return renderTableBlock(item.rows, this.color, Math.max(1, width - CONTENT_PREFIX.length));
       case "fence":
         return dim(item.label ? codeOpenLabel(item.label) : "└ end", this.color);
       case "code":
@@ -125,7 +158,7 @@ export class AssistantMessage {
     }
     while (this.cacheItems.length < this.finalized.length) {
       const item = this.finalized[this.cacheItems.length];
-      const logical = typeof item === "string" ? item : this.styleItem(item);
+      const logical = typeof item === "string" ? item : this.styleItem(item, width);
       this.cacheItems.push(this.wrapLogical(logical, width));
     }
     const lines = [];

package/lib/composer-terminal.js

@@ -1,8 +1,8 @@
+import { ANSI_SEQUENCE } from "./text-width.js";
 import { graphemes, stripAnsi, textWidth, wrapTextCells } from "./text-width.js";
 
 const DEFAULT_COLUMNS = 80;
 const INPUT_MARKER = "\n  ▷ ";
-const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
 const SGR_SEQUENCE = /^\x1b\[([0-9;]*)m$/;
 
 export function prepareComposerFrame(frame = {}, columns = DEFAULT_COLUMNS) {

package/lib/event-controller.js

@@ -3,7 +3,6 @@ import {
   cancelledText,
   contextBuiltLine,
   errorLine,
-  goalContinuedLine,
   planUpdatedLine,
   turnCompletedLine,
 } from "./rendering.js";
@@ -32,8 +31,14 @@ export function createEventController({
     }
     switch (eventType) {
       case "assistant_delta":
+        output.setActivityLabel?.("Working");
         output.assistantAppend?.(event.text || "");
         return;
+      case "turn_step_retry": {
+        const attempt = Number(event.attempt);
+        output.setActivityLabel?.(attempt > 0 ? `Retrying ${attempt}` : "Retrying");
+        return;
+      }
       case "context_built": {
         if (output.handleContextBuilt?.(event)) {
           output.resetContextUsage?.();
@@ -113,19 +118,12 @@ export function createEventController({
         await input.answerQuestion?.(event);
         return;
       case "queued_input_delivered":
-        output.setGoalChasing?.(false);
         output.deliverQueuedInput?.(event.input || "", event.mode || "steering", event.input_id || "");
         return;
-      case "goal_continued":
-        output.closeAssistant?.();
-        output.setGoalChasing?.(true);
-        output.log?.(() => goalContinuedLine(event.round));
-        return;
       case "turn_failed":
         output.clearQueuedInputs?.();
         output.clearCompactContext?.();
         output.closeAssistant?.();
-        output.setGoalChasing?.(false);
         output.log?.(() => errorLine(event.error));
         resetTurnState();
         return;
@@ -133,7 +131,6 @@ export function createEventController({
         output.clearQueuedInputs?.();
         output.clearCompactContext?.();
         output.closeAssistant?.();
-        output.setGoalChasing?.(false);
         output.log?.(() => cancelledText());
         resetTurnState();
         return;
@@ -141,8 +138,9 @@ export function createEventController({
         output.clearQueuedInputs?.();
         output.clearCompactContext?.();
         output.closeAssistant?.();
-        output.setGoalChasing?.(false);
-        output.log?.(turnCompletedLine(event, toolStats));
+        if (state.activeGoal?.status !== "active") {
+          output.log?.(turnCompletedLine(event, toolStats));
+        }
         resetTurnState();
         return;
       default:

package/lib/frontend-cli-implementation.js

@@ -16,6 +16,7 @@ import {
 } from "./runtime-protocol.js";
 import { executeLocalSlashCommand, loadLocalSettings } from "./local-slash-commands.js";
 import { loadCliState, saveCliState } from "./cli-state-store.js";
+import { loadPromptHistory, savePromptHistory } from "./prompt-history-store.js";
 import { setTheme } from "./theme.js";
 import { createTurnController } from "./turn-controller.js";
 import { createCommandController } from "./command-controller.js";
@@ -30,6 +31,8 @@ import { createCliRuntimeController } from "./cli-runtime-controller.js";
 import { createCliOutputController } from "./cli-output-controller.js";
 import { createCliInputActions } from "./cli-input-actions.js";
 import { cliHelp, oneShotHelp, runOneShot } from "./one-shot.js";
+import { runSend, sendHelp } from "./send.js";
+import { listenIpc } from "./ipc.js";
 import { createTui } from "./tui/tui.js";
 import { Container } from "./tui/component.js";
 import { ComposerArea } from "./components/composer-area.js";
@@ -72,6 +75,19 @@ if (cliArgs[0] === "run" && cliArgs.some((arg) => arg === "--help" || arg === "-
   process.stdout.write(`${oneShotHelp}\n`);
   return;
 }
+if (cliArgs[0] === "send" && cliArgs.some((arg) => arg === "--help" || arg === "-h")) {
+  process.stdout.write(`${sendHelp}\n`);
+  return;
+}
+if (cliArgs[0] === "send") {
+  try {
+    process.exitCode = await runSend({ args: cliArgs });
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 2;
+  }
+  return;
+}
 if (cliArgs.some((arg) => arg === "--version" || arg === "--help" || arg === "-h")) {
   if (cliArgs.includes("--help") || cliArgs.includes("-h")) {
     process.stdout.write(`${cliHelp}\n\n`);
@@ -102,7 +118,9 @@ const sessionState = cliState.session;
 const turnStateData = cliState.turn;
 const inputStateData = cliState.input;
 const displayState = cliState.display;
+const promptHistory = loadPromptHistory();
 let input = null;
+let ipcServer = null;
 const compactContextState = createCompactContextState();
 const isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
 const tui = isTty
@@ -143,6 +161,7 @@ const {
   writeError: writeErrorOutput,
   closeAssistant,
   renderHistory,
+  setTurnContext,
 } = outputController;
 
 const runtimeClient = createRuntimeClient({
@@ -168,6 +187,10 @@ const runtimeClient = createRuntimeClient({
     displayState.lastEventSequence = 0;
     turnStateData.active = false;
     turnStateData.interruptRequested = false;
+    displayState.activityLabel = "";
+    displayState.lastTurnId = "";
+    setTurnContext("");
+    clearActivityTimer();
     inputActions?.clearPendingInputs();
     if (!wasClosing) {
       runtimeState.failure = error;
@@ -206,15 +229,17 @@ const runtimeController = createCliRuntimeController({
   requireInitialization: requireRuntimeInitialization,
   state: cliState,
   getCommands: () => commandController,
-  getTurnController: () => turnController,
   getTaskMonitor: () => taskMonitorController,
   getCompactContextState: () => compactContextState,
   askModelMenu: (...args) => inputActions.askModelMenu(...args),
   askEffortMenu: (...args) => inputActions.askEffortMenu(...args),
   askSessionMenu: (...args) => inputActions.askSessionMenu(...args),
+  askForkPointMenu: (...args) => inputActions.askForkPointMenu(...args),
   askTeamBlueprint: (...args) => inputActions.askTeamBlueprint(...args),
+  askContextBoard: (...args) => inputActions.askContextBoard(...args),
   restoreLiveTurn,
   renderHistory,
+  onSessionRestored: rebindSendEndpoint,
   clearPendingInputs: (...args) => inputActions.clearPendingInputs(...args),
   closeAssistant,
   refreshInputState,
@@ -227,7 +252,6 @@ const request = runtimeController.request;
 turnController = createTurnController({
   request,
   state: turnState,
-  refreshGoalState: runtimeController.refreshGoalState,
   onTurnStart: () => {
     displayState.assistantHeaderShown = false;
   },
@@ -257,6 +281,9 @@ commandController = createCommandController({
     },
     startCompactCommand: runtimeController.startCompactCommand,
     runSessionsSelector: runtimeController.runSessionsSelector,
+    runForkSelector: runtimeController.runForkSelector,
+    runContextBoard: runtimeController.runContextBoard,
+    printContextReport: runtimeController.printContextReport,
     runLocalCommand: async (text) => {
       if (!Object.keys(sessionState.settings).length) {
         sessionState.settings = await loadLocalSettings(undefined, sessionState.info.workspace_root || sessionState.info.cwd || process.cwd());
@@ -322,6 +349,9 @@ const eventController = createEventController({
     get activeTurn() {
       return turnStateData.active;
     },
+    get activeGoal() {
+      return sessionState.info.goal;
+    },
     debug: cliArgs.includes("--debug"),
   },
   input: { answerQuestion: (...args) => inputActions.answerQuestion(...args) },
@@ -337,12 +367,10 @@ const eventController = createEventController({
     log: logOutput,
     debug: (text) => writeErrorOutput(`${text}\n`),
     updateGoal: updateGoalState,
-    setGoalChasing: (enabled) => {
-      displayState.goalChasing = Boolean(enabled);
-    },
     setStats: (stats) => {
       displayState.stats = stats;
     },
+    setActivityLabel: outputController.setActivityLabel,
     redraw: redrawInput,
     clearCompactContext: () => compactContextState.clear(),
     deliverQueuedInput: (...args) => inputActions.deliverQueuedInput(...args),
@@ -353,7 +381,10 @@ inputActions = createCliInputActions({
   state: cliState,
   request,
   output: outputController,
+  promptHistory,
+  onPromptHistory: (history) => savePromptHistory(history),
   getTurnController: () => turnController,
+  getCommandController: () => commandController,
   getTaskMonitor: () => taskMonitorController,
   getLineInput: () => input,
   pausePrompt: () => inputController.pause(),
@@ -427,6 +458,26 @@ function updateGoalState(goal) {
   sessionState.info = { ...sessionState.info, goal: goal && typeof goal === "object" ? goal : null };
   redrawInput();
 }
+
+async function rebindSendEndpoint() {
+  try {
+    await ipcServer?.close();
+    ipcServer = null;
+    const sessionId = String(sessionState.info.session_id || "");
+    if (!sessionId) {
+      return;
+    }
+    ipcServer = await listenIpc({
+      sessionId,
+      getSessionId: () => sessionState.info.session_id,
+      dispatch: (text) => inputActions.dispatchExternal(text),
+      onUnavailable: () => logOutput(`Send endpoint unavailable: another rind process owns session ${sessionId}.`),
+    });
+  } catch (error) {
+    ipcServer = null;
+    writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
+  }
+}
 function resetContextUsage() {
   displayState.stats = { context_usage_percent: 0 };
   redrawInput();
@@ -442,25 +493,57 @@ async function renderEvent(message) {
     return;
   }
   if (message?.event?.type === "turn_started") {
-    if (turnStateData.id && String(message.turn_id || "") !== turnStateData.id) {
+    const nextTurnId = String(message.turn_id || "");
+    if (!nextTurnId || (!turnStateData.id && displayState.lastTurnId === nextTurnId)
+      || (turnStateData.id && nextTurnId !== turnStateData.id)) {
       return;
     }
-    turnStateData.id = String(message.turn_id || "");
+    clearActivityTimer();
+    turnStateData.id = nextTurnId;
+    displayState.lastTurnId = nextTurnId;
+    setTurnContext(nextTurnId);
     turnStateData.active = Boolean(turnStateData.id);
+    turnStateData.interruptRequested = false;
+    displayState.activityLabel = "Working";
+    displayState.assistantHeaderShown = false;
+    refreshInputState();
   }
   const result = await eventController.handle(message);
   if (["turn_completed", "turn_failed", "turn_cancelled"].includes(message?.event?.type)) {
     turnStateData.id = "";
+    setTurnContext("");
+    displayState.activityLabel = "";
+    await runtimeController.refreshGoalState();
+    const goalActive = sessionState.info.goal?.status === "active";
+    turnStateData.active = goalActive;
+    turnStateData.interruptRequested = false;
+    if (!goalActive) {
+      clearActivityTimer();
+    }
+    refreshInputState();
   }
   return result;
 }
 
 function restoreLiveTurn(value) {
-  if (!value || typeof value !== "object") return;
+  if (!value || typeof value !== "object" || String(value.status || "") !== "running") {
+    displayState.lastTurnId = "";
+    setTurnContext("");
+    return;
+  }
   const turnId = String(value.turn_id || "");
-  if (!turnId) return;
+  if (!turnId) {
+    displayState.lastTurnId = "";
+    setTurnContext("");
+    return;
+  }
+  clearActivityTimer();
   turnStateData.id = turnId;
   turnStateData.active = true;
+  turnStateData.interruptRequested = false;
+  displayState.activityLabel = "Working";
+  displayState.lastTurnId = turnId;
+  setTurnContext(turnId);
   displayState.assistantHeaderShown = false;
   const text = String(value.assistant_text || "");
   if (text) outputController.assistantAppend(text);
@@ -471,7 +554,7 @@ function composeFrame(width = process.stdout.columns || 80) {
   if (!session) {
     return null;
   }
-  const choiceMenu = ["model", "theme", "sessions", "team-blueprints"].includes(session.mode);
+  const choiceMenu = ["model", "theme", "sessions", "team-blueprints", "fork"].includes(session.mode);
   if (session.mode === "prompt" && session.menuState) {
     session.menuState.setInput(session.editor.input());
   }
@@ -500,6 +583,8 @@ function composeFrame(width = process.stdout.columns || 80) {
   }
   if (session.mode === "question") {
     const editing = session.questionState.isEditing();
+    session.editor.setViewportWidth(width);
+    const editorCursor = editing ? session.editor.cursorPosition() : null;
     const menu = questionMenuFrame(
       session.questionState.options(),
       session.questionState.selectedIndex(),
@@ -507,17 +592,18 @@ function composeFrame(width = process.stdout.columns || 80) {
       editing,
       CUSTOM_ANSWER_LABEL,
       width,
+      editorCursor,
     );
     return {
       showCaret,
       prompt: mainPromptText(width),
       inputText: session.question,
-      cursor: editing ? session.editor.cursorPosition() : { line: 0, column: session.question.length },
+      cursor: editorCursor ?? { line: 0, column: session.question.length },
       menuText: menu.text.trimEnd(),
       menuCursor: editing ? menu.cursor : null,
     };
   }
-  if (session.mode === "sessions") {
+  if (session.mode === "sessions" || session.mode === "team-blueprints" || session.mode === "fork") {
     return {
       showCaret,
       prompt: mainPromptText(width),
@@ -526,13 +612,15 @@ function composeFrame(width = process.stdout.columns || 80) {
       menuText: sessionMenuText(session.choiceState.options(), session.choiceState.selectedIndex()).trimEnd(),
     };
   }
-  if (session.mode === "team-blueprints") {
+  if (session.mode === "context-board") {
     return {
-      showCaret,
-      prompt: mainPromptText(width),
-      inputText: session.inputText,
-      cursor: { line: 0, column: session.inputText.length },
-      menuText: sessionMenuText(session.choiceState.options(), session.choiceState.selectedIndex()).trimEnd(),
+      showCaret: false,
+      prompt: "",
+      inputText: "",
+      cursor: { line: 0, column: 0 },
+      menuText: typeof session.board?.render === "function"
+        ? session.board.render(session.pageIndex, width)
+        : "",
     };
   }
   const matches = session.menuState
@@ -590,6 +678,7 @@ function closeRuntime() {
   runtimeState.status = "closing";
   clearActivityTimer();
   taskMonitorController.stop();
+  void ipcServer?.close();
   void runtimeClient.shutdown();
   closeInput();
 }
@@ -598,6 +687,7 @@ function forceCloseRuntime() {
   runtimeState.status = "closing";
   clearActivityTimer();
   taskMonitorController.stop();
+  void ipcServer?.close();
   closeInput();
   runtimeClient.forceShutdown();
 }

package/lib/ipc.js

@@ -0,0 +1,186 @@
+import { mkdir, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import net from "node:net";
+
+const CONNECT_TIMEOUT_MS = 2000;
+
+export function ipcEndpointName(sessionId) {
+  const id = String(sessionId || "");
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) {
+    throw new Error("Invalid session id.");
+  }
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\rind-${id}`;
+  }
+  return path.join(process.env.RIND_HOME || path.join(homedir(), ".rind"), "ipc", `${id}.sock`);
+}
+
+export async function listenIpc({ sessionId, getSessionId, dispatch, net: netImpl = net, onUnavailable = () => {} }) {
+  const endpoint = ipcEndpointName(sessionId);
+  const server = netImpl.createServer();
+  let listening = false;
+  let closing = false;
+  let settled = false;
+  let recovering = false;
+
+  server.on("connection", (socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        return;
+      }
+      socket.removeAllListeners("data");
+      respond(socket, buffer.slice(0, newlineIndex));
+    });
+    socket.on("error", () => {});
+  });
+
+  const ready = new Promise((resolve) => {
+    const settle = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve();
+    };
+    server.on("listening", () => {
+      listening = true;
+      settle();
+    });
+    server.on("error", () => {
+      if (settled || recovering) {
+        return;
+      }
+      recovering = true;
+      void recover().then(settle, settle).finally(() => {
+        recovering = false;
+      });
+    });
+  });
+
+  function respond(socket, line) {
+    let input = "";
+    try {
+      const message = JSON.parse(line);
+      if (typeof message.input === "string") {
+        input = message.input;
+      }
+    } catch {
+      return socket.end(`${JSON.stringify({ ok: false, message: "Invalid request." })}\n`);
+    }
+    const payload = closing
+      ? { ok: false, message: "Session is shutting down." }
+      : input.trim()
+        ? { ok: true, session_id: String(getSessionId() || "") }
+        : { ok: false, message: "Empty input." };
+    socket.end(`${JSON.stringify(payload)}\n`);
+    if (payload.ok) {
+      dispatch(input);
+    }
+  }
+
+  async function recover() {
+    if (process.platform === "win32") {
+      onUnavailable();
+      return;
+    }
+    if (await probeEndpoint(netImpl, endpoint)) {
+      onUnavailable();
+      return;
+    }
+    await unlink(endpoint).catch(() => {});
+    await new Promise((resolve) => {
+      const onRetryError = () => {
+        onUnavailable();
+        resolve();
+      };
+      server.once("error", onRetryError);
+      server.listen(endpoint, () => {
+        server.removeListener("error", onRetryError);
+        listening = true;
+        resolve();
+      });
+    });
+  }
+
+  if (process.platform !== "win32") {
+    await mkdir(path.dirname(endpoint), { recursive: true }).catch(() => {});
+  }
+  server.listen(endpoint);
+  await ready;
+  return {
+    close() {
+      closing = true;
+      return new Promise((resolve) => {
+        server.close(() => {
+          if (process.platform !== "win32" && listening) {
+            void unlink(endpoint).catch(() => {});
+          }
+          resolve();
+        });
+      });
+    },
+  };
+}
+
+function probeEndpoint(netImpl, endpoint) {
+  return new Promise((resolve) => {
+    const probe = netImpl.connect(endpoint);
+    probe.once("connect", () => {
+      probe.destroy();
+      resolve(true);
+    });
+    probe.once("error", () => resolve(false));
+  });
+}
+
+export function sendIpc({ session, input, timeoutMs = CONNECT_TIMEOUT_MS, net: netImpl = net }) {
+  const endpoint = ipcEndpointName(session);
+  return new Promise((resolve) => {
+    const socket = netImpl.connect(endpoint);
+    let timer = null;
+    let settled = false;
+    let buffer = "";
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify({ input: String(input || "") })}\n`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        return;
+      }
+      let payload = null;
+      try {
+        payload = JSON.parse(buffer.slice(0, newlineIndex));
+      } catch {
+        payload = null;
+      }
+      finish(payload && typeof payload === "object" ? payload : { ok: false, message: "Invalid response from the rind session." });
+    });
+    socket.on("error", () => finish({ ok: false, message: notRunningMessage(session) }));
+    timer = setTimeout(() => {
+      finish({ ok: false, message: notRunningMessage(session) });
+    }, timeoutMs);
+  });
+}
+
+function notRunningMessage(sessionId) {
+  return `rind session ${sessionId} is not running — the id is shown in the target session's banner and /status.`;
+}