@assuredloop/orca-bot-kit 0.31.0 → 0.33.0

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 };
 }