@assuredloop/orca-bot-kit 0.26.1 → 0.27.0

package/README.md

@@ -365,19 +365,6 @@ address that is none of your bots folder's sessions, the hook tells it so, and
 names the address `obk message to` would have given. The message goes either
 way ([ADR 0032](docs/adr/0032-a-native-message-outside-the-fleet-is-warned-about.md)).
 
-And a third: at the end of each turn, it tells the session once about fleet
-mail the kit sent it that is still unread, without typing into its tab
-([ADR 0035](docs/adr/0035-messaging-transport.md)). It asks Orca only when the kit
-knows of mail for that session.
-
-A Codex bot gets one more hook too. Inside Codex's sandbox the kit cannot always
-tell whether the receiver of a message has its harness in front, as for a Claude
-session busy running a command, so `obk message send` leaves that nudge, and the
-hook, which Codex runs outside its sandbox right after the command, decides it and
-types it, or says why not ([ADR 0034](docs/adr/0034-orca-is-the-host.md)). Codex
-asks you to trust a hook it has not seen before, so a Codex bot made before this
-hook asks again once.
-
 So: kill a tab, or reboot, and `obk up` brings the session back with the
 conversation it was having, rather than starting a new one. Clear a session —
 `/clear` on Claude Code, `/new` on Codex — and the kit writes down the new id,
@@ -477,7 +464,12 @@ 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
 session takes it off the bot and keeps its conversations in the book under
-`retired`. Retiring a bot closes
+`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
+they started, with SIGTERM and, after up to 3 seconds, SIGKILL. It names each
+process it stopped, and each it left: one that only shares a process group with
+them, or one it could not stop. Where it cannot read the processes, as inside
+Codex's sandbox, it says so and stops nothing. Retiring a bot closes
 its tabs, removes its Orca project and moves its folder to `retired/`; it will
 not touch a bot whose Orca project holds a tab your book does not name. The
 folder moves only once Orca no longer lists the project; if Orca still lists it,
@@ -557,6 +549,8 @@ What it looks for:
   `<bot>.<session>` every fleet's sessions had before 0.10.0, which a session of
   another fleet can write to. Its next start through the kit gives it one of its
   own, so the finding names the `obk restart … --session` that does it;
+- **a process still running in a retired session's work dir**: one from before
+  retire stopped them, or one it could not stop, with its pid and command;
 - **leftovers no book owns**: an Orca project inside your bots folder with no
   bot in it, a tab in a bot's project that the book does not name, a start
   prompt written for a session that has gone, a clone of a skills source you no
@@ -580,7 +574,7 @@ verdict: which of these matter, and in what order, is for you or for Bot Father.
 ## Sessions and bots that talk
 
 Ask the kit how to reach a session, and it answers with the road and the
-address ([ADR 0035](docs/adr/0035-messaging-transport.md)):
+address ([ADR 0042](docs/adr/0042-messaging-transport.md)):
 
 ```sh
 obk message to    --bots /path/to/my-bots --to api-bot/daily
@@ -623,17 +617,17 @@ mailbox where it was and says so, and the harness starts all the same. A check
 holds its turn for 40 seconds at most: with more mail than it reads in that
 time, it shows what it read and says the rest is still waiting.
 
-Nothing in a mailbox wakes anybody, so each message gets one signal that tells
-the receiver to look. Orca's own notice comes first: Orca types it into an idle
-tab. The kit watches an idle receiver for up to 8 seconds, and reads the
-receiver's own record of its turns. When Orca's notice is there, the kit types
-nothing. When no turn started, the kit types its own line. A Claude session busy
-with a turn gets nothing typed: its hook tells it at the end of the turn. A busy
-Codex session gets the kit's line, which Codex takes into the turn it is having.
-The send says which signal went. A session that is not up is not typed into at
-all; its message waits. When a session is retired, the kit says how many
-messages sent to it were not read with `obk message check`, and who sent them
-([ADR 0035](docs/adr/0035-messaging-transport.md)).
+Nothing in a mailbox wakes anybody, so each message gets one signal: Orca's
+own notice, which Orca types into the receiver's tab once it is idle. A busy
+receiver gets it a minute or a few after its turn ends. The kit types nothing
+into the receiver's tab, and the send says which road it took. For urgent mail,
+`obk message send --interrupt` presses Escape once in a busy receiver's tab to
+end its turn, and then sends the message, so the notice comes at once. Codex
+keeps a command it was running as a background terminal after an Escape. A
+receiver reads its mail with `obk message check`, which marks it read: a bare
+`orca orchestration check` leaves it unread, and Orca then gives no more
+notices for that mailbox
+([ADR 0042](docs/adr/0042-messaging-transport.md)).
 
 A message longer than 4 KiB is written to a file beside your bots folder and
 named in the message, so a long one arrives whole without landing a document in

