@nanocollective/roster 0.1.0-alpha.4 → 0.1.0-alpha.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanocollective/roster",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.40",
   "description": "An agent-run org, powered by GitHub. Scaffold AI staff members whose brain is a repo.",
   "type": "module",
   "bin": {

package/templates/brain/.github/workflows/%%STAFF%%-daily.yaml

@@ -18,6 +18,12 @@ concurrency:
 
 jobs:
   session:
+    # The ceiling on what session.yaml's job token may do: reading the checkout, and the one
+    # comment that says a run failed when the App that would normally say so is what broke.
+    # A called workflow cannot raise these, so they have to be granted here.
+    permissions:
+      contents: read
+      issues: write
     uses: %%OPS_REPO%%/.github/workflows/session.yaml@main
     with:
       staff: %%STAFF%%

package/templates/brain/.github/workflows/%%STAFF%%-mention.yaml

@@ -53,6 +53,12 @@ jobs:
         (github.event_name == 'issues' &&
          contains(github.event.issue.body, '%%MENTION%%'))
       )
+    # The ceiling on what session.yaml's job token may do: reading the checkout, and the one
+    # comment that says a run failed when the App that would normally say so is what broke.
+    # A called workflow cannot raise these, so they have to be granted here.
+    permissions:
+      contents: read
+      issues: write
     uses: %%OPS_REPO%%/.github/workflows/session.yaml@main
     with:
       staff: %%STAFF%%

package/templates/brain/CHARTER.md

@@ -11,10 +11,10 @@ between %%MENTION%% and everyone else.
 Write it before the first unattended run. A generated charter would produce a generic agent,
 which is the failure this whole arrangement exists to avoid.
 
-Write it with your own AI:
+Write it with your own AI. This prints a brief to paste into whichever agent you use (in
+Claude Code it is also /charter, from inside this repo):
 
-    cd %%DIR%% && claude
-    /charter
+    roster brief charter %%STAFF%%
 
 Or write it by hand. The headings below are the shape that has worked; the words are yours.
 

package/templates/brain/README.md

@@ -10,6 +10,7 @@ on, and has decided.
 | `memory/INDEX.md` | One line per fact, read at every boot. |
 | `memory/notes/` | The argument behind a fact, read on demand. |
 | `log/decisions.md` | Why things were decided. Not boot context. |
+| `strategy/` | Longer role documents, and `ideas.md`: ideas parked here rather than filed as issues. |
 | `.github/workflows/` | Three callers. The body lives in `%%OPS_REPO%%`. |
 
 Scheduled runs and mentions are wired up by roster. To see what this staff member is actually

package/templates/brain/log/decisions.md

@@ -4,3 +4,6 @@ Why things were decided, newest first. Not boot context: this is read when a dec
 being revisited, not every morning.
 
 One entry per decision. What was decided, why, and what would change it back.
+
+This file holds the current month. Move anything older into `log/decisions/<YYYY-MM>.md`:
+`roster lint` warns past 24KB.

package/templates/brain/strategy/ideas.md

@@ -0,0 +1,7 @@
+# Ideas
+
+Speculative ideas, one line each, parked here rather than filed as issues. An issue is for
+something that needs a ruling; an idea that does not yet is noise on the tracker.
+
+Promote one to an issue when it serves a priority in `org/priorities.md` and needs a ruling.
+Delete one when it stops being interesting.

package/templates/briefs/priorities.md

@@ -0,0 +1,46 @@
+Write `org/priorities.md` for %%ORG_NAME%%.
+
+You are helping %%HUMAN%% decide what their AI staff should work on this month. Every staff
+member reads this file at the start of every run and picks work that serves it, so a vague
+priority produces scattered work.
+
+## Where you are
+
+- `%%OPS_REPO_DIR%%/org/business.md`: what the business is. **Read it first**, and don't ask
+  anything it already answers.
+- `%%OPS_REPO_DIR%%/org/priorities.md`: the current file, which you are replacing.
+
+If you cannot read files where you are running, ask %%HUMAN%% to paste `org/business.md`.
+
+## Interview
+
+Ask one question at a time. You are after:
+
+- **The one outcome that matters most this month**, and how they will know it happened.
+- **At most two more**, in order. Push back on a fourth: past three it is a wish list.
+- **What is out of scope this month**: work that is tempting but not now. Naming it is what
+  stops the staff doing it.
+
+Prefer outcomes ("a stranger pays for it") to activities ("improve the landing page"). If an
+answer is an activity, ask what it is for.
+
+## Write it
+
+Use exactly this shape:
+
+```
+## What matters this month
+
+### Priorities, in order
+
+1. The first outcome, and how you will know it happened.
+2. The second.
+3. The third.
+
+### Out of scope this month
+
+- One thing per line.
+```
+
+Keep each priority to a sentence or two. Don't add anything %%HUMAN%% didn't say without
+listing it after the file so they can check it.

