@assuredloop/orca-bot-kit 0.24.1 → 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.24.1",
+  "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/cli.js

@@ -31,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';
 
@@ -140,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
@@ -329,6 +335,7 @@ const COMMANDS = {
   '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. */
@@ -792,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/orca.js

@@ -420,8 +420,9 @@ const ON_A_CHOICE = /^( *[›❯] +)\d+\. /;
  * Every one seen is a numbered list of choices with the harness's pointer on
  * one (tech notes, section 1; ADR 0034). The same pointer starts the harness's
  * input line and its echo of the user's past turns, and the input line is the
- * lowest of them whenever it is on screen, so only the lowest pointer row is
- * asked about: a question counts while it stands in the input line's place.
+ * lowest of them whenever it is on screen, so the lowest pointer row is asked
+ * about: a question counts while it stands in the input line's place, or
+ * while it is the last thing drawn right above the input box (#491).
  * Unnumbered lists do not count. Codex puts a status row right under its input
  * line, lined up with it, and by its layout that is one.
  */
@@ -434,6 +435,37 @@ export function questionIn(rows) {
   // there is none: under old words of one in the history, the input line is
   // the lowest pointer, and nothing below it is a foot.
   if (rows.slice(Math.max(at, 0)).some((row) => FORM_FOOT.test(row))) return true;
+  if (pointedChoiceAt(rows, at)) return true;
+  // Claude Code 2.1.289 draws its Teach list above its input box, whose own
+  // `❯` stays the lowest pointer row (#491). A question there is the last
+  // thing drawn above the box's top rule: its foot, or its numbered choices
+  // with the pointer on one, under it a foot that a narrow pane wraps onto
+  // rows of its own. The same words with anything after them are history.
+  if (at < 1 || !RULE_ROW.test(rows[at - 1])) return false;
+  let end = rows.slice(0, at - 1).findLastIndex((row) => row.trim() !== '');
+  if (end < 0) return false;
+  if (FORM_FOOT.test(rows[end])) return true;
+  while (end > 0 && FOOT_PART.test(rows[end])) end -= 1;
+  if (!NUMBERED.test(rows[end])) return false;
+  let first = end;
+  while (first > 0 && NUMBERED.test(rows[first - 1])) first -= 1;
+  for (let row = first; row <= end; row += 1) {
+    if (pointedChoiceAt(rows, row)) return true;
+  }
+  return false;
+}
+
+/** A rule Claude Code draws right across, as the top of its input box: `─` or `▔`. */
+const RULE_ROW = /^ *[─▔]{8,}/;
+
+/** A numbered choice, with the pointer on it or not. */
+const NUMBERED = /^ *(?:[›❯] +)?\d+\. /;
+
+/** A part of a foot, as a narrow pane wraps it: `Enter to confirm ·`, `Esc to cancel`. */
+const FOOT_PART = /\b(?:Enter to (?:continue|confirm|select)|Esc to cancel)\b/i;
+
+/** Whether `rows[at]` has the pointer on a numbered choice, with another lined up right above or below it. */
+function pointedChoiceAt(rows, at) {
   const pointer = at < 0 ? null : ON_A_CHOICE.exec(rows[at]);
   if (pointer === null) return false;
   const column = pointer[1].length;

package/src/temp.js

@@ -1,6 +1,7 @@
 // `obk temp make` and `obk temp retire`: a session's own temporary sessions
-// (PRD 6.4, #227). And `obk temp trust-hooks`, the one answer a maker gives its
-// Codex run's hooks review (#238).
+// (PRD 6.4, #227). And `obk temp trust-hooks` and `obk temp answer`, the
+// answers a maker gives its Codex run's hooks review (#238) and its Claude
+// session's Teach auto mode form (#489).
 //
 // Any long-lived session can make a temporary session of its own bot for a
 // piece of work, and retire it when the work is done, without Bot Father, who
@@ -348,59 +349,232 @@ export async function trustHooks(bots, { tab, name }) {
   if (harness !== 'codex') {
     throw new Error(`${run} runs on ${harness}, and temp trust-hooks answers a Codex run's "${HOOKS_REVIEW}" alone. ${nothing}`);
   }
+  await answerScreen(caller, name, {
+    what: 'hooks review',
+    mark: HOOKS_REVIEW,
+    done: `"${TRUST_ALL}" was chosen on its hooks review`,
+    answer(rows, { send }) {
+      const keys = keysToTrustAll(rows);
+      if (keys === undefined) {
+        throw new Error(`${run}'s screen shows no "${HOOKS_REVIEW}" with its choices, so there is nothing for this to answer. It shows: ${shown(rows)}. ${nothing}`);
+      }
+      send(keys);
+    },
+  });
+  return { bot: caller.bot, session: name, maker: caller.session };
+}
+
+/**
+ * The keys that take Codex's hooks review to "2. Trust all and continue" and
+ * answer it, from wherever its pointer is: arrows, then return, never a digit
+ * (a digit and return once took whatever was highlighted). Undefined when the
+ * rows show no such review with the pointer on one of its choices.
+ */
+function keysToTrustAll(rows) {
+  if (!rows.some((row) => row.includes(HOOKS_REVIEW))) return undefined;
+  if (!rows.some((row) => new RegExp(`^ *(?:› +)?2\\. ${TRUST_ALL}`).test(row))) return undefined;
+  const pointer = rows.map((row) => /^ *› +(\d+)\. /.exec(row)).findLast((found) => found !== null);
+  if (pointer === undefined) return undefined;
+  const moves = 2 - Number(pointer[1]);
+  return (moves > 0 ? '\x1b[B'.repeat(moves) : '\x1b[A'.repeat(-moves)) + '\r';
+}
+
+/** What a screen shows, on one line: its rows with words in them, cut short. */
+function shown(rows) {
+  const text = rows.map((row) => row.trim()).filter((row) => row !== '').join(' ⏎ ');
+  return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+}
+
+/**
+ * Answer a screen of `name`, a temporary session the caller made: under the
+ * session's turn for a line (#482), read its screen and hand it to
+ * `answer(rows, { send, look })`, which sends keys with `send`, may read the
+ * screen again with `look`, and throws when the screen is not its to answer.
+ * Then wait for `mark` to leave the screen. `what` names the screen and `done`
+ * says what was sent, for the sentences that refuse or fail; `done` may be a
+ * function of what `answer` returned.
+ */
+async function answerScreen(caller, name, { what, mark, done, answer }) {
+  const run = `${caller.bot}/${name}`;
+  const nothing = 'Nothing was typed.';
   const tabId = readBook(caller.home).sessions[name]?.tab;
   const handle = tabId === undefined ? undefined : tabs(caller.home).find((one) => one.tabId === tabId)?.handle;
   if (handle === undefined) {
-    throw new Error(`${run} has no tab open in Orca, so there is no review of its to answer. ${nothing}`);
+    throw new Error(`${run} has no tab open in Orca, so there is no ${what} of its to answer. ${nothing}`);
   }
-  // The session's turn for a line (#482), for the look and the keys.
   const turn = takeLineTurn(caller.home, name, TYPING_WAIT_MS);
   if (turn === undefined) throw new Error(`${run}: ${TYPING_HELD}.`);
+  let answered;
   try {
     const seen = screenRows(handle);
     if (seen.rows === undefined) {
-      throw new Error(`${run}'s screen could not be read (${seen.unreadable}), so the kit cannot tell whether its hooks review is there. ${nothing}`);
+      throw new Error(`${run}'s screen could not be read (${seen.unreadable}), so the kit cannot tell whether its ${what} is there. ${nothing}`);
     }
-    const keys = keysToTrustAll(seen.rows);
-    if (keys === undefined) {
-      throw new Error(`${run}'s screen shows no "${HOOKS_REVIEW}" with its choices, so there is nothing for this to answer. It shows: ${shown(seen.rows)}. ${nothing}`);
-    }
-    // The return is inside the text: `--enter` would be a second key.
-    orca(['terminal', 'send', '--terminal', handle, '--text', keys]);
+    answered = answer(seen.rows, {
+      // The return, where there is one, is inside the text: `--enter` would be a second key.
+      send: (keys) => orca(['terminal', 'send', '--terminal', handle, '--text', keys]),
+      look: () => screenRows(handle),
+    });
   } finally {
     turn.release();
   }
   for (let waited = 0; ; waited += 500) {
     const after = screenRows(handle);
-    if (after.rows !== undefined && !after.rows.some((row) => row.includes(HOOKS_REVIEW))) break;
+    if (after.rows !== undefined && !after.rows.some((row) => row.includes(mark))) return answered;
     if (waited >= REVIEW_GONE_MS) {
-      const still = after.rows === undefined ? `its screen could not be read again (${after.unreadable})` : `its screen still shows "${HOOKS_REVIEW}"`;
-      throw new Error(`${run}: "${TRUST_ALL}" was chosen on its hooks review, but ${REVIEW_GONE_MS / 1000} seconds later ${still}. Look at its tab.`);
+      const still = after.rows === undefined ? `its screen could not be read again (${after.unreadable})` : `its screen still shows "${mark}"`;
+      throw new Error(`${run}: ${typeof done === 'function' ? done(answered) : done}, but ${REVIEW_GONE_MS / 1000} seconds later ${still}. Look at its tab.`);
     }
     await pause(500);
   }
-  return { bot: caller.bot, session: name, maker: caller.session };
 }
 
+/** The title of Claude Code's "Teach auto mode" screen, in each known shape. */
+const TEACH_TITLE = 'Teach auto mode about your environment?';
+
+/** The foot that ends a Claude Code form, below which its input box sits. */
+const TEACH_FOOT = /Enter to .*· Esc to cancel/;
+
 /**
- * The keys that take Codex's hooks review to "2. Trust all and continue" and
- * answer it, from wherever its pointer is: arrows, then return, never a digit
- * (a digit and return once took whatever was highlighted). Undefined when the
- * rows show no such review with the pointer on one of its choices.
+ * The known shapes of the Teach screen, from its title to its foot, each as
+ * captured live, with what answers it. Rows are compared trimmed, the pointer
+ * `❯` taken out, so the pointer may sit on any one of them.
+ *
+ * Claude Code 2.1.283's form (#261's live test, #416) is answered with Esc,
+ * which cancels it (Not now), never a return, which is Continue. Claude Code
+ * 2.1.289's numbered list (#489's live run 1) is answered with "2. Not now",
+ * never "1. Yes" or "3. Don't show again" (the architect's ruling on #489).
  */
-function keysToTrustAll(rows) {
-  if (!rows.some((row) => row.includes(HOOKS_REVIEW))) return undefined;
-  if (!rows.some((row) => new RegExp(`^ *(?:› +)?2\\. ${TRUST_ALL}`).test(row))) return undefined;
-  const pointer = rows.map((row) => /^ *› +(\d+)\. /.exec(row)).findLast((found) => found !== null);
-  if (pointer === undefined) return undefined;
-  const moves = 2 - Number(pointer[1]);
-  return (moves > 0 ? '\x1b[B'.repeat(moves) : '\x1b[A'.repeat(-moves)) + '\r';
+const TEACH_SHAPES = [
+  {
+    name: 'the 2.1.283 form',
+    rows: [
+      TEACH_TITLE,
+      'Claude Code reads this project, your recent Claude sessions, and optionally your shell history and other',
+      'repositories. Claude analyzes this data and customizes auto mode to make better decisions.',
+      'How you use Claude here     Mixed',
+      'Also scan shell history     true',
+      'Also scan your other repos  false',
+      'Continue',
+      '←/→ to change usage · Enter to continue · Esc to cancel',
+    ],
+  },
+  {
+    name: 'the 2.1.289 list',
+    rows: [
+      TEACH_TITLE,
+      'Auto mode works better when it knows your environment. Takes about a minute.',
+      '1. Yes',
+      '2. Not now',
+      "3. Don't show again",
+      'Enter to confirm · Esc to cancel',
+    ],
+  },
+];
+
+/** The 2.1.289 list's choice this kit takes, and the row it is on. */
+const NOT_NOW_CHOICE = '2. Not now';
+
+/** A row as a shape is compared: trimmed, with its pointer, wherever it sits, taken out. */
+const unpointed = (row) => row.replace('❯', ' ').trim();
+
+/** The full-width rule Claude Code draws right above the screen's title: `─` in 2.1.289, `▔` in 2.1.283. */
+const ABOVE_TITLE = /^(?:─+|▔+)$/;
+
+/**
+ * The Teach screen on `rows`, from its title to its foot, the rows below the
+ * foot (the input box) left out: `{ shape, block }` when its non-blank rows
+ * are one known shape's, in its order and nothing else, with the pointer on
+ * exactly one; otherwise `{ misfit }`, why not.
+ *
+ * It counts only in the frame Claude Code drew it in, in both live captures:
+ * a full-width rule as the non-blank row right above the title, and, right
+ * below the foot, nothing or the input box's top rule. A quote of the screen
+ * in a turn, with the turn's own rows around it, is refused (the review of
+ * #490). A quote of the frame as well would still look the same: the frame
+ * narrows what passes, and is no proof that the screen is live.
+ */
+function teachScreen(rows) {
+  const from = rows.findIndex((row) => row.trim() === TEACH_TITLE);
+  if (from < 0) return { misfit: `it shows no "${TEACH_TITLE}"` };
+  const foot = rows.findIndex((row, at) => at > from && TEACH_FOOT.test(row));
+  if (foot < 0) return { misfit: `it shows "${TEACH_TITLE}" with no foot row ending "Esc to cancel" under it` };
+  const above = rows.slice(0, from).findLast((row) => row.trim() !== '');
+  if (above === undefined || !ABOVE_TITLE.test(above.trim())) {
+    return { misfit: `the row right above its title is ${above === undefined ? 'nothing' : `"${above.trim()}"`}, not the full-width rule Claude Code draws there` };
+  }
+  const below = rows.slice(foot + 1).find((row) => row.trim() !== '');
+  if (below !== undefined && !below.trimStart().startsWith('─')) {
+    return { misfit: `the row right below its foot is "${below.trim()}", not the top rule of the input box` };
+  }
+  const block = rows.slice(from, foot + 1).filter((row) => row.trim() !== '');
+  const misfits = TEACH_SHAPES.map((shape) => {
+    const pointers = block.filter((row) => row.includes('❯')).length;
+    if (pointers !== 1) return `${pointers} rows with the pointer ❯, where ${shape.name} has one`;
+    const odd = block.find((row) => !shape.rows.includes(unpointed(row)));
+    if (odd !== undefined) return `a row ${shape.name} does not have: ${odd.trim()}`;
+    const missing = shape.rows.find((row) => !block.map(unpointed).includes(row));
+    if (missing !== undefined) return `no row ${missing}, which ${shape.name} has`;
+    if (block.length !== shape.rows.length) return `${block.length} rows, where ${shape.name} has ${shape.rows.length}`;
+    const moved = block.findIndex((row, at) => unpointed(row) !== shape.rows[at]);
+    if (moved >= 0) return `the row ${block[moved].trim()} where ${shape.name} has ${shape.rows[moved]}`;
+    return undefined;
+  });
+  const fits = misfits.findIndex((misfit) => misfit === undefined);
+  if (fits >= 0) return { shape: TEACH_SHAPES[fits], block };
+  return { misfit: `its Teach screen is no shape the kit knows: it has ${misfits.join('; and it has ')}` };
 }
 
-/** What a screen shows, on one line: its rows with words in them, cut short. */
-function shown(rows) {
-  const text = rows.map((row) => row.trim()).filter((row) => row !== '').join(' ⏎ ');
-  return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+/** The whole screen, a row to a line: what decides is often at its foot. */
+const wholeScreen = (rows) => rows.filter((row) => row.trim() !== '').map((row) => `    ${row}`).join('\n');
+
+/**
+ * Answer the first-run screen of a temporary session the caller made (#489):
+ * Claude Code's Teach auto mode screen, in one of the shapes the kit knows,
+ * matched exactly. The 2.1.283 form gets Esc. The 2.1.289 list gets arrows to
+ * "2. Not now" where needed, a second look that the pointer is there and the
+ * list is otherwise as it was, and only then a return. Anything else is refused with
+ * nothing typed. Like `trustHooks`, it is one command a permission rule of its
+ * own can allow. Returns `{ bot, session, maker, sent }`, `sent` saying what
+ * answered it.
+ */
+export async function answerTemp(bots, { tab, name }) {
+  const caller = callerIn(bots, tab, 'answer', "answer a session's first-run screen");
+  const nothing = 'Nothing was typed.';
+  ownTemp(caller, name, 'answer for', nothing);
+  const run = `${caller.bot}/${name}`;
+  const sent = await answerScreen(caller, name, {
+    what: `"${TEACH_TITLE}"`,
+    mark: TEACH_TITLE,
+    done: (said) => `${said} was sent to its Teach auto mode screen`,
+    answer(rows, { send, look }) {
+      const seen = teachScreen(rows);
+      if (seen.misfit !== undefined) {
+        const hooks = rows.some((row) => row.includes(HOOKS_REVIEW)) ? ` A Codex run's "${HOOKS_REVIEW}" is answered with temp trust-hooks.` : '';
+        throw new Error(`${run}'s screen is not one temp answer answers: ${seen.misfit}.${hooks} ${nothing} It shows:\n${wholeScreen(rows)}`);
+      }
+      if (seen.shape === TEACH_SHAPES[0]) {
+        send('\x1b');
+        return 'Esc (Not now)';
+      }
+      const at = seen.block.findIndex((row) => row.includes('❯'));
+      const moves = seen.block.findIndex((row) => unpointed(row) === NOT_NOW_CHOICE) - at;
+      if (moves !== 0) send(moves > 0 ? '\x1b[B'.repeat(moves) : '\x1b[A'.repeat(-moves));
+      // The guard, before every return, arrows or none: the list again, its
+      // rows in the same order (an exact shape), and the pointer on "2. Not now".
+      const again = look();
+      const now = again.rows === undefined ? { misfit: `it could not be read again (${again.unreadable})` } : teachScreen(again.rows);
+      const on = now.block?.find((row) => row.includes('❯'));
+      if (now.shape !== seen.shape || unpointed(on) !== NOT_NOW_CHOICE) {
+        const why = now.misfit ?? `its pointer is on ${unpointed(on)}, not ${NOT_NOW_CHOICE}`;
+        const sent = moves === 0 ? 'Nothing was typed' : `The arrows to "${NOT_NOW_CHOICE}" went in`;
+        throw new Error(`${run}: ${sent}, but then ${why}, so no return was sent. Look at its tab.${again.rows === undefined ? '' : ` It shows:\n${wholeScreen(again.rows)}`}`);
+      }
+      send('\r');
+      return `"${NOT_NOW_CHOICE}"`;
+    },
+  });
+  return { bot: caller.bot, session: name, maker: caller.session, sent };
 }
 
 /**