@assuredloop/orca-bot-kit 0.36.1 → 0.38.0

package/README.md

@@ -474,6 +474,18 @@ It closes the session's tab — one tab, by its own handle — and opens a new o
 with the conversation the book holds, so the session comes back as itself. With
 no `--session` it does that for every session of the bot.
 
+Closing the old tab ends the harness there, and the background shells it ran
+end with it: a timer, a watch, a long build. So once a session whose tab the
+restart closed is back with its conversation, the kit types one line into its
+new tab. A session whose tab was already closed, or that starts fresh, gets no
+line. The line says that its background shells
+ended, that the kit cannot tell which ones ran or whether a scheduled job still
+runs, and that it should look at its scheduled jobs before it makes one again.
+It also asks the session to read its mail and do what it asks. The line goes in
+only when the tab shows no question, form or menu, within 20 seconds. The
+report says under each tab whether the line went in. When it did not, it says
+why, and you tell the session yourself.
+
 What it will not do, in order of how much it would cost you. It closes only a
 tab your book names, so Bot Father's ops tab and anything you opened yourself
 are left alone. It will not close a tab whose conversation the book cannot name:
@@ -516,7 +528,15 @@ effort and context go back to the new harness's defaults unless you give them
 too. A pause closes the tabs the way a restart does, with the
 same refusals, and one more: it also refuses a tab with only its shell in front
 whose conversation the book does not name. `obk up` leaves what is paused
-closed until `obk unpause` brings it back with its conversations. Retiring a
+closed until `obk unpause` brings it back with its conversations. The closed
+tab ended the background shells of each paused session, as a restart does. So
+the unpause tells each session it took off pause and resumed, in one typed
+line, as a restart does: its old tab is closed and its background shells
+ended, and it looks at its scheduled jobs and its mail. The report says under
+each tab whether the line went in. In the `--json` answer, `restartLine` means
+the same after an unpause as after a restart: `true` when the line went in, or
+`false` with the reason in `restartLineTrouble`, and then you tell the session
+yourself. Retiring a
 session takes it off the bot and keeps its conversations in the book under
 `retired`. Once its tab is closed, it stops what the session left running in
 its work dir: each of your processes whose working folder is there, and what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assuredloop/orca-bot-kit",
-  "version": "0.36.1",
+  "version": "0.38.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/cli.js

@@ -690,7 +690,7 @@ const commands = {
     const answer = { bots, bot, session, changed, created: [], completed: [], ...up };
     return {
       answer,
-      lines: tabLines(answer, `${changed ? 'Unpaused' : 'Not paused, so brought up as it is'}: ${what}. Your bots folder: ${bots}`),
+      lines: tabLines(answer, `${changed ? 'Unpaused' : 'Not paused, so brought up as it is'}: ${what}. Your bots folder: ${bots}`, 'pause'),
     };
   },
 
@@ -1918,7 +1918,7 @@ function settingsLine({ bot, session, running, settings, rules }) {
   return `${word.padEnd(9)}  ${who}  ${each.join('  ')}  rules ${rules.state}`;
 }
 
