@assuredloop/orca-bot-kit 0.31.0 → 0.32.0

package/README.md

@@ -152,14 +152,19 @@ a Codex session
 ([ADR 0045](docs/adr/0045-a-codex-sessions-work-dir-stays-in-its-bot-folder.md)).
 
 A bot or a session can also run on [Pi](https://pi.dev) (`--harness pi`, tested
-with Pi 1.1.0). Pi asks before no tool call, so a Pi session is always
+with Pi 1.3.0). Pi asks before no tool call, so a Pi session is always
 `dangerously-skip`, and the kit refuses `auto` and `ask` for it. Sign in to Pi
 yourself first: `obk up` asks Pi which models it can use, and starts nothing
 when Pi has none, or not the one the session names. The kit gives a Pi session
 its id, so `obk up` resumes it after its tab is closed. Pi has no context
-setting: name a model that carries it. Mail, temporary sessions, skills and
-health for a Pi session come later, and so do `obk init --harness pi` and
-`obk session clear` and `compact` on Pi.
+setting: name a model that carries it. A Pi session reads its bot's
+`AGENTS.md` and loads its bot's skills from `.agents/skills`; when
+`obk skills build` changes them, it types `/reload` into an idle Pi tab. Pi has
+no permission rules and no hooks, so the bot's allow list does not limit a Pi
+session. `obk health` reads a Pi session's model and thinking level from Pi's
+own record, and says when Pi cannot run it. `obk session clear` types Pi's
+`/new` into a Pi tab. `obk session compact` on Pi types nothing, and says so.
+`obk init --harness pi` and `obk session compact` on Pi come later.
 
 Every bot gets the kit's default permission rules, written by the kit with
 nobody asked: its own commands for this bots folder, reading a long message,

package/SETUP.md

@@ -38,7 +38,7 @@ git --version
 /Applications/Orca.app/Contents/Resources/bin/orca status --json
 claude --version                                        # at least one of these
 codex --version                                         # 0.156.1 or newer
-pi --version                                            # 1.1.0, for a bot on Pi
+pi --version                                            # 1.3.0, for a bot on Pi
 ```
 
 The Orca line must come back with `ok: true` and `result.runtime.reachable:

package/package.json

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

package/src/clear.js

@@ -19,12 +19,12 @@ 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 { FEEDBACK_PANEL, feedbackPanelIn, findProject, orca, QUESTION_ON_SCREEN, questionIn, screenRows, tabs, tabToTypeInto, TIMED_OUT } from './orca.js';
+import { FEEDBACK_PANEL, feedbackPanelIn, findProject, orca, piAtWorkIn, piBox, 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). */
+/** The harness's own command for each, as typed into its input line. Codex's and Pi's clear is `/new` (tech notes, sections 3 and 6). */
 const COMMANDS = {
-  clear: { claude: '/clear', codex: '/new' },
+  clear: { claude: '/clear', codex: '/new', pi: '/new' },
   compact: { claude: '/compact', codex: '/compact' },
 };
 
@@ -100,7 +100,13 @@ const CHAR_GAP_MS = 100;
 const AT_WORK = [/esc to interrupt/i, /^\s*\S\s+\S+…\s+\(\d/];
 
 /**
- * Clear the session: `/clear` on Claude Code, `/new` on Codex. Returns
+ * The selected row of Pi 1.3.0's slash menu, which it draws below its input
+ * box (pi-tui's `select-list.js`; read in code, #663).
+ */
+const PI_SELECTED = /^ *→ +/;
+
+/**
+ * Clear the session: `/clear` on Claude Code, `/new` on Codex and Pi. Returns
  * `{ bot, session, harness, was, now }`, the conversation the book held before
  * (or null) and the one it holds now.
  */
@@ -168,7 +174,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 }`.
- * A `verb`, clear or compact, is refused on Pi until a later slice of #547.
+ * A compact is refused on Pi: a later slice of #547 may add it.
  */
 export function sessionToType(bots, bot, session, verb) {
   botsNamed(bots, bot);
@@ -176,7 +182,7 @@ export function sessionToType(bots, bot, session, verb) {
   const known = readBot(home, bot);
   const [settings] = sessionsOf(known, session);
   const name = `${bot} ${session}`;
-  if (verb !== undefined && harnessOf(settings, known.harness) === 'pi') {
+  if (verb === 'compact' && harnessOf(settings, known.harness) === 'pi') {
     throw new Error(`${name} runs on Pi, and obk session ${verb} does not work on a Pi session yet: a later slice of #547 adds it. Nothing was typed.`);
   }
   const unpause = `${shellWord(ownCli())} unpause --bots ${shellWord(bots)} --bot ${bot}`;