package/templates/ops/.github/workflows/session.yaml

@@ -25,7 +25,7 @@ on:
         type: string
       model:
         required: false
-        default: claude-opus-5
+        default: claude-opus-5-5
         type: string
       timeout_minutes:
         required: false
@@ -69,11 +69,22 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: ${{ inputs.timeout_minutes }}
 
+    # `issues: write` is for the failure notice alone, which falls back to this job's own token
+    # when the App's cannot be minted. A called workflow cannot raise what its caller granted, so
+    # the callers ask for the same.
+    permissions:
+      contents: read
+      issues: write
+
     # secrets are not usable in a step-level `if`, so the presence check is hoisted here.
     env:
       HAS_PUBLIC_APP: ${{ secrets.PUBLIC_APP_ID != '' }}
 
     steps:
+      # For the run record at the end. A job has no start time of its own to read back.
+      - name: Start the clock
+        run: echo "ROSTER_STARTED=$(date +%s)" >> "$GITHUB_ENV"
+
       - name: Mint the private-tracker token
         id: private
         uses: actions/create-github-app-token@v2
@@ -161,6 +172,36 @@ jobs:
             echo "product: $repo -> $dir"
           done
 
+      # What people have open on the product repos, so the agent does not open competing work
+      # on files a human branch is rewriting. Read by "Compose the prompt" below; never
+      # fatal, because without it the prompt just has no section about it.
+      - name: Gather human work in flight
+        if: steps.plan.outputs.products != ''
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ steps.public.outputs.token || steps.private.outputs.token }}
+        run: node roster-ops/inflight.mjs --staff "${{ inputs.staff }}" --ops roster-ops --brains . --out .roster-run/inflight.md
+
+      # staff.yaml names the variable its prompts use for the public token (`public_token_env`),
+      # and an `env:` key cannot be an expression, so the name is exported here for every later
+      # step. PUBLIC_TOKEN is always set as well; this only adds the name the manifest chose.
+      - name: Export the public token under its manifest name
+        if: steps.public.outputs.token != ''
+        env:
+          BRAIN_DIR: ${{ steps.plan.outputs.brain_dir }}
+          TOKEN: ${{ steps.public.outputs.token }}
+        run: |
+          set -euo pipefail
+          name=$(sed -n 's/^public_token_env:[[:space:]]*//p' "$BRAIN_DIR/staff.yaml" | head -1 | tr -d "\"' ")
+          case "$name" in
+            ""|PUBLIC_TOKEN|GH_TOKEN|GITHUB_TOKEN) exit 0 ;;
+          esac
+          if ! [[ "$name" =~ ^[A-Z_][A-Z0-9_]*$ ]]; then
+            echo "::warning::public_token_env '$name' is not a variable name; only PUBLIC_TOKEN is set"
+            exit 0
+          fi
+          echo "$name=$TOKEN" >> "$GITHUB_ENV"
+
       # Commits read as the bot, not as a human, so the git history stays legible.
       - name: Set git identity
         env:
@@ -236,13 +277,12 @@ jobs:
       # `uses:` cannot be an expression, so an Action-based runner has to be written out
       # literally. This is the reference one; every other agent goes through the step below.
       - name: Run the session
+        id: session_action
         if: steps.agent.outputs.kind == 'action'
         uses: anthropics/claude-code-action@v1
         env:
           GH_TOKEN: ${{ steps.private.outputs.token }}
           PUBLIC_TOKEN: ${{ steps.public.outputs.token }}
-          # Kept as an alias while charters and memory still name it. Retire once they do not.
-          PIPWEB_TOKEN: ${{ steps.public.outputs.token }}
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN || secrets.AGENT_TOKEN }}
           # These repos are private and single-user, so the usual reason to hide a run's output does