-function tabLines({ bots, created, completed, rules, skills, permissions = [], tabs, paused = [], projects = [], found = [] }, summary) {
+function tabLines({ bots, created, completed, rules, skills, permissions = [], tabs, paused = [], projects = [], found = [] }, summary, closedBy = 'restart') {
   const lines = [
     ...created.map((entry) => `created    ${entry}`),
     ...completed.map((entry) => `completed  ${entry}`),
@@ -1929,7 +1929,7 @@ function tabLines({ bots, created, completed, rules, skills, permissions = [], t
 
   for (const tab of tabs) {
     lines.push(`${tab.created ? 'opened' : 'found '}     ${tab.title}  tab ${tab.tabId}  terminal ${tab.terminal}`);
-    lines.push(...harnessLines(tab, bots));
+    lines.push(...harnessLines(tab, bots, closedBy));
     if (tab.noMailbox) {
       lines.push(`             it has no mailbox: ${noMailboxYet({ bots, bot: tab.bot, session: tab.name })}`);
     }
@@ -1962,7 +1962,7 @@ function tabLines({ bots, created, completed, rules, skills, permissions = [], t
  * The caller decides what to do next from these lines, so they say both what
  * was typed and what was seen afterwards, and never one in place of the other.
  */
-function harnessLines(tab, bots) {
+function harnessLines(tab, bots, closedBy) {
   if (!tab.created || tab.name === null) return [];
 
   // Nothing was typed into it, so there is nothing more to say about a harness
@@ -1988,6 +1988,7 @@ function harnessLines(tab, bots) {
       `             Look at it:  ${lookAt(tab.terminal)}`,
       ...ANSWER_IT,
       ...promptLines(tab),
+      ...restartLines(tab, closedBy),
     ];
   }
 
@@ -2009,7 +2010,7 @@ function harnessLines(tab, bots) {
       ...ANSWER_IT,
     ];
 
-  lines.push(...promptLines(tab), ...listLines(tab));
+  lines.push(...promptLines(tab), ...listLines(tab), ...restartLines(tab, closedBy));
   if (tab.unclaimed !== undefined) lines.push(...unclaimedLines(tab, bots));
   return lines;
 }
@@ -2024,6 +2025,18 @@ function listLines(tab) {
   return [];
 }
 
+/**
+ * Whether a session `obk restart` resumed was typed the line that tells it what
+ * the restart ended (#726), or one `obk unpause` resumed, what the pause ended
+ * (#732): `closedBy` names which. When it was not, the caller is the one left
+ * to tell it.
+ */
+function restartLines(tab, closedBy) {
+  if (tab.restartLine === true) return [`             it was typed one line that tells it what the ${closedBy} ended: its background shells, and to look at its scheduled jobs and its mail.`];
+  if (tab.restartLine === false) return [`             it was not told what the ${closedBy} ended (${tab.restartLineTrouble}): tell it yourself that its background shells ended, and to look at its scheduled jobs and its mail.`];
+  return [];
+}
+
 /**
  * Whether the session got its start prompt, as its own record has it (#274):
  * received, or not confirmed yet. Nothing for a session that was told nothing.

package/src/message.js

@@ -16,6 +16,7 @@
 // Escape a sender asks for with --interrupt. Orca gives no notice to a tab its
 // window has not loaded, so the send says when the receiver's is one (#579).
 
+import { randomUUID } from 'node:crypto';
 import { mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
@@ -24,7 +25,7 @@ import { setTimeout as pause } from 'node:timers/promises';
 import { MAILBOX_WAIT_MS, readBook, takeLineTurn, takeMailboxTurn, TYPING_HELD, TYPING_WAIT_MS } from './book.js';
 import { botDir, botNames, readBot } from './bot.js';
 import { harnessOf, isAddressOf, kitFolders, ownCli, reachesMail, SHELL_ENV, shellWord } from './launch.js';
-import { ackMailbox, coordinatorOf, isRunning, listedOrphaned, loadInWindow, postMessage, pressEscape, readMailbox, tabs, tabToTypeInto, TERMINAL_ENV, TIMED_OUT, useMailbox } from './orca.js';
+import { ackMailbox, coordinatorOf, isRunning, listedOrphaned, loadInWindow, postMessage, pressEscape, readMailbox, readsCarryRequest, tabs, tabToTypeInto, TERMINAL_ENV, TIMED_OUT, useMailbox } from './orca.js';
 
 /**
  * How much of a message travels as itself. Above this it is written to a file
@@ -365,10 +366,18 @@ function mailOf(bots, who, peek, until) {
   // acknowledging is handed over again to the next. From 1.4.246 a read
   // acknowledges the batch it hands over and says so (`deliveryAcknowledged`),
   // and an acknowledgement answers with no batch, so the next is read again
-  // (#729; read in the 1.4.246 and 1.4.255 source).
+  // (#729; read in the 1.4.246 and 1.4.255 source). So a read that is not a
+  // peek is asked again, under the same request id, when Orca does not answer
+  // it in time (#735).
   const messages = [];
   const read = { bots, bot: who.bot, session: who.session, mailbox: who.mailbox, read: !peek, messages };
-  let found = readMailbox(who.mailbox, { peek, handle }, timeLeft(until));
+  let found;
+  try {
+    found = peek ? readMailbox(who.mailbox, { peek, handle }, timeLeft(until)) : take(who.mailbox, handle, until, timeLeft(until));
+  } catch (error) {
+    if (peek || error.code !== TIMED_OUT) throw error;
+    return { ...read, trouble: `${error.message} Orca may have taken letters as read without the kit seeing them. Other mail waits for the next check.` };
+  }
   for (;;) {
     const batch = (found.messages ?? []).map((message) => asMessage(bots, message));
     if (peek || !found.deliveryId || batch.length === 0) {
@@ -383,7 +392,7 @@ function mailOf(bots, who, peek, until) {
         return { ...read, trouble: `${who.bot}/${who.session} has more mail than one check reads in ${HOLD_MS / 1000} seconds, so it stopped there. The rest is still waiting: check again.` };
       }
       try {
-        found = readMailbox(who.mailbox, { handle }, wait);
+        found = take(who.mailbox, handle, until, wait);
       } catch (error) {
         // A read Orca did not answer about may have taken the next batch all
         // the same, and taken is read: that batch is not handed over again.
@@ -417,6 +426,31 @@ function mailOf(bots, who, peek, until) {
   }
 }
 
+/**
+ * Take the next batch of `mailbox`, read as `handle`, under a request id of
+ * its own, the first call given `options` (#735). Orca keeps the answer of a
+ * read under its id: the same read asked again with that id answers the same
+ * batch and takes nothing new, waits for the first if it is still running,
+ * and runs as new if the first never reached Orca (read in the 1.4.246 and
+ * 1.4.255 source). So a read Orca does not answer in time is asked again with
+ * the same id while the check's hold lasts, and a batch Orca took as read is
+ * shown once. No other call is asked again: a send, a bind or an ack Orca did
+ * not answer about is not sent twice (#734).
+ */
+function take(mailbox, handle, until, options) {
+  const request = randomUUID();
+  for (;;) {
+    try {
+      return readMailbox(mailbox, { handle, request }, options);
+    } catch (error) {
+      // A read that went without the id is not asked again (#734).
+      if (error.code !== TIMED_OUT || !readsCarryRequest()) throw error;
+      options = timeLeft(until, false);
+      if (options === undefined) throw error;
+    }
+  }
+}
+
 /**
  * How long a check holds the session's turn, all its Orca calls together. Well
  * inside the minute `up` waits for the turn before it writes a new tab, so a

package/src/orca.js

@@ -1021,6 +1021,36 @@ function panePid(ptyId, readMs) {
   return { pane };
 }
 
+/**
+ * The ids of the ptys Orca holds a process for, from `diagnostics memory`, as
+ * a set, or undefined when the kit cannot tell (#733). Each session there is a
+ * pty of Orca's own registry, which drops a pty once its process has ended
+ * (read in the 1.4.255 bundle; seen live, the pty went from the answer as its
+ * pane process and shell ended). An Orca that refuses the command, or an
+ * answer in another shape, cannot tell. Nor can an answer with no worktree at
+ * all: Orca answers a snapshot that failed with an empty list (read in the
+ * 1.4.255 bundle), and the kit cannot tell that from a machine with no
+ * terminal.
+ */
+export function livePtys() {
+  let worktrees;
+  try {
+    worktrees = orca(['diagnostics', 'memory']).worktrees;
+  } catch {
+    return undefined;
+  }
+  if (!Array.isArray(worktrees) || worktrees.length === 0) return undefined;
+  const ids = new Set();
+  for (const worktree of worktrees) {
+    if (!Array.isArray(worktree?.sessions)) return undefined;
+    for (const session of worktree.sessions) {
+      if (typeof session?.sessionId !== 'string') return undefined;
+      ids.add(session.sessionId);
+    }
+  }
+  return ids;
+}
+
 /** The `lsof` and `stty` the kit asks, by their fixed paths, as `ps`. */
 export const LSOF = '/usr/sbin/lsof';
 const STTY = '/bin/stty';
@@ -1299,9 +1329,37 @@ export function postMessage({ to, from, subject, body, type = 'status', thread }
  * and says so with `deliveryAcknowledged: true` (#729). Read as
  * the terminal `handle` when one is given, which is how a read works from a tab
  * bound to another Run; otherwise as this process's own terminal.
+ *
+ * A read given a `request` id carries it as `--retry-request`: Orca keeps its
+ * answer under that id, and the same read asked again with it answers the
+ * same batch and takes nothing new (#735). An Orca that refuses the flag as
+ * unknown did nothing, and is asked again without it, as for `--full`.
+ */
+export function readMailbox(id, { peek = false, handle, request } = {}, options) {
+  const args = ['orchestration', 'check', '--run', id, ...as(handle), ...(peek ? ['--peek'] : [])];
+  if (request !== undefined && retryKnown) {
+    try {
+      return orchestration([...args, '--retry-request', request], options);
+    } catch (error) {
+      if (error.code !== 'invalid_argument' || error.reason !== RETRY_UNKNOWN) throw error;
+      retryKnown = false;
+    }
+  }
+  return orchestration(args, options);
+}
+
+/** Orca's own words when its CLI does not know `--retry-request` on `check`: nothing was done. */
+const RETRY_UNKNOWN = 'Unknown flag --retry-request for command: orchestration check';
+
+/** Whether this Orca may know `--retry-request` on `check`: false once it has refused it. */
+let retryKnown = true;
+
+/**
+ * Whether a read given a request id still carries it. Once Orca has refused
+ * the flag, a read goes without it, and a read with no id is never asked again
+ * after a time-out: it would take another batch, not answer the first (#735).
  */
-export const readMailbox = (id, { peek = false, handle } = {}, options) =>
-  orchestration(['orchestration', 'check', '--run', id, ...as(handle), ...(peek ? ['--peek'] : [])], options);
+export const readsCarryRequest = () => retryKnown;
 
 /**
  * The newest `limit` messages in a mailbox, newest first, with every column

package/src/pause.js

@@ -40,10 +40,14 @@ export async function pauseSessions(bots, { bot, session }) {
  */
 export async function unpauseSessions(bots, { bot, session }) {
   const home = fleetMember(bots, bot, 'unpause', session);
-  sessionsOf(readBot(home, bot), session);
+  const sessions = sessionsOf(readBot(home, bot), session);
 
   const changed = markPaused(bots, bot, session, false);
-  return { bot, session, changed, ...(await bringUp(bots, { bot, session })) };
+  // The sessions this took the pause off are told, once they are resumed, what
+  // their closed tab ended (#732). One still paused on its own is not brought
+  // up, so it is told nothing; nothing is told when nothing was paused.
+  const unpaused = changed ? new Set(sessions.map((one) => one.name)) : undefined;
+  return { bot, session, changed, ...(await bringUp(bots, { bot, session, unpaused })) };
 }
 
 /**

package/src/restart.js

@@ -34,7 +34,7 @@ import { setTimeout as pause } from 'node:timers/promises';
 import { bookFile, readBook } from './book.js';
 import { botDir, readBot } from './bot.js';
 import { ownCli, shellWord } from './launch.js';
-import { closeTab, closeTerminal, findProject, frontOfTab, orcaCli, tabs } from './orca.js';
+import { closeTab, closeTerminal, findProject, frontOfTab, livePtys, orcaCli, tabs } from './orca.js';
 import { botsNamed, bringUp, prepareBots, sessionsOf } from './up.js';
 
 /**
@@ -69,7 +69,9 @@ export async function restartSessions(bots, { bot: name, session: onlySession }
 
   const going = tabsToClose(bots, name, home, sessions.filter((session) => session.paused !== true), { quit: true });
   const closed = await closeTabs(home, going, bots, name, commandLine('restart', bots, name, onlySession));
-  return { closed, ...(await bringUp(bots, { bot: name, session: onlySession })) };
+  // The sessions whose tabs this closed are the ones the restart ended
+  // something of, and the ones told so once they are back (#726).
+  return { closed, ...(await bringUp(bots, { bot: name, session: onlySession, restarted: new Set(closed.map((tab) => tab.name)) })) };
 }
 
 /**
@@ -114,9 +116,11 @@ export function tabsToClose(bots, name, home, sessions, { keepless = false, quit
  * Close the tabs `tabsToClose` gave, one at a time by their own handles, and
  * wait until Orca's listing agrees they are gone. Returns one entry per tab.
  * `again` is the command that asked, as the user would run it again: what to do
- * once a tab Orca would not close has been closed by hand.
+ * once a tab Orca would not close has been closed by hand. With `retiring`, the
+ * caller starts no harness in the tabs' place, so a tab Orca still lists after
+ * the wait may count as gone once its process is shown to have ended (#733).
  */
-export async function closeTabs(home, going, bots, name, again) {
+export async function closeTabs(home, going, bots, name, again, { retiring = false } = {}) {
   const closed = [];
   for (const { name: session, tab } of going) {
     try {
@@ -125,12 +129,12 @@ export async function closeTabs(home, going, bots, name, again) {
       // A tab that would not close still holds its session, so nothing is
       // opened after this: two harnesses on one conversation is worse than a
       // restart that did not happen.
-      throw new Error(alsoClosed(error.message, closed, bots, name));
+      throw new Error(alsoClosed(error.message, closed, bots, name, retiring ? again : undefined));
     }
     closed.push({ bot: name, name: session, tabId: tab.tabId, terminal: tab.handle });
   }
 
-  await gone(home, closed, bots, name);
+  await gone(home, closed, bots, name, retiring ? { again, ptys: new Map(going.map(({ tab }) => [tab.tabId, tab.ptyId])) } : undefined);
   return closed;
 }
 
@@ -185,8 +189,21 @@ const ASK_MS = 100;
  * A listing that never catches up is not something the kit can put right, so it
  * stops and says which tab it is waiting on. The conversation is in the book,
  * which is the way back to it.
+ *
+ * A retire, given as `retire: { again, ptys }`, starts nothing in the tabs'
+ * place, and what it must not leave behind is a live harness (#733). Orca
+ * 1.4.255 can go on listing a closed tab for minutes, `connected: false`,
+ * after its process has ended: a pane its window still holds (tech notes,
+ * section 1). That row alone does not prove the process ended, since a pane
+ * can say it is not connected while its pty is live, and so Orca's own list
+ * of live ptys is read too. Once the wait is over, a tab of the retire's
+ * counts as gone when every row Orca lists for it says `connected: false`
+ * with the pty the kit closed, and Orca holds no process for that pty.
+ * Anything the kit cannot read is "cannot tell", and the retire stops as
+ * before, with the retire to run again: the user wants the session gone, not
+ * back.
  */
-async function gone(home, closed, bots, bot) {
+async function gone(home, closed, bots, bot, retire) {
   // Nothing closed is nothing to wait for, and a bot that has never been up has
   // no Orca project to ask: Orca refuses the listing (tech notes, section 1).
   if (closed.length === 0) return;
@@ -194,18 +211,40 @@ async function gone(home, closed, bots, bot) {
   const ids = closed.map((tab) => tab.tabId);
 
   for (;;) {
-    const there = new Set(tabs(home).map((tab) => tab.tabId));
-    const left = ids.filter((id) => there.has(id));
+    const listed = tabs(home);
+    const there = new Set(listed.map((tab) => tab.tabId));
+    let left = ids.filter((id) => there.has(id));
     if (left.length === 0) return;
 
     if (Date.now() >= until) {
       const one = left.length === 1;
-      throw new Error(`Orca answered the close for ${one ? 'this tab' : 'these tabs'} and is still listing ${one ? 'it' : 'them'} ${SETTLED_MS / 1000} seconds later: ${left.join(', ')}. Nothing was opened in ${one ? 'its' : 'their'} place, because a tab that is on the way out is not a tab to start a harness in. The conversations are in the book: ${shellWord(ownCli())} up --bots ${shellWord(bots)} --bot ${bot} brings them back once Orca has caught up.`);
+      if (retire === undefined) {
+        throw new Error(`Orca answered the close for ${one ? 'this tab' : 'these tabs'} and is still listing ${one ? 'it' : 'them'} ${SETTLED_MS / 1000} seconds later: ${left.join(', ')}. Nothing was opened in ${one ? 'its' : 'their'} place, because a tab that is on the way out is not a tab to start a harness in. The conversations are in the book: ${shellWord(ownCli())} up --bots ${shellWord(bots)} --bot ${bot} brings them back once Orca has caught up.`);
+      }
+      left = stillRunning(listed, left, retire.ptys);
+      if (left.length === 0) return;
+      const few = left.length === 1;
+      throw new Error(`Orca answered the close for ${few ? 'this tab' : 'these tabs'} and is still listing ${few ? 'it' : 'them'} ${SETTLED_MS / 1000} seconds later, and the kit cannot tell that ${few ? 'its harness has' : 'their harnesses have'} stopped: ${left.join(', ')}. The retire stopped there. Once Orca has caught up, run the same retire again: ${retire.again}`);
     }
     await pause(ASK_MS);
   }
 }
 
+/**
+ * Of the tab ids `left`, the ones Orca's listing `listed` does not show to have
+ * ended: a tab ended when each row for it says `connected: false` with the pty
+ * `ptys` gives it, and `livePtys` reads and lacks that pty.
+ */
+function stillRunning(listed, left, ptys) {
+  const live = livePtys();
+  if (live === undefined) return left;
+  return left.filter((id) => {
+    const pty = ptys.get(id);
+    const ended = (tab) => tab.connected === false && tab.ptyId === pty;
+    return typeof pty !== 'string' || live.has(pty) || !listed.filter((tab) => tab.tabId === id).every(ended);
+  });
+}
+
 /**
  * A session the kit will not close a tab on: it is live, and the book does not
  * say which conversation is in it — a Codex hooks file trusted too late is
@@ -225,10 +264,17 @@ function cannotComeBack(bots, bot, name, was) {
   ].join(' ');
 }
 
-/** What a failed close owes whoever is reading: the tabs that went before it. */
-function alsoClosed(why, closed, bots, bot) {
+/**
+ * What a failed close owes whoever is reading: the tabs that went before it.
+ * For a retire, given as the command to run again, the way on is that retire,
+ * not `up`: the user wants those sessions gone, not back (#733).
+ */
+function alsoClosed(why, closed, bots, bot, retireAgain) {
   if (closed.length === 0) return why;
 
   const one = closed.length === 1;
+  if (retireAgain !== undefined) {
+    return `${why} ${closed.map((tab) => tab.name).join(', ')} ${one ? 'was' : 'were'} closed before it, and nothing more was retired. Once that tab can be closed, run the same retire again: ${retireAgain}`;
+  }
   return `${why} ${closed.map((tab) => tab.name).join(', ')} ${one ? 'was' : 'were'} closed before it and nothing was opened in ${one ? 'its' : 'their'} place: ${shellWord(ownCli())} up --bots ${shellWord(bots)} --bot ${bot} brings ${one ? 'it' : 'them'} back with ${one ? 'its' : 'their'} conversation.`;
 }

package/src/retire.js

@@ -45,9 +45,11 @@ export const retiredDir = (bots) => path.join(bots, 'retired');
  * removed, and `processes` when it has a work dir: what `stopProcesses`
  * stopped and left of what it started there (#537). `retiredWith` holds one
  * `{ bot, session, maker, closed }` for each session that went with it,
- * deepest first, with its own `promptsLeft` and `processes`.
+ * deepest first, with its own `promptsLeft` and `processes`. `again` is the
+ * command the user ran, as they would run it again: what a refusal names, for
+ * this session and each that goes with it.
  */
-export async function retireSession(bots, { bot, session }) {
+export async function retireSession(bots, { bot, session }, again = commandLine('retire', bots, bot, session)) {
   const home = fleetMember(bots, bot, 'retire', session);
   const known = readBot(home, bot);
   const sessions = sessionsOf(known, session);
@@ -59,11 +61,11 @@ export async function retireSession(bots, { bot, session }) {
   let processes;
   try {
     for (const { name } of made) {
-      const { retiredWith: theirs, ...gone } = await retireSession(bots, { bot, session: name });
+      const { retiredWith: theirs, ...gone } = await retireSession(bots, { bot, session: name }, again);
       retiredWith.push(...theirs, { ...gone, maker: session });
     }
 
-    closed = await closeTabs(home, tabsToClose(bots, bot, home, sessions, { keepless: true }), bots, bot, commandLine('retire', bots, bot, session));
+    closed = await closeTabs(home, tabsToClose(bots, bot, home, sessions, { keepless: true }), bots, bot, again, { retiring: true });
     // Only once its tab is closed: its harness starts nothing more.
     const dir = workDirOf(sessions[0], home);
     if (dir !== undefined) processes = await stopProcesses([{ session, dir }]);
@@ -137,7 +139,7 @@ export async function retireBot(bots, { bot }) {
   // taken away with one of them still open. `closeTabs` waits until Orca agrees
   // they are gone.
   const booked = Object.keys(readBook(home).sessions).map((name) => ({ name }));
-  const closed = await closeTabs(home, tabsToClose(bots, bot, home, booked, { keepless: true }), bots, bot, commandLine('retire', bots, bot));
+  const closed = await closeTabs(home, tabsToClose(bots, bot, home, booked, { keepless: true }), bots, bot, commandLine('retire', bots, bot), { retiring: true });
   // Once their tabs are closed, and before the folder moves (#537).
   const dirs = known.sessions.flatMap((session) => {
     const dir = workDirOf(session, home);

package/src/temp.js

@@ -367,7 +367,8 @@ const promptLeft = (why, written, left) =>
 export async function retireTemp(bots, { tab, name }) {
   const caller = callerIn(bots, tab, 'retire');
   ownTemp(caller, name, 'retire', 'Nothing was retired.');
-  return { ...(await retireSession(bots, { bot: caller.bot, session: name })), maker: caller.session };
+  const again = `${shellWord(ownCli())} temp retire --bots ${shellWord(bots)} --name ${name}`;
+  return { ...(await retireSession(bots, { bot: caller.bot, session: name }, again)), maker: caller.session };
 }
 
 /**

package/src/up.js

@@ -49,7 +49,7 @@ const SECOND_LOOK_MS = 2000;
  * one bot and `session` one of its sessions, for a caller that wants one thing
  * back rather than the fleet.
  */
-export async function bringUp(bots, { bot: onlyBot, session: onlySession } = {}) {
+export async function bringUp(bots, { bot: onlyBot, session: onlySession, restarted, unpaused } = {}) {
   const named = botsNamed(bots, onlyBot);
   if (onlySession !== undefined && onlyBot === undefined) {
     throw new Error('--session needs --bot: say which bot the session belongs to.');
@@ -72,7 +72,7 @@ export async function bringUp(bots, { bot: onlyBot, session: onlySession } = {})
     for (const session of sessionsOf(bot, onlySession)) {
       if (session.paused === true) paused.push({ bot: bot.name, session: session.name });
     }
-    const up = await bringUpBot(bots, home, bot, onlySession);
+    const up = await bringUpBot(bots, home, bot, onlySession, { restarted, unpaused });
     report.push(...up.tabs);
     if (up.project !== undefined) projects.push(up.project);
   }
@@ -230,7 +230,7 @@ export function sessionsOf(bot, onlySession) {
   return named;
 }
 
-async function bringUpBot(bots, home, bot, onlySession) {
+async function bringUpBot(bots, home, bot, onlySession, { restarted, unpaused } = {}) {
   const name = bot.name;
   const title = displayName(name);
   const sessions = awake(sessionsOf(bot, onlySession));
@@ -250,7 +250,10 @@ async function bringUpBot(bots, home, bot, onlySession) {
 
   const live = new Map(tabs(home).map((tab) => [tab.tabId, tab]));
   const report = [];
-  for (const session of sessions) report.push(await bringUpSession(bots, home, live, session, bot, title));
+  // Which command closed the session's old tab, when one did and the session
+  // is to be told what that ended (#726, #732).
+  const endedBy = (name) => (restarted?.has(name) ? 'restart' : unpaused?.has(name) ? 'unpause' : undefined);
+  for (const session of sessions) report.push(await bringUpSession(bots, home, live, session, bot, title, endedBy(session.name)));
 
   // The ops tab, and the whole of what the kit knows about it: Bot Father's
   // project needs one tab that is not a session, for work across the fleet. Any
@@ -274,7 +277,7 @@ async function bringUpBot(bots, home, bot, onlySession) {
   return { tabs: report, project: change === undefined && windowTrouble === undefined ? undefined : project };
 }
 
-async function bringUpSession(bots, home, live, session, bot, title) {
+async function bringUpSession(bots, home, live, session, bot, title, endedBy) {
   const harness = harnessOf(session, bot.harness);
   const book = readBook(home);
   const was = book.sessions[session.name];
@@ -431,11 +434,21 @@ async function bringUpSession(bots, home, live, session, bot, title) {
     ? undefined
     : await heldInRecord(home, session.name, harness, launch.prompt, { launched, running: tui.running === true });
 
+  // A session whose tab `obk restart` closed lost the background shells its
+  // harness ran there, and nothing else tells it (#726). So does one that
+  // `obk unpause` took off pause: its old tab is closed (#732). So once it is
+  // resumed it is typed one line that says so, through the same gate, whatever
+  // its harness. For Codex that line is its first turn too, so it takes the
+  // place of the list line below.
+  const told = endedBy === undefined || launch.resume === undefined ? undefined
+    : tui.running === true ? await typeListLine(home, session.name, made.tabId, { line: (endedBy === 'unpause' ? unpauseLine : restartLine)(bots) })
+    : { typed: false, why: 'its harness did not come up in the new tab' };
+
   // A Codex session resumed here is not among Orca's agents until its first
   // turn: Codex fires its SessionStart then and not at the resume, seen live on
   // 0.157.1 (#226). So it is given one line, through the same gate as a mail
   // notice, which the owner allowed. A fresh start's first turn is its prompt.
-  const list = harness === 'codex' && launch.resume !== undefined && tui.running === true
+  const list = told === undefined && harness === 'codex' && launch.resume !== undefined && tui.running === true
     ? await typeListLine(home, session.name, made.tabId, { line: listLine(bots) })
     : undefined;
 
@@ -456,6 +469,8 @@ async function bringUpSession(bots, home, live, session, bot, title) {
     unclaimed: which.unclaimed,
     listLine: list?.typed,
     listLineTrouble: list?.why,
+    restartLine: told?.typed,
+    restartLineTrouble: told?.why,
   });
 }
 
@@ -516,6 +531,42 @@ const listLine = (bots) => 'obk: this session was resumed in a new tab, and the
   + ` Read your mail with \`${shellWord(ownCli())} message check --bots ${shellWord(bots)}\`, and do what it asks.`
   + ' That includes mail you read just before this line. If there is none, reply "ok".';
 
+/**
+ * The line a session is typed once `obk restart` has resumed it in a new tab,
+ * in the architect's ruling (#726). It says only what the kit knows: the old
+ * tab's harness ended, and its background shells with it. The kit cannot tell
+ * which shells ran, nor whether a scheduled job survived (one was seen to), so
+ * the session looks before it makes a job again. The mail part is the list
+ * line's as #709 left it, but for its last sentence: "If nothing needs doing"
+ * where the list line says "If there is none". This line also asks the session
+ * to start its shells again, and a session with no mail must not reply "ok"
+ * and stop there (the architect's ruling on PR #731).
+ */
+const restartLine = (bots) => 'obk: obk restart closed this session\'s old tab and resumed the conversation in this new one.'
+  + ' Closing the old tab ended the harness there, and the background shells it ran ended with it.'
+  + whatToDoAfterTheClose(bots);
+
+/**
+ * What the restart line and the unpause line both say after their first two
+ * sentences: what the kit cannot tell, and what the session does about it.
+ */
+const whatToDoAfterTheClose = (bots) => ' The kit cannot tell which shells ran, or whether a scheduled job of the harness still runs.'
+  + ' Look at the harness\'s scheduled jobs before you make one again, so that only one of each runs.'
+  + ' Start again the shells you still need.'
+  + ` Read your mail with \`${shellWord(ownCli())} message check --bots ${shellWord(bots)}\`, and do what it asks.`
+  + ' That includes mail you read just before this line. If nothing needs doing, reply "ok".';
+
+/**
+ * The line a session is typed once `obk unpause` has taken it off pause and
+ * resumed it in a new tab, in the architect's ruling (#732). Its first two
+ * sentences take the place of the restart line's: the kit cannot tell whether
+ * the pause closed the old tab or it was closed before, and the words are true
+ * either way. The rest is the restart line's, word for word.
+ */
+const unpauseLine = (bots) => 'obk: obk unpause took this session off pause and resumed its conversation in this new tab.'
+  + ' Its old tab is closed, which ended the harness there, and the background shells it ran ended with it.'
+  + whatToDoAfterTheClose(bots);
+
 /**
  * How long a resumed Codex tab is given to be one the kit may type into: live,
  * Orca named the agent 7 to 11 s after the restart (#226), and the gate waits
@@ -969,7 +1020,7 @@ export const promptPath = (bots, bot, session) =>
 export const oldPromptPath = (bots, bot, session) =>
   path.join(`${bots}.prompts`, `${encodeURIComponent(bot)}.${encodeURIComponent(session)}.txt`);
 
-function entry(tab, { bot, name, created, running = false, blockedReason, promptReceived, promptFile, resumed, noConversation, harnessChanged, ranOn, unclaimed, noMailbox = false, listLine, listLineTrouble, notLaunched }) {
+function entry(tab, { bot, name, created, running = false, blockedReason, promptReceived, promptFile, resumed, noConversation, harnessChanged, ranOn, unclaimed, noMailbox = false, listLine, listLineTrouble, restartLine, restartLineTrouble, notLaunched }) {
   const made = { bot, name, title: tab.title, tabId: tab.tabId, terminal: tab.handle, created, harnessStarted: running };
   // A tab whose shell was not ready for the launch line, and why: nothing was
   // typed into it (#498).
@@ -981,6 +1032,8 @@ function entry(tab, { bot, name, created, running = false, blockedReason, prompt
   // and why not when it was not (#226).
   if (listLine !== undefined) made.listLine = listLine;
   if (listLineTrouble !== undefined) made.listLineTrouble = listLineTrouble;
+  if (restartLine !== undefined) made.restartLine = restartLine;
+  if (restartLineTrouble !== undefined) made.restartLineTrouble = restartLineTrouble;
   // The id the book held that had no conversation behind it, now in the history.
   if (noConversation !== undefined) made.noConversation = noConversation;
   // The id the book held that ran on another harness, the one this session