@assuredloop/orca-bot-kit 0.31.0 → 0.33.0

package/README.md

@@ -5,14 +5,14 @@ a manager, developers, reviewers, a personal helper. Each bot keeps its
 identity, its rules, its skills and its sessions across restarts.
 
 [Orca](https://github.com/stablyai/orca) is the host: a bot is an Orca project
-and a session is a tab, on Claude Code or Codex. The kit is an npm package with
+and a session is a tab, on Claude Code, Codex or Pi. The kit is an npm package with
 an `obk` command and a set of skills. You are meant to manage the fleet by
 talking to Bot Father, the first bot, whose skills call the CLI for you — not by
 editing files.
 
 The design is in [`docs/prd/prd.md`](docs/prd/prd.md); the decisions with lasting
 consequences are in [`docs/adr/`](docs/adr/); what we know about Orca and the
-two harnesses is in [`docs/tech-notes.md`](docs/tech-notes.md).
+harnesses is in [`docs/tech-notes.md`](docs/tech-notes.md).
 
 ## Start here
 
@@ -51,13 +51,13 @@ details and, when you say so, files the issue or gives you the text to paste.
 ## Status
 
 Early. The CLI creates your bots folder, brings Bot Father up in Orca, creates
-bots and their sessions on either harness, and builds each bot's `AGENTS.md`
-from its charter and the rules it carries.
+bots and their sessions on any of the three harnesses, and builds each bot's
+`AGENTS.md` from its charter and the rules it carries.
 
 ## Install
 
-Node.js >= 24.21.0, git, and Orca with at least one of Claude Code or Codex
-installed and configured. That line because the kit keeps writers out of each
+Node.js >= 24.21.0, git, and Orca with at least one of Claude Code, Codex or
+Pi installed and configured. That line because the kit keeps writers out of each
 other's way in a bot's book with a SQLite write transaction, through Node's own
 `node:sqlite`. That module is older than the 24 line; 24.21.0 is the first
 release measured here that loads it without an experimental warning on stderr,
@@ -86,8 +86,8 @@ to npm with a provenance statement. Nothing else publishes.
 obk init --bots /absolute/path/to/my-bots --harness claude
 ```
 
-`--harness claude|codex` says which harness Bot Father itself runs on; there is
-no default. This makes the folder a git repository and seeds it:
+`--harness claude|codex|pi` says which harness Bot Father itself runs on; there
+is no default. This makes the folder a git repository and seeds it:
 
 ```
 my-bots/
@@ -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, and `obk session compact` types Pi's `/compact`.
+`obk init --harness pi` puts Bot Father itself on Pi.
 
 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,
@@ -530,8 +535,8 @@ leaves it running until the session is next restarted; after that, `--on --at`
 puts it back.
 `obk groom --compact` compacts its conversation between runs.
 
-The grooming session is always a Claude Code one, even on a Codex Bot Father (add
-it with `--harness claude` there): it is the clock, and where the reports arrive.
+The grooming session is always a Claude Code one, even on a Codex or Pi Bot Father
+(add it with `--harness claude` there): it is the clock, and where the reports arrive.
 To have the grooming itself done on Codex, turn it on with `--run-on codex`, and
 give the runs their model and effort:
 

package/SETUP.md

@@ -20,7 +20,7 @@ Everything else you can find out by looking.
 ## What you are making
 
 Orca is the host. A bot is an Orca project and a session is a tab, running
-Claude Code or Codex. You are making the first bot, **Bot Father**, and a folder
+Claude Code, Codex or Pi. You are making the first bot, **Bot Father**, and a folder
 that holds the whole fleet's configuration as a git repository of theirs.
 
 When you are done they will have an Orca project called Bot Father with two
@@ -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
 ```
 
 The Orca line must come back with `ok: true` and `result.runtime.reachable:
@@ -63,7 +63,7 @@ If Node is older than 24.21.0, say so and stop. The kit's book of sessions is a
 SQLite write transaction through Node's own `node:sqlite`, and 24.21.0 is the
 first release measured here that loads it without an experimental warning.
 
-If neither harness is installed, say so and stop. If only one is, that is fine,
+If no harness is installed, say so and stop. If only one is, that is fine,
 and it is the one Bot Father will run on.
 
 If Codex is older than 0.156.1, say so and ask them to update it before a bot
@@ -121,15 +121,17 @@ book of sessions. It holds none of the kit's code. The bots commit their own
 changes to it; the kit's commands never commit, and pushing it somewhere is
 theirs to decide.
 
-**Which harness Bot Father runs on**, `claude` or `codex`. There is no default
-and the kit will not guess. It is Bot Father's own harness only; each bot they
-make later chooses its own. If only one harness is installed, say so and confirm
-it rather than asking as though the choice were open.
+**Which harness Bot Father runs on**, `claude`, `codex` or `pi`. There is no
+default and the kit will not guess. It is Bot Father's own harness only; each
+bot they make later chooses its own. If only one harness is installed, say so
+and confirm it rather than asking as though the choice were open. If they choose
+`pi`, they sign in to Pi themselves first: the kit never handles Pi's
+credentials, and `obk init` starts nothing while Pi can use no model.
 
 ## 4. Make the fleet
 
 ```sh
-obk init --bots <their path> --harness claude|codex
+obk init --bots <their path> --harness claude|codex|pi
 ```
 
 This makes the folder a git repository, seeds it, writes Bot Father, and opens

package/package.json

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

package/skills/obk-grooming/SKILL.md

@@ -242,8 +242,9 @@ places and sending one to the other loses it.
 The pass runs in a session of Bot Father's own, `grooming`, on Claude Code's
 own scheduler. Add it like any session, with the model and effort it is to run
 at: `obk session add --bots <folder> --bot bot-father --name grooming --model
-<m> --effort <e>`, with `--harness claude` where Bot Father runs on Codex, then
-`obk up`. Its launch line carries them, so they are what every run uses.
+<m> --effort <e>`, with `--harness claude` where Bot Father runs on Codex or
+Pi, then `obk up`. Its launch line carries them, so they are what every run
+uses.
 
 The runs can be done on Codex instead. The session stays this Claude Code one,
 the clock and the reader, and `obk groom --on --at <HH:MM> --run-on codex

package/src/bot.js

@@ -791,7 +791,7 @@ function asMapping(bot, file) {
 export function requireBotsFolder(bots) {
   const dir = botsDir(bots);
   if (statSync(dir, { throwIfNoEntry: false })?.isDirectory() !== true) {
-    throw new Error(`${bots} is not a bots folder: run obk init --bots <path> --harness claude|codex first.`);
+    throw new Error(`${bots} is not a bots folder: run obk init --bots <path> --harness claude|codex|pi first.`);
   }
   return dir;
 }

package/src/clear.js

@@ -16,16 +16,16 @@ import { setTimeout as pause } from 'node:timers/promises';
 
 import { readBook, takeTypingTurn, TYPING_HELD, TYPING_WAIT_MS } from './book.js';
 import { botDir, readBot } from './bot.js';
-import { claudeTranscript, codexRollout } from './conversations.js';
+import { claudeTranscript, codexRollout, piSession } 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' },
-  compact: { claude: '/compact', codex: '/compact' },
+  clear: { claude: '/clear', codex: '/new', pi: '/new' },
+  compact: { claude: '/compact', codex: '/compact', pi: '/compact' },
 };
 
 /** The pointer each harness starts its input line with (tech notes, section 1). */
@@ -100,12 +100,18 @@ 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.
  */
 export async function clearSession(bots, { bot, session }) {
-  const it = sessionToType(bots, bot, session, 'clear');
+  const it = sessionToType(bots, bot, session);
   const was = readBook(it.home).sessions[session]?.session ?? null;
   const { command, handle, typing } = await enter(it, 'clear');
 
@@ -141,7 +147,7 @@ export async function clearSession(bots, { bot, session }) {
  * command began, and not yet when COMPACT_MS passed without one.
  */
 export async function compactSession(bots, { bot, session }) {
-  const it = sessionToType(bots, bot, session, 'compact');
+  const it = sessionToType(bots, bot, session);
   // What the record holds when /compact is typed is not this compact's: one
   // that ends while the kit waits for the session to be idle is the one
   // before it (review of PR #466). So only what is written after counts.
@@ -168,17 +174,13 @@ 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.
  */
-export function sessionToType(bots, bot, session, verb) {
+export function sessionToType(bots, bot, session) {
   botsNamed(bots, bot);
   const home = realpathSync(botDir(bots, bot));
   const known = readBot(home, bot);
   const [settings] = sessionsOf(known, session);
   const name = `${bot} ${session}`;
-  if (verb !== undefined && 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}`;
   if (known.paused === true) throw new Error(`${bot} is paused, so ${name} is not running and nothing was typed. Bring it back with ${unpause}.`);
   if (settings.paused === true) throw new Error(`${name} is paused, so it is not running and nothing was typed. Bring it back with ${unpause} --session ${session}.`);
@@ -211,6 +213,7 @@ async function enter(it, verb, before = () => {}) {
         before();
       },
       cannot: (wrong) => (verb === 'compact' && wrong.menu && it.harness === 'codex' ? ` ${harnessName(it.harness)} here cannot compact: its menu does not offer ${COMMANDS[verb][it.harness]}.` : ''),
+      close: it.harness === 'pi' ? PI_CLOSE : undefined,
     });
     return { ...typed, typing };
   } catch (error) {
@@ -225,17 +228,25 @@ async function enter(it, verb, before = () => {}) {
  * screen: by default the slash menu's check, which a command with words after
  * it does not pass, since Codex closes its menu at the space (#480). `before`
  * runs just before the command is typed; `cannot` adds to a refusal what a
- * wrong screen means; past `deadline`, a time, what was typed is taken back
- * and nothing is entered. Returns the command, the handle it went into, and
- * when it was typed.
+ * wrong screen means; `close`, `{ key, check }`, is one more key typed once
+ * `check` passes, and its own check of the screen before the return; past
+ * `deadline`, a time, what was typed is taken back and nothing is entered.
+ * Returns the command, the handle it went into, and when it was typed.
  */
-export async function typeCommand(it, command, { before = () => {}, check = menuWrong, cannot = () => '', deadline = Infinity } = {}) {
+export async function typeCommand(it, command, { before = () => {}, check = menuWrong, cannot = () => '', close, deadline = Infinity } = {}) {
   // 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)) {
@@ -286,22 +297,31 @@ export async function typeCommand(it, command, { before = () => {}, check = menu
     takeBack();
     throw new Error(`${it.name}: ${command} was being typed, and after ${sofar} ${look.why}, so what was typed was taken back and nothing was entered.`);
   };
+  const typeKey = (char) => {
+    try {
+      send(handle, char);
+    } catch (error) {
+      // A send Orca did not answer in time may have gone in all the same.
+      // Counted only where the line was empty before the first key, so the
+      // one backspace too many can take nothing of the user's (#480 review).
+      if (error.code === TIMED_OUT && (it.harness === 'codex' || it.harness === 'pi')) typed += 1;
+      throw error;
+    }
+    typed += 1;
+  };
   try {
     for (const char of command) {
       if (typed > 0) await lookAgain();
-      try {
-        send(handle, char);
-      } catch (error) {
-        // A send Orca did not answer in time may have gone in all the same.
-        // Counted only where the line was empty before the first key, so the
-        // one backspace too many can take nothing of the user's (#480 review).
-        if (error.code === TIMED_OUT && it.harness === 'codex') typed += 1;
-        throw error;
-      }
-      typed += 1;
+      typeKey(char);
     }
     await lookAgain();
     let wrong = await typedWrong(handle, it.harness, command, version, check);
+    if (wrong === undefined && close !== undefined) {
+      await lookAgain();
+      typeKey(close.key);
+      await lookAgain();
+      wrong = await typedWrong(handle, it.harness, command, version, close.check);
+    }
     if (wrong === undefined && Date.now() > deadline) wrong = { why: 'its time ran out' };
     if (wrong !== undefined) {
       takeBack();
@@ -373,7 +393,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 +414,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 +429,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 +439,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 +499,53 @@ 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, and this cannot tell it apart: PI_CLOSE does.
+ */
+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;
+}
+
+/**
+ * Pi 1.3.0 applies a menu list still drawn from an earlier key against that
+ * key's prefix, so `/compact` under a list for `/compa` submits `/ccompact`,
+ * and `/new` under one for `/n` submits `/nnew`; the screen cannot tell that
+ * list from a fresh one. A space makes Pi list `/compact ` or `/new `, for
+ * which it has nothing, and so close the menu; with no menu, Return submits
+ * the line trimmed, the command (tech notes, section 6; #671, #673).
+ */
+const PI_CLOSE = { key: ' ', check: (rows, harness, command, version, draft) => piClosedWrong(rows, command, draft) };
+
+/**
+ * Why the screen does not show Pi's editor reading `command`, a space after
+ * it, with no menu below the box, or undefined when it does. A list still
+ * drawn has its selected row.
+ */
+function piClosedWrong(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?.trim() ?? lines.join(' ⏎ ');
+  if (line !== command || (draft === undefined && lines.length !== 1)) return { why: `its input line reads "${line}" after the space` };
+  const selected = box.below.find((row) => PI_SELECTED.test(row));
+  if (selected !== undefined) return { why: `a menu is still below its input box after the space, its selected row "${selected.trim()}"` };
+  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;
@@ -517,6 +585,7 @@ async function answerWhereToRun(it, handle, command) {
 /** Where the harness keeps the record of `conversation`, or undefined when it has none yet. */
 function recordFile(harness, home, conversation) {
   if (conversation === null) return undefined;
+  if (harness === 'pi') return piSession(home, conversation);
   return harness === 'claude' ? claudeTranscript(home, conversation) : codexRollout(conversation);
 }
 
@@ -549,9 +618,9 @@ function compactedSince(harness, record, since) {
       } catch {
         return false;
       }
-      // Claude Code's marker, and Codex's (tech notes, sections 2 and 3).
-      const compaction = harness === 'claude'
-        ? entry?.type === 'system' && entry.subtype === 'compact_boundary'
+      // Claude Code's marker, Codex's, and Pi's (tech notes, sections 2, 3 and 6).
+      const compaction = harness === 'claude' ? entry?.type === 'system' && entry.subtype === 'compact_boundary'
+        : harness === 'pi' ? entry?.type === 'compaction'
         : entry?.type === 'compacted';
       found = compaction && Date.parse(entry.timestamp) >= since;
       return found;
@@ -580,4 +649,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

@@ -39,7 +39,7 @@ import { BOT_FATHER, bringUp, ownMailbox } from './up.js';
 const USAGE = `obk — Orca Bot Kit.
 
 Usage:
-  obk init --bots <path> --harness claude|codex
+  obk init --bots <path> --harness claude|codex|pi
                             Create your bots folder: a git repo holding your
                             bots' configuration, with Bot Father in it, and
                             open Bot Father in Orca.
@@ -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
@@ -607,8 +610,6 @@ async function record(bots, bot) {
 
 const commands = {
   async init(bots, values) {
-    // Bot Father on Pi is not in the first slice of #547.
-    if (values.harness === 'pi') throw new Error('init does not take --harness pi yet: Bot Father runs on claude or codex, and its other bots may run on Pi. Nothing was written.');
     // Asked before anything is written, so an Orca that is down leaves the disk
     // exactly as it was and the caller can simply run the command again.
     refuseWhenOrcaIsDown();
@@ -1840,6 +1841,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 +1859,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 +1869,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/conversations.js

@@ -49,7 +49,7 @@ const PI_FILE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z_(.+)\.jsonl$/;
 const piIdOf = (name) => PI_FILE.exec(name)?.[1];
 
 /** Where Pi keeps the conversation `id` of this bot home, or undefined when it has none yet. */
-const piSession = (home, id) => {
+export const piSession = (home, id) => {
   const name = files(piDir(home)).find((one) => piIdOf(one) === id);
   return name === undefined ? undefined : path.join(piDir(home), name);
 };