@@ -233,9 +239,16 @@ export async function typeCommand(it, command, { before = () => {}, check = menu
   // Nothing may be in the input line before: no draft for the command to join.
   // Orca gives a draft in the line beside the screen, and the screen's line
   // then reads the pointer alone (#510, #516). Where it gives none, Codex's
-  // line on the screen has to be empty.
+  // line on the screen has to be empty, and so do Pi's editor rows.
   const emptyLine = ({ rows, draft }) => {
     if (draft !== undefined) throw new Error(`${it.name}: nothing was typed, because its input line holds a draft: it reads "${draft}".${shownEnd(rows)}`);
+    if (it.harness === 'pi') {
+      const box = piBox(rows);
+      if (box === undefined) throw new Error(`${it.name}: nothing was typed, because its screen shows no input box.${shownEnd(rows)}`);
+      const line = box.editor.map((row) => row.trim()).filter((row) => row !== '').join(' ⏎ ');
+      if (line !== '') throw new Error(`${it.name}: nothing was typed, because its input line is not empty: it reads "${line}".${shownEnd(rows)}`);
+      return;
+    }
     if (it.harness !== 'codex') return;
     const line = rows.findLast((row) => /^ *›/.test(row))?.trim();
     if (!CODEX_EMPTY.includes(line)) {
@@ -295,7 +308,7 @@ export async function typeCommand(it, command, { before = () => {}, check = menu
         // 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;
+        if (error.code === TIMED_OUT && (it.harness === 'codex' || it.harness === 'pi')) typed += 1;
         throw error;
       }
       typed += 1;
@@ -373,7 +386,7 @@ function lookAt(it, { idle = true } = {}) {
   }
   if (found.agent !== it.harness) return { why: `Orca names ${found.agent} in it, and the session runs on ${it.harness}` };
   // The gate has read the screen already: it saw no question on it.
-  const signal = signalIn(found.rows);
+  const signal = signalIn(found.rows, it.harness);
   if (signal !== undefined) return { why: signal };
   if (idle && !found.idle) return { why: 'it is busy with a turn: Orca\'s tui-idle did not answer ok' };
   return { handle: found.handle, rows: found.rows, draft: found.draft };
@@ -394,7 +407,7 @@ async function typedWrong(handle, harness, command, version, check) {
     const seen = screenRows(handle, READ_MS);
     // The screen that lets the return in has to pass the look too: a turn or
     // a question that shows on it stops it at once (review of c1e5ba4).
-    const signal = seen.rows === undefined ? undefined : signalIn(seen.rows);
+    const signal = seen.rows === undefined ? undefined : signalIn(seen.rows, harness);
     if (signal !== undefined) return { why: signal, rows: seen.rows };
     const wrong = seen.rows === undefined ? { why: `its screen could not be read (${seen.unreadable})` } : check(seen.rows, harness, command, version, seen.draft);
     if (wrong === undefined || Date.now() >= until) return wrong && { ...wrong, rows: seen.rows };
@@ -409,9 +422,9 @@ async function typedWrong(handle, harness, command, version, check) {
  */
 const PANEL_WHY = 'its panel of feedback drafts is open above its input box, and the kit does not answer it, since a draft sent from it goes to Anthropic: it clears once the user reviews, sends or dismisses the drafts in that tab';
 
-/** Why `rows` say not to type now, as the look says it, or undefined: a turn at work, or a question. */
-function signalIn(rows) {
-  const working = rows.find((row) => AT_WORK.some((marker) => marker.test(row)));
+/** Why `rows` of `harness` say not to type now, as the look says it, or undefined: a turn at work, or a question. */
+function signalIn(rows, harness) {
+  const working = rows.find((row) => AT_WORK.some((marker) => marker.test(row))) ?? piAtWorkIn(rows, harness);
   if (working !== undefined) return `it is busy with a turn: its screen shows "${working.trim()}"`;
   if (feedbackPanelIn(rows)) return PANEL_WHY;
   if (questionIn(rows)) return 'a question of its harness\'s own is on its screen';
@@ -419,6 +432,7 @@ function signalIn(rows) {
 }
 
 function menuWrong(rows, harness, command, version, draft) {
+  if (harness === 'pi') return piMenuWrong(rows, command, draft);
   const at = rows.findLastIndex((row) => /^ *[›❯]/.test(row));
   if (at < 0) return { why: 'its screen shows no input line' };
   // Claude Code 2.1.288 puts a non-breaking space after its pointer (live run 4).
@@ -478,6 +492,28 @@ function codexMenuWrong(rows, at, line, command, version) {
   return undefined;
 }
 
+/**
+ * With the slash menu open, Return in Pi 1.3.0 runs the selected row's
+ * command (pi-tui's `editor.js`, `tui.select.confirm`; read in code, #663).
+ * So the editor's one row, or Orca's draft where it gives one, reads the
+ * command, and the selected row below the box names it. A menu still drawn
+ * for an earlier part of the command looks the same when its selected row is
+ * the command too: the kit's gap between keys and its reads make that
+ * unlikely, and this cannot tell it apart.
+ */
+function piMenuWrong(rows, command, draft) {
+  const box = piBox(rows);
+  if (box === undefined) return { why: 'its screen shows no input box' };
+  const lines = box.editor.map((row) => row.trim()).filter((row) => row !== '');
+  const line = draft ?? lines.join(' ⏎ ');
+  if (line !== command || (draft === undefined && lines.length !== 1)) return { why: `its input line reads "${line}"` };
+  const selected = box.below.find((row) => PI_SELECTED.test(row));
+  if (selected === undefined) return { why: 'no menu of commands came up below its input box', menu: true };
+  const name = selected.replace(PI_SELECTED, '').trim().split(/\s+/)[0];
+  if (`/${name}` !== command) return { why: `the selected row of its menu is "${selected.trim()}"`, menu: true };
+  return undefined;
+}
+
 /** The Codex version that wrote the rollout of `conversation`, from its session_meta line; undefined when that cannot be read. */
 function codexVersion(conversation) {
   const file = typeof conversation === 'string' ? codexRollout(conversation) : undefined;
@@ -580,4 +616,4 @@ 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], { timeoutMs: SEND_MS });
 
-const harnessName = (harness) => (harness === 'claude' ? 'Claude Code' : 'Codex');
+const harnessName = (harness) => ({ claude: 'Claude Code', codex: 'Codex', pi: 'Pi' })[harness];

package/src/cli.js

@@ -122,7 +122,7 @@ Usage:
                             moves the folder only once Orca no longer lists
                             the project.
   obk temp make --bots <path> --name <session> [--role <role>[:<option>]]
-                (--prompt <text> | --prompt-file <path>) [--harness claude|codex]
+                (--prompt <text> | --prompt-file <path>) [--harness claude|codex|pi]
                 [--model <m>] [--effort <e>] [--context <c>]
                 [--approval ${APPROVALS.join('|')}] [--extra-arg=<arg>]...
                             Run in a session's own tab: make a temporary
@@ -133,7 +133,9 @@ Usage:
                             you say otherwise; on another harness than yours
                             it takes only your approval. --approval is refused
                             wider than yours, unless obk permission approval
-                            --temps allowed it for the bot. It works in
+                            --temps allowed it for the bot. On Pi it runs as
+                            dangerously-skip, Pi's one level, so that holds
+                            there too. It works in
                             work/<session>, and has the task as its start
                             prompt. The book records it as temporary, made by
                             you.
@@ -168,7 +170,8 @@ Usage:
                             "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.
+                            screen, and types nothing then. On a Pi session
+                            it answers nothing, and says what the screen is.
   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
@@ -1840,6 +1843,11 @@ function rulesLines(rules, bots) {
       ...(entry.bytes > CODEX_CAP
         ? [`             it is over the ${CODEX_CAP / 1024} KiB Codex reads, so a Codex session will not see all of it.`]
         : []),
+      // What applies to Pi and what does not, said wherever the rules are
+      // reported, so the reader never takes the allow list for a limit (#659).
+      ...(entry.pi === true
+        ? [`${'pi'.padEnd(9)}  ${entry.bot}  its Pi sessions read AGENTS.md when they start. Pi has no permission rules and no hooks, so the kit writes neither for Pi: a Pi session runs as dangerously-skip, and the bot's allow list does not limit it.`]
+        : []),
     ];
   });
 }
@@ -1853,6 +1861,7 @@ function skillsLines(skills) {
   return skills.flatMap((entry) => [
     entry.bot,
     ...(entry.trouble === undefined ? [] : [`  ${'trouble'.padEnd(9)}  ${entry.trouble}`]),
+    ...(entry.pi === undefined ? [] : [`  ${'pi'.padEnd(9)}  its Pi sessions load the skills in .agents/skills, which the kit names on each Pi launch line; a running Pi session takes a change at /reload`]),
     ...entry.skills.map((skill) => `  ${(skill.managed ? 'linked' : 'yours').padEnd(9)}  ${skill.name.padEnd(24)}  ${skill.from ?? 'no list names it; the kit leaves it alone'}`),
     ...(entry.removed ?? []).map((name) => `  ${'removed'.padEnd(9)}  ${name.padEnd(24)}  no list names it now`),
     ...(entry.sessions ?? []).map((one) => toldLine(entry.bot, one)),
@@ -1862,9 +1871,13 @@ function skillsLines(skills) {
 /** What `skills build` did about one running session of a bot whose skills changed. */
 function toldLine(bot, { session, harness, state, read, blocked, trouble }) {
   const who = `${bot}/${session}`;
-  const after = harness === 'claude' ? 'Once that is settled, type /reload-skills in its tab.' : 'Its next turn takes the change by itself.';
+  const reload = harness === 'pi' ? '/reload' : '/reload-skills';
+  const after = harness === 'codex' ? 'Its next turn takes the change by itself.' : `Once that is settled, type ${reload} in its tab.`;
   const [word, says] = {
-    reloaded: ['reloaded', '/reload-skills was typed into its tab; a busy session runs it when its turn ends'],
+    reloaded: ['reloaded', harness === 'pi'
+      ? '/reload was typed into its tab; Pi takes the change at its next turn'
+      : '/reload-skills was typed into its tab; a busy session runs it when its turn ends'],
+    busy: ['not told', 'it is busy, and Pi refuses /reload while it works, so nothing was typed. Once its turn ends, type /reload in its tab.'],
     'next-turn': ['next turn', `Codex takes the change at the start of its next turn. If a skill is not there then, a restart makes it appear${read?.length > 0 ? `; meanwhile it can read ${read.join(', ')}` : ''}`],
     'not-up': ['not told', 'not up; it reads its skills when it starts'],
     blocked: ['not told', `its tab is waiting for an answer (${blocked}), so nothing was typed. ${after}`],

package/src/health.js

@@ -23,11 +23,12 @@ import path from 'node:path';
 
 import { bookFile, readBook, sessionIdsIn, tabIdsIn } from './book.js';
 import { botDir, botNames, botsDir, readBot, tempRoles, unknownKeys } from './bot.js';
-import { transcriptsIn } from './conversations.js';
+import { hasConversation, transcriptsIn } from './conversations.js';
 import { hookTrouble } from './hooks.js';
 import { APPROVALS, bypassFlags, harnessOf, HARNESSES, isAddressOf, ownCli, promptFile, sessionTrouble, set, SHELL_ENV, shellWord, workDirOf } from './launch.js';
 import { frontOfTab, mailIn, orcaDefaultArgs, projects, runMissing, tabs, tabToTypeInto, wordsOfProcess } from './orca.js';
 import { permissionsTrouble } from './permissions.js';
+import { askPi } from './pi.js';
 import { processesIn } from './processes.js';
 import { TAB_ENV } from './record.js';
 import { agentsTrouble, rulesStamp } from './rules.js';
@@ -51,7 +52,9 @@ export function checkHealth(bots, { bot: onlyBot } = {}) {
 
   const found = [...orcaSettingFindings(), ...leftInOrca(bots, setups), ...leftBeside(bots)];
   const sessions = [];
-  for (const name of names) found.push(...aboutBot(bots, name, setups, sessions));
+  // Pi is asked only when a bot has a Pi session, and each question once (#660).
+  const pi = askPi();
+  for (const name of names) found.push(...aboutBot(bots, name, setups, sessions, pi));
   return { found, sessions };
 }
 
@@ -185,7 +188,7 @@ function leftBeside(bots) {
 }
 
 /** Everything wrong with one bot. Its running sessions are added to `sessions`. */
-function aboutBot(bots, name, setups, sessions) {
+function aboutBot(bots, name, setups, sessions, pi) {
   const home = botDir(bots, name);
 
   let bot;
@@ -206,6 +209,7 @@ function aboutBot(bots, name, setups, sessions) {
     ...agentsTrouble(bots, home, bot).map(said('config')),
     ...hooksOf(bots, home, bot).map(said('config')),
     ...permissionsTrouble(home, bot).map(said('config')),
+    ...piReadiness(home, bot, pi).map(said('config')),
     ...skillsTrouble(bots, home, bot).map(said('skill')),
     ...inOrca(bots, home, bot, setups, sessions),
     ...leftRunning(home, bot),
@@ -261,6 +265,40 @@ function sessionSettings(home, bot) {
   });
 }
 
+/**
+ * Why Pi cannot run this bot's Pi sessions, paused ones too, in the words
+ * `up` would refuse them with (#660): Pi does not run, can use no model, or
+ * cannot use the model a session names. When Pi cannot list its models at
+ * all, that is said instead, and no model is judged. Pi is asked read only,
+ * through the answers `pi` keeps for the whole run, and never about its
+ * credentials.
+ */
+function piReadiness(home, bot, pi) {
+  const onPi = bot.sessions.filter((session) => harnessOf(session, bot.harness) === 'pi');
+  if (onPi.length === 0) return [];
+  const where = path.join(home, 'bot.yaml');
+  const names = onPi.map((session) => session.name).join(', ');
+  const runs = pi.runs();
+  if (runs !== undefined) {
+    return [{ where, says: `Pi does not run here (${runs}), and ${bot.name}'s sessions ${names} run on Pi. obk up will not start them until it does. Install Pi.` }];
+  }
+  const models = pi.models();
+  if (models.failed !== undefined) {
+    return [{ where, says: `Pi could not list its models: pi --list-models failed (${models.failed}), and ${bot.name}'s sessions ${names} run on Pi. The kit cannot say whether Pi can use their models. Run that command yourself to see why.` }];
+  }
+  if (!models.any) {
+    return [{ where, says: `Pi has no model it can use: it is signed in to no provider, and ${bot.name}'s sessions ${names} run on Pi. obk up will not start them until it is. Sign in to Pi yourself (start pi and use /login, or set a provider's API key). The kit never handles Pi's credentials.` }];
+  }
+  return onPi.filter((session) => set(session.model)).flatMap((session) => {
+    const model = String(session.model).trim();
+    const found = pi.model(model);
+    if (found.failed !== undefined) {
+      return [{ where, says: `${bot.name}'s session ${session.name} runs on Pi with the model ${model}, and the kit cannot say whether Pi can use it: pi --list-models ${found.search} failed (${found.failed}). Run that command yourself to see why.` }];
+    }
+    return found.listed ? [] : [{ where, says: `${bot.name}'s session ${session.name} runs on Pi with the model ${model}, and Pi cannot use it: pi --list-models lists none matching it. obk up will not start the session. Sign in to its provider in Pi yourself, or give the session a model Pi lists.` }];
+  });
+}
+
 /** What is wrong with the roles the bot's temporary sessions are made in (#465). */
 function rolesTrouble(home, bot) {
   const where = path.join(home, 'bot.yaml');
@@ -471,7 +509,7 @@ function inOrca(bots, home, bot, setups, sessions) {
     }
   }
 
-  found.push(...offTheBook(real ?? home, bot, book, onRecord));
+  found.push(...offTheBook(bots, real ?? home, bot, book, onRecord));
 
   // A tab outside the book is somebody else's, and in Bot Father's project it
   // is the ops tab: the one tab the kit deliberately keeps no record of, so it
@@ -555,9 +593,11 @@ function unannounced(bots, home, bot, name, entry) {
  * The conversations a harness has on record in this bot's folder that the book
  * does not name anywhere. The hook is how an id reaches the book, and when it
  * fails it fails quietly (ADR 0022), so this is where a stale book shows: the
- * harness's own record set beside it (ADR 0012).
+ * harness's own record set beside it (ADR 0012). Pi has no hook of the kit's,
+ * so for Pi it also names a session whose conversation in the book Pi has no
+ * record of (#660).
  */
-function offTheBook(home, bot, book, onRecord) {
+function offTheBook(bots, home, bot, book, onRecord) {
   // A retired session's conversations are in the book too, under `retired`.
   const named = sessionIdsIn(book);
   for (const entry of Object.values(book.sessions)) {
@@ -566,10 +606,32 @@ function offTheBook(home, bot, book, onRecord) {
 
   // A subagent's conversation is no session's, so the book has no reason to name it.
   const stray = onRecord.filter((one) => !one.subagent && !named.has(one.id));
-  if (stray.length === 0) return [];
+  const listed = (some) => some.map((one) => `${one.id} (begun ${one.at})`).join(', ');
+  const give = `To give one to a session, write it into ${bookFile(home)} under that session as  session: <id>  and run obk up again.`;
+  const found = [];
+
+  const hooked = stray.filter((one) => one.harness !== 'pi');
+  if (hooked.length > 0) {
+    found.push(finding('session', bookFile(home), `The harness has conversations on record in ${bot.name}'s folder that the book does not name: ${listed(hooked)}. The kit's hook may have missed them: a clear it did not record, or a Codex hooks file trusted late. ${give}`, bot.name));
+  }
 
-  const listed = stray.map((one) => `${one.id} (begun ${one.at})`).join(', ');
-  return [finding('session', bookFile(home), `The harness has conversations on record in ${bot.name}'s folder that the book does not name: ${listed}. The kit's hook may have missed them: a clear it did not record, or a Codex hooks file trusted late. To give one to a session, write it into ${bookFile(home)} under that session as  session: <id>  and run obk up again.`, bot.name)];
+  // The kit has no hook in Pi: it names a Pi session's conversation on the
+  // launch line, so one the book does not name was begun inside Pi (#660).
+  const onPi = stray.filter((one) => one.harness === 'pi');
+  if (onPi.length === 0) return found;
+  found.push(finding('session', bookFile(home), `Pi has conversations on record in ${bot.name}'s folder that the book does not name: ${listed(onPi)}. Pi begins one when /new is typed in its tab, and the kit's Pi extension tells the book of it, so these were missed: the tab ran without the extension (a tab Orca brought back by itself, or one the kit started before it had the extension), or the extension's record went wrong. ${give}`, bot.name));
+
+  // A Pi session whose conversation in the book Pi has no record of, while Pi
+  // has one the book does not name: it is in another conversation than the
+  // book holds, and its next start would begin the book's one afresh. A book
+  // id with no record and no such conversation is a session before its first
+  // turn, which Pi has written nothing for yet, and is not said.
+  for (const session of bot.sessions) {
+    const id = book.sessions[session.name]?.session;
+    if (harnessOf(session, bot.harness) !== 'pi' || bot.paused === true || session.paused === true || typeof id !== 'string' || hasConversation('pi', home, id)) continue;
+    found.push(finding('session', bookFile(home), `${bot.name}'s session ${session.name} has the conversation ${id} in the book, and Pi has no record of it in this bot's folder, while Pi has conversations there that the book does not name. So it is likely in one of those, and its next start would begin ${id} afresh rather than go on with it. Write the one it is in into ${bookFile(home)} under ${session.name} as  session: <id>, then ${shellWord(ownCli())} restart --bots ${shellWord(bots)} --bot ${bot.name} --session ${session.name}`, bot.name));
+  }
+  return found;
 }
 
 /** Every conversation on record in the bot's folder, from every harness any of its sessions runs on or a retired one may have, as `obk usage` reads them. */
@@ -580,7 +642,7 @@ function recordIn(home, bot, book) {
   if (Array.isArray(book.retired) && book.retired.length > 0) for (const harness of HARNESSES) harnesses.add(harness);
   return [...harnesses]
     .filter((harness) => HARNESSES.includes(harness))
-    .flatMap((harness) => transcriptsIn(harness, home));
+    .flatMap((harness) => transcriptsIn(harness, home).map((one) => ({ ...one, harness })));
 }
 
 /** What a directory holds, and nothing at all when there is no directory. */

package/src/launch.js

@@ -226,6 +226,19 @@ export const set = (value) => value !== undefined && value !== null && String(va
 /** Which harness a session runs on: its own, or the bot's. */
 export const harnessOf = (session, botHarness) => (set(session.harness) ? session.harness : botHarness);
 
+/** Whether a bot runs on Pi: as its own harness, or in one of its sessions. */
+export const runsOnPi = (bot) => bot.harness === 'pi'
+  || bot.sessions.some((session) => harnessOf(session, bot.harness) === 'pi');
+
+/**
+ * The folder a Pi session loads its bot's skills from: the bot's own
+ * `.agents/skills`, which the kit links every bot's skills into for Codex
+ * (`SKILL_DIRS` in skills.js). `--no-approve` keeps Pi from the folder's own
+ * skills, and a folder named with `--skill` loads whatever the trust (tech
+ * notes, section 6, #659).
+ */
+export const piSkillsDir = (home) => path.join(home, '.agents', 'skills');
+
 /**
  * A session's name on Claude Code, which is also the address another Claude
  * session writes to (ADR 0042). It goes on the launch line as `-n`, and it is
@@ -431,6 +444,13 @@ export function launchCommand(session, { harness, home, workDir, prompt, promptF
     // Pi trusts none of the folder's own files (`.pi/`, `.agents/skills`), so it
     // shows no trust screen and runs nothing the kit has not looked at (#578).
     words.push('--no-approve');
+    // So it is given the bot's skills by name, from the bot folder and nowhere
+    // every Pi session reads (#659).
+    words.push('--skill', piSkillsDir(home));
+    // The kit's own extension, from this kit's own folder: Pi has no hooks, so
+    // this is how the book hears of a `/new` in the tab (#662). Pi loads a file
+    // named here whatever the trust.
+    words.push('--extension', PI_EXTENSION);
     // The id the book holds, resumed or new: Pi opens the conversation with it,
     // and makes it when there is none (tech notes, section 6).
     words.push('--session-id', resume ?? sessionId);
@@ -576,6 +596,9 @@ export const shellWord = quoted;
 export const mailboxStep = (bots, bot, session) =>
   [ownCli(), 'session', 'mailbox', '--bots', bots, '--bot', bot, '--session', session].map(quoted).join(' ');
 
+/** The kit's Pi extension, beside this file (src/pi-record.js). */
+const PI_EXTENSION = fileURLToPath(new URL('./pi-record.js', import.meta.url));
+
 /**
  * The CLI that is running, by the path it was started by: the kit calls itself
  * back with this, never with the bare name `obk`, because the bare name is

package/src/orca.js

@@ -484,7 +484,7 @@ export function harnessInTab(handle, timeoutMs, readMs) {
     blockedReason: answer.result?.wait?.blockedReason,
     agent,
     ...frontOf(handle, shown?.ptyId, readMs),
-    ...screenOf(handle, readMs),
+    ...screenOf(handle, readMs, agent),
   };
 }
 
@@ -502,14 +502,15 @@ export const QUESTION_ON_SCREEN = 'question-on-screen';
 
 /**
  * What the tab `handle` renders: `{ question }`, true when it shows a question
- * of its harness's own, with the `rows` it read, or `{ screenUnreadable: <why> }`. Orca refusing is an
+ * of its harness's own, `agent` the one Orca names there, with the `rows` it
+ * read, or `{ screenUnreadable: <why> }`. Orca refusing is an
  * answer that cannot be read, not an error, and so is anything that is not the
  * rendered screen: accumulated output comes back in fragments (tech notes,
  * section 1).
  */
-function screenOf(handle, readMs) {
+function screenOf(handle, readMs, agent) {
   const read = screenRows(handle, readMs);
-  return read.rows === undefined ? { screenUnreadable: read.unreadable } : { question: questionIn(read.rows), rows: read.rows, draft: read.draft };
+  return read.rows === undefined ? { screenUnreadable: read.unreadable } : { question: questionIn(read.rows, agent), rows: read.rows, draft: read.draft };
 }
 
 /**
@@ -539,6 +540,83 @@ const POINTER_ROW = /^ *[›❯]/;
 /** How a harness's form says it is answered, as Claude Code 2.1.283 draws its foot (#416). */
 const FORM_FOOT = /Enter to (?:continue|confirm|select)\b.*Esc to cancel/i;
 
+/**
+ * How Pi 1.3.0 ends each of its selectors and dialogs: its cancel key, by
+ * default `escape/ctrl+c` (`Escape/Ctrl+C` under /model), then what it does.
+ * Pi points with `→` and has no numbers, so neither rule above sees one, and
+ * Orca calls the tab idle under it (developer-660, live, 2026-10-19; tech
+ * notes, section 6, for the trust screen). Pi draws it from the user's
+ * keybindings, so a rebound cancel key is not seen.
+ */
+const PI_FOOT = /\bescape\/ctrl\+c (?:to )?(?:cancel|close|skip setup)\b/i;
+
+/**
+ * The rules of Pi 1.3.0's input box, each across the whole width: the bottom
+ * one only `─`, or with Pi's ` ↓ <n> more ` (or ` ↑ <n> more `) while a long
+ * draft scrolls; the top one starting `──`, with Pi's status in it while it
+ * works, `── ⠋ Working ───…` (pi-tui `editor.js`, `custom-editor.js`; read in
+ * code, #663). Pi wraps its editor's text a column short of the width, so no
+ * row of a draft is as long as a rule.
+ */
+const PI_SCROLL = / [↑↓] \d+ more /;
+const PI_RULE = new RegExp(`^─+(?:${PI_SCROLL.source}─*)?$`);
+const PI_TOP_RULE = /^──.*─$/;
+
+/** The words in a row of Pi's, once its rule characters and its scroll label are taken out. */
+const piWords = (row) => row.replace(PI_SCROLL, '').replaceAll('─', '').trim();
+
+/**
+ * Pi's two rules on a rendered screen, `{ bottom, top }` or `{ bottom, status
+ * }` as indexes into `rows`, or `{}` with no bottom rule. The bottom rule is
+ * the lowest rule. Then, up from it, only rows with a rule's ends count, and
+ * the first that decides is taken: one as long is the top rule, and rows
+ * above it are the chat (Pi's own dividers among them). One not as long,
+ * with words of more than ASCII in it, is a status: Pi lays out by columns
+ * and the kit counts characters, so a status with wide or combining
+ * characters is not as long. An ASCII status always is, so one not as long
+ * with ASCII words is an editor row, and the walk goes on (reviews of PR
+ * #666).
+ */
+function piRules(rows) {
+  const bottom = rows.findLastIndex((row) => PI_RULE.test(row.trimEnd()));
+  if (bottom < 0) return {};
+  const width = [...rows[bottom].trimEnd()].length;
+  for (let at = bottom - 1; at >= 0; at -= 1) {
+    const row = rows[at].trimEnd();
+    if (!PI_TOP_RULE.test(row)) continue;
+    if ([...row].length === width) return { bottom, top: at };
+    if (/[^\x20-\x7e]/.test(piWords(row))) return { bottom, status: at };
+  }
+  return { bottom };
+}
+
+/**
+ * Pi's input box on a rendered screen, `{ top, editor, below }`: its top rule,
+ * every row between its two rules, and the rows under the bottom one (Pi's
+ * slash menu, then its footer). Undefined when `piRules` finds no top rule.
+ */
+export function piBox(rows) {
+  const { bottom, top } = piRules(rows);
+  if (top === undefined) return undefined;
+  return { top: rows[top], editor: rows.slice(top + 1, bottom), below: rows.slice(bottom + 1) };
+}
+
+/**
+ * The row of a rendered screen that says the harness is at work, as only Pi
+ * draws it, or undefined: its input box's top rule with anything in it but
+ * the rule and the scroll label, or a status `piRules` found instead. Pi's
+ * usual status is a plain `Working`, and an extension can put its own words
+ * there, so no word is looked for; Pi's startup help says `escape to
+ * interrupt` too, and is no turn. `agent` is the harness Orca names in the
+ * tab: the row counts only where it is pi (#663).
+ */
+export function piAtWorkIn(rows, agent) {
+  if (agent !== 'pi') return undefined;
+  const { top, status } = piRules(rows);
+  if (status !== undefined) return rows[status];
+  return top !== undefined && piWords(rows[top]) !== '' ? rows[top] : undefined;
+}
+
 /** That pointer on a numbered choice, and the column its number starts in. */
 const ON_A_CHOICE = /^( *[›❯] +)\d+\. /;
 
@@ -553,8 +631,14 @@ const ON_A_CHOICE = /^( *[›❯] +)\d+\. /;
  * 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.
+ *
+ * `agent` is the harness Orca names in the tab. For Pi, a row anywhere with
+ * Pi's own foot counts too (#659): Pi keeps no closed selector in its chat, so
+ * only text a model printed can put those words higher up, and then nothing is
+ * typed, which is the safe way to be wrong. Other harnesses never see it.
  */
-export function questionIn(rows) {
+export function questionIn(rows, agent) {
+  if (agent === 'pi' && rows.some((row) => PI_FOOT.test(row))) return true;
   if (feedbackPanelIn(rows)) return true;
   const at = rows.findLastIndex((row) => POINTER_ROW.test(row));
   // A form of the harness's own has no numbers but a foot that says how to
@@ -704,7 +788,9 @@ export function tabToTypeInto(home, tabId, timeoutMs) {
   if (seen.question === undefined) {
     return { unsure: `the kit could not tell whether a question is waiting on its screen (${seen.screenUnreadable}), so nothing was typed` };
   }
-  return { handle: live.handle, agent: seen.agent, idle: seen.answered, rows: seen.rows, draft: seen.draft };
+  // Orca's tui-idle does not answer the same each time for a Pi tab (tech
+  // notes, section 6), so Pi's own word that it is at work counts too.
+  return { handle: live.handle, agent: seen.agent, idle: seen.answered && piAtWorkIn(seen.rows, seen.agent) === undefined, rows: seen.rows, draft: seen.draft };
 }
 
 /**

package/src/pi-record.js

@@ -0,0 +1,96 @@
+// The kit's Pi extension: what a Claude Code or Codex session's SessionStart
+// hook does, for a Pi session (#662).
+//
+// Pi has no hooks; it has extensions. Every Pi launch line names this file with
+// `--extension`, and Pi loads it even with `--no-approve`. At each session_start,
+// a `/new` in the tab included, it runs the kit's own `session record`, as the
+// hooks do (src/hooks.js), and hands Pi the start prompt when the kit answers
+// with one. Seen live on Pi 1.3.0 (tech notes, section 6): the extension runs in
+// Pi's own process, so the command it starts is Pi's child, as a hook is the
+// harness's, and it has Pi's environment, the tab's id included.
+//
+// It runs inside the user's session, so it stays out of the way: whatever goes
+// wrong, it goes wrong quietly, and a book left stale is for the health check
+// to find (ADR 0022). It handles no credentials, types into no tab and reaches
+// no network.
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** The CLI beside this file: the kit whose launch line named it (#220). */
+const CLI = fileURLToPath(new URL('./cli.js', import.meta.url));
+
+/** How long the kit is given to answer, as the hooks' TIMEOUT gives a harness. */
+const WAIT_MS = 10_000;
+
+/** What Pi calls the start prompt the kit hands it. */
+const CUSTOM_TYPE = 'obk-start-prompt';
+
+export default function piRecord(pi) {
+  pi.on('session_start', async (event, ctx) => {
+    try {
+      const bot = botAbove(ctx.cwd);
+      if (bot === undefined) return;
+
+      const said = { session_id: ctx.sessionManager.getSessionId(), source: event.reason, hook_event_name: event.type };
+      const duty = (await record(bot, said))?.hookSpecificOutput?.additionalContext;
+      // Into the conversation for its next turn, as Claude Code's
+      // additionalContext is: no turn is started for it.
+      if (typeof duty === 'string' && duty !== '') pi.sendMessage({ customType: CUSTOM_TYPE, content: duty, display: true });
+    } catch {
+      // Nothing: see above.
+    }
+  });
+}
+
+/**
+ * The bot whose home is `cwd` or the nearest folder above it, as
+ * `{ bots, bot }`, or undefined. A bot lives at `<bots>/bots/<bot>` with its
+ * `bot.yaml` (botDir in src/bot.js). A kit tab starts at the bot home; a folder
+ * below it holds too.
+ */
+function botAbove(cwd) {
+  if (typeof cwd !== 'string' || cwd === '') return undefined;
+  for (let dir = path.resolve(cwd); ; dir = path.dirname(dir)) {
+    const parent = path.dirname(dir);
+    if (path.basename(parent) === 'bots' && existsSync(path.join(dir, 'bot.yaml'))) {
+      return { bots: path.dirname(parent), bot: path.basename(dir) };
+    }
+    if (parent === dir) return undefined;
+  }
+}
+
+/** The kit's answer to what Pi said, or undefined when it has none or none could be had. */
+function record({ bots, bot }, said) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(CLI, ['session', 'record', '--bots', bots, '--bot', bot], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        timeout: WAIT_MS,
+        killSignal: 'SIGKILL',
+      });
+    } catch {
+      resolve(undefined);
+      return;
+    }
+    let out = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      out += chunk;
+    });
+    child.on('error', () => resolve(undefined));
+    child.on('close', (code) => {
+      if (code !== 0) return resolve(undefined);
+      try {
+        resolve(JSON.parse(out));
+      } catch {
+        resolve(undefined);
+      }
+    });
+    child.stdin.on('error', () => {});
+    child.stdin.end(JSON.stringify(said));
+  });
+}

package/src/pi.js

@@ -20,36 +20,74 @@ const THINKING = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
  * the models they name; a session that names none takes Pi's own default.
  */
 export function piTrouble(models) {
-  const version = ask(['--version']);
-  if (version.error !== undefined || version.status !== 0) {
-    const why = version.error?.code === 'ENOENT' ? 'there is no pi on PATH' : (version.error?.message ?? ((version.stderr ?? '').trim() || `it exited with ${version.status}`));
-    return `Pi does not run here (${why}), so no Pi session was started. Install Pi, then run this again.`;
-  }
-
-  const any = ask(['--list-models']);
-  if (any.error !== undefined || any.status !== 0 || /^No models available\b/m.test(any.stdout ?? '')) {
+  const pi = askPi();
+  const runs = pi.runs();
+  if (runs !== undefined) return `Pi does not run here (${runs}), so no Pi session was started. Install Pi, then run this again.`;
+  if (pi.models().any !== true) {
     return 'Pi has no model it can use: it is signed in to no provider. Sign in to Pi yourself (start pi and use /login, or set a provider\'s API key), then run this again. The kit never handles Pi\'s credentials.';
   }
-
   for (const model of new Set(models)) {
-    const found = ask(['--list-models', withoutThinking(model)]);
-    if (found.error !== undefined || found.status !== 0) {
-      const why = found.error?.message ?? ((found.stderr ?? '').trim() || `it exited with ${found.status ?? found.signal}`);
-      return `Pi cannot say whether it can use the model ${model}: pi --list-models ${withoutThinking(model)} failed (${why}), so no Pi session was started. Run that command yourself to see why, then run this again.`;
+    const found = pi.model(model);
+    if (found.failed !== undefined) {
+      return `Pi cannot say whether it can use the model ${model}: pi --list-models ${found.search} failed (${found.failed}), so no Pi session was started. Run that command yourself to see why, then run this again.`;
     }
-    // Pi says it has no model at all before it searches, so the answer may be
-    // that one too, when a provider dropped out since the question above.
-    if (/^No models (matching|available)\b/m.test(found.stdout ?? '')) {
+    if (!found.listed) {
       return `Pi cannot use the model ${model}: pi --list-models lists none matching it. Sign in to its provider in Pi yourself, or give the session a model Pi lists.`;
     }
   }
   return undefined;
 }
 
+/**
+ * Pi's answers, each question asked once however often it is asked here: for
+ * a caller that asks about many sessions, as `obk health` does (#660).
+ *
+ * - `runs()`: undefined when `pi --version` answers, or why it does not.
+ * - `models()`: `{ any }`, whether `pi --list-models` lists any model, or
+ *   `{ failed }` with why that question failed.
+ * - `model(m)`: `{ search, listed }`, whether `pi --list-models <search>` lists
+ *   a model matching `m` without its thinking level, or `{ search, failed }`
+ *   with why that question failed.
+ */
+export function askPi() {
+  const asked = new Map();
+  const once = (args) => {
+    const key = args.join('\0');
+    if (!asked.has(key)) asked.set(key, ask(args));
+    return asked.get(key);
+  };
+  return {
+    runs() {
+      const version = once(['--version']);
+      if (version.error === undefined && version.status === 0) return undefined;
+      return version.error?.code === 'ENOENT' ? 'there is no pi on PATH' : (version.error?.message ?? ((version.stderr ?? '').trim() || `it exited with ${version.status}`));
+    },
+    models() {
+      const all = once(['--list-models']);
+      if (failed(all)) return { failed: why(all) };
+      return { any: !/^No models available\b/m.test(all.stdout ?? '') };
+    },
+    model(model) {
+      const search = withoutThinking(model);
+      const found = once(['--list-models', search]);
+      if (failed(found)) return { search, failed: why(found) };
+      // Pi says it has no model at all before it searches, so the answer may be
+      // that one too, when a provider dropped out since the question above.
+      return { search, listed: !/^No models (matching|available)\b/m.test(found.stdout ?? '') };
+    },
+  };
+}
+
 /** The model without a trailing `:<thinking level>`, which `--list-models` does not match. */
-function withoutThinking(model) {
+export function withoutThinking(model) {
   const at = model.lastIndexOf(':');
   return at > 0 && THINKING.includes(model.slice(at + 1)) ? model.slice(0, at) : model;
 }
 
+const failed = (answer) => answer.error !== undefined || answer.status !== 0;
+
+/** Why a question to Pi failed: the error, what Pi printed, or how it ended. */
+const why = (answer) => answer.error?.message
+  ?? ((answer.stderr ?? '').trim() || (answer.signal ? `it was killed by ${answer.signal}` : `it exited with ${answer.status}`));
+
 const ask = (args) => spawnSync('pi', args, { encoding: 'utf8', timeout: ASK_MS });

package/src/rules.js

@@ -22,7 +22,7 @@ import { parse } from 'yaml';
 
 import { botDir, botNames, displayName, readBot, refuseOutside } from './bot.js';
 import { dropRemovedHooks } from './hooks.js';
-import { ownCli, shellWord } from './launch.js';
+import { ownCli, runsOnPi, shellWord } from './launch.js';
 
 /** The kit's own units, inside the installed package. */
 const KIT_RULES = fileURLToPath(new URL('../rules', import.meta.url));
@@ -73,8 +73,16 @@ const checksum = (text) => createHash('sha256').update(text).digest('hex').slice
  * What the bot carries is `failed` — a name that resolves to nothing, a unit
  * that cannot be read — and the user fixes it in a list. The file itself is
  * `conflict`, which only the person who edited it can settle.
+ *
+ * A bot that runs on Pi has `pi: true` too, for the report to say what the
+ * kit does and does not write for Pi (#659).
  */
 export function buildAgents(bots, home, bot) {
+  const built = agentsInto(bots, home, bot);
+  return runsOnPi(bot) ? { ...built, pi: true } : built;
+}
+
+function agentsInto(bots, home, bot) {
   const file = path.join(home, AGENTS);
 
   let built;

package/src/settings.js

@@ -2,7 +2,7 @@
 //
 // A session can run on settings other than the ones bot.yaml asks for: it
 // started before a change, a default of the user's own leaked in, or a flag was
-// dropped. Each harness writes down what it used (tech notes, sections 2 and 3),
+// dropped. Each harness writes down what it used (tech notes, sections 2, 3 and 6),
 // so the two can be put side by side. Read only: these are the harness's files.
 //
 // Four answers, and only one of them is good news. A record that cannot be read,
@@ -10,7 +10,8 @@
 // setting the session never asked for is not a disagreement either, whatever the
 // harness chose: it is `not-asked-for`.
 
-import { DEFAULT_APPROVAL } from './launch.js';
+import { defaultApproval } from './launch.js';
+import { withoutThinking } from './pi.js';
 import { lines } from './usage.js';
 
 export const SETTINGS = ['model', 'effort', 'context', 'approval'];
@@ -22,47 +23,56 @@ export const SETTINGS = ['model', 'effort', 'context', 'approval'];
  * every setting asked for is then unknown.
  */
 export function settingsInUse(harness, session, file, since) {
-  const used = file === undefined ? {} : (harness === 'claude' ? fromClaude : fromCodex)(sinceStart(lines(file), since));
-  return Object.fromEntries(SETTINGS.map((name) => [name, judged(harness, name, asked(session, name), used[name])]));
+  const entries = file === undefined ? [] : lines(file);
+  const start = startOf(entries, since);
+  // Pi's reader also looks before the start, for the selection a reply follows.
+  const used = harness === 'pi' ? fromPi(entries, start)
+    : (harness === 'claude' ? fromClaude : fromCodex)(start === -1 ? [] : entries.slice(start));
+  return Object.fromEntries(SETTINGS.map((name) => [name, judged(harness, name, asked(harness, session, name), used[name])]));
 }
 
 /**
- * What the record says since the kit last started the session. A start resumes
- * the conversation it had, so the file still holds what the process before it
- * wrote, and that says what that process ran with, not this one. Everything
+ * Where the record since the kit last started the session begins, or -1. A
+ * start resumes the conversation it had, so the file still holds what the
+ * process before it wrote, and that says what that process ran with, not this
+ * one. Everything
  * from the first line written at or after the start counts, a line with no time
  * of its own included. With no start to go by, no line can be shown to be this
  * process's, so none counts.
  */
-function sinceStart(entries, since) {
+function startOf(entries, since) {
   const from = Date.parse(since ?? '');
-  if (Number.isNaN(from)) return [];
-  const first = entries.findIndex((entry) => Date.parse(entry.timestamp ?? '') >= from);
-  return first === -1 ? [] : entries.slice(first);
+  if (Number.isNaN(from)) return -1;
+  return entries.findIndex((entry) => Date.parse(entry.timestamp ?? '') >= from);
 }
 
 /** What the session asks for, as bot.yaml has it, or undefined when it asks for nothing. */
-function asked(session, name) {
+function asked(harness, session, name) {
   const value = session[name];
   const set = value !== undefined && value !== null && String(value).trim() !== '';
   // The kit puts an approval level on every launch line, so a session always
-  // asks for one: the default, when it names none (ADR 0015).
-  if (name === 'approval') return set ? String(value).trim() : DEFAULT_APPROVAL;
+  // asks for one: its harness's default, when it names none (ADR 0015). Pi
+  // has one level (#547).
+  if (name === 'approval') return set ? String(value).trim() : defaultApproval(harness);
   return set ? String(value).trim() : undefined;
 }
 
 function judged(harness, name, configured, observed) {
-  const shown = observed === undefined ? {} : { observed: said(name, observed) };
+  // A Pi reply can leave two values open (see fromPi): its own, which shows,
+  // and the selection before it. Agreeing with one of the two is not a match.
+  const choices = observed?.choices ?? [observed];
+  const shown = choices[0] === undefined ? {} : { observed: said(name, choices[0]) };
   if (configured === undefined) return { state: 'not-asked-for', ...shown };
-  const verdict = same(harness, name, configured, observed);
-  if (verdict === undefined) return { state: 'unknown', configured, ...shown };
-  return { state: verdict ? 'match' : 'mismatch', configured, ...shown };
+  const verdicts = choices.map((choice) => same(harness, name, configured, choice));
+  if (verdicts.every((verdict) => verdict === false)) return { state: 'mismatch', configured, ...shown };
+  if (verdicts.length === 1 && verdicts[0] === true) return { state: 'match', configured, ...shown };
+  return { state: 'unknown', configured, ...shown };
 }
 
 /** Whether the record says what was asked for; undefined when it cannot say. */
 function same(harness, name, configured, observed) {
   if (observed === undefined) return undefined;
-  if (name === 'model') return sameModel(configured, observed);
+  if (name === 'model') return harness === 'pi' ? samePiModel(configured, observed) : sameModel(configured, observed);
   // Codex reports the window it was given at 95%, rounded down (tech notes,
   // section 3): 200000 comes back as 190000.
   if (name === 'context') return Number(observed) === Math.floor(Number(configured) * 0.95);
@@ -82,6 +92,27 @@ function sameModel(configured, observed) {
   return model.includes('-') ? observed === model : observed.split('-').includes(model);
 }
 
+/**
+ * A Pi model as bot.yaml names it, `openai/gpt-6-luna` or `gpt-6-luna`, maybe
+ * with a trailing `:<thinking level>`, against the `<provider>/<model>` Pi
+ * wrote down: it matches either whole, in any case, as Pi does. Pi also takes
+ * a pattern that is part of a model's id, and which model it then chose
+ * depends on what else it lists, so such a pattern cannot be judged (Pi 1.3.0,
+ * resolveModelReference). Pi matches a display name too, which the record
+ * does not hold: such a pattern shows as a mismatch.
+ */
+function samePiModel(configured, observed) {
+  const model = withoutThinking(configured).toLowerCase();
+  const ran = observed.toLowerCase();
+  const provider = ran.slice(0, ran.indexOf('/'));
+  const id = ran.slice(ran.indexOf('/') + 1);
+  if (model === ran || model === id) return true;
+  // A provider before a slash is only a hint: the whole pattern may be part of an id.
+  const slash = model.indexOf('/');
+  const part = id.includes(model) || (slash !== -1 && model.slice(0, slash) === provider && id.includes(model.slice(slash + 1)));
+  return part ? undefined : false;
+}
+
 /** The permission mode Claude Code records for each level (tech notes, section 2). */
 const CLAUDE_MODES = { auto: 'auto', ask: 'default', 'dangerously-skip': 'bypassPermissions' };
 
@@ -134,6 +165,65 @@ function fromClaude(entries) {
   return used;
 }
 
+/** The api of a virtual model's catalog entry (Pi 1.3.0, virtual-models.js). */
+const PI_VIRTUAL = 'pi-virtual';
+
+/**
+ * What a Pi record says it runs with, from `start` on: the model, as
+ * `<provider>/<model>`, and the thinking level (tech notes, section 6). Pi
+ * writes nothing about approval.
+ *
+ * The latest line that names one decides. A `model_change` or
+ * `thinking_level_change` line decides alone. A reply names the model that
+ * answered, and the level it was asked at. On a resume with `--model` or
+ * `--thinking`, Pi writes no change line, so a change before a reply may be
+ * stale; but a change to a virtual model, such as `router/auto`, stays the
+ * selection while the router is registered, and its replies name the model
+ * it routed to (Pi 1.3.0, getBranchSelection, docs/virtual-models.md). The
+ * record cannot show what is registered now. So the reply stands when the
+ * change names the same model, or a model a reply shows is physical, and
+ * otherwise the two are left open. A router may change the level as well, so
+ * a reply's level stands alone only on a physical model. A reply a router
+ * could not route names the virtual model, and is passed over, as Pi does.
+ */
+function fromPi(entries, start) {
+  const named = (provider, model) => (typeof provider === 'string' && typeof model === 'string' ? `${provider}/${model}` : undefined);
+  const text = (value) => (typeof value === 'string' ? value : undefined);
+  const assistant = (entry) => (entry.type === 'message' && entry.message?.role === 'assistant' ? entry.message : undefined);
+  const reply = (entry) => (assistant(entry)?.api === PI_VIRTUAL ? undefined : assistant(entry));
+  const modelOf = (entry) => (entry.type === 'model_change' ? named(entry.provider, entry.modelId) : named(reply(entry)?.provider, reply(entry)?.model));
+  const levelOf = (entry) => text(entry.type === 'thinking_level_change' ? entry.thinkingLevel : reply(entry)?.thinkingLevel);
+  const changeBefore = (type, read, at) => {
+    for (let before = at - 1; before >= 0; before -= 1) if (entries[before].type === type) return read(entries[before]);
+    return undefined;
+  };
+  const physical = (model) => entries.some((entry) => entry.type !== 'model_change' && modelOf(entry) === model);
+  const latest = (read) => {
+    if (start === -1) return -1;
+    for (let at = entries.length - 1; at >= start; at -= 1) if (read(entries[at]) !== undefined) return at;
+    return -1;
+  };
+  /** The model the line at `at` says, and whether it is a physical one that a reply's level is sure of. */
+  const modelAt = (at) => {
+    const own = modelOf(entries[at]);
+    if (entries[at].type === 'model_change') return { model: own, sure: false };
+    const earlier = changeBefore('model_change', modelOf, at);
+    if (own === undefined) return { sure: false };
+    // The reply itself shows its own model is physical, so a change to that model is settled too.
+    if (earlier === undefined || physical(earlier)) return { model: own, sure: true };
+    return { model: { choices: [own, earlier] }, sure: false };
+  };
+
+  const model = latest(modelOf);
+  const level = latest(levelOf);
+  const own = level === -1 ? undefined : levelOf(entries[level]);
+  const earlier = level === -1 || entries[level].type === 'thinking_level_change' ? undefined : changeBefore('thinking_level_change', levelOf, level);
+  return {
+    model: model === -1 ? undefined : modelAt(model).model,
+    effort: earlier === undefined || earlier === own || modelAt(level).sure ? own : { choices: [own, earlier] },
+  };
+}
+
 /** What a Codex rollout says it runs with: its latest turn, and its latest count. */
 function fromCodex(entries) {
   const used = {};

package/src/skills.js

@@ -8,7 +8,9 @@
 // away reaches it without a restart. Claude Code takes it through its own
 // `/reload-skills`, which `obk skills build` types into the session's tab.
 // Codex has no such command and takes it at the start of its next turn (tech
-// notes, sections 2 and 3). Outwards: the kit takes away only the links it put
+// notes, sections 2 and 3). Pi loads the Codex directory, which its launch
+// line names, and takes a change at its own `/reload`, typed only while it is
+// idle (section 6, #659). Outwards: the kit takes away only the links it put
 // there, and never the skill one was pointing at.
 //
 // An entry names one of four shelves: the kit's own (`kit:<name>`), an online
@@ -25,7 +27,7 @@ import { parse, parseDocument, stringify } from 'yaml';
 
 import { bookFile, readBook, takeLineTurn, TYPING_HELD, TYPING_WAIT_MS } from './book.js';
 import { botDir, botNames, changesExactly, leadsOutside, readBot, refuseOutside, withBotTurn, writeWhole, YAML_OUT } from './bot.js';
-import { harnessOf, ownCli, shellWord } from './launch.js';
+import { harnessOf, ownCli, piSkillsDir, runsOnPi, shellWord } from './launch.js';
 import { orcaTrouble, tabToTypeInto, typeIntoTab } from './orca.js';
 import { listIn } from './rules.js';
 import { cloneDir, isCloned, leavesClone, readSources, skillsIn, wrongClone } from './sources.js';
@@ -142,12 +144,18 @@ export function removeSkill(bots, bot, ref) {
 /**
  * Give one bot the skills its lists name. Returns what there is to report:
  * `{ bot, skills, linked, removed }` for a bot whose links are in place, and
- * `{ bot, skills, trouble }` for one whose list the kit could not follow.
+ * `{ bot, skills, trouble }` for one whose list the kit could not follow. A bot
+ * that runs on Pi has `pi` too: the directory its Pi sessions load (#659).
  *
  * A list with one entry the kit cannot follow links nothing at all: half a
  * bot's skills is not a bot anybody asked for, and the user fixes one line.
  */
 export function linkSkills(bots, home, bot) {
+  const entry = linkInto(bots, home, bot);
+  return runsOnPi(bot) ? { ...entry, pi: piSkillsDir(home) } : entry;
+}
+
+function linkInto(bots, home, bot) {
   const record = readRecord(home);
   const held = new Map();
 
@@ -440,7 +448,7 @@ const LOOK_MS = 2000;
  * harness's own means (PRD 6.5: changes reach running sessions without a
  * restart, and the sessions a change affects are told). Returns one entry per
  * session, in the bot's order: `{ session, harness, state }`, where the state
- * is `reloaded`, `next-turn` (with `read`), `not-up`, `blocked` (with
+ * is `reloaded`, `next-turn` (with `read`), `busy`, `not-up`, `blocked` (with
  * `blocked`) or `unknown` (with `trouble`).
  *
  * Claude Code gets `/reload-skills` typed into its tab, through the same gate
@@ -449,7 +457,11 @@ const LOOK_MS = 2000;
  * command and takes the change at the start of its next turn by itself, so
  * nothing is typed, and the caller is given the SKILL.md of each skill linked
  * in, for the session to read if the skill has not appeared (tech notes,
- * sections 2 and 3). Nothing is ever restarted.
+ * sections 2 and 3). Pi gets its own `/reload` through the same gate, and only
+ * while it is idle: a busy Pi refuses the command and keeps nothing for later,
+ * so a busy one is `busy`, and one with a draft in its input line is typed
+ * nothing either, since the command would join the draft (section 6, #659).
+ * Nothing is ever restarted.
  */
 function tellSessions(home, bot, linked) {
   let book;
@@ -478,9 +490,6 @@ function tellSessions(home, bot, linked) {
     const told = { session: session.name, harness };
     const tab = typeof book[session.name]?.tab === 'string' ? book[session.name].tab : undefined;
     if (tab === undefined) return { ...told, state: 'not-up' };
-    // Skills reach a Pi session in a later slice (#547), and nothing is typed
-    // into its tab before then.
-    if (harness === 'pi') return { ...told, state: 'unknown', trouble: 'it runs on Pi, and the kit does not give a Pi session skills yet, so nothing was typed' };
     if (down !== undefined) return { ...told, state: 'unknown', trouble: `the kit could not look at its tab, and nothing was typed: ${down}` };
     let turn;
     try {
@@ -505,7 +514,11 @@ function tellSessions(home, bot, linked) {
         const read = linked.map((name) => path.join(home, SKILL_DIRS.codex, name, MANIFEST)).filter((file) => existsSync(file));
         return { ...told, state: 'next-turn', read };
       }
-      typeIntoTab(found.handle, '/reload-skills');
+      if (harness === 'pi') {
+        if (found.draft !== undefined) return { ...told, state: 'unknown', trouble: `its input line holds a draft, "${found.draft}", and /reload would join it, so nothing was typed` };
+        if (!found.idle) return { ...told, state: 'busy' };
+      }
+      typeIntoTab(found.handle, harness === 'pi' ? '/reload' : '/reload-skills');
       return { ...told, state: 'reloaded' };
     } catch (error) {
       // The links are made whatever Orca says, so this is reported, not

package/src/temp.js

@@ -34,9 +34,10 @@ import { setTimeout as pause } from 'node:timers/promises';
 import { readBook, takeLineTurn, TYPING_HELD, TYPING_WAIT_MS, updateBook } from './book.js';
 import { addSession, dropSession, NAME, readBot, tempRoles } from './bot.js';
 import { untrustedKitHooks } from './hook-trust.js';
-import { approvalRank, DEFAULT_APPROVAL, harnessOf, isShortPrompt, ownCli, refuseApprovalArgs, shellWord, startPrompt, workDirOf } from './launch.js';
+import { approvalRank, DEFAULT_APPROVAL, harnessOf, isShortPrompt, ownCli, piApprovalTrouble, refuseApprovalArgs, set, shellWord, startPrompt, workDirOf } from './launch.js';
 import { findSession, sessionInTab } from './message.js';
 import { orca, screenRows, tabs } from './orca.js';
+import { piTrouble } from './pi.js';
 import { retireSession } from './retire.js';
 import { BOT_FATHER, bringUp, promptPath } from './up.js';
 
@@ -75,11 +76,23 @@ export async function makeTemp(bots, { tab, ...given }) {
 
   const maker = bot.sessions.find((session) => session.name === caller.session);
   const { settings, chosen } = settingsFor(bot, maker, role?.option ?? {}, given);
-  if (chosen.harness.value === 'pi') {
-    throw new Error(`${name} would run on Pi, and a temporary session on Pi comes in a later slice of #547. Make it on claude or codex. Nothing was made.`);
-  }
-  refuseWiderApproval(bots, caller, bot, maker, given.approval);
+  const onPi = chosen.harness.value === 'pi';
+  // A blank --approval names no level, so on Pi it is judged as left out (the review of PR #651).
+  const asked = onPi && !set(given.approval) ? undefined : given.approval;
+  if (onPi) {
+    // Pi has one level, whatever the maker's is (the owner, #547).
+    const trouble = piApprovalTrouble(asked, name);
+    if (trouble !== undefined) throw new Error(`${trouble} Nothing was made.`);
+    settings.approval = 'dangerously-skip';
+    if (asked === undefined) chosen.approval = { value: 'dangerously-skip', from: 'harness' };
+  }
+  refuseWiderApproval(bots, caller, bot, maker, asked ?? (onPi ? settings.approval : undefined), onPi && asked === undefined ? name : undefined);
   refuseApprovalArgs(chosen.harness.value, given.extra_args);
+  // Asked before anything is written, so a Pi that cannot start one makes nothing (#578).
+  if (onPi) {
+    const trouble = piTrouble(set(settings.model) ? [settings.model] : []);
+    if (trouble !== undefined) throw new Error(`${trouble} Nothing was made.`);
+  }
   settings.name = name;
   if (given.extra_args !== undefined) settings.extra_args = given.extra_args;
   if (given.prompt !== undefined) settings.prompt = given.prompt;
@@ -189,9 +202,10 @@ function settingsFor(bot, maker, option, given) {
 /**
  * Refuse an approval wider than the widest of the maker's own and the bot's
  * `temp_approval`, which only the user's yes through `permission approval
- * --temps` widens (ADR 0051).
+ * --temps` widens (ADR 0051). `onPi` names a Pi session that was given no
+ * level: Pi's one level is what is judged then (#648).
  */
-function refuseWiderApproval(bots, caller, bot, maker, asked) {
+function refuseWiderApproval(bots, caller, bot, maker, asked, onPi) {
   if (asked === undefined) return;
   // A blank level is the kit's default at launch (ADR 0015), so it is judged as that.
   const effective = (given) => (given === undefined || given === null || String(given).trim() === '' ? DEFAULT_APPROVAL : given);
@@ -199,7 +213,8 @@ function refuseWiderApproval(bots, caller, bot, maker, asked) {
   const own = effective(maker?.approval);
   const widest = approvalRank(bot.temp_approval) > approvalRank(own) ? bot.temp_approval : own;
   if (approvalRank(level) <= approvalRank(widest)) return;
-  throw new Error(`--approval ${level} is wider than ${caller.session}'s own approval, ${own}${widest === own ? '' : `, and than ${caller.bot}'s temp_approval, ${widest}`}, and a session does not widen another's approval. The user allows it for ${caller.bot}'s temporary sessions with  ${shellWord(ownCli())} permission approval --bots ${shellWord(bots)} --bot ${caller.bot} --temps --approval ${level}. Nothing was made.`);
+  const what = onPi === undefined ? `--approval ${level}` : `${onPi} would run on Pi, and every Pi session runs as ${level}, which`;
+  throw new Error(`${what} is wider than ${caller.session}'s own approval, ${own}${widest === own ? '' : `, and than ${caller.bot}'s temp_approval, ${widest}`}, and a session does not widen another's approval. The user allows it for ${caller.bot}'s temporary sessions with  ${shellWord(ownCli())} permission approval --bots ${shellWord(bots)} --bot ${caller.bot} --temps --approval ${level}. Nothing was made.`);
 }
 
 /**
@@ -651,11 +666,54 @@ const wholeScreen = (rows) => rows.filter((row) => row.trim() !== '').map((row)
  */
 export async function answerTemp(bots, { tab, name }) {
   const caller = callerIn(bots, tab, 'answer', "answer a session's first-run screen");
-  ownTemp(caller, name, 'answer for', 'Nothing was typed.');
-  const sent = await answerTeach({ run: `${caller.bot}/${name}`, home: caller.home, session: name }, 'temp');
+  const { bot, session } = ownTemp(caller, name, 'answer for', 'Nothing was typed.');
+  const target = { run: `${caller.bot}/${name}`, home: caller.home, session: name };
+  if (harnessOf(session, bot.harness) === 'pi') sayPiScreen(target, 'temp');
+  const sent = await answerTeach(target, 'temp');
   return { bot: caller.bot, session: name, maker: caller.session, sent };
 }
 
+/**
+ * The foot of an extension's question in Pi 1.3.0: `ctx.ui.select` and
+ * `confirm` draw the trust question's list foot, `ctx.ui.input` its own.
+ */
+const PI_ASK_FOOT = /(?:↑↓ navigate +enter select|enter submit) +escape\/ctrl\+c cancel/;
+
+/** The foot of each step of Pi 1.3.0's first-time setup. */
+const PI_SETUP_FOOT = /enter (?:continue|finish) +escape\/ctrl\+c skip setup/;
+
+/**
+ * Refuse to answer a Pi session's screen, and say what it is (#648). The kit
+ * starts Pi with `--no-approve`, and then no screen of Pi's own waits for a
+ * key where Pi has its settings already (tech notes, section 6). What still
+ * can is named and left to the user: Pi's trust question, its first-time
+ * setup, its warning that waits for a key, and an extension's question.
+ * Nothing is typed, so no turn for a line is taken.
+ */
+function sayPiScreen({ run, home, session }, kind) {
+  const nothing = 'Nothing was typed.';
+  const tabId = readBook(home).sessions[session]?.tab;
+  const handle = tabId === undefined ? undefined : tabs(home).find((one) => one.tabId === tabId)?.handle;
+  if (handle === undefined) {
+    throw new Error(`${run} runs on Pi and has no tab open in Orca, so there is no screen of its to answer. ${nothing}`);
+  }
+  const seen = screenRows(handle);
+  if (seen.rows === undefined) {
+    throw new Error(`${run} runs on Pi, and its screen could not be read (${seen.unreadable}). ${nothing}`);
+  }
+  const has = (test) => seen.rows.some((row) => test(row.trim()));
+  const what = has((row) => row === 'Trust project folder?')
+    ? `Pi's project-trust question, which Pi does not ask when the kit starts it with --no-approve. Trusting a folder is the user's choice`
+    : has((row) => PI_SETUP_FOOT.test(row))
+      ? 'Pi\'s first-time setup, which asks for a theme and whether to share anonymous usage data (analytics) when Pi has no settings.json yet. Both are the user\'s choice'
+      : has((row) => row.endsWith('Press any key to continue...'))
+        ? 'a warning of Pi\'s that waits for a key, such as its notice of an old hooks/ folder in ~/.pi/agent or the project. It is the user\'s to read and answer'
+        : has((row) => PI_ASK_FOOT.test(row))
+          ? 'a question from an extension of Pi\'s, not from Pi or the kit. It is the user\'s to answer'
+          : `no first-run screen of Pi's: the kit starts Pi with --no-approve, and then Pi asks nothing before it works`;
+  throw new Error(`${run} runs on Pi, and its screen shows ${what}. ${kind} answer answers none of Pi's screens. ${nothing} It shows:\n${wholeScreen(seen.rows)}`);
+}
+
 /**
  * Answer `target`'s Teach auto mode screen with Not now, for `temp answer` or
  * `session answer` (`kind`). Returns what answered it.
@@ -714,6 +772,7 @@ export async function trustSessionHooks(bots, { tab, bot, session }) {
  */
 export async function answerSession(bots, { tab, bot, session }) {
   const target = longLivedTarget(bots, { tab, bot, session }, 'answer');
+  if (target.harness === 'pi') sayPiScreen(target, 'session');
   const sent = await answerTeach(target, 'session');
   return { bot: target.bot, session: target.session, sent };
 }