package/package.json

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

package/rules/mail.md

@@ -12,12 +12,12 @@ If your harness refuses a message, do not send it again by another road. Tell
 your maker or your user, with the harness's reason. A refusal can mean a missing
 permission rule, which they can add through the kit after the user's yes.
 
-Mail is queued, not an interruption. Read it when you finish what you are on.
+Mail is queued, not an interruption. When Orca says you have mail, read it
+with `"${OBK_CLI:-obk}" message check --bots <bots>`, never a bare `orca
+orchestration check`: that leaves it unread, and Orca stops telling you of mail.
 
 Ask for a reply when you need one, and send one when you were asked for one.
 
-A message sent is queued, not read or acted on: the reply, or the work done,
-is what shows it arrived. Look for one before you send it again.
+A sent message is only queued. Look for the reply or the work before you resend.
 
-Write to the session that needs it, not to several in the hope that one of
-them is right.
+Write only to the session that needs it, not to several at once.

package/src/book.js

@@ -6,12 +6,14 @@
 // theirs. Beside each session's tab it holds the harness session id that
 // session is running under, and every id it ran under before.
 
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { isDeepStrictEqual } from 'node:util';
 import { parse, stringify } from 'yaml';
 
+import { kitFolders } from './launch.js';
+
 const HEADER = `# What Orca calls this bot on this machine, and where each of its sessions
 # lives. \`obk up\` writes this file; it is committed with the rest of the repo.
 #
@@ -151,7 +153,7 @@ function takeLock(home) {
   try {
     return lockOn(lockFile(home), WAIT_MS);
   } catch (error) {
-    throw waitedTooLong(home, error);
+    throw error instanceof LockNotWritable ? error : waitedTooLong(home, error);
   }
 }
 
@@ -162,7 +164,21 @@ function takeLock(home) {
  * `EXCLUSIVE`, alone, once every `SHARED` holder has let go.
  */
 function lockOn(file, waitMs, how = 'IMMEDIATE') {
-  mkdirSync(path.dirname(file), { recursive: true });
+  // SQLite opens a file it cannot write read-only, without a word, and a
+  // read-only connection's BEGIN passes while another process holds the lock:
+  // seen in Codex's sandbox (#534). So the file is opened for writing first,
+  // and a lock that cannot be held is an error, never a turn that is not one.
+  // Only while this process holds no turn on it: closing any descriptor of a
+  // file lets go of every lock the process holds on that file, and SQLite's
+  // own are among them. A file a turn is held on was written already.
+  if (!heldHere.has(file)) {
+    try {
+      mkdirSync(path.dirname(file), { recursive: true });
+      closeSync(openSync(file, 'a'));
+    } catch (error) {
+      throw new LockNotWritable(file, error);
+    }
+  }
 
   const db = new DatabaseSync(file);
   try {
@@ -181,17 +197,24 @@ function lockOn(file, waitMs, how = 'IMMEDIATE') {
     throw error;
   }
 
+  heldHere.set(file, (heldHere.get(file) ?? 0) + 1);
   return {
     release() {
       try {
         db.exec('COMMIT');
       } finally {
         db.close();
+        const left = heldHere.get(file) - 1;
+        if (left > 0) heldHere.set(file, left);
+        else heldHere.delete(file);
       }
     },
   };
 }
 
+/** How many turns this process holds on each lock file, by its path. */
+const heldHere = new Map();
+
 /**
  * Where a writer takes its turn: a folder of the kit's own beside the bots repo,
  * carrying that folder's own name, the way start-prompt files sit beside it
@@ -213,14 +236,31 @@ function lockOn(file, waitMs, how = 'IMMEDIATE') {
  * the bots folder through a link and another by its real path, and two paths
  * would be two locks for one book (#375).
  */
-const lockFile = (home) => {
+const lockFile = (home) => path.join(botLocks(home), `${encodeURIComponent(path.basename(realpathSync(home)))}.lock`);
+
+/**
+ * The bot's own folder of locks, `<bots>.locks/<bot>/`: the one a Codex
+ * session of the bot is given to write, beside its mail and its start prompts
+ * (#534). One folder per bot, so a bot's sessions can take each other's turns
+ * and no other bot's.
+ */
+const botLocks = (home) => {
   const real = realpathSync(home);
-  return path.join(
-    `${path.dirname(path.dirname(real))}.locks`,
-    `${encodeURIComponent(path.basename(real))}.lock`,
-  );
+  return kitFolders(path.dirname(path.dirname(real)), path.basename(real)).locks;
 };
 
+/**
+ * A lock the kit cannot write. Inside Codex's sandbox that is a session
+ * started before the kit gave its bot a folder of locks, so it says what puts
+ * it right.
+ */
+class LockNotWritable extends Error {
+  constructor(file, why) {
+    super(`the kit cannot write its lock ${file} (${why.code ?? why.message}), so it did not take the turn, and nothing was done. A Codex session started before this version of the kit cannot write its bot's folder of locks: restart this session with the kit. Elsewhere, make ${path.dirname(file)} writable.`);
+    this.code = why.code;
+  }
+}
+
 /**
  * One session's turn at its mailbox (#321): held by `session mailbox` for its
  * whole step, by `message check` in the session's own tab for its bind, read and
@@ -286,11 +326,11 @@ export function takeTypingTurn(home, session, waitMs) {
 
 /**
  * A session's turn for one whole line, sent with its return in one go, as the
- * mail nudge is: through the typing turn's gate, waited for `waitMs` at most,
+ * mail interrupt is: through the typing turn's gate, waited for `waitMs` at most,
  * and then held beside any other line, so whole lines never wait on each
  * other, only on typing one key at a time. Returns `{ release }`, or undefined
  * when the gate did not come within `waitMs`. Every whole line the kit types
- * takes it: the nudge, the list line, the skills reload and the grooming line (#482).
+ * takes it: the mail interrupt, the list line, the skills reload and the grooming line (#482).
  */
 export function takeLineTurn(home, session, waitMs) {
   const gate = turnOn(home, session, 'typing', waitMs);
@@ -312,8 +352,9 @@ export const TYPING_WAIT_MS = 5000;
 export const TYPING_HELD = `the kit is typing into it, and it was still at it after ${TYPING_WAIT_MS / 1000} s, so nothing was typed`;
 
 /**
- * How long a typing turn waits for the lines already on their way: a nudge
- * holds its line's turn while Orca waits up to 5 s to see it start a turn.
+ * How long a typing turn waits for the lines already on their way: a line
+ * re-issued to Orca holds its turn while Orca waits up to 5 s to see it start
+ * a turn.
  */
 const LINES_WAIT_MS = 10_000;
 
@@ -344,10 +385,8 @@ const SQLITE_BUSY = 5;
  * link by one command and by its real path by another, and two paths would be
  * two turns.
  */
-const mailboxLockFile = (home, session) => {
-  const real = realpathSync(home);
-  return path.join(`${path.dirname(path.dirname(real))}.locks`, `${path.basename(real)}.${session}.mailbox.lock`);
-};
+const mailboxLockFile = (home, session) =>
+  path.join(botLocks(home), `${path.basename(realpathSync(home))}.${session}.mailbox.lock`);
 
 /**
  * Something else has been writing the book for longer than this run is prepared

package/src/cli.js

@@ -19,14 +19,14 @@ import { checkHealth, orcaSettingFindings } from './health.js';
 import { initBots } from './init.js';
 import { nameSession } from './name.js';
 import { APPROVALS, harnessOf, HARNESSES, ownCli, refuseApprovalArgs, shellWord, workDirOf } from './launch.js';
-import { checkMail, decideLeftNudges, lookUp, noMailboxYet, sendMessage, sessionInTab, stillUnread, WATCH_MS } from './message.js';
+import { checkMail, lookUp, noMailboxYet, sendMessage, sessionInTab } from './message.js';
 import { orcaCli, orcaTrouble, RELOAD_LINE, TERMINAL_ENV } from './orca.js';
 import { allowIn, beyondDefaults, refuseBroad, refuseNoCodexForm, runsOnClaude, runsOnCodex, takeBack, writePermissions } from './permissions.js';
 import { pauseSessions, unpauseSessions } from './pause.js';
 import { recordSession, SHELL_ENV, TAB_ENV } from './record.js';
 import { restartSessions } from './restart.js';
 import { clearSession, compactSession } from './clear.js';
-import { retireBot, retireSession, unreadWords } from './retire.js';
+import { retireBot, retireSession } from './retire.js';
 import { sentWarning } from './sent.js';
 import { readRoster } from './roster.js';
 import { buildAgents, buildRules, CODEX_CAP } from './rules.js';
@@ -109,7 +109,9 @@ Usage:
                             End a session: close its tab and take it off the
                             bot, keeping its conversations in the book, and
                             first do the same for the temporary sessions it
-                            made, and theirs. Or end a bot: close its tabs,
+                            made, and theirs. It stops what the session left
+                            running in its work dir, and names each process.
+                            Or end a bot: close its tabs,
                             remove its Orca project and move its folder to
                             retired/. It will not retire a bot whose Orca
                             project holds a tab your book does not name, and
@@ -207,9 +209,12 @@ Usage:
                             the Orca mailbox. Nothing is sent.
   obk message send --bots <path> --to <bot>[/<session>] [--from <bot>/<session>]
                    --subject <text> [--text <text> | --text-file <path>]
-                   [--thread <id>]
-                            Put a message in that session's Orca mailbox and
-                            tell its tab to look. A message too long to travel
+                   [--thread <id>] [--interrupt]
+                            Put a message in that session's Orca mailbox. Orca
+                            tells it to look once it is idle. --interrupt is
+                            for urgent mail: when the session is busy, the kit
+                            presses Escape once in its tab first, to end its
+                            turn, so it looks now. A message too long to travel
                             as itself is written to a file beside your bots
                             folder and named in the message. A pair the
                             harness's own messaging reaches is not carried:
@@ -305,17 +310,6 @@ Usage:
                             Claude session's native message, it warns the
                             session when the address was none of this bots
                             folder's own. It never stops a message.
-  obk session nudge --bots <path> --bot <bot>
-                            For the kit's own hook, not for typing: after a
-                            Codex session's shell command, it decides the mail
-                            nudges a send there left because it could not
-                            tell from inside Codex's sandbox, and types each
-                            one or says why not.
-  obk session mail --bots <path> --bot <bot>
-                            For the kit's own hook, not for typing: at the end
-                            of a Claude session's turn, it tells the session
-                            once about each fleet mail the kit sent it that is
-                            still unread. It types nothing into the tab.
   obk session name --bots <path> --bot <bot>
                             For the kit's own hook, not for typing: after a
                             Codex session's turn, it names the session's thread
@@ -409,6 +403,7 @@ async function run(argv) {
       'text-file': { type: 'string' },
       thread: { type: 'string' },
       peek: { type: 'boolean' },
+      interrupt: { type: 'boolean' },
       charter: { type: 'string' },
       allow: { type: 'string', multiple: true },
       disallow: { type: 'string', multiple: true },
@@ -476,8 +471,6 @@ async function run(argv) {
   // The send hook is quiet whatever it is given, a bots folder that is not
   // there included, so it goes before anything that can complain (ADR 0032).
   if (command === SENT) return sent(path.resolve(values.bots));
-  if (command === NUDGE) return nudgeLeft();
-  if (command === MAIL) return mailHook(path.resolve(values.bots), values.bot);
   if (command === NAME) return nameThread(path.resolve(values.bots), values.bot);
 
   // One fleet, one identity, whatever spelling of its path was given (#164).
@@ -548,8 +541,6 @@ const ANSWER_IT = [
 /** The commands a harness runs rather than a person: the kit's hooks. */
 const RECORD = 'session record';
 const SENT = 'session sent';
-const NUDGE = 'session nudge';
-const MAIL = 'session mail';
 const NAME = 'session name';
 
 /**
@@ -569,45 +560,6 @@ function sent(bots) {
   return 0;
 }
 
-/**
- * What the kit's Codex hook does after a shell command: decide the nudges a
- * send in this tab left for it, outside Codex's sandbox, and say to the session
- * what became of each, as Codex's `additionalContext` (#350, ADR 0034). Silent
- * when nothing was left, never a decision, and never anything but exit 0.
- */
-async function nudgeLeft() {
-  try {
-    const said = JSON.parse(readFileSync(0, 'utf8'));
-    if (said?.hook_event_name !== 'PostToolUse') return 0;
-    const decided = await decideLeftNudges(process.env[TAB_ENV]);
-    if (decided.length > 0) {
-      const words = decided.map((one) => `Your mail "${one.subject}" to ${one.to}: ${one.nudged ? "the kit's hook nudged its tab, from outside Codex's sandbox:" : "the kit's hook looked at its tab from outside Codex's sandbox, and"} ${nudgeLine(one, one.to).trim()}`);
-      process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: words.join('\n') } })}\n`);
-    }
-  } catch {
-    // Nothing: a hook does not disturb the session it runs in.
-  }
-  return 0;
-}
-
-/**
- * What the kit's Claude Code Stop hook does at a turn end (#509, ADR 0035): tell
- * the session once about fleet mail still unread, as the Stop event's
- * additional context, which the session goes on with. Not a block: Claude Code
- * 2.1.296 draws a block's reason in red as "Stop hook error", and its additional
- * context as "Stop hook feedback". Nothing typed into the tab; never anything
- * but exit 0; silent whenever it cannot be sure.
- */
-function mailHook(bots, bot) {
-  try {
-    const reason = stillUnread(sameFleet(bots), bot, JSON.parse(readFileSync(0, 'utf8')), process.env[TAB_ENV], process.env[TERMINAL_ENV]);
-    if (reason !== undefined) process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'Stop', additionalContext: reason } })}\n`);
-  } catch {
-    // Nothing: a hook does not disturb the session it runs in.
-  }
-  return 0;
-}
-
 /**
  * What the kit's Codex Stop hook does at a turn end: name the session's thread
  * after its bot and session, once it is idle (#480). Silent, never a decision,
@@ -737,7 +689,7 @@ const commands = {
           ...withLines(retired.retiredWith, retired.session),
           ...closedLines(retired.closed),
           `retired    ${retired.bot} ${retired.session}: off ${path.join('bots', retired.bot, 'bot.yaml')}, and its conversations kept in the book under retired`,
-          ...unreadLines(retired.unread),
+          ...processLines(retired.processes),
           ...leftLines(retired.promptsLeft),
         ],
       };
@@ -749,6 +701,7 @@ const commands = {
         answer: { bots, ...retired },
         lines: [
           ...closedLines(retired.closed),
+          ...processLines(retired.processes),
           `${'trouble'.padEnd(9)}  Orca project ${retired.project}`,
           `             ${retired.trouble}`,
           `Retire it again:  ${shellWord(ownCli())} retire --bots ${shellWord(bots)} --bot ${retired.bot}`,
@@ -767,7 +720,7 @@ const commands = {
           retired.windowReloaded ? "reloaded   Orca's window, so its sidebar no longer shows the project" : RELOAD_LINE,
         ]),
         `retired    ${retired.bot}: moved to ${path.relative(bots, retired.moved)}, with its book, charter and memory`,
-        ...(retired.unread ?? []).flatMap((one) => unreadLines(one, `${retired.bot}/${one.session}`)),
+        ...processLines(retired.processes),
         ...leftLines(retired.promptsLeft),
       ],
     };
@@ -824,7 +777,7 @@ const commands = {
         ...withLines(retired.retiredWith, retired.session),
         ...closedLines(retired.closed),
         `retired    ${retired.bot} ${retired.session}, a temporary session of ${retired.maker}'s: off ${path.join('bots', retired.bot, 'bot.yaml')}, and its conversations kept in the book under retired`,
-        ...unreadLines(retired.unread),
+        ...processLines(retired.processes),
         ...leftLines(retired.promptsLeft),
       ],
     };
@@ -1189,6 +1142,7 @@ const commands = {
       text: values.text,
       textFile: values['text-file'],
       thread: values.thread,
+      interrupt: values.interrupt === true,
     });
     const where = `${answer.to.bot}/${answer.to.session}`;
 
@@ -1207,7 +1161,7 @@ const commands = {
         ...(answer.file === undefined
           ? []
           : [`             it was too long to travel as itself, so it went as a file:  ${answer.file}`]),
-        ...[nudgeLine(answer, where)],
+        ...sentLines(answer, where),
       ],
     };
   },
@@ -1348,46 +1302,23 @@ function toLines(answer, bots, where) {
 }
 
 /**
- * What became of the line that tells the receiver to look. The message is in
- * its mailbox whatever this says, so each of these is about the tab and not
- * about the message.
+ * What the send says after `sent`: the road it took, and what the interrupt
+ * came to when one was asked for (#555).
  */
