@assuredloop/orca-bot-kit 0.18.0 → 0.19.0

package/skills/obk-reviewing/NOTICE.md

@@ -16,6 +16,9 @@ noted, with thanks:
   has no caller, premature abstraction, "I would have done it differently",
   about five items, and showing what was set aside. Its `poteto-mode`
   bugbot-triage reference gave fix, dismiss or ask, and "when in doubt, ask".
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **obra/superpowers**, `requesting-code-review`, `receiving-code-review` and
   `subagent-driven-development/task-reviewer-prompt.md` (the last for bounded
   reading, "declined to judge", the read-only rule and one focused test only
@@ -27,6 +30,9 @@ noted, with thanks:
   pattern: read, restate, verify, evaluate, respond, implement, with the stop
   on an unclear item, the check for who calls it, the order of fixes, and
   correcting your own pushback without a speech.
+  Revision: obra/superpowers@5bf4e78011075bcfc0dc295f0724994cd123ee71
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **mattpocock/skills**, `code-review`: the smell baseline in full, with its
   own guards: every entry a labelled judgement call, the repo's documented
   standard overriding it, and anything tooling enforces skipped. Also pinning
@@ -34,17 +40,26 @@ noted, with thanks:
   missing, unasked-for and misunderstood, quoting the rule for a standards
   breach, and the two axes staying separate so neither hides the other. The
   smells are Fowler's, from *Refactoring* chapter 3.
+  Revision: mattpocock/skills@c55ee46073ed923f86ce59a5eb3b6d895095d1b7
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **Cursor thermos**, with `thermo-nuclear-review`: scope held to what the
   change touches, not spending the author's time on a breakage the change
   intends, what over-reporting costs you,
   reading the change before the discussion, and never presenting a finding with
   the research unfinished when the answer was there to be read.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **addyosmani/agent-skills**: passing the artefact and the contract without
   the conclusion, the one structural problem outranking ten small ones, and,
   from `doubt-driven-development`, sorting findings into misread, valid,
   trade-off and noise in that order, with the brief fixed first for a misread.
   Its `code-review-and-quality`: not softening a real issue, which pstack's
   `code-quality-review` says too.
+  Revision: addyosmani/agent-skills@dc27a9c2e13721158157632de61b4106c6c2a2a1
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **Anthropic's built-in review**, as behaviour observed rather than text
   taken: the angles worth separating, naming the behaviour a deleted line held
   up, following a change out to its callers, confirmed against plausible
@@ -53,6 +68,10 @@ noted, with thanks:
   bug states its trigger, not collapsing finding into judging,
   correctness outranking cleanup, and saying when a review was less than it was
   meant to be.
+  Revision: none (Claude Code's built-in review, its behaviour observed rather
+  than a text read)
 - **ECC's reviewer prompt**, through the research pack: the four questions
   before a finding, a defensible severity, zero findings being expected,
   consolidating repeats, and the list of findings that are usually wrong.
+  Revision: affaan-m/ECC@07756cee15788a54506031462794ad645719b028 (as recorded
+  in the research pack's source-book-2.md, read 2026-09-19)

package/skills/obk-tdd/NOTICE.md

@@ -14,6 +14,9 @@ thanks:
   `to-spec`: the existing seam preferred, the highest one, and the fewer the
   better. Its `diagnosing-bugs`: the correct seam for a bug test, and no
   correct seam being the finding.
+  Revision: mattpocock/skills@c55ee46073ed923f86ce59a5eb3b6d895095d1b7
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **obra/superpowers**, `test-driven-development` and its `writing-good-tests`:
   naming the break a test catches, deriving the expected value by hand, change
   detectors, behaviour rather than text, your contract rather than the
@@ -21,16 +24,25 @@ thanks:
   the mutation classes. Its `verification-before-completion`: the
   revert-the-fix proof. Its `writing-plans`: a requirement's silence not being
   permission, and the few uncovered input classes most likely to bite.
+  Revision: obra/superpowers@5bf4e78011075bcfc0dc295f0724994cd123ee71
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **Cursor pstack**, `tdd` and `principle-test-behavior-not-implementation`:
   the five shapes that observe no behaviour and the fix for each (asserting
   what a stand-in received rather than that it was called, and the relation
   across rows of data that is kept), "prefer no
   new test over a bad test", the honest exit when a test is impractical, and
   the report that names the failing-before and passing-after runs.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **addyosmani/agent-skills**, `test-driven-development` and
   `constraint-driven-development`: finding out how the project tests before
   writing anything, repetition being no fault in a test, a subagent for the
   reproduction test, and the cheap roads to green.
+  Revision: addyosmani/agent-skills@dc27a9c2e13721158157632de61b4106c6c2a2a1
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **citypaul/.dotfiles**, `tdd` and `mutation-testing` with its
   `mutator-rules`: the mutation loop, survivor triage into killed, equivalent
   or named and deferred, the equivalence question, the high-value logic worth
@@ -38,15 +50,34 @@ thanks:
   mixed true and false, no identity values), the tool-run mechanics in
   `mutation-tools.md`, keeping the harness out of the inner loop, triangulating
   after a fake, and refusing to manufacture a red.
+  Revision: citypaul/.dotfiles@a109f9972bb46671c624fc05752031523e1cf6fc
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **Kent Beck's own rules file**: one test at a time, the smallest code that
   passes, structure and behaviour kept apart, and the two-level test for a
   defect.
+  Revision: KentBeck/BPlusTree3@ca80e4d85a99cd0af2effe717f709d43e80403bc
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **nizos/tdd-guard**: the ladder to a clean red.
+  Revision: nizos/tdd-guard@2579ec1823fac5f4afb73be678d9c500b19885ac (as
+  recorded in the research pack's source-book-2.md, read 2026-09-19)
 
-Ideas paraphrased, with no text taken: Trail of Bits' mutation-testing skill
-(CC BY-SA 4.0) on equivalent mutants, Anthropic's Claude Code documentation on
-separate test authorship, alexop.dev on why one context cannot hold both
-halves, and the published work on mutation testing at scale.
+Ideas paraphrased, with no text taken:
+
+- **Trail of Bits' mutation-testing skill**, in `trailofbits/skills` (CC BY-SA
+  4.0), on equivalent mutants.
+  Revision: trailofbits/skills@123037ec8aed26f0d86327cc39137ee5043e5deb (as
+  recorded in the research pack's source-book-2.md, read 2026-09-19)
+- **Anthropic's Claude Code documentation**, "Claude Code: Best practices", on
+  separate test authorship.
+  Read: 2026-09-19 (read for the research pack's source-book-1.md, of that date)
+- **alexop.dev**, "A Claude Code TDD Skill: Forcing Red-Green-Refactor", on why
+  one context cannot hold both halves.
+  Read: 2026-09-19 (read for the research pack's source-book-1.md, of that date)
+- **The published work on mutation testing at scale**, Petrović and others,
+  "Practical Mutation Testing at Scale" (arXiv 2102.11378).
+  Read: 2026-09-19 (read for the research pack's source-book-1.md, of that date)
 
 Our own, with no source behind them: the order to break things in, the red
 from an archived baseline for behaviour that already existed, checking that an

package/skills/obk-teach/NOTICE.md

@@ -45,6 +45,9 @@ thanks:
   print, and the reply being the explanation itself rather than a report about
   it). Its worked density example is not carried; the rules it illustrates
   are.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 
 Made generic, which is what the owner asked for. The original is built on top
 of two other skills it invokes by name, and a kit skill carries what it needs

package/skills/obk-why/NOTICE.md

@@ -37,6 +37,9 @@ The skill `obk-why` was consolidated for this kit from this, MIT, with thanks:
   including one line per source consulted covering the empty and skipped ones;
   and turning the findings into a preserve, change, avoid and risk constraint
   set when the question precedes a change.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - The same skill's `references/sources/code-archaeology.md`. Its pitfalls: the
   squash merge that flattens a branch's steps, the commit message that calls a
   behaviour change a small refactor so the diff has to be read instead, the

package/skills/obk-writing/NOTICE.md

@@ -30,6 +30,9 @@ Each licence below was read from the file named beside it.
   read machine-written when every sentence is clipped to the same length; its
   heading rule, that a heading carries the point rather than the topic; its
   list rules; and the instruction to call each thing by one name everywhere.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **Cursor `plugins`, `pstack/skills/unslop`**: same licence. Two of its rules
   are load-bearing here. Say what it does rather than how it feels, with its
   test: ask what the sentence tells the reader to do or know, restate it as a
@@ -44,6 +47,9 @@ Each licence below was read from the file named beside it.
   named above are kept in their positive form, not every rule in the catalogue,
   and the word list is left where it is, as something to review against rather
   than to load.
+  Revision: cursor/plugins@6ed0f7a9504f577d7529064103cecce9be7dfc5e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **`citypaul/.dotfiles`, `claude/.claude/skills/technical-writing`**: MIT,
   that skill's own nested `LICENSE`, "Copyright (c) 2025 Adam Bulmer", which
   governs its directory rather than the repository root's MIT licence in
@@ -63,6 +69,9 @@ Each licence below was read from the file named beside it.
   leads with the decision requested. And from `resources/formatting.md`, bold
   for the one phrase a skimmer must not miss, and a numbered list claiming that
   order matters.
+  Revision: citypaul/.dotfiles@a109f9972bb46671c624fc05752031523e1cf6fc
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **`mattpocock/skills`, `skills/in-progress/writing-shape`**: MIT,
   `mattpocock_skills/LICENSE`, "Copyright (c) 2026 Matt Pocock". The grounding
   idea, which nothing else in the sources has: every concept a block leans on
@@ -73,6 +82,9 @@ Each licence below was read from the file named beside it.
   drowns the opening. Its format arguments are also taken: prose carries an
   argument and lists carry parallel items, a table where the same shape repeats
   three times or more, and quoting where the original wording is the point.
+  Revision: mattpocock/skills@c55ee46073ed923f86ce59a5eb3b6d895095d1b7
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **`anthropics/skills`, `skills/internal-comms`**: Apache 2.0, that skill's
   own `LICENSE.txt`, "Copyright 2026 Anthropic, PBC." The only source here that
   is explicitly about audience, platform and register for non-engineering
@@ -83,11 +95,17 @@ Each licence below was read from the file named beside it.
   read is a constraint on the writing rather than a detail: something meant to
   be read in under a minute by people with some but not much context is a
   different piece from the same facts written to be landed on.
+  Revision: anthropics/skills@34040c9c568585f6929bedeaad110ad08f079624
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **`garrytan/gstack`, `document-generate/SKILL.md`**: MIT,
   `garrytan_gstack/LICENSE`, "Copyright (c) 2026 Garry Tan". Its voice section:
   lead with the point, be concrete, name the real thing and the real number.
   Its rule to gloss a piece of jargon on first use even where the user
   introduced the term.
+  Revision: garrytan/gstack@a6b3a57512ca6d5c6aa5b68f74f736195021f96e
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 - **`addyosmani/agent-skills`, `skills/doubt-driven-development`** and
   **`citypaul/.dotfiles`, `claude/.claude/skills/double-check`**: MIT,
   `addyosmani_agent-skills/LICENSE` ("Copyright (c) 2025 Addy Osmani") and
@@ -99,6 +117,12 @@ Each licence below was read from the file named beside it.
   than deferring, since a fresh reader can be wrong for want of context; and
   stop when a pass finds only small or known things, bounded at about three
   passes, with a piece still failing then reported as not ready.
+  Revision: addyosmani/agent-skills@dc27a9c2e13721158157632de61b4106c6c2a2a1
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
+  Revision: citypaul/.dotfiles@a109f9972bb46671c624fc05752031523e1cf6fc
+  (reconstructed: the research pack's 2026-09-20 clone the skills were built
+  from; the revision actually read was not recorded)
 
 **Left out on a licence.** `anthropics/skills`' `doc-coauthoring` has the best
 statement of reader testing in the corpus, but its directory holds no licence

package/src/cli.js

@@ -28,7 +28,7 @@ import { readRoster } from './roster.js';
 import { buildAgents, buildRules, CODEX_CAP } from './rules.js';
 import { addSkill, buildSkills, linkSkills, removeSkill } from './skills.js';
 import { addSource, fetchSources } from './sources.js';
-import { makeTemp, retireTemp } from './temp.js';
+import { makeTemp, retireTemp, trustHooks } from './temp.js';
 import { readUsage } from './usage.js';
 import { BOT_FATHER, bringUp, ownMailbox } from './up.js';
 
@@ -99,18 +99,25 @@ Usage:
   obk temp make --bots <path> --name <session>
                 (--prompt <text> | --prompt-file <path>) [--harness claude|codex]
                 [--model <m>] [--effort <e>] [--context <c>]
-                [--approval ${APPROVALS.join('|')}]
+                [--approval ${APPROVALS.join('|')}] [--extra-arg=<arg>]...
                             Run in a long-lived session's own tab: make a
                             temporary session of that session's bot for a piece
                             of work, and bring it up. It takes your harness,
                             model, effort, context and approval unless you say
-                            otherwise, works in work/<session>, and has the task
-                            as its start prompt. The book records it as
-                            temporary, made by you.
+                            otherwise; on another harness than yours it takes
+                            only your approval. It works in work/<session>, and
+                            has the task as its start prompt. The book records
+                            it as temporary, made by you.
   obk temp retire --bots <path> --name <session>
                             Run in the maker's own tab: retire a temporary
                             session it made, as obk retire does. It refuses a
                             long-lived session, or one another session made.
+  obk temp trust-hooks --bots <path> --name <session>
+                            Run in the maker's own tab: answer the hooks review
+                            of a Codex temporary session it made with "Trust
+                            all and continue", and check the review went. It
+                            refuses anything else on that screen, and types
+                            nothing then.
   obk rules build --bots <path> [--bot <bot>]
                             Build every bot's AGENTS.md from its charter and
                             the rule units it carries, or just the one you
@@ -190,7 +197,8 @@ Usage:
                             with its settings, its tab and the conversation it
                             is in. It reads your files and reports them as they
                             stand; what to make of them is yours.
-  obk groom --bots <path> [--on [--at <HH:MM>] | --at <HH:MM> | --off | --now | --compact]
+  obk groom --bots <path> [--on [--at <HH:MM>] [--run-on codex [--model <m>] [--effort <e>] [--extra-arg=<arg>]...]
+                | --at <HH:MM> | --off | --now | --compact]
                             Say what the daily grooming is: Bot Father's session
                             grooming, and the job scheduled in it on Claude
                             Code's own scheduler. Add that session like any
@@ -201,7 +209,11 @@ Usage:
                             day, so run it by hand once and read it first. --at
                             moves it, --off unschedules it, and --compact
                             compacts its conversation between runs. It fires
-                            only while its tab is up in Orca.
+                            only while its tab is up in Orca. --run-on codex
+                            makes each run a temporary Codex session of the
+                            grooming session's, launched with --model, --effort
+                            and --extra-arg, which reports back by the kit's
+                            mail and is retired.
   obk usage --bots <path> [--bot <bot>] [--session <name>] [--since <time>] [--until <time>]
                             Say what your sessions have used: the conversations
                             each one had, their calls and tokens (their
@@ -260,6 +272,7 @@ const COMMANDS = {
   'session mailbox': ['bots', 'bot', 'session'],
   'temp make': ['bots', 'name'],
   'temp retire': ['bots', 'name'],
+  'temp trust-hooks': ['bots', 'name'],
 };
 
 /** What each flag is for, in the sentence a caller reads when it is missing. */
@@ -333,6 +346,7 @@ async function run(argv) {
       disallow: { type: 'string', multiple: true },
       ...Object.fromEntries(SETTINGS.map(([flag]) => [flag, { type: 'string' }])),
       'extra-arg': { type: 'string', multiple: true },
+      'run-on': { type: 'string' },
       json: { type: 'boolean' },
       help: { type: 'boolean', short: 'h' },
       version: { type: 'boolean' },
@@ -601,6 +615,7 @@ const commands = {
       if (values[flag] !== undefined) given[key] = values[flag];
     }
     if (values.context !== undefined) given.context = asNumberOrText(values.context);
+    if (values['extra-arg'] !== undefined) given.extra_args = values['extra-arg'];
     const made = await makeTemp(bots, { tab, ...given });
     const { tabs, rules, skills, permissions, paused, projects } = made.up;
     const answer = { bots, bot: made.bot, session: made.session, maker: made.maker, settings: made.settings, created: [], completed: [], rules, skills, permissions, tabs, paused, projects };
@@ -625,6 +640,16 @@ const commands = {
     };
   },
 
+  async 'temp trust-hooks'(bots, values) {
+    const tab = callerTab(bots, true);
+    refuseWhenOrcaIsDown();
+    const trusted = await trustHooks(bots, { tab, name: values.name });
+    return {
+      answer: { bots, ...trusted },
+      lines: [`trusted    ${trusted.bot} ${trusted.session}'s hooks, a temporary session of ${trusted.maker}'s: chose "Trust all and continue" on its hooks review, and the review has gone`],
+    };
+  },
+
   'bot create'(bots, values) {
     const made = createBot(bots, { name: values.name, harness: values.harness, charter: values.charter });
     // The bot's AGENTS.md is the rules build's, here as everywhere else, so
@@ -821,7 +846,16 @@ const commands = {
     }
     // --at on its own moves grooming that is on to another time.
     const ask = asks[0] ?? (values.at === undefined ? undefined : 'move');
-    const groom = grooming(bots, { at: values.at, ask });
+    // What each run is launched with when it runs on Codex (#238): given only
+    // with --run-on, and refused by grooming() when it is not.
+    const given = ['run-on', 'model', 'effort', 'extra-arg'].some((flag) => values[flag] !== undefined);
+    const run = !given ? undefined : {
+      harness: values['run-on'],
+      ...(values.model === undefined ? {} : { model: values.model }),
+      ...(values.effort === undefined ? {} : { effort: values.effort }),
+      ...(values['extra-arg'] === undefined ? {} : { extra_args: values['extra-arg'] }),
+    };
+    const groom = grooming(bots, { at: values.at, ask, run });
     return { answer: { bots, groom }, lines: groomLines(groom, bots) };
   },
 
@@ -1275,6 +1309,7 @@ function jobLines(jobs, bots, head) {
     const [job] = jobs;
     return [
       `${head}  on, daily at ${job.at ?? job.cron}  job ${job.id}`,
+      ...(job.run === undefined ? [] : [`${more}Each run is a temporary ${job.run.harness} session: model ${job.run.model ?? `${job.run.harness}'s own`}, effort ${job.run.effort ?? `${job.run.harness}'s own`}.`]),
       `${more}Each run renews it; with no run, Claude Code ends it at ${job.expires}.`,
       `Turn it off:  ${groomCommand(bots)} --off`,
     ];

package/src/groom.js

@@ -25,12 +25,20 @@
 // asked for, or none. Run in any order, the last one typed is what holds
 // (review of PR #322).
 //
+// A job can make its runs on Codex instead (#238, PRD 6.8): the session stays the
+// Claude Code one, the clock and the reader, and at each fire it makes the run
+// as a temporary Codex session of its own (`obk temp make`), with the job's
+// model and effort on the run's launch line. The run does the grooming, sends
+// its report back by the kit's mail and is retired by the session, which first
+// retires any run an earlier fire left. What the runs are on is in the job's
+// prompt and nowhere else, so the kit reads it back from there.
+//
 // Claude Code ends a recurring job a week after it was made, so the job's own
 // prompt ends by renewing it. A renewal that fails either way shows here: no
 // job means the fleet has quietly stopped being groomed, two mean it is groomed
 // twice, and both are said plainly.
 
-import { existsSync, realpathSync } from 'node:fs';
+import { existsSync, mkdirSync, realpathSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
 import { botDir, readBot, requireBotsFolder } from './bot.js';
@@ -38,7 +46,7 @@ import { readBook } from './book.js';
 import { claudeTranscript } from './conversations.js';
 import { harnessOf, ownCli, shellWord } from './launch.js';
 import { tabs, tabToTypeInto, typeIntoTab } from './orca.js';
-import { BOT_FATHER } from './up.js';
+import { BOT_FATHER, promptPath } from './up.js';
 import { lines } from './usage.js';
 
 /** Bot Father's session the grooming runs in. */
@@ -50,6 +58,12 @@ const AT = /^([01]\d|2[0-3]):([0-5]\d)$/;
 /** A daily cron as the kit writes one: minute, hour, every day. */
 const DAILY = /^(\d{1,2}) (\d{1,2}) \* \* \*$/;
 
+/** The harnesses a job can make its runs on, besides running them in the session itself (#238). */
+const RUN_ON = ['codex'];
+
+/** The name each run is given, filled in by the session at the fire it makes it. */
+const RUN_NAME = 'groom-<YYYYMMDD-HHMM>';
+
 /** How long Claude Code keeps a recurring job after it was made (tech notes, section 2). */
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -79,8 +93,9 @@ export const markerOf = (bots) => `obk grooming for ${bots}`;
  * (or null), the grooming jobs alive in its conversation as the command found
  * them, before anything it typed was done, and what it typed (or null).
  */
-export function grooming(bots, { at, ask } = {}) {
+export function grooming(bots, { at, ask, run } = {}) {
   requireBotsFolder(bots);
+  refuseRun(run, ask);
 
   // The folder as the file system knows it: Claude Code files a transcript
   // under the real path, and Orca knows a tab's project by it.
@@ -108,7 +123,7 @@ export function grooming(bots, { at, ask } = {}) {
     ? groomingJobs(ofThisProcess(home, entry), markerOf(bots), Date.now())
     : [];
 
-  const line = ask === undefined ? undefined : lineFor(ask, { bots, session, jobs, at });
+  const line = ask === undefined ? undefined : lineFor(ask, { bots, session, jobs, at, run });
   if (line !== undefined) typeInto(bots, home, session, tab, line);
 
   // A move is turning it on at another time, and is typed as one.
@@ -120,7 +135,7 @@ export function grooming(bots, { at, ask } = {}) {
  * nothing to ask. Everything that makes the ask impossible refuses here, before
  * Orca is asked for anything.
  */
-function lineFor(ask, { bots, session, jobs, at }) {
+function lineFor(ask, { bots, session, jobs, at, run }) {
   // Nothing to turn off is an answer, unless a session is there to be told: an
   // `--on` typed a moment ago may still be waiting in its tab.
   if (ask === 'off' && jobs.length === 0 && !(session?.harness === 'claude' && session.up)) return undefined;
@@ -147,7 +162,28 @@ function lineFor(ask, { bots, session, jobs, at }) {
       ? `grooming is off, so there is no time to keep. Say when: ${groomCommand(bots)} --on --at <HH:MM>.`
       : `the grooming jobs there run at different times (${times.join(', ')}). Say which one to keep: ${groomCommand(bots)} --on --at <HH:MM>.`);
   }
-  return onLine(bots, cronOf(when), jobs);
+  // A move keeps what the runs are on, when every job there says the same.
+  const runs = [...new Set(jobs.map((job) => JSON.stringify(job.run ?? null)))];
+  const keep = ask === 'move' && runs.length === 1 ? JSON.parse(runs[0]) ?? undefined : undefined;
+  return onLine(bots, cronOf(when), jobs, run ?? keep);
+}
+
+/**
+ * Refuse what the run was given before anything else is looked at: its flags
+ * go with --on, --run-on takes codex, and a model, an effort or an extra
+ * argument is the run's, so it goes with --run-on codex.
+ */
+function refuseRun(run, ask) {
+  if (run === undefined) return;
+  if (run.harness === undefined) {
+    throw new Error('--model, --effort and --extra-arg are what each grooming run is launched with when it runs on Codex, and go with --run-on codex. The grooming session\'s own runs use its own settings. Nothing was typed.');
+  }
+  if (!RUN_ON.includes(run.harness)) {
+    throw new Error(`--run-on takes codex: grooming runs either in its Claude Code session, as it does without --run-on, or as a temporary Codex session made at each fire. Got: ${run.harness === '' ? 'nothing' : run.harness}. Nothing was typed.`);
+  }
+  if (ask !== 'on') {
+    throw new Error('--run-on says what the grooming runs are on, and goes with --on. Nothing was typed.');
+  }
 }
 
 /**
@@ -230,7 +266,8 @@ export function groomingJobs(entries, marker, now) {
       const { cron, prompt, recurring } = call.input ?? {};
       const made = Date.parse(entry.timestamp ?? '');
       if (recurring === false || typeof prompt !== 'string' || !prompt.startsWith(marker) || Number.isNaN(made)) continue;
-      alive.set(result.id, { id: result.id, at: timeOf(cron), cron, made, expires: made + WEEK_MS });
+      const run = runIn(prompt);
+      alive.set(result.id, { id: result.id, at: timeOf(cron), cron, made, expires: made + WEEK_MS, ...(run === undefined ? {} : { run }) });
     }
   }
   return [...alive.values()]
@@ -239,6 +276,32 @@ export function groomingJobs(entries, marker, now) {
     .map((job) => ({ ...job, made: new Date(job.made).toISOString(), expires: new Date(job.expires).toISOString() }));
 }
 
+/**
+ * What a job's runs are on, read out of its prompt: the harness, model and
+ * effort its \`temp make\` is given, each left out when it was not; undefined
+ * for a job whose runs are the session's own.
+ */
+function runIn(prompt) {
+  const make = / temp make ([^`]*)`/.exec(prompt);
+  if (make === null) return undefined;
+  const value = (flag) => {
+    const found = new RegExp(`(?:^| )--${flag}(?:=| )('[^']*'|\\S+)`).exec(make[1]);
+    return found === null ? undefined : found[1].replace(/^'(.*)'$/, '$1');
+  };
+  const run = { harness: value('harness') };
+  if (run.harness === undefined) return undefined;
+  for (const field of ['model', 'effort']) {
+    const got = value(field);
+    if (got !== undefined) run[field] = got;
+  }
+  // Each extra argument as the job wrote it, one shell word, read back to what
+  // it was given as, so a move keeps them all (review of PR #439).
+  const extra = [...make[1].matchAll(/(?:^| )--extra-arg=('(?:[^']|'\\'')*'|[A-Za-z0-9,._+:@%/=-]+)/g)]
+    .map((found) => (found[1].startsWith('\'') ? found[1].slice(1, -1).replaceAll(`'\\''`, '\'') : found[1]));
+  if (extra.length > 0) run.extra_args = extra;
+  return run;
+}
+
 /** `HH:MM` as the daily cron Claude Code takes: `04:00` is `0 4 * * *`. */
 const cronOf = (at) => {
   const [, hour, minute] = AT.exec(at);
@@ -268,11 +331,81 @@ const run = (bots) =>
  * fired with, so the job carries itself on; the one that fired is then the
  * older of the two.
  */
-const jobPrompt = (bots, cron) =>
-  `${run(bots)} When the report is sent, renew this schedule, which Claude Code ends a week after it was made: `
+const jobPrompt = (bots, cron, onRun) => (onRun === undefined
+  ? `${run(bots)} When the report is sent, ${renewal(cron)}`
+  // A run on Codex reports in a later turn, and may never: the job renews at
+  // the fire, once the run is made, so a run that never reports does not end
+  // the schedule with it (review of PR #439).
+  : `${runElsewhere(bots, onRun)} Then ${renewal(cron)} Then end your turn. ${readReport(bots)}`);
+
+/** The part of a job that renews it, which Claude Code would otherwise end a week after it was made. */
+const renewal = (cron) =>
+  'renew this schedule, which Claude Code ends a week after it was made: '
   + `call CronCreate with cron "${cron}", recurring true, and this whole prompt, word for word, as its prompt; `
   + `then call CronList and CronDelete every other job there whose prompt starts with "${PREFIX}".`;
 
+/**
+ * The part of a job whose runs are on Codex (#238): clear what an earlier run
+ * left, make this fire's run, and read its report when it comes. Each command
+ * is the kit by its own path, as the run above names it, because a Claude Code
+ * allow rule matches a command as written (#344). The run's task goes in a file
+ * the kit writes now, beside the bots folder, as it leaves every prompt.
+ */
+function runElsewhere(bots, onRun) {
+  const kit = shellWord(ownCli());
+  const folder = shellWord(bots);
+  const retire = `\`${kit} temp retire --bots ${folder} --name ${RUN_NAME}\``;
+  const make = [
+    `${kit} temp make --bots ${folder} --name ${RUN_NAME} --harness ${onRun.harness}`,
+    ...(onRun.model === undefined ? [] : [`--model ${shellWord(onRun.model)}`]),
+    ...(onRun.effort === undefined ? [] : [`--effort ${shellWord(onRun.effort)}`]),
+    ...(onRun.extra_args ?? []).map((arg) => `--extra-arg=${shellWord(arg)}`),
+    `--prompt-file ${shellWord(writeRunTask(bots))}`,
+  ].join(' ');
+  return `${markerOf(bots)}: the daily grooming for this fleet, run on ${onRun.harness} as a temporary session of yours `
+    + `that does the work and reports back to you. First, if any of your temporary sessions whose names start with groom- `
+    + `is still there (${BOT_FATHER}'s bot.yaml lists them), a run an earlier fire left, retire each with ${retire}, `
+    + `its own name in place of ${RUN_NAME}. Then make this fire's run with \`${make}\`, `
+    + `where ${RUN_NAME} is this fire's date and time. Its tab can stop on Codex's first-run screens: answer its folder trust `
+    + 'yourself, as the make\'s output and your rules say, and the review of its hooks with '
+    + `\`${kit} temp trust-hooks --bots ${folder} --name ${RUN_NAME}\`, its name in place of ${RUN_NAME}.`;
+}
+
+/** The part of a Codex job for the later turn its run's report comes in: read it, send it on, retire the run. */
+function readReport(bots) {
+  const retire = `\`${shellWord(ownCli())} temp retire --bots ${shellWord(bots)} --name ${RUN_NAME}\``;
+  const road = `\`${shellWord(ownCli())} message to --bots ${shellWord(bots)} --to ${BOT_FATHER}/<that session>\``;
+  // Claude Code's own messaging reaches every session on the machine, so a
+  // name that only looks right can be another fleet's session (#450).
+  return `When a line comes saying fleet mail from that run is waiting, read the mail the way the line says: it is the grooming report. `
+    + `Send it on, as it is, to ${BOT_FATHER}'s management session, as a grooming run's report goes: to exactly the address or mailbox `
+    + `${road} answers, and to no other. If your messaging does not list that address, send the report nowhere else, and say so. `
+    + `Then retire the run with ${retire}, its name in place of ${RUN_NAME}. Schedule nothing then: the job renewed itself when it fired.`;
+}
+
+/**
+ * Write the task a Codex run is started with, and answer where: do the daily
+ * grooming with the obk-grooming skill, send the report to the grooming session
+ * by the kit's mail, and stop. It schedules nothing: the schedule is the
+ * grooming session's.
+ */
+function writeRunTask(bots) {
+  const real = realHome(bots);
+  const kit = shellWord(ownCli());
+  const file = path.resolve(promptPath(real, BOT_FATHER, `${GROOMING}-run`));
+  const task = `You are one run of the daily grooming of the fleet in ${real}, made by ${BOT_FATHER}'s ${GROOMING} session. `
+    + 'Run the daily grooming for this fleet, with the obk-grooming skill. Fix this run\'s end now and read what has happened '
+    + `since the last run's end up to it, counting with ${kit} usage --since <last end> --until <this end>, and write this end down for the next run. `
+    + 'Work out what it cost with obk-finops, and keep each bot\'s profile notes. '
+    + `The kit here is ${kit}: run it wherever a skill says obk. The bots folder is ${real}. `
+    + `When the grooming is done, send one short report to ${BOT_FATHER}/${GROOMING} by the kit's mail: `
+    + `ask for the road with ${kit} message to --bots ${shellWord(real)} --to ${BOT_FATHER}/${GROOMING}, then send it with the message send command its answer names. `
+    + 'Then stop: schedule nothing, make no session, and say nothing more.\n';
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, task);
+  return file;
+}
+
 /**
  * The part of a line that clears the grooming jobs the session has when it runs
  * the line, which is not always what the kit saw when it typed it.
@@ -281,11 +414,11 @@ const clearing = (jobs) =>
   `call CronList, and call CronDelete on every job there whose prompt starts with "${PREFIX}"`
   + (jobs.length === 0 ? '' : ` (when this was typed they were ${jobs.map((job) => job.id).join(', ')})`);
 
-const onLine = (bots, cron, jobs) =>
+const onLine = (bots, cron, jobs, onRun) =>
   `obk groom asks you to schedule the daily grooming. First ${clearing(jobs)}. `
   + `Then call CronCreate once, with cron "${cron}", recurring true, and as its prompt everything after "Prompt:" `
   + 'at the end of this line, word for word. Do not run the grooming now; say in one line what you scheduled. '
-  + `Prompt: ${jobPrompt(bots, cron)}`;
+  + `Prompt: ${jobPrompt(bots, cron, onRun)}`;
 
 const offLine = (jobs) =>
   `obk groom asks you to turn the daily grooming off: ${clearing(jobs)}. `

package/src/health.js

@@ -25,7 +25,7 @@ import { bookFile, readBook, sessionIdsIn, tabIdsIn } from './book.js';
 import { botDir, botNames, botsDir, readBot, unknownKeys } from './bot.js';
 import { transcriptsIn } from './conversations.js';
 import { hookTrouble } from './hooks.js';
-import { bypassFlags, harnessOf, HARNESSES, ownCli, sessionTrouble, SHELL_ENV, shellWord } from './launch.js';
+import { bypassFlags, harnessOf, HARNESSES, isAddressOf, ownCli, sessionTrouble, SHELL_ENV, shellWord } from './launch.js';
 import { frontOfTab, orcaDefaultArgs, projects, tabs, wordsOfProcess } from './orca.js';
 import { permissionsTrouble } from './permissions.js';
 import { TAB_ENV } from './record.js';
@@ -259,7 +259,26 @@ function runningOn(bots, home, bot, book, handles, sessions) {
     // that is not its own harness, or a front that cannot be read, leaves it
     // unsaid, and nothing unsaid is a finding.
     const restart = `${shellWord(ownCli())} restart --bots ${shellWord(bots)} --bot ${bot.name} --session ${session.name}`;
+    // A Claude session is written to by its name, and Claude Code's own
+    // messaging reaches every session on the machine. One under a name the kit
+    // did not make, such as the bare <bot>.<session> every fleet had before
+    // #286, can be written to by another fleet's session (#450). Its next start
+    // through the kit gives it a name of its own; one that Orca brought back,
+    // or that has run since, keeps the old one until then.
     const front = frontOfTab(handle);
+    const address = entry.address;
+    if (harnessOf(session, bot.harness) === 'claude' && typeof address === 'string' && address !== '' && !isAddressOf(bot.name, session.name, address)) {
+      const shared = address === `${bot.name}.${session.name}`
+        ? `the name every fleet's ${bot.name}/${session.name} was given before #286, so it is shared: a Claude session of another fleet with that bot and session can write to it, thinking it is its own`
+        : `not one the kit made for it, so it may not be this session's alone: another session, in this fleet or another, can go by it too`;
+      // A restart closes the tab, and with no conversation in the book it
+      // refuses rather than end one that is running, so the fix starts there.
+      // With only the shell in front there is nothing to end, and it goes.
+      const fix = typeof entry.session === 'string' || front.front === 'shell'
+        ? `${restart} starts it on an address of its own, <bot>.<session> and a token.`
+        : `The book does not say which conversation it is running, and a restart refuses until it does: write the id into ${bookFile(home)} under ${session.name} as  session: <id>, then ${restart} starts it on an address of its own, <bot>.<session> and a token.`;
+      found.push(finding('session', bookFile(home), `${bot.name}'s session ${session.name} goes by the address ${address}, ${shared}. ${fix}`, bot.name));
+    }
     if (front.front === 'shell') {
       found.push(finding('session', entry.tab, `${bot.name}'s session ${session.name} is not running: its tab ${entry.tab} is open with only the tab's shell in front, so its harness quit or crashed. obk up finds the tab open and types nothing into it, so it does not bring the session back; ${restart} does.`, bot.name));
       continue;