@@ -264,11 +304,11 @@ jobs:
       # argument: it is thousands of words containing quotes and backticks, and argv limits and
       # shell quoting fail at 07:00 rather than in review.
       - name: Run the session
+        id: session_cli
         if: steps.agent.outputs.kind == 'cli'
         env:
           GH_TOKEN: ${{ steps.private.outputs.token }}
           PUBLIC_TOKEN: ${{ steps.public.outputs.token }}
-          PIPWEB_TOKEN: ${{ steps.public.outputs.token }}
           AGENT_MODEL: ${{ steps.agent.outputs.model || inputs.model }}
           AGENT_FLAGS: ${{ steps.agent.outputs.flags }}
           # Kept for a custom `run` written before permissions existed.
@@ -289,6 +329,10 @@ jobs:
           # an `env:` key cannot be an expression.
           export "$TOKEN_ENV=$TOKEN"
           export AGENT_PROMPT_FILE="$PWD/.roster-prompt.txt"
+          # Where an agent that can report its own turns and cost writes them. Optional: the
+          # run record reads it if it is there and records what it cannot know as unknown.
+          mkdir -p .roster-run
+          export AGENT_RESULT_FILE="$PWD/.roster-run/agent-result.json"
 
           if [ -n "$INSTALL" ]; then
             echo "::group::install ${{ steps.agent.outputs.id }}"
@@ -297,20 +341,70 @@ jobs:
           fi
           eval "$RUN"
 
-      # A failed unattended run is otherwise a red X in a tab nobody opens. New in the roster
-      # migration, and deliberate: every failure path should end somewhere a human reads.
+      # What this run was and what it cost, in the job summary and as an artifact with a stable
+      # name, which is what the portal's Runs screen and `roster doctor` read back. Never fatal:
+      # a missing record costs a row in a table, and failing the job over it would cost the run.
+      - name: Write down the run
+        if: always()
+        continue-on-error: true
+        env:
+          STAFF: ${{ inputs.staff }}
+          KIND: ${{ inputs.kind }}
+          AGENT_ID: ${{ steps.agent.outputs.id }}
+          MODEL: ${{ steps.agent.outputs.model || inputs.model }}
+          AGENT_OUTCOME: ${{ steps.session_action.outcome != 'skipped' && steps.session_action.outcome || steps.session_cli.outcome }}
+          JOB_STATUS: ${{ job.status }}
+          RESULT_FILE: ${{ steps.session_action.outputs.execution_file || format('{0}/.roster-run/agent-result.json', github.workspace) }}
+        run: node roster-ops/run-record.mjs --out .roster-run/run.json
+
+      - name: Keep the run record
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: roster-run
+          path: .roster-run/run.json
+          if-no-files-found: ignore
+
+      # A failed unattended run is otherwise a red X in a tab nobody opens, so every failure path
+      # has to end somewhere a human reads.
+      #
+      # It cannot lean on anything that might be what failed. The App token is the first thing a
+      # renamed repo, a rotated key or an uninstalled App breaks, and a canary sat red for twelve
+      # days because its alert used exactly that token. So: the App token when there is one, and
+      # this job's own token when there is not or it is refused. The plan may not have run
+      # either, so the brain repo falls back to the caller's, which is the same repo, and
+      # staff.yaml is read over the API when it was never checked out.
       - name: Say so if the run did not finish
         if: failure() || cancelled()
         env:
-          GH_TOKEN: ${{ steps.private.outputs.token }}
+          APP_TOKEN: ${{ steps.private.outputs.token }}
+          JOB_TOKEN: ${{ github.token }}
           BRAIN_DIR: ${{ steps.plan.outputs.brain_dir }}