-function nudgeLine(answer, where) {
-  const seconds = answer.watchedMs === undefined ? '' : ` in ${Math.max(Math.round(answer.watchedMs / 1000), 1)} s`;
-  if (answer.signal === 'orca') return `             Orca's notice reached it${seconds}, so no line was typed: it reads the mail from there.`;
-  if (answer.signal === 'hook') {
-    return answer.because === 'busy'
-      ? "             it is busy with a turn, so nothing was typed into its tab: its own hook tells it about the mail when that turn ends."
-      : `             a turn of other work started in its tab${seconds}, not Orca's notice, so nothing was typed: its own hook tells it about the mail when that turn ends.`;
-  }
-  const why = {
-    'no-turn': `no turn started in its tab in ${WATCH_SECONDS} s, so the kit's line was typed`,
-    busy: "it is busy with a turn, and Codex takes a line into the turn it is having, so the kit's line was typed",
-    'other-turn': "a turn of other work started in its tab, not Orca's notice, so the kit's line was typed",
-  }[answer.because];
-  const head = why === undefined ? '             ' : `             ${why}: `;
-  if (answer.nudged && answer.nudgeWatched === false) {
-    return `${head}its tab was typed into, and Orca could not say whether it was taken: ${answer.nudgeUnseen} The message waits in its mailbox for its next check either way.`;
-  }
-  if (answer.nudged && answer.nudgeUnseen !== undefined) {
-    return `${head}its tab was typed into, but Orca did not see the line start a turn: it may be queued behind the work in hand, or lost. The message waits in its mailbox for its next check either way.`;
-  }
-  if (answer.nudged) return `${head}its tab was told to look; it will read it when it is done with what it is doing.`;
-  if (answer.blocked !== undefined) {
-    return `             its tab has something waiting to be answered (${answer.blocked}), so nothing was typed into it. Settle that, and the mail is there.`;
-  }
-  if (answer.nudgeLeft) {
-    return `             it is queued, and its tab could not be told to look from here: ${answer.nudgeTrouble}. So the nudge is left for this session's hook, which looks at the tab from outside Codex's sandbox when this command is done, and says what it did.`;
+function sentLines(answer, where) {
+  const road = "             it is in its Orca mailbox, and Orca's own notice tells it to look once it is idle.";
+  if (answer.interrupted === true) {
+    return [
+      `${road.replace('once it is idle', 'now')}`,
+      `             it was busy, so the kit pressed Escape once in its tab to end its turn.${answer.to.harness === 'codex' ? ' Codex keeps a command it was running as a background terminal after an Escape.' : ''}`,
+    ];
   }
-  if (answer.nudgeTrouble !== undefined) {
-    return `             it is queued, and its tab could not be told to look: ${answer.nudgeTrouble}`;
+  if (answer.interrupted === false) {
+    return [road, answer.idle ? `             it is idle, so it was not interrupted.` : `             it was not interrupted: ${answer.interruptTrouble}.`];
   }
-  return `             ${where} is not up, so nothing was typed anywhere: the message waits in its mailbox.`;
+  return [road];
 }
 
-/** The watch before the kit's line, as the send says it (#509, ADR 0035). */
-const WATCH_SECONDS = WATCH_MS / 1000;
-
 /**
  * What there is to say about the work dir this command was given: one finding
  * when it leads out of the bot home, through `..` or a link or as a path
@@ -1459,12 +1390,19 @@ const closedLines = (closed) => closed.map((tab) => `closed     ${tab.bot} ${tab
 const withLines = (retiredWith, session) => retiredWith.flatMap((gone) => [
   ...closedLines(gone.closed),
   `retired    ${gone.bot} ${gone.session}, a temporary session of ${gone.maker}'s, along with ${session}: off ${path.join('bots', gone.bot, 'bot.yaml')}, and its conversations kept in the book under retired`,
-  ...unreadLines(gone.unread),
+  ...processLines(gone.processes),
   ...leftLines(gone.promptsLeft),
 ]);
 
-/** The mail a retired session did not read, as far as the kit knows (#509). */
-const unreadLines = (unread, who = 'it') => (unread === undefined ? [] : [`unread     ${unreadWords(unread, who)}`]);
+/** What a retire stopped of what its sessions left running, and what it named and left (#537). */
+function processLines(processes) {
+  if (processes === undefined) return [];
+  if (processes.unreadable !== undefined) return [`processes  the kit cannot tell which processes were left running in the work dir, so it stopped none: ${processes.unreadable}`];
+  return [
+    ...processes.stopped.map((one) => `stopped    pid ${one.pid} of ${one.session}, with ${one.signal}: ${one.command}${one.cwd === null ? '' : `  in ${one.cwd}`}`),
+    ...processes.left.map((one) => `left       pid ${one.pid} in ${one.cwd ?? 'a folder lsof did not name'}: ${one.command}. Not stopped: ${one.why}.`),
+  ];
+}
 
 /** What a retire could not remove, and how to: nothing reads these files now (#393). */
 const leftLines = (left = []) => left.flatMap(({ file, reason }) => [

package/src/commands.js

@@ -37,8 +37,6 @@ export const COMMANDS = {
   'message check': ['bots'],
   'session record': ['bots', 'bot'],
   'session sent': ['bots', 'bot'],
-  'session nudge': ['bots', 'bot'],
-  'session mail': ['bots', 'bot'],
   'session name': ['bots', 'bot'],
   'session mailbox': ['bots', 'bot', 'session'],
   'session trust-hooks': ['bots', 'bot', 'session'],
@@ -61,7 +59,7 @@ export const DEFAULT_COMMANDS = [
   'skills add', 'skills remove', 'skills build', 'skills fetch', 'skills update', 'source add',
   'session add', 'session change', 'session clear', 'session compact',
   'message to', 'message send', 'message check',
-  'session record', 'session sent', 'session nudge', 'session mail', 'session name', 'session mailbox',
+  'session record', 'session sent', 'session name', 'session mailbox',
   'session trust-hooks', 'session answer',
   'temp make', 'temp roles', 'temp retire', 'temp trust-hooks', 'temp answer',
 ];

package/src/conversations.js

@@ -159,43 +159,6 @@ export function heldAsUserTurn(harness, file, text) {
   return held;
 }
 
-/**
- * Where the harness keeps the conversation `id` of this bot home, and how long
- * that record is now: `{ harness, file, size }`, so a later look reads only
- * what was written after this moment. Undefined when there is no id, no
- * record, or it cannot be read (#509).
- */
-export function recordMark(harness, home, id) {
-  if (typeof id !== 'string' || id === '') return undefined;
-  try {
-    const file = harness === 'codex' ? codexRollout(id) : claudeTranscript(home, id);
-    if (file === undefined) return undefined;
-    const found = statSync(file);
-    return found.isFile() ? { harness, file, size: found.size } : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Whether a turn of the user's written after `mark` holds `text` anywhere in
- * it (#509). A record that cannot be read says no: not seeing a thing is not
- * seeing it.
- */
-export function userTurnSince(mark, text) {
-  if (mark === undefined || mark === null) return false;
-  let held = false;
-  try {
-    eachLine(mark.file, (line) => {
-      held = line !== undefined && userTexts(mark.harness, line).some((said) => said.includes(text));
-      return held;
-    }, { from: mark.size });
-  } catch {
-    return false;
-  }
-  return held;
-}
-
 /** The texts of one record line, when it is a turn of the user's. */
 function userTexts(harness, line) {
   let parsed;