@assuredloop/orca-bot-kit 0.23.0 → 0.25.0

package/SETUP.md

@@ -200,6 +200,7 @@ waiting for:
 | Codex's update offer, `1. Update now` | `\r` | return: its selection starts on **Update now**, which accepts it | Codex 0.156.1; seen on 0.157.1 (offering 0.158.0) with the selection on **Update now**, not pressed; 0.158.0 offered 0.160.0, taken on 2026-10-02 by Bot Father's restarts |
 | `[oh-my-zsh] Would you like to update?` | `n` | they update their own shell | oh-my-zsh bf77e35 |
 | Claude Code's `Teach auto mode about your environment?` | `\x1b` | Esc, which cancels it (**Not now**). On 2.1.283 it is a form, not a list: `How you use Claude here`, `Also scan shell history`, `Also scan your other repos`, `Continue`, and `Enter to continue · Esc to cancel`. **Never send a return**: Enter is **Continue**, which starts a scan of the project, recent Claude sessions and, by default, the machine's shell history | Not yet proven: Esc cancels in Claude Code 2.1.283's code, not yet seen live (#370); the form was seen live twice on 2.1.283, in #261's live test and #239's live run 1 (#416); 2.1.278 showed a numbered list, answered with 2. Not now |
+| Claude Code 2.1.289's `Teach auto mode about your environment?`, a numbered list: `1. Yes`, `2. Not now`, `3. Don't show again`, and `Enter to confirm · Esc to cancel`, above the input box | `\x1b[B\r` | down, then return, to **2. Not now**: its selection starts on **1. Yes**. Read the screen after the down arrow, and send the return only with the selection on **2. Not now**. Never **1. Yes**, which starts the teach scan, and never **3. Don't show again** | Not yet proven: the list was seen live on 2.1.289 with its selection on 1. Yes, in #489's live run 1, and was not answered there |
 
 Each key counts on where the selection starts, as it did on the version named.
 Read the screen in front of you before you send: if the selection is somewhere
@@ -221,6 +222,27 @@ Codex's `/new` question (seen on 0.156.1, 0.157.1, 0.158.0 and 0.160.0) is alway
 home. The kit never makes a git worktree, so
 `2. New worktree` is never the answer.
 
+A bot's own temporary sessions are answered by their maker, through the kit, so
+that one narrow permission rule allows it rather than a rule to type into any
+tab. On Codex's hooks review, the maker runs
+`obk temp trust-hooks --bots <their path> --name <session>`. On Claude Code's
+`Teach auto mode` screen, it runs `obk temp answer --bots <their path> --name <session>`.
+That command reads the screen and answers only when it holds one of the two
+shapes in the table exactly as the kit knows it: Esc for the 2.1.283 form, and
+**2. Not now** for the 2.1.289 list. On the list it sends the arrows, reads the
+screen again, and sends the return only with the selection on **2. Not now**.
+It refuses any other screen, types nothing then, and prints what it saw.
+Afterwards it checks that the screen has gone. In
+auto mode the maker's bot needs this rule, with the kit's full CLI path for
+`<kit>`, as the command's own output prints it:
+
+```text
+Bash(<kit> temp answer:*)
+```
+
+Ask the user, and only after their yes run
+`obk bot change --bots <their path> --bot <bot> --allow 'Bash(<kit> temp answer:*)'`.
+
 **Anything you do not recognise: type nothing.** Tell them what is on the
 screen and which tab it is in, and wait. A keypress into a menu you have not read
 is how a harness quits back to the shell.

package/package.json

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

package/skills/obk-bot-building/SKILL.md

@@ -294,6 +294,7 @@ otherwise `/Applications/Orca.app/Contents/Resources/bin/orca`. A bare
 | Codex's update offer, `1. Update now` | `\r` | **Update now**, where it starts | Codex 0.156.1 |
 | `[oh-my-zsh] Would you like to update?` | `n` | no: the user updates it | oh-my-zsh bf77e35 |
 | Claude Code's `Teach auto mode…` | `\x1b` | Esc: Not now; no return | Not yet proven, below |
+| The same, 2.1.289's list | `\x1b[B\r` | down, return: **2. Not now** | Not yet proven, below |
 
 Each key counts on where the selection starts on the version named. Read the
 screen before you send: if the selection is elsewhere or the options have
@@ -309,7 +310,10 @@ Claude Code's `Teach auto mode` on 2.1.283 is a form, not a list, ending
 Enter is Continue, which scans the project, recent sessions and the machine's
 shell history. Esc cancels it (Not now) in its code; that is not yet proven
 live, though the form was seen live twice on 2.1.283. On 2.1.278 it was a
-numbered list, answered with `2. Not now`. Codex's hooks
+numbered list, answered with `2. Not now`, and on 2.1.289 it is one again:
+`1. Yes`, `2. Not now`, `3. Don't show again`, above the input box, its
+selection on 1. Yes (seen live, not answered, in #489). Go down to 2. Not now,
+read the screen, and only then return. Codex's hooks
 question matters most. The kit's hook is how the book learns which
 conversation the session is running, and until it is answered the
 conversation has not started. Codex's trust applies to the repository root,
@@ -323,7 +327,13 @@ exception: answer it with `obk temp trust-hooks --bots <bots> --name
 <session>`, not with the keys. It reads the screen, chooses **Trust all and
 continue** only if the review is there, and checks that the review went. A
 permission rule can allow that one command, where it cannot allow keys sent
-into any tab.
+into any tab. The same goes for Claude Code's `Teach auto mode` screen on a
+temporary session you made: answer it with `obk temp answer --bots <bots>
+--name <session>`. It answers only a shape in the table exactly as the kit
+knows it (Esc on the 2.1.283 form, 2. Not now on the 2.1.289 list, the return
+only after a second look), refuses any other screen, and checks that it went. Its
+rule is `Bash(<kit> temp answer:*)`, `<kit>` the kit's CLI path as the
+command prints it; ask the user before `obk bot change --allow` adds it.
 
 Where the kit says no session came up, the shell swallowed the launch line,
 usually while it was asking its own question. Answer the shell, then close

package/src/book.js

@@ -152,8 +152,13 @@ function takeLock(home) {
   }
 }
 
-/** The lock on `file`, waited for `waitMs` at most: see `takeLock` for why it is this one. */
-function lockOn(file, waitMs) {
+/**
+ * The lock on `file`, waited for `waitMs` at most: see `takeLock` for why it is
+ * this one. `how` is SQLite's: `IMMEDIATE`, one holder at a time; `SHARED`,
+ * any number at once, none while an `EXCLUSIVE` is held or waited for; and
+ * `EXCLUSIVE`, alone, once every `SHARED` holder has let go.
+ */
+function lockOn(file, waitMs, how = 'IMMEDIATE') {
   mkdirSync(path.dirname(file), { recursive: true });
 
   const db = new DatabaseSync(file);
@@ -161,7 +166,13 @@ function lockOn(file, waitMs) {
     // A writer that arrives while another is working waits for it rather than
     // failing at once, and gives up saying so rather than waiting for ever.
     db.exec(`PRAGMA busy_timeout = ${waitMs}`);
-    db.exec('BEGIN IMMEDIATE');
+    if (how === 'SHARED') {
+      // A reading transaction holds its shared lock from its first read.
+      db.exec('BEGIN');
+      db.prepare('SELECT count(*) FROM sqlite_master').get();
+    } else {
+      db.exec(`BEGIN ${how}`);
+    }
   } catch (error) {
     db.close();
     throw error;
@@ -233,6 +244,86 @@ export function takeMailboxTurn(home, session) {
   }
 }
 
+/**
+ * A session's turn to have its Codex thread named (#480), beside its mailbox
+ * turn: `{ release }`, or undefined at once when another naming holds it, so
+ * that two turn ends close together type the name once.
+ */
+export const takeNameTurn = (home, session) => turnOn(home, session, 'name', 0);
+
+/**
+ * A session's typing turn (#480, the architect's ruling), for what the kit
+ * types into the session's tab one key at a time: no line of the kit's may
+ * land in between and send what is there with its own return. Two locks
+ * beside its mailbox turn: `typing`, the gate, held for the whole typing, and
+ * `lines`, taken alone once the lines already on their way have gone in.
+ * Returns `{ release }`, or undefined when it did not come within `waitMs`,
+ * or the lines in flight did not finish within LINES_WAIT_MS.
+ */
+export function takeTypingTurn(home, session, waitMs) {
+  const gate = turnOn(home, session, 'typing', waitMs);
+  if (gate === undefined) return undefined;
+  let lines;
+  try {
+    lines = turnOn(home, session, 'lines', LINES_WAIT_MS, 'EXCLUSIVE');
+  } finally {
+    if (lines === undefined) gate.release();
+  }
+  if (lines === undefined) return undefined;
+  return {
+    release() {
+      try {
+        lines.release();
+      } finally {
+        gate.release();
+      }
+    },
+  };
+}
+
+/**
+ * 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,
+ * 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).
+ */
+export function takeLineTurn(home, session, waitMs) {
+  const gate = turnOn(home, session, 'typing', waitMs);
+  if (gate === undefined) return undefined;
+  try {
+    return turnOn(home, session, 'lines', 0, 'SHARED');
+  } finally {
+    gate.release();
+  }
+}
+
+/**
+ * How long a kit path waits for a session's typing turn before it types
+ * nothing (#480, #482): a naming holds it for seconds.
+ */
+export const TYPING_WAIT_MS = 5000;
+
+/** What a kit path reports when the session's typing turn did not come within TYPING_WAIT_MS. */
+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.
+ */
+const LINES_WAIT_MS = 10_000;
+
+/** A turn of the kit's own for one session, on a file beside its mailbox turn's. */
+function turnOn(home, session, kind, waitMs, how) {
+  try {
+    return lockOn(mailboxLockFile(home, session).replace(/\.mailbox\.lock$/, `.${kind}.lock`), waitMs, how);
+  } catch (error) {
+    if (error.errcode === SQLITE_BUSY) return undefined;
+    throw error;
+  }
+}
+
 /**
  * How long a step, a check or an `up` waits for a session's turn. Longer than a
  * step can hold it — three Orca calls of twenty seconds each at most — and short

package/src/clear.js

@@ -14,12 +14,12 @@
 import { realpathSync, statSync } from 'node:fs';
 import { setTimeout as pause } from 'node:timers/promises';
 
-import { readBook } from './book.js';
+import { readBook, takeTypingTurn, TYPING_HELD, TYPING_WAIT_MS } from './book.js';
 import { botDir, readBot } from './bot.js';
 import { claudeTranscript, codexRollout } from './conversations.js';
 import { harnessOf, ownCli, shellWord } from './launch.js';
 import { eachLine, firstLine } from './lines.js';
-import { findProject, orca, QUESTION_ON_SCREEN, questionIn, screenRows, tabs, tabToTypeInto } from './orca.js';
+import { findProject, orca, QUESTION_ON_SCREEN, questionIn, screenRows, tabs, tabToTypeInto, TIMED_OUT } from './orca.js';
 import { botsNamed, sessionsOf, typeListLine } from './up.js';
 
 /** The harness's own command for each, as typed into its input line. Codex's clear is `/new` (tech notes, section 3). */
@@ -58,6 +58,13 @@ const CODEX_BARE_LINE = '0.160.0';
 /** How long the session is given to be idle before nothing is typed, and how long each look waits on it. */
 const IDLE_WAIT_MS = 30_000;
 const LOOK_MS = 2000;
+/**
+ * How long each look between two characters waits on Orca's tui-idle, whose
+ * answer it does not use: an open slash menu keeps it from answering ok (live
+ * run 3 of #391). Short, so a naming holds the session's typing turn for
+ * seconds (#480).
+ */
+const CHAR_LOOK_MS = 250;
 /** How long the screen is given to show the command typed, or Codex's question after `/new`. */
 const SCREEN_MS = 3000;
 /** How long the book is given to hold the new conversation, and a harness to record a compaction (the architect: up to 5 minutes). */
@@ -95,14 +102,20 @@ const AT_WORK = [/esc to interrupt/i, /^\s*\S\s+\S+…\s+\(\d/];
 export async function clearSession(bots, { bot, session }) {
   const it = sessionToType(bots, bot, session);
   const was = readBook(it.home).sessions[session]?.session ?? null;
-  const { command, handle } = await enter(it, 'clear');
+  const { command, handle, typing } = await enter(it, 'clear');
 
-  if (it.harness === 'codex') {
-    await answerWhereToRun(it, handle, command);
-    const line = await typeListLine(it.home, it.tabId, RECORD_LINE);
-    if (!line.typed) {
-      throw new Error(`${it.name}: ${command} went in, but the line that starts the new conversation's first turn was not typed (${line.why}), and Codex reports a new conversation only at its first turn. The book still holds ${was ?? 'no conversation'}. Look at its tab.`);
+  // Codex's question and the line after it are part of the clear, typed in
+  // the typing turn it took for the command.
+  try {
+    if (it.harness === 'codex') {
+      await answerWhereToRun(it, handle, command);
+      const line = await typeListLine(it.home, it.session, it.tabId, { line: RECORD_LINE, held: true });
+      if (!line.typed) {
+        throw new Error(`${it.name}: ${command} went in, but the line that starts the new conversation's first turn was not typed (${line.why}), and Codex reports a new conversation only at its first turn. The book still holds ${was ?? 'no conversation'}. Look at its tab.`);
+      }
     }
+  } finally {
+    typing.release();
   }
 
   const until = Date.now() + CLEAR_MS;
@@ -128,9 +141,10 @@ export async function compactSession(bots, { bot, session }) {
   // that ends while the kit waits for the session to be idle is the one
   // before it (review of PR #466). So only what is written after counts.
   let record;
-  const { typedAt } = await enter(it, 'compact', () => {
+  const { typedAt, typing } = await enter(it, 'compact', () => {
     record = recordAt(it.harness, it.home, readBook(it.home).sessions[session]?.session ?? null);
   });
+  typing.release();
 
   const until = typedAt + COMPACT_MS;
   for (;;) {
@@ -150,7 +164,7 @@ export async function compactSession(bots, { bot, session }) {
  * The session as something to type into, once everything that refuses before
  * Orca is asked to type has been asked: `{ name, home, session, harness, tabId }`.
  */
-function sessionToType(bots, bot, session) {
+export function sessionToType(bots, bot, session) {
   botsNamed(bots, bot);
   const home = realpathSync(botDir(bots, bot));
   const known = readBot(home, bot);
@@ -174,22 +188,58 @@ function sessionToType(bots, bot, session) {
  * Type the harness's command for `verb` into the session's tab and press
  * return, once it is idle and the screen shows the command typed and nothing
  * else. `before` runs just before the command is typed. Returns the command,
- * the handle it went into, and when it was typed.
+ * the handle it went into, when it was typed, and the session's typing turn
+ * (#482), taken once it is idle, as the naming takes it, and held for the
+ * caller to release.
  */
 async function enter(it, verb, before = () => {}) {
-  const command = COMMANDS[verb][it.harness];
-  const { handle, rows } = await idleTab(it);
+  let typing;
+  try {
+    const typed = await typeCommand(it, COMMANDS[verb][it.harness], {
+      before: () => {
+        typing = takeTypingTurn(it.home, it.session, TYPING_WAIT_MS);
+        if (typing === undefined) throw new Error(`${it.name}: ${TYPING_HELD}. Run this again in a moment.`);
+        before();
+      },
+      cannot: (wrong) => (verb === 'compact' && wrong.menu ? ` ${harnessName(it.harness)} here cannot compact: its menu does not offer ${COMMANDS[verb][it.harness]}.` : ''),
+    });
+    return { ...typed, typing };
+  } catch (error) {
+    typing?.release();
+    throw error;
+  }
+}
+
+/**
+ * Type `command` into the session's tab, `it` as `sessionToType` gives it, and
+ * press return, once it is idle and `check` finds nothing wrong with the
+ * screen: by default the slash menu's check, which a command with words after
+ * it does not pass, since Codex closes its menu at the space (#480). `before`
+ * runs just before the command is typed; `cannot` adds to a refusal what a
+ * wrong screen means; past `deadline`, a time, what was typed is taken back
+ * and nothing is entered. Returns the command, the handle it went into, and
+ * when it was typed.
+ */
+export async function typeCommand(it, command, { before = () => {}, check = menuWrong, cannot = () => '', deadline = Infinity } = {}) {
   // On Codex, what is typed cannot be read back once its menu is open, so
   // nothing may be in its input line before: no draft for the command to join.
-  if (it.harness === 'codex') {
+  const emptyLine = (rows) => {
+    if (it.harness !== 'codex') return;
     const line = rows.findLast((row) => /^ *›/.test(row))?.trim();
     if (!CODEX_EMPTY.includes(line)) {
       throw new Error(`${it.name}: nothing was typed, because its input line is not empty: it reads "${line ?? 'nothing'}".${shownEnd(rows)}`);
     }
-  }
+  };
+  emptyLine((await idleTab(it)).rows);
   const version = it.harness === 'codex' ? codexVersion(readBook(it.home).sessions[it.session]?.session) : undefined;
 
   before();
+  // What `before` waited for can have changed the session: one more look,
+  // with no wait, before the first key (#480 review).
+  const ready = lookAt(it);
+  if (ready.why !== undefined) throw new Error(`${it.name}: nothing was typed, because ${ready.why}.`);
+  emptyLine(ready.rows);
+  const { handle } = ready;
   const typedAt = Date.now();
   // One character a send, each after a look through the gate, so nothing goes
   // in as one burst and nothing goes in once something asks a question
@@ -197,31 +247,63 @@ async function enter(it, verb, before = () => {}) {
   // Between characters, and once more before the return, the look is the gate
   // and the harness's own at-work row, not Orca's tui-idle: an open slash menu
   // can stop it answering ok (live run 3).
+  // The characters Orca took, and so what is in the input line of ours.
   let typed = 0;
+  // Taken back, one backspace a character, in one send, so the input line is
+  // as it was. Whatever stops the typing takes them back, a send Orca refused
+  // or a look that threw included (#480 review); a take-back Orca refuses
+  // too leaves nothing more the kit can do.
+  const takeBack = () => {
+    const keys = '\x7f'.repeat(typed);
+    typed = 0;
+    if (keys === '') return;
+    try {
+      send(handle, keys);
+    } catch {
+      // Said by the error that stopped the typing.
+    }
+  };
   const lookAgain = async () => {
     await pause(CHAR_GAP_MS);
     const look = lookAt(it, { idle: false });
+    // Past the caller's deadline nothing more goes in: a hook stopped partway
+    // would leave the text in the input line (#480 review).
+    if (look.why === undefined && Date.now() > deadline) look.why = 'its time ran out';
     if (look.why === undefined) return;
-    send(handle, '\x7f'.repeat(typed));
-    throw new Error(`${it.name}: ${command} was being typed, and after ${command.slice(0, typed)} ${look.why}, so what was typed was taken back and nothing was entered.`);
+    const sofar = command.slice(0, typed);
+    takeBack();
+    throw new Error(`${it.name}: ${command} was being typed, and after ${sofar} ${look.why}, so what was typed was taken back and nothing was entered.`);
   };
-  for (const char of command) {
-    if (typed > 0) await lookAgain();
-    send(handle, char);
-    typed += 1;
-  }
-  await lookAgain();
-  const wrong = await typedWrong(handle, it.harness, command, version);
-  if (wrong !== undefined) {
-    // Taken back, one backspace a character, so the input line is as it was.
-    send(handle, '\x7f'.repeat(command.length));
-    const cannot = verb === 'compact' && wrong.menu ? ` ${harnessName(it.harness)} here cannot compact: its menu does not offer ${command}.` : '';
-    throw new Error(`${it.name}: ${command} was typed but not entered, and was taken back, because ${wrong.why}.${cannot}${shownEnd(wrong.rows)}`);
+  try {
+    for (const char of command) {
+      if (typed > 0) await lookAgain();
+      try {
+        send(handle, char);
+      } catch (error) {
+        // A send Orca did not answer in time may have gone in all the same.
+        // Counted only where the line was empty before the first key, so the
+        // one backspace too many can take nothing of the user's (#480 review).
+        if (error.code === TIMED_OUT && it.harness === 'codex') typed += 1;
+        throw error;
+      }
+      typed += 1;
+    }
+    await lookAgain();
+    let wrong = await typedWrong(handle, it.harness, command, version, check);
+    if (wrong === undefined && Date.now() > deadline) wrong = { why: 'its time ran out' };
+    if (wrong !== undefined) {
+      takeBack();
+      throw new Error(`${it.name}: ${command} was typed but not entered, and was taken back, because ${wrong.why}.${cannot(wrong)}${shownEnd(wrong.rows)}`);
+    }
+    // A return of its own, not `--enter`: Orca's gate can refuse a line sent
+    // with `--enter` while it names a reason, and on Codex a return inside the
+    // text lands in the draft (helpers in the system tests, #329).
+    send(handle, '\r');
+    typed = 0;
+  } catch (error) {
+    takeBack();
+    throw error;
   }
-  // A return of its own, not `--enter`: Orca's gate can refuse a line sent
-  // with `--enter` while it names a reason, and on Codex a return inside the
-  // text lands in the draft (helpers in the system tests, #329).
-  send(handle, '\r');
   return { command, handle, typedAt };
 }
 
@@ -235,6 +317,7 @@ async function idleTab(it) {
   const until = Date.now() + IDLE_WAIT_MS;
   for (;;) {
     const look = lookAt(it);
+    if (look.moved) throw new Error(`${it.name}: nothing was typed, because ${look.why}.`);
     let why = look.why;
     // The wait is a cutoff, not a count of looks: a yes that comes after it
     // is too late (as for LIST_LINE, review of PR #421).
@@ -248,11 +331,23 @@ async function idleTab(it) {
 /**
  * One look through the typing gate at the session's tab: `{ handle }` when
  * nothing on its screen asks a question and nothing says it is at work, and,
- * with `idle`, Orca's tui-idle answered ok; or `{ why }`, naming the signal.
+ * with `idle`, Orca's tui-idle answered ok; or `{ why }`, naming the signal,
+ * with `moved` when the book holds another tab for the session now, or, where
+ * `it.conversation` is given, another conversation.
  * Throws when the tab holds no harness.
  */
 function lookAt(it, { idle = true } = {}) {
-  const found = tabToTypeInto(it.home, it.tabId, LOOK_MS);
+  // A restart can give the session a new tab while this waits or types, and
+  // a hook can outlive its Codex (#480): only the tab the book holds is the
+  // session's.
+  const entry = readBook(it.home).sessions[it.session];
+  if (entry?.tab !== it.tabId) return { moved: true, why: `the book no longer holds its tab ${it.tabId} for it, but ${entry?.tab ?? 'none'}` };
+  // And, for a caller typing for one conversation, a `/new` in the same tab
+  // gives the session another (#480 review).
+  if (it.conversation !== undefined && entry.session !== it.conversation) {
+    return { moved: true, why: `the book no longer holds the conversation ${it.conversation} for it, but ${entry.session ?? 'none'}` };
+  }
+  const found = tabToTypeInto(it.home, it.tabId, idle ? LOOK_MS : CHAR_LOOK_MS);
   if (found.blocked !== undefined) {
     return {
       why: found.blocked === QUESTION_ON_SCREEN
@@ -274,13 +369,14 @@ function lookAt(it, { idle = true } = {}) {
 
 /**
  * Why the screen does not show `command` typed and ready, or undefined when it
- * does: the input line, the lowest row the harness's pointer starts, reads the
- * pointer and the command and nothing else, and the slash menu's selected row
- * names the command. `menu` is set when the input line was right and the menu
- * was not. Read again for SCREEN_MS while it is not so: a screen
+ * does, as `check` reads it: for a slash command alone, the input line, the
+ * lowest row the harness's pointer starts, reads the pointer and the command
+ * and nothing else, and the slash menu's selected row names the command.
+ * `menu` is set when the input line was right and the menu was not. Read
+ * again for SCREEN_MS while it is not so: a screen
  * takes a moment to draw what was typed.
  */
-async function typedWrong(handle, harness, command, version) {
+async function typedWrong(handle, harness, command, version, check) {
   const until = Date.now() + SCREEN_MS;
   for (;;) {
     const seen = screenRows(handle, READ_MS);
@@ -288,7 +384,7 @@ async function typedWrong(handle, harness, command, version) {
     // a question that shows on it stops it at once (review of c1e5ba4).
     const signal = seen.rows === undefined ? undefined : signalIn(seen.rows);
     if (signal !== undefined) return { why: signal, rows: seen.rows };
-    const wrong = seen.rows === undefined ? { why: `its screen could not be read (${seen.unreadable})` } : menuWrong(seen.rows, harness, command, version);
+    const wrong = seen.rows === undefined ? { why: `its screen could not be read (${seen.unreadable})` } : check(seen.rows, harness, command, version);
     if (wrong === undefined || Date.now() >= until) return wrong && { ...wrong, rows: seen.rows };
     await pause(ASK_MS);
   }
@@ -449,7 +545,10 @@ function shownEnd(rows) {
 /** How many rows of the screen a refusal shows. */
 const SHOWN_ROWS = 12;
 
+/** How long Orca is given to take one send: a send it never answers must not hold the caller (#480 review). */
+const SEND_MS = 5000;
+
 /** Type `keys` into the tab as they are, with no return of Orca's. */
-const send = (handle, keys) => orca(['terminal', 'send', '--terminal', handle, '--text', keys]);
+const send = (handle, keys) => orca(['terminal', 'send', '--terminal', handle, '--text', keys], { timeoutMs: SEND_MS });
 
 const harnessName = (harness) => (harness === 'claude' ? 'Claude Code' : 'Codex');

package/src/cli.js

@@ -16,6 +16,7 @@ import { addSession, allowedNow, allowRules, botDir, changeBot, changeSession, c
 import { addCommand, groomCommand, grooming, upCommand } from './groom.js';
 import { checkHealth, orcaSettingFindings } from './health.js';
 import { initBots } from './init.js';
+import { nameSession } from './name.js';
 import { APPROVALS, HARNESSES, ownCli, shellWord, workDirOf } from './launch.js';
 import { checkMail, decideLeftNudges, lookUp, noMailboxYet, sendMessage, sessionInTab } from './message.js';
 import { orcaCli, orcaTrouble, RELOAD_LINE, TERMINAL_ENV } from './orca.js';
@@ -30,7 +31,7 @@ import { readRoster } from './roster.js';
 import { buildAgents, buildRules, CODEX_CAP } from './rules.js';
 import { addSkill, buildSkills, linkSkills, removeSkill } from './skills.js';
 import { addSource, fetchSources } from './sources.js';
-import { listRoles, makeTemp, optionsLine, retireTemp, trustHooks } from './temp.js';
+import { answerTemp, listRoles, makeTemp, optionsLine, retireTemp, trustHooks } from './temp.js';
 import { readUsage } from './usage.js';
 import { BOT_FATHER, bringUp, ownMailbox } from './up.js';
 
@@ -139,6 +140,12 @@ Usage:
                             all and continue", and check the review went. It
                             refuses anything else on that screen, and types
                             nothing then.
+  obk temp answer --bots <path> --name <session>
+                            Run in the maker's own tab: answer Claude Code's
+                            "Teach auto mode" screen on a temporary session it
+                            made with Not now, in a shape the kit knows, and
+                            check the screen went. It refuses any other
+                            screen, and types nothing then.
   obk rules build --bots <path> [--bot <bot>]
                             Build every bot's AGENTS.md from its charter and
                             the rule units it carries, or just the one you
@@ -274,6 +281,11 @@ Usage:
                             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 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
+                            <bot>.<session> with Codex's /rename, once the
+                            session is idle, so its tab says which it is.
   obk session mailbox --bots <path> --bot <bot> --session <name>
                             For the kit's own launch line, not for typing: run
                             in the session's own tab, it gives the session its
@@ -317,11 +329,13 @@ const COMMANDS = {
   'session record': ['bots', 'bot'],
   'session sent': ['bots', 'bot'],
   'session nudge': ['bots', 'bot'],
+  'session name': ['bots', 'bot'],
   'session mailbox': ['bots', 'bot', 'session'],
   'temp make': ['bots', 'name'],
   'temp roles': ['bots'],
   'temp retire': ['bots', 'name'],
   'temp trust-hooks': ['bots', 'name'],
+  'temp answer': ['bots', 'name'],
 };
 
 /** What each flag is for, in the sentence a caller reads when it is missing. */
@@ -449,6 +463,7 @@ async function run(argv) {
   // 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 === NAME) return nameThread(path.resolve(values.bots), values.bot);
 
   // One fleet, one identity, whatever spelling of its path was given (#164).
   const bots = command === 'init' ? path.resolve(values.bots) : sameFleet(path.resolve(values.bots));
@@ -517,6 +532,7 @@ const ANSWER_IT = [
 const RECORD = 'session record';
 const SENT = 'session sent';
 const NUDGE = 'session nudge';
+const NAME = 'session name';
 
 /**
  * What the kit's send hook says after a native message: a warning the session
@@ -556,6 +572,21 @@ function nudgeLeft() {
   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,
+ * and never anything but exit 0: what it could not type now waits for the next
+ * turn end.
+ */
+async function nameThread(bots, bot) {
+  try {
+    await nameSession(bots, bot, JSON.parse(readFileSync(0, 'utf8')), process.env[TAB_ENV]);
+  } catch {
+    // Nothing: a hook does not disturb the session it runs in.
+  }
+  return 0;
+}
+
 /**
  * What the kit's hook does with what the harness told it, and what it answers.
  *
@@ -768,6 +799,19 @@ const commands = {
     };
   },
 
+  async 'temp answer'(bots, values) {
+    const tab = callerTab(bots, true);
+    refuseWhenOrcaIsDown();
+    const answered = await answerTemp(bots, { tab, name: values.name });
+    return {
+      answer: { bots, ...answered },
+      lines: [
+        `answered   ${answered.bot} ${answered.session}, a temporary session of ${answered.maker}'s: sent ${answered.sent} to its "Teach auto mode about your environment?" screen, and the screen has gone`,
+        `rule       a maker's bot runs this under one permission rule, which the user approves:  Bash(${shellWord(ownCli())} temp answer:*)`,
+      ],
+    };
+  },
+
   'bot create'(bots, values) {
     const made = createBot(bots, { name: values.name, harness: values.harness, charter: values.charter });
     // The bot's AGENTS.md is the rules build's, here as everywhere else, so

package/src/groom.js

@@ -42,7 +42,7 @@ import { existsSync, mkdirSync, realpathSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
 import { botDir, readBot, requireBotsFolder } from './bot.js';
-import { readBook } from './book.js';
+import { readBook, takeLineTurn, TYPING_HELD, TYPING_WAIT_MS } from './book.js';
 import { claudeTranscript } from './conversations.js';
 import { harnessOf, ownCli, shellWord } from './launch.js';
 import { tabs, tabToTypeInto, typeIntoTab } from './orca.js';
@@ -189,21 +189,28 @@ function refuseRun(run, ask) {
 /**
  * Type `line` into the grooming tab, through the kit's one gate for typing into
  * a running session: nothing goes into a tab with something on screen waiting
- * for an answer, or with anything but Claude Code in front of it.
+ * for an answer, or with anything but Claude Code in front of it. In the
+ * session's turn for a line, so it never lands in what the kit is typing (#482).
  */
 function typeInto(bots, home, session, tab, line) {
   if (!session.up) {
     throw new Error(`${BOT_FATHER}'s ${GROOMING} session is not up, so nothing was typed. Bring it up with ${upCommand(bots)}, then run this again.`);
   }
-  const found = tabToTypeInto(home, tab, LOOK_MS);
-  if (found.blocked !== undefined) {
-    throw new Error(`the ${GROOMING} tab is waiting for an answer (${found.blocked}), so nothing was typed. Answer it in the tab, then run this again.`);
-  }
-  if (found.unsure !== undefined) throw new Error(`the ${GROOMING} tab: ${found.unsure}.`);
-  if (found.handle === undefined || found.agent !== 'claude') {
-    throw new Error(`the ${GROOMING} tab has no Claude Code in front of it, so nothing was typed. Bring it back with ${restartCommand(bots)}, then run this again.`);
+  const turn = takeLineTurn(home, GROOMING, TYPING_WAIT_MS);
+  if (turn === undefined) throw new Error(`the ${GROOMING} tab: ${TYPING_HELD}. Run this again in a moment.`);
+  try {
+    const found = tabToTypeInto(home, tab, LOOK_MS);
+    if (found.blocked !== undefined) {
+      throw new Error(`the ${GROOMING} tab is waiting for an answer (${found.blocked}), so nothing was typed. Answer it in the tab, then run this again.`);
+    }
+    if (found.unsure !== undefined) throw new Error(`the ${GROOMING} tab: ${found.unsure}.`);
+    if (found.handle === undefined || found.agent !== 'claude') {
+      throw new Error(`the ${GROOMING} tab has no Claude Code in front of it, so nothing was typed. Bring it back with ${restartCommand(bots)}, then run this again.`);
+    }
+    typeIntoTab(found.handle, line);
+  } finally {
+    turn.release();
   }
-  typeIntoTab(found.handle, line);
 }
 
 /**