-          BRAIN_REPO: ${{ steps.plan.outputs.brain_repo }}
+          BRAIN_REPO: ${{ steps.plan.outputs.brain_repo || github.repository }}
+          ISSUE: ${{ inputs.issue_number }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         run: |
-          set -euo pipefail
-          issue="${{ inputs.issue_number }}"
+          set -uo pipefail
+          issue="$ISSUE"
+          if [ -z "$issue" ] && [ -n "$BRAIN_DIR" ] && [ -f "$BRAIN_DIR/staff.yaml" ]; then
+            issue=$(sed -n 's/^status_issue:[[:space:]]*//p' "$BRAIN_DIR/staff.yaml" | head -1)
+          fi
+          if [ -z "$issue" ]; then
+            issue=$(GH_TOKEN="${APP_TOKEN:-$JOB_TOKEN}" gh api "repos/$BRAIN_REPO/contents/staff.yaml" \
+              -H "Accept: application/vnd.github.raw" 2>/dev/null \
+              | sed -n 's/^status_issue:[[:space:]]*//p' | head -1)
+          fi
+          issue="${issue%%[[:space:]#]*}"
           if [ -z "$issue" ]; then
-            issue=$(sed -n 's/^status_issue:[[:space:]]*//p' "$BRAIN_DIR/staff.yaml" | head -1 || true)
+            echo "::error::no status_issue in staff.yaml and no issue in the trigger, so nobody was told"
+            exit 1
+          fi
+
+          body="This run did not finish, so there is no answer coming. [Run ${GITHUB_RUN_ID}]($RUN_URL) has the error."
+          if [ -n "$APP_TOKEN" ] && GH_TOKEN="$APP_TOKEN" gh issue comment "$issue" --repo "$BRAIN_REPO" --body "$body"; then
+            exit 0
           fi
-          [ -n "$issue" ] || { echo "no status_issue in staff.yaml; nothing to comment on"; exit 0; }
-          gh issue comment "$issue" --repo "$BRAIN_REPO" --body \
-            "This run did not finish, so there is no answer coming. [Run ${{ github.run_id }}](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) has the error."
+          # Posted as github-actions rather than as the staff member, which is itself the clue.
+          GH_TOKEN="$JOB_TOKEN" gh issue comment "$issue" --repo "$BRAIN_REPO" --body \
+            "$body The staff member's own App could not post it, so check the App is installed on this repo and its APP_ID and APP_PRIVATE_KEY secrets are current."

package/templates/ops/agents.mjs

@@ -43,7 +43,7 @@ export const PRESETS = {
   "claude-code-action": {
     kind: "action",
     token_env: "CLAUDE_CODE_OAUTH_TOKEN",
-    model: "claude-opus-5",
+    model: "claude-opus-5-5",
     permissions: CLAUDE_TOOLS,
     option: (k, v) => `--${k} ${shellArg(v)}`,
   },
@@ -52,9 +52,13 @@ export const PRESETS = {
   claude: {
     kind: "cli",
     install: "npm install -g @anthropic-ai/claude-code",
-    run: 'claude -p --model "$AGENT_MODEL" $AGENT_FLAGS < "$AGENT_PROMPT_FILE"',
+    // JSON rather than text so the run record can read turns and cost off it. The log still
+    // carries the answer, inside the `result` field.
+    run:
+      'claude -p --model "$AGENT_MODEL" $AGENT_FLAGS --output-format json < "$AGENT_PROMPT_FILE"' +
+      ' | tee "$AGENT_RESULT_FILE"',
     token_env: "CLAUDE_CODE_OAUTH_TOKEN",
-    model: "claude-opus-5",
+    model: "claude-opus-5-5",
     permissions: CLAUDE_TOOLS,
     option: (k, v) => `--${k} ${shellArg(v)}`,
   },

package/templates/ops/compose.mjs

@@ -186,6 +186,12 @@ function parseScalar(raw, line) {
 
 const MAX_INCLUDE_DEPTH = 8;
 
+/* A partial's output is scanned again by the template that included it, so a value containing
+   `{{` would be rendered as though somebody had written it into a prompt: a PR title saying
+   `{{nope}}` failed the run, and one saying `{{> some/file}}` read that file in. Values are
+   fenced off with a character no template can contain, and let back out once, at the end. */
+const FENCE = "\u0000";
+
 export function render(template, ctx, readPartial, depth = 0) {
   if (depth > MAX_INCLUDE_DEPTH) throw new Error("include depth exceeded; a partial probably includes itself");
 
@@ -220,10 +226,10 @@ export function render(template, ctx, readPartial, depth = 0) {
       }
       throw new Error(`unknown or empty placeholder: {{${path}}}`);
     }
-    return String(v);
+    return String(v).replace(/\{\{/g, FENCE);
   });
 
-  return out;
+  return depth === 0 ? out.replaceAll(FENCE, "{{") : out;
 }
 
 function lookup(ctx, path) {
@@ -282,7 +288,7 @@ function defaultMarker(name) {
 // Composition
 // ---------------------------------------------------------------------------
 
-export function compose({ opsDir, brainsDir, staff, kind }) {
+export function compose({ opsDir, brainsDir, staff, kind, runDir }) {
   const org = parseYaml(readFileSync(join(opsDir, "org.yaml"), "utf8"), "org.yaml");
 
   const entry = (org.staff ?? []).find((s) => s.handle === staff);
@@ -317,6 +323,12 @@ export function compose({ opsDir, brainsDir, staff, kind }) {
   // sends it to a 404 before it has read anything. So the absence is a value of its own.
   if (Object.keys(event).length) event = { ...event, no_comment: !event.comment_id };
 
+  // What people have open on the product repos, gathered by inflight.mjs just before this runs.
+  // Read as a value and never rendered as a template: it is PR titles, which are a person's
+  // words, and a `{{` in one must not be able to break composition.
+  const inflightFile = join(runDir ?? join(brainsDir, ".roster-run"), "inflight.md");
+  const inflight = existsSync(inflightFile) ? readFileSync(inflightFile, "utf8").trim() : "";
+
   const humans = readHumans(org);
   const ctx = {
     org,
@@ -344,6 +356,7 @@ export function compose({ opsDir, brainsDir, staff, kind }) {
     // without the one the prose already names. Empty when there is only one, which is what
     // makes `{{#if humans_extra}}` the right way to mention the others at all.
     human_list: humanSentence(humans),
+    inflight,
     humans_extra: humanSentence(humans.slice(1)),
   };
 

package/templates/ops/inflight.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Finds the pull requests people have open on a staff member's product repos, before the prompt
+// is composed, so the agent knows what a human is in the middle of changing.
+//
+// Written because nothing told them. While a person had a long branch open rewriting a product's
+// copy, the staff opened five pull requests and nine issues chasing that same copy, and four of
+// those pull requests were overtaken by the branch. Each one was reasonable on its own; none of
+// them could see the branch.
+//
+// Vendored alongside compose.mjs for the same reason: it runs on the runner, and must not depend
+// on npm. It asks GitHub through `gh`, which every runner has, and it never fails a run: with no
+// answer the prompt simply has no section about it.
+//
+// Usage:  node roster-ops/inflight.mjs --staff cto --ops roster-ops --brains . --out .roster-run/inflight.md
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseYaml } from "./compose.mjs";
+
+/** Enough to see an overlap without reading a 37,000-line branch into the prompt. */
+const MAX_PRS = 10;
+const MAX_FILES = 20;
+const MAX_DIRS = 6;
+
+/**
+ * A person, rather than one of this org's Apps or anybody else's automation.
+ *
+ * `gh` marks an App author as a bot and names it `app/<slug>`; a bot's own login ends `[bot]`.
+ * A machine user is none of those, which is why the org's own bot logins are passed in too.
+ */
+export function isHuman(author, bots = []) {
+  if (!author) return false;
+  const login = String(author.login ?? "");
+  if (!login || author.is_bot) return false;
+  if (login.startsWith("app/") || /\[bot\]$/i.test(login)) return false;
+  const bare = (s) => String(s).toLowerCase().replace(/\[bot\]$/, "").replace(/^app\//, "");
+  return !bots.some((b) => bare(b) === bare(login));
+}
+
+/** The repos a staff member works in: their own `works_in`, or else every product repo. */
+export function productRepos(org, manifest) {
+  const own = (manifest?.works_in ?? []).map((w) => String(w?.repo ?? "")).filter(Boolean);
+  if (own.length) return own;
+  return (org.repos ?? []).filter((r) => r.role === "product").map((r) => `${org.org}/${r.name}`);
+}
+
+/** The top directories a change touches, so a wide one reads as "the copy" rather than a list. */
+function directories(paths) {
+  const counts = new Map();
+  for (const p of paths) {
+    const parts = p.split("/");
+    const dir = parts.length === 1 ? "(root)" : parts.slice(0, Math.min(2, parts.length - 1)).join("/") + "/";
+    counts.set(dir, (counts.get(dir) ?? 0) + 1);
+  }
+  return [...counts].sort((a, b) => b[1] - a[1]).slice(0, MAX_DIRS);
+}
+
+function days(iso, now) {
+  const d = Math.floor((now - new Date(iso).getTime()) / 86400_000);
+  return d <= 0 ? "today" : d === 1 ? "1 day" : `${d} days`;
+}
+
+/**
+ * The markdown the prompt carries, or "" for nothing in flight.
+ *
+ * Titles are a person's words and go in as data: compose.mjs substitutes this file as a value,
+ * never renders it as a template, so a `{{` in a title cannot break a run.
+ */
+export function describe(found, now = Date.now()) {
+  const lines = [];
+  for (const { repo, prs } of found) {
+    for (const pr of prs.slice(0, MAX_PRS)) {
+      const paths = (pr.files ?? []).map((f) => f.path).filter(Boolean);
+      const total = Math.max(pr.changedFiles ?? 0, paths.length);
+      const title = String(pr.title ?? "").replace(/\s+/g, " ").trim();
+      lines.push(
+        `- **${repo}#${pr.number}** "${title}" by @${pr.author.login}, open ${days(pr.createdAt, now)}` +
+          `, branch \`${pr.headRefName}\`${pr.isDraft ? ", draft" : ""}, ${total} file${total === 1 ? "" : "s"}`,
+      );
+      if (!paths.length) continue;
+      if (total > MAX_FILES) {
+        lines.push(`  - mostly under ${directories(paths).map(([d, n]) => `\`${d}\` (${n})`).join(", ")}`);
+      }
+      const shown = paths.slice(0, MAX_FILES).map((p) => `\`${p}\``).join(", ");
+      const more = total - Math.min(paths.length, MAX_FILES);
+      lines.push(`  - ${shown}${more > 0 ? `, and ${more} more` : ""}`);
+    }
+    if (prs.length > MAX_PRS) lines.push(`- and ${prs.length - MAX_PRS} more open on ${repo}`);
+  }
+  return lines.length ? lines.join("\n") + "\n" : "";
+}
+
+/** Everything open by a person, per repo. `gh` is passed in so a test never needs the network. */
+export function gather({ org, manifest, gh }) {
+  const bots = [manifest?.bot, manifest?.public_bot].filter(Boolean);
+  const out = [];
+  for (const repo of productRepos(org, manifest)) {
+    let raw;
+    try {
+      raw = gh([
+        "pr",
+        "list",
+        "--repo",
+        repo,
+        "--state",
+        "open",
+        "--limit",
+        "50",
+        "--json",
+        "number,title,author,createdAt,headRefName,isDraft,changedFiles,files",
+      ]);
+    } catch (err) {
+      // One unreadable repo is not a reason to say nothing about the others.
+      console.error(`::warning::inflight: ${repo}: ${String(err.message).split("\n")[0]}`);
+      continue;
+    }
+    const prs = JSON.parse(raw || "[]")
+      .filter((pr) => isHuman(pr.author, bots))
+      // Oldest first: the long-lived branch is the one most likely to be overtaking everybody.
+      .sort((a, b) => String(a.createdAt).localeCompare(String(b.createdAt)));
+    if (prs.length) out.push({ repo, prs });
+  }
+  return out;
+}
+
+function main(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i += 2) args[argv[i].replace(/^--/, "")] = argv[i + 1];
+  if (!args.staff) throw new Error("--staff is required");
+  const opsDir = resolve(args.ops ?? ".");
+  const org = parseYaml(readFileSync(join(opsDir, "org.yaml"), "utf8"), "org.yaml");
+  const entry = (org.staff ?? []).find((s) => s.handle === args.staff);
+  if (!entry) throw new Error(`org.yaml has no staff member "${args.staff}"`);
+  const manifestPath = join(resolve(args.brains ?? ".."), entry.dir ?? entry.handle, "staff.yaml");
+  const manifest = existsSync(manifestPath)
+    ? parseYaml(readFileSync(manifestPath, "utf8"), "staff.yaml")
+    : {};
+
+  const gh = (a) => execFileSync("gh", a, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  const text = describe(gather({ org, manifest, gh }));
+  const out = resolve(args.out ?? ".roster-run/inflight.md");
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, text);
+  process.stdout.write(text || "no human pull requests open on the product repos\n");
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  try {
+    main(process.argv.slice(2));
+  } catch (err) {
+    // Never the reason a run fails. Without it the prompt has no section, which is how every
+    // run went before this existed.
+    console.error(`::warning::inflight: ${err.message}`);
+  }
+}

package/templates/ops/org/operating.md

@@ -15,13 +15,33 @@ question instead of doing work has wasted its slot.
 - **Never end a run blocked.** If everything on the list is genuinely blocked, do the most useful
   unblocked thing you can find and say so in the report.
 
+## Choosing work
+
+- **Serve the priorities.** Work that serves none of the ranked priorities in `org/priorities.md`
+  waits, unless something is broken. Say which priority a PR serves.
+- **Product before process.** Guards, checks, claim-policing and measuring your own output earn a
+  run when they protect something that has shipped. Most runs should move the product forward; if
+  your last few went on meta-work, this one does not.
+
+## Keeping your tracker clean
+
+{{human.name}} should never have to ask whether an issue can be closed.
+
+- **Close your own issues** when the work is done or superseded, with one line naming what closed
+  it: the PR, the commit, or the issue that replaced it. Do not leave one open "in case".
+- **Sweep them on every daily run.** Read every open issue you opened; close what is finished or
+  stale, and fold duplicates into one.
+- **Ideas live in your brain, not on the tracker.** Park a speculative idea as one line in
+  `strategy/ideas.md`. Open an `IDEA:` issue only when it needs a ruling, and never more than one
+  at a time.
+
 ## What you may not do
 
 - **You cannot ship to the outside world.** Anything public goes through {{human.name}}. The gate is
   mechanical rather than a promise: protected branches mean you open a PR and their merge is the
   approval. **Do not look for a way around it.** Being unable to ship unreviewed is what earns the
   autonomy.
-- **Never close a `decision` issue.** Those are {{human.name}}'s rulings to close.
+- **Never close a `decision` issue**, even in a sweep. Those are {{human.name}}'s rulings to close.
 - **Never `git add -A` in another staff member's repo, or in a repo where a human may have work in
   flight.** Stage explicit paths. Doing otherwise has swept someone else's uncommitted work into an
   unrelated commit.

package/templates/ops/org/voice.md

@@ -12,6 +12,15 @@ bodies, run reports, briefs to other staff, and how you talk to them in a sessio
 - **An issue title is the ask, not the topic.**
 - **Say the default** on anything needing a ruling: what you do if they say nothing.
 
+**Length ceilings.** Lead with the outcome or the ask, then stop at:
+
+- **A comment or reply: 100 words.** Most need three lines.
+- **An issue or PR body: 200 words.**
+- **The pinned status issue: 300 words**, readable on one phone screen.
+
+Past the ceiling, the detail goes in a file in your brain and the comment links to it in one
+line. A status {{human.name}} has to rewrite before they can use it has cost more than it saved.
+
 **Cut on sight:**
 
 - Context they already have. They founded this; it does not need explaining to them.

package/templates/ops/prompts/_inflight.md

@@ -0,0 +1,14 @@
+{{#if inflight}}
+## Human work in flight
+
+People have these pull requests open on the product repos, and each one is theirs. A long-lived
+branch is usually rewriting what you would otherwise be about to change.
+
+- **Do not open competing work on files they touch**: no pull request, and no issue asking for a
+  change there. It gets overtaken when their branch lands, and it costs them a review first.
+- **If you have something to say about that work, say it on their pull request**, briefly, and
+  leave the decision to them.
+- If today's task sits on those files, say so in your report and take the next thing.
+
+{{inflight}}
+{{/if}}

package/templates/ops/prompts/_paths.md

@@ -5,7 +5,8 @@ repos sit side by side inside it:
 
 - `{{staff.dir}}/` - your brain. **Start by reading it.**
 - `{{ops.dir}}/` - the org's shared brain: `org/operating.md`, `org/voice.md`, `org/guardrails.md`,
-  `org/business.md`. **Read-only to you.** Propose a change as a PR; do not edit it in place.
+  `org/business.md`, `org/priorities.md`. **Read-only to you.** Propose a change as a PR; do not
+  edit it in place.
 {{#if peers}}
 {{peer_list}}
 {{/if}}