@assuredloop/orca-bot-kit 0.30.0 → 0.32.0

package/README.md

@@ -152,30 +152,37 @@ 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,
 `git add` and `git commit`
 ([ADR 0050](docs/adr/0050-the-kit-writes-every-bots-default-permission-rules.md)).
 `obk permission`, `obk retire`, `obk pause`, `obk restart`, `obk bot create`,
-`obk bot change`, `obk session add`, `obk session change`, `obk init` and
-`obk run` are not in the set, and keep your yes
+`obk bot change`, `obk session add`, `obk session change` and `obk init` are
+not in the set, and keep your yes
 ([ADR 0051](docs/adr/0051-permission-changes-and-risky-operations-have-commands-of-their-own.md)).
 A rule beyond the set is written by `obk permission allow`, after your yes to
 the exact rule. A bot that still holds a rule that the kit gave every bot
 before and that is no longer in the set keeps it: the rule of `obk restart`,
 `obk bot create`, `obk bot change`, `obk session add`, `obk session change`,
 `obk session mail` or `obk session nudge`, or of Orca's
-`orca orchestration check --run`. `obk rules build` and `obk up` name it, with
-the `obk permission disallow` command that takes it back.
+`orca orchestration check --run`. So does a bot that holds a rule you allowed
+for the kit's `run` command, which the kit no longer has. `obk rules build` and
+`obk up` name each such rule, with the `obk permission disallow` command that
+takes it back.
 
 Neither command touches Orca. `obk up` is what makes it all real there: an Orca
 project per bot, a tab per session, each started at the bot home with its own
@@ -680,82 +687,7 @@ fleet at all. Turn it off for a session with your own
 the kit will report that session as out of reach of fleet mail rather than
 failing quietly.
 
-## Working on the kit
+## Contributing
 
-```sh
-npm test                      # the whole suite, in a few minutes
-npm run test:system           # what the system tests would drive, and nothing else
-npm run test:system -- --yes  # drive them, on this machine, for real
-npm run test:system -- --yes test/system/groom.test.js  # only the ones you name
-npm run mutate                # the mutation audit, on what your branch changed
-```
-
-The tests come in two layers, and every test file belongs to one of them.
-
-`npm test` is `test/*.test.js` and `test/dev/*.test.js`: unit tests and
-end-to-end runs of the CLI in a throwaway folder, with a fake `orca` on PATH. It
-needs nothing but Node, so [GitHub Actions](.github/workflows/ci.yml) runs it on
-every pull request, split into shards that run side by side, on Node 25.8.0, the
-current line. A release runs every shard on 25.8.0 and again on 24.21.0, the
-floor `engines.node` promises users, with only the kit's own dependencies
-installed, before anything is published. The floor leaves out `test/dev/`, the
-tests that need a development tool.
-
-`npm run test:system` is `test/system/*.test.js`: the real `obk` against the
-real Orca and the real harnesses on your own machine. No CI runner can do that,
-so these are run by hand before a change that touches Orca or a harness is
-merged. A system test touches only what it creates and removes it afterwards,
-except the mailbox Runs Orca gives no way to delete, which the run names; it
-never closes a tab it did not open. Before any test loads, the command copies
-your `~/.claude.json` and `~/.codex/config.toml` into a new
-`obk-config-backup-*` folder in your temp folder, readable by you alone, and
-says where; if a copy fails, no test runs. After the run it says whether each
-file still matches its copy, and never copies one back: that is yours to
-decide. The trust its harnesses write into your `~/.codex/config.toml` and
-`~/.claude.json` for the run's own throwaway folders is taken out again after
-the run, and named; nothing else in them is changed.
-An Orca project the run leaves in one of its own throwaway folders is named,
-with its setup id, and fails the run; the command removes none itself.
-
-They run on the machine the command is typed on, so the command will not start
-them by itself. On its own it says what it is about to drive — whose machine,
-which Orca, which files, and what they will do to it — and then stops without
-driving any of it, answering non-zero so that a run which did not run them
-cannot be read as one that passed. `-- --yes` is how you say you meant it. When
-Orca is not answering, the command says which Orca it asked and skips, rather
-than report a kit that is not broken. Name files after it to run only those;
-each must be one of the `*.test.js` files under `test/system/`, links followed,
-and a name that is not is refused before anything runs. This command is the
-only way in: a system test loaded any other way, with `node --test` or an
-editor's runner, skips and says how to run it.
-
-`npm run mutate` runs [StrykerJS](https://stryker-mutator.io) over the
-JavaScript this branch changed against `main` — committed, still in the working
-tree, or not tracked yet — and reports the mutants the tests do not kill. It is
-an audit, not a step of every pull request
-([PRD 7.3](docs/prd/prd.md#prd-21-73-decided-rules-inside-the-skills)): the everyday
-check is the implementer's own hand check, and the tool runs over the whole
-suite at a milestone or when the owner asks, or once, narrowed to the changed
-logic, for a change at the core of the kit. A surviving mutant is a change to
-the code that no test objects to. It is worth a test only where it shows a gap
-in behaviour the requirement cares about, and that test is written by the
-separate test author. Name targets yourself to check a whole area instead:
-
-```sh
-npm run mutate -- 'src/**/*.js'
-```
-
-Every mutant means running the tests again, so the check does not run them the
-way `npm test` does. It runs [`scripts/mutation-suite.js`](scripts/mutation-suite.js)
-instead: the same test files, one at a time, stopping at the first file that
-fails, trying the file that killed the last mutant first and then the quickest.
-On a ten-core machine, `src/up.js` as it was when this was measured (128 lines,
-76 mutants) took about twelve minutes that way. Running the whole suite for every mutant, as it used to, took
-forty, and counted a mutant as killed whenever a run of it ran out of time. A
-change across several files takes proportionally longer, so check one or two at
-a time.
-
-The check still takes minutes where the suite takes seconds, which is why it is
-a command of its own. StrykerJS is a development dependency of this repo, pinned
-to an exact version and needing Node 22 or newer; the kit itself neither ships
-it nor needs it.
+How to run the kit's own tests, and how they are laid out, is in
+[CONTRIBUTING.md](CONTRIBUTING.md). The package does not ship it.

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:
@@ -144,8 +144,8 @@ Read everything it prints. Three parts of it matter to them:
   beside the bots folder, and its commits. The kit writes this set for every
   bot, with nobody asked. Say in a sentence what it allows, and that
   `obk permission`, `obk retire`, `obk pause`, `obk restart`, `obk bot create`,
-  `obk bot change`, `obk session add`, `obk session change`, `obk init` and
-  `obk run` are not in it and keep their yes;
+  `obk bot change`, `obk session add`, `obk session change` and `obk init` are
+  not in it and keep their yes;
 - **anything it says about Orca's own default launch arguments.** Orca adds
   these to every agent it launches, relaunches and resumes. When they carry a
   permission bypass, every session runs in that mode whatever approval level the

package/package.json

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

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

@@ -214,12 +214,13 @@ does not have yet to its `bot.yaml` and its settings, or for Codex its
 `.codex/rules/obk.rules`, and say which rules they wrote. The set leaves out
 the commands that keep the user's yes: `obk permission`, `obk retire`, `obk
 pause`, `obk restart`, `obk bot create`, `obk bot change`, `obk session add`,
-`obk session change`, `obk init` and `obk run`. A bot that still holds a rule that the
+`obk session change` and `obk init`. A bot that still holds a rule that the
 kit gave every bot before and that is no longer in the set (`obk restart`,
 `obk bot create`, `obk bot change`, `obk session add`, `obk session change`,
 `obk session mail`, `obk session nudge`, or Orca's `orca orchestration check
---run`) keeps it, and `obk rules build` and `obk up` name
-it with the `obk permission disallow` command that takes it back; run that
+--run`) keeps it, and so does a bot that holds a rule the user allowed for the
+kit's `run` command, which the kit no longer has. `obk rules build` and `obk up`
+name each such rule with the `obk permission disallow` command that takes it back; run that
 command only after the user's yes. Never write a
 permission rule into a settings or rules file by hand.
 
@@ -245,11 +246,7 @@ out; the kit refuses it, and it refuses a rule of its own default set too. Keep
 each rule narrow: a program and what it does. The kit refuses a rule that lets
 the bot run any command, a program with any arguments, or a shell or
 interpreter with any arguments; a user who wants one for a bot adds it to that
-bot's settings themselves. For a test run with a time limit, propose `obk run`
-with the real command after `--`, such as
-`Bash(<kit> run --timeout 300 -- go test:*)`: the kit refuses a rule for
-`perl -e 'alarm …'`, since perl runs whatever its arguments say. Propose no
-rule for what the charter does not grant.
+bot's settings themselves. Propose no rule for what the charter does not grant.
 
 A bot that should learn across its sessions can use its harness's own memory,
 turned on for that bot alone, whatever the user's own setting is for everything

package/src/bot.js

@@ -8,7 +8,6 @@
 // writes nothing, rather than leave a bot half made or a bot.yaml half edited.
 
 import { accessSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { isSeq, parse, parseDocument, stringify } from 'yaml';
@@ -133,25 +132,6 @@ function whereItLeads(target) {
 export const displayName = (name) =>
   name.split('-').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
 
-/**
- * What Orca is asked to call a bot's project. A fleet whose bots folder is under
- * the system's temp folder, as a system test's or a live check's is, gets a mark
- * and the name of the first folder under the temp folder, so its Bot Father is
- * never taken for the owner's in Orca's sidebar (#401). Every other fleet's
- * project is called what it always was. Tab titles keep `displayName` either way.
- */
-export function projectName(bots, name) {
-  let under;
-  try {
-    under = path.relative(realpathSync(os.tmpdir()), realpathSync(bots));
-  } catch {
-    return displayName(name);
-  }
-  // The temp folder itself, or anywhere outside it, is not a throwaway fleet's.
-  if (under === '' || under === '..' || under.startsWith(`..${path.sep}`) || path.isAbsolute(under)) return displayName(name);
-  return `${displayName(name)} · temp fleet ${under.split(path.sep)[0]}`;
-}
-
 /**
  * A bot's own file: which harness its sessions run on unless they say
  * otherwise, and the sessions it keeps.

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

@@ -21,7 +21,7 @@ import { nameSession } from './name.js';
 import { APPROVALS, harnessOf, HARNESSES, ownCli, refuseApprovalArgs, shellWord, workDirOf } from './launch.js';
 import { checkMail, lookUp, noMailboxYet, sendMessage, sessionInTab } from './message.js';
 import { orcaCli, orcaTrouble, RELOAD_LINE, TERMINAL_ENV } from './orca.js';
-import { allowIn, beyondDefaults, botDefaults, refuseBroad, refuseNoCodexForm, runsOnClaude, runsOnCodex, takeBack, writePermissions } from './permissions.js';
+import { allowIn, beyondDefaults, botDefaults, isRunRule, refuseBroad, refuseNoCodexForm, runsOnClaude, runsOnCodex, takeBack, writePermissions } from './permissions.js';
 import { pauseSessions, unpauseSessions } from './pause.js';
 import { recordSession, SHELL_ENV, TAB_ENV } from './record.js';
 import { restartSessions } from './restart.js';
@@ -34,7 +34,6 @@ import { addSkill, buildSkills, linkSkills, removeSkill } from './skills.js';
 import { addSource, fetchSources } from './sources.js';
 import { answerSession, answerTemp, listRoles, makeTemp, optionsLine, retireTemp, trustHooks, trustSessionHooks } from './temp.js';
 import { readUsage } from './usage.js';
-import { parseRun, runBounded } from './run.js';
 import { BOT_FATHER, bringUp, ownMailbox } from './up.js';
 
 const USAGE = `obk — Orca Bot Kit.
@@ -123,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
@@ -134,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.
@@ -169,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
@@ -327,22 +329,13 @@ Usage:
                             For the kit's own launch line, not for typing: run
                             in the session's own tab, it gives the session its
                             mailbox, or binds the one it has, to that tab.
-  obk run --timeout <seconds> -- <command> [<arg> ...]
-                            Run one command with a hard time limit, with no
-                            shell, and exit with its exit code. When the time
-                            runs out, it stops the command and everything it
-                            started (SIGTERM, then SIGKILL after 3 s), says so
-                            on stderr, and exits 124. A command it cannot find
-                            exits 127. A rule can allow it for one command,
-                            such as Bash(obk run --timeout 300 -- go test:*).
-                            It needs no --bots, and takes no --json.
   obk --version             Print the kit's version.
   obk --help                Print this text.
 
 Every command is safe to run again. Most only add what is missing; the ones
 that close a tab or take something away say so above. Every bot is allowed
-the kit's commands by default, except obk permission, retire, pause, init and
-run, which keep the user's yes.
+the kit's commands by default, except obk permission, retire, pause and init,
+which keep the user's yes.
 Add --json to any of them for the same answer as JSON.
 
 For another build of Orca, OBK_ORCA names its CLI, and OBK_ORCA_DATA the full
@@ -396,10 +389,6 @@ function version() {
 }
 
 async function run(argv) {
-  // What follows `obk run --timeout <n> --` is the command's own, flags and
-  // all, so it is read by `run` alone, before the kit reads its flags (#532).
-  if (argv[0] === 'run') return runBounded(parseRun(argv.slice(1)));
-
   const { values, positionals, tokens } = parseArgs({
     args: argv,
     allowPositionals: true,
@@ -1819,7 +1808,7 @@ function permissionsLines(permissions, bots) {
     ...(entry.trouble === undefined ? [] : [`${'refused'.padEnd(9)}  ${entry.trouble}`]),
     ...(listed.has(entry.bot) || !listed.add(entry.bot) ? [] : [
       ...(entry.defaults ?? []).map((rule) => `${'allowed'.padEnd(9)}  ${entry.bot}  ${rule}`),
-      ...(entry.held ?? []).map((rule) => `${'holds'.padEnd(9)}  ${entry.bot}  ${rule}, which is no longer one of the kit's defaults. To take it back:  ${disallow(entry.bot, rule)}`),
+      ...(entry.held ?? []).map((rule) => `${'holds'.padEnd(9)}  ${entry.bot}  ${rule}, ${isRunRule(rule) ? 'which is for obk run, a command the kit no longer has' : "which is no longer one of the kit's defaults"}. To take it back:  ${disallow(entry.bot, rule)}`),
     ]),
     ...(entry.written.length === 0
       ? []
@@ -1854,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.`]
+        : []),
     ];
   });
 }
@@ -1867,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)),
@@ -1876,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/commands.js

@@ -46,7 +46,6 @@ export const COMMANDS = {
   'temp retire': ['bots', 'name'],
   'temp trust-hooks': ['bots', 'name'],
   'temp answer': ['bots', 'name'],
-  run: ['timeout'],
 };
 
 /**
@@ -69,14 +68,12 @@ export const DEFAULT_COMMANDS = [
  * The commands kept out of the default permission set, which keep the user's
  * yes (ADR 0051): the ones that change permissions, close a long-lived
  * session, make the bots folder, or make or change a bot or its sessions,
- * which the owner leaves to Bot Father (#548, #615); and `run`, which runs
- * whatever its arguments say, so a rule for it names its command (#532).
+ * which the owner leaves to Bot Father (#548, #615).
  */
 export const KEPT_BACK = [
   'init', 'retire', 'pause', 'restart', 'bot create',
   'bot change', 'session add', 'session change',
   'permission allow', 'permission disallow', 'permission approval',
-  'run',
 ];
 
 /**
@@ -87,8 +84,8 @@ export const KEPT_BACK = [
 export const NO_LONGER_DEFAULT = ['restart', 'bot create', 'bot change', 'session add', 'session change'];
 
 /**
- * The commands kit 0.26.0 gave every bot by default and that the kit no longer
- * has (#555). A bot may still hold their rules, which the kit names and leaves
- * (#564).
+ * The commands the kit no longer has: the two kit 0.26.0 gave every bot by
+ * default (#555), and `run` (#532), which #652 took out of the kit. A bot may
+ * still hold their rules, which the kit names and leaves (#564).
  */
-export const REMOVED = ['session mail', 'session nudge'];
+export const REMOVED = ['session mail', 'session nudge', 'run'];