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

package/docs/writing-a-charter.md

@@ -15,26 +15,27 @@ particular, which takes longer to notice than no work at all.
 
 ## Write it with your own AI
 
-```bash
-roster brief charter <handle>
-```
+**Write the charter**, on that staff member's card on the [Staff screen](portal.md#staff), does
+the whole round trip. It copies a brief with every file it refers to already inside it, so a chat
+window with no filesystem is as useful as an agent standing in the repo. Paste the reply back
+into the box and you get a diff and a save button, never a silent write.
+
+It runs about 19,000 characters, on purpose: one paste into a large-context model beats six
+rounds of it asking for files it will never get.
 
-That prints a self-contained brief. Paste it into whatever agent you use, or pipe it:
-`roster brief charter cto | pbcopy`. In Claude Code, `cd <staff-dir> && claude` then
-`/charter` runs the same text, because `roster hire` generates the slash command from it.
+**The peers' charters are in there**, along with `org/business.md` and the shared operating
+layer. That is the part that matters most, because without them the model writes a second copy
+of whoever it was shown. The brief then interviews you, drafts from your answers, and tells you
+what it cut and why.
 
-**Or do the whole round trip in the portal.** *Write the charter* on that staff member's card
-copies the same brief with every file it refers to already inside it, including the peers'
-charters, so a chat window with no filesystem can do it. Paste the reply back and you get a diff
-and a save. See [the portal](portal.md).
+From a terminal, the same brief:
 
-The brief tells the agent to read `org/business.md`, the shared operating
-layer, and every peer's charter, then interviews you and drafts from your answers. It also tells
-you what it cut and why.
+```bash
+roster brief charter <handle>            # or: roster brief charter cto | pbcopy
+```
 
-There is nothing agent-specific in it. Claude Code gets a slash command because it is the
-reference runner and the shape happens to fit; everything else gets the same words from
-`roster brief`.
+In Claude Code, `cd <staff-dir> && claude` then `/charter` runs the same text, because `roster
+hire` generates the slash command from it. There is nothing agent-specific in any of it.
 
 ## What goes in it, and what does not
 
@@ -73,7 +74,7 @@ status issue, and the surfaces the manifest declares.
 
 ## Keep it agreeing with the manifest
 
-`roster lint` fails if the charter and `staff.yaml` disagree. The manifest is the
+Health, and `roster lint`, fail if the charter and `staff.yaml` disagree. The manifest is the
 machine-readable half of the same document: handle, schedule, peers, surfaces, identities. If
 the charter says it reviews pull requests on the product repo, `works_in` had better include it.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanocollective/roster",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "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

@@ -25,6 +25,7 @@ jobs:
       ops_repo: %%OPS_REPO%%
       model: %%MODEL%%
       timeout_minutes: %%TIMEOUT%%
+      allowed_tools: "%%ALLOWED_TOOLS%%"
     secrets:
       APP_ID: ${{ secrets.%%SECRET_PREFIX%%_APP_ID }}
       APP_PRIVATE_KEY: ${{ secrets.%%SECRET_PREFIX%%_APP_PRIVATE_KEY }}

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

@@ -30,20 +30,25 @@ concurrency:
 
 jobs:
   answer:
-    # Only the human, only on a real mention. A bot quoting the phrase must never wake the loop.
+    # Only a human this org answers to, only on a real mention. A bot quoting the phrase must
+    # never wake the loop.
+    #
+    # The list is every login in `org.yaml`'s `humans:` (or the singular `human:`), so a second
+    # founder can wake a staff member without their comment being dropped in silence. One human
+    # is a one-element list: the gate has a single shape whatever the org looks like.
     #
     # The outer gate is on `sender` — the account that performed the action — and not on the author
     # of the thing it acted on. That distinction is load-bearing on the `issues` route: the pinned
-    # status issue is opened by the human and then edited by this staff member on every run, so an
+    # status issue is opened by a human and then edited by this staff member on every run, so an
     # author check would let the agent's own edit wake another run, which would edit it again.
     #
     # One spelling of the mention is enough: GitHub's `contains` is documented as not case
     # sensitive, so this already matches an uppercase mention at the start of a sentence.
     if: >-
-      github.event.sender.login == '%%HUMAN%%' &&
+      contains(fromJSON('%%HUMAN_LOGINS%%'), github.event.sender.login) &&
       (
         (github.event_name == 'issue_comment' &&
-         github.event.comment.user.login == '%%HUMAN%%' &&
+         contains(fromJSON('%%HUMAN_LOGINS%%'), github.event.comment.user.login) &&
          contains(github.event.comment.body, '%%MENTION%%')) ||
         (github.event_name == 'issues' &&
          contains(github.event.issue.body, '%%MENTION%%'))
@@ -55,6 +60,7 @@ jobs:
       ops_repo: %%OPS_REPO%%
       model: %%MODEL%%
       timeout_minutes: %%MENTION_TIMEOUT%%
+      allowed_tools: "%%ALLOWED_TOOLS%%"
       issue_number: ${{ github.event.issue.number }}
       comment_id: ${{ github.event.comment.id }}
     secrets:

package/templates/brain/staff.yaml

@@ -13,7 +13,6 @@ schedule: "%%SCHEDULE%%"
 model: %%MODEL%%
 timeout_minutes: %%TIMEOUT%%
 mention_timeout_minutes: %%MENTION_TIMEOUT%%
-pr_mention_timeout_minutes: %%PR_MENTION_TIMEOUT%%
 
 bot: %%APP%%[bot]
 public_bot: %%PUBLIC_APP%%[bot]

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

@@ -15,7 +15,7 @@ on:
         required: true
         type: string
       kind:
-        description: "daily | mention | pr-mention"
+        description: "daily | mention"
         required: false
         default: daily
         type: string
@@ -29,13 +29,13 @@ on:
         type: string
       timeout_minutes:
         required: false
-        default: 60
+        default: 90
         type: number
       allowed_tools:
         required: false
         default: "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch"
         type: string
-      # Trigger context. Empty on a scheduled run; set when a comment or a PR woke us.
+      # Trigger context. Empty on a scheduled run; set when a comment woke us.
       issue_number:
         required: false
         default: ""
@@ -44,10 +44,6 @@ on:
         required: false
         default: ""
         type: string
-      pr_number:
-        required: false
-        default: ""
-        type: string
     secrets:
       APP_ID:
         required: true
@@ -102,9 +98,7 @@ jobs:
       # missed". It sits here, before any checkout, so the eyes land in seconds rather than after
       # the clones.
       #
-      # `mention` only. A pr-mention is already acknowledged by the forwarder in the public product
-      # repo, on the comment the human actually left, and reacting again here would put two on it.
-      # A daily run has nothing to react to.
+      # `mention` only: a daily run has nothing to react to.
       #
       # An `issues` payload carries no comment, so the eyes go on the issue itself. That is the
       # route where a mention is typed straight into the body of a new issue.
@@ -191,20 +185,6 @@ jobs:
             [ -d "$dir" ] && identify "$dir" "${PUBLIC_SLUG:-$PRIVATE_SLUG}"
           done
 
-      # A PR request is answered on the PR's own branch, never on a new one.
-      - name: Check out the PR branch
-        if: inputs.pr_number != ''
-        env:
-          GH_TOKEN: ${{ steps.public.outputs.token || steps.private.outputs.token }}
-          PRODUCT_DIR: ${{ steps.plan.outputs.product_dir }}
-          PRODUCT_REPO: ${{ steps.plan.outputs.product_repo }}
-        run: |
-          set -euo pipefail
-          [ -n "$PRODUCT_DIR" ] || { echo "no product repo to check a PR out of"; exit 1; }
-          cd "$PRODUCT_DIR"
-          gh pr checkout "${{ inputs.pr_number }}" --repo "$PRODUCT_REPO"
-          echo "on $(git branch --show-current)"
-
       - uses: pnpm/action-setup@v6
         if: steps.plan.outputs.needs_node == 'true'
         with:
@@ -226,7 +206,6 @@ jobs:
           ROSTER_CONTEXT: >-
             {"issue_number":"${{ inputs.issue_number }}",
              "comment_id":"${{ inputs.comment_id }}",
-             "pr_number":"${{ inputs.pr_number }}",
              "repo":"${{ github.repository }}",
              "actor":"${{ github.actor }}"}
         run: |
@@ -274,9 +253,11 @@ jobs:
           # No --max-turns. A run that legitimately needs more turns should get them: capping it
           # fails the action *after* the work is done and committed, which is a false red rather
           # than a saved penny. timeout-minutes is the real bound.
+          # The permission flags come from agents.mjs, which is the only thing that knows
+          # which agent is running and therefore how to say "may write" to it.
           claude_args: >-
             --model ${{ inputs.model }}
-            --allowedTools "${{ inputs.allowed_tools }}"
+            ${{ steps.agent.outputs.flags }}
           prompt: ${{ steps.compose.outputs.text }}
 
       # Any agent with a command line. The prompt is handed over as a file, never as an
@@ -289,6 +270,8 @@ jobs:
           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.
           AGENT_TOOLS: ${{ inputs.allowed_tools }}
           AGENT_TOKEN: ${{ secrets.AGENT_TOKEN }}
           FALLBACK_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

package/templates/ops/agents.mjs

@@ -24,6 +24,19 @@ import { parseYaml } from "./compose.mjs";
  * `uses:` cannot be an expression. Only the reference Claude runner is one of these.
  * `cli` is everything else: install a package, run a command. That path is open-ended.
  */
+/* Claude says what an agent may do as a list of its own tool names. The three levels are the
+   same list narrowed: everything, everything but the network, and nothing that writes. */
+const CLAUDE_TOOLS = {
+  full: '--allowedTools "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch"',
+  workspace: '--allowedTools "Bash,Read,Write,Edit,Glob,Grep"',
+  "read-only": '--allowedTools "Read,Glob,Grep,WebFetch,WebSearch"',
+};
+
+/** Single quotes, because every one of these ends up inside `eval` in the session. */
+function shellArg(v) {
+  return `'${String(v).replace(/'/g, "'\\''")}'`;
+}
+
 export const PRESETS = {
   // The reference runner, and the default. Uses Anthropic's own action, which handles tool
   // permissions and output for us.
@@ -31,15 +44,19 @@ export const PRESETS = {
     kind: "action",
     token_env: "CLAUDE_CODE_OAUTH_TOKEN",
     model: "claude-opus-5",
+    permissions: CLAUDE_TOOLS,
+    option: (k, v) => `--${k} ${shellArg(v)}`,
   },
 
   // The same agent through its plain CLI, for anyone who would rather not depend on the action.
   claude: {
     kind: "cli",
     install: "npm install -g @anthropic-ai/claude-code",
-    run: 'claude -p --model "$AGENT_MODEL" --allowedTools "$AGENT_TOOLS" < "$AGENT_PROMPT_FILE"',
+    run: 'claude -p --model "$AGENT_MODEL" $AGENT_FLAGS < "$AGENT_PROMPT_FILE"',
     token_env: "CLAUDE_CODE_OAUTH_TOKEN",
     model: "claude-opus-5",
+    permissions: CLAUDE_TOOLS,
+    option: (k, v) => `--${k} ${shellArg(v)}`,
   },
 
   codex: {
@@ -47,20 +64,66 @@ export const PRESETS = {
     install: "npm install -g @openai/codex",
     // `exec -` reads the prompt from stdin. The sandbox has to be opened up because the whole
     // point of a session is that it edits the checkout and pushes.
-    run: 'codex exec - --model "$AGENT_MODEL" --sandbox danger-full-access < "$AGENT_PROMPT_FILE"',
+    run: 'codex exec - --model "$AGENT_MODEL" $AGENT_FLAGS < "$AGENT_PROMPT_FILE"',
     token_env: "CODEX_API_KEY",
     model: "gpt-5-codex",
+    /* Codex spells freedom as a sandbox plus an approval policy, and both have to be said:
+       a sandbox that allows writes still stops to ask by default, and a run that stops to ask
+       at 07:00 is a run that times out having done nothing. */
+    permissions: {
+      full: '--sandbox danger-full-access -c approval_policy="never"',
+      workspace: '--sandbox workspace-write -c approval_policy="never"',
+      "read-only": '--sandbox read-only -c approval_policy="never"',
+    },
+    // `-c key=value` is its highest-precedence override, so anything else goes through it.
+    option: (k, v) => `-c ${k}=${shellArg(JSON.stringify(v))}`,
   },
 
   nanocoder: {
     kind: "cli",
     install: "npm install -g @nanocollective/nanocoder",
-    // `run` is its non-interactive mode; --trust-directory skips the first-run prompt that
-    // would otherwise hang a runner, and --plain avoids the TUI. The prompt is an argument
-    // here rather than stdin, so it is read out of the file.
-    run: 'nanocoder --model "$AGENT_MODEL" --mode yolo --trust-directory --plain run "$(cat "$AGENT_PROMPT_FILE")"',
+    /* `run` is its non-interactive mode; --trust-directory skips the first-run prompt that
+       would otherwise hang a runner, and --plain avoids the TUI. The prompt is an argument
+       here rather than stdin, so it is read out of the file.
+
+       NANOCODER_PROVIDERS_FILE is the part that makes it work unattended. Nanocoder is a
+       client, not a model: it reads its providers from `agents.config.json` found in the
+       working directory. In a session that directory is the workspace root — the place the
+       repos are checked out *into* — which belongs to no repo, so a committed config would
+       never be found. Pointing at the ops repo's copy gives every staff member the same
+       providers from a file that is version controlled. A missing file is ignored, so this is
+       safe when somebody has configured it another way. */
+    run:
+      'NANOCODER_PROVIDERS_FILE="${NANOCODER_PROVIDERS_FILE:-roster-ops/agents.config.json}" ' +
+      'nanocoder --model "$AGENT_MODEL" $AGENT_FLAGS --trust-directory --plain run "$(cat "$AGENT_PROMPT_FILE")"',
     token_env: "NANOCODER_API_KEY",
     model: "",
+    /* Its development modes. `plan` is genuinely read-only: it reasons and proposes and edits
+       nothing, which is the right answer for a staff member you are not ready to trust yet. */
+    permissions: {
+      full: "--mode yolo",
+      workspace: "--mode auto-accept",
+      "read-only": "--mode plan",
+    },
+    option: (k, v) => `--${k} ${shellArg(v)}`,
+    /* A client rather than a model, so it cannot run until it has been told whose model to
+       call. Written on init and reported by doctor when it is missing, because the failure
+       without it is a run that installs, starts, finds no provider and exits. */
+    config: {
+      path: "agents.config.json",
+      contents: {
+        nanocoder: {
+          providers: [
+            {
+              name: "openrouter",
+              baseUrl: "https://openrouter.ai/api/v1",
+              apiKey: "${NANOCODER_API_KEY}",
+              models: ["FILL IN: a model this provider serves, and set it as `model` in org.yaml"],
+            },
+          ],
+        },
+      },
+    },
   },
 };
 
@@ -96,9 +159,60 @@ export function resolveAgent(org, staff = {}) {
     token_env: merged.token_env,
     // The staff member's own model wins; then the agent's default. Empty means "the agent's".
     model: staff.model ?? merged.model ?? "",
+    flags: flagsFor(merged, spec, org, staff),
+    config: merged.config ?? null,
   };
 }
 
+/** The three levels, in the order a person would climb them. */
+export const LEVELS = ["read-only", "workspace", "full"];
+
+/**
+ * What the agent is allowed to do, in its own words.
+ *
+ * org.yaml says `permissions: full` and every agent hears something different: Claude a list
+ * of tool names, Codex a sandbox and an approval policy, nanocoder a development mode. The
+ * translation lives here because it is the only place that knows which agent is running, and
+ * because the alternative is a config file written in one tool's vocabulary that quietly means
+ * nothing to the other two.
+ *
+ * `options` is the escape hatch, in that agent's own vocabulary, spelled onto its command line
+ * by the preset. Anything roster does not model is still reachable without waiting for us.
+ */
+function flagsFor(merged, spec, org, staff) {
+  const out = [];
+  const asked = staff.permissions ?? spec.permissions ?? org.permissions ?? "full";
+  if (!LEVELS.includes(asked)) {
+    throw new Error(`unknown permissions "${asked}". One of: ${LEVELS.join(", ")}`);
+  }
+
+  /* `allowed_tools` predates the levels and is Claude's own vocabulary, so it still wins for
+     an agent that takes a tool list. Nothing translates it for the others: a list written for
+     one tool is not a permission level for another, and guessing would be worse than saying so. */
+  const tools = staff.allowed_tools ?? org.defaults?.allowed_tools;
+  const table = merged.permissions;
+  if (tools && table === CLAUDE_TOOLS) {
+    const list = Array.isArray(tools) ? tools.join(",") : String(tools);
+    out.push(`--allowedTools "${list.replace(/\s+/g, "")}"`);
+  } else if (table) {
+    out.push(table[asked]);
+  }
+
+  const options = { ...(spec.options ?? {}), ...(staff.options ?? {}) };
+  const speller = merged.option;
+  for (const [k, v] of Object.entries(options)) {
+    if (v === undefined || v === null || v === "") continue;
+    if (!speller) {
+      throw new Error(
+        `agent "${merged.id ?? "custom"}" has options but no way to spell them.\n` +
+          "  A custom agent takes its options in its own `run` command.",
+      );
+    }
+    out.push(speller(k, v));
+  }
+  return out.filter(Boolean).join(" ");
+}
+
 function strip(o) {
   const out = {};
   for (const [k, v] of Object.entries(o)) if (v !== undefined && v !== null && v !== "") out[k] = v;
@@ -138,6 +252,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     `model=${agent.model}`,
     `install<<AGENT_EOF_9c1f\n${agent.install}\nAGENT_EOF_9c1f`,
     `run<<AGENT_EOF_9c1f\n${agent.run}\nAGENT_EOF_9c1f`,
+    `flags<<AGENT_EOF_9c1f\n${agent.flags}\nAGENT_EOF_9c1f`,
   ].join("\n");
   process.stdout.write(out + "\n");
 }

package/templates/ops/compose.mjs

@@ -212,9 +212,9 @@ export function render(template, ctx, readPartial, depth = 0) {
       if (path.startsWith("event.")) {
         throw new Error(
           `{{${path}}} needs trigger context, which arrives as ROSTER_CONTEXT.\n` +
-            `  A "mention" or "pr-mention" prompt is written for a comment that woke it, so it cannot\n` +
+            `  A "mention" prompt is written for the comment that woke it, so it cannot\n` +
             `  be composed without one. To see it locally:\n` +
-            `    ROSTER_CONTEXT='{"issue_number":"1","comment_id":"1","pr_number":"1","repo":"o/r"}' \\\n` +
+            `    ROSTER_CONTEXT='{"issue_number":"1","comment_id":"1","repo":"o/r"}' \\\n` +
             `      node compose.mjs --staff <handle> --kind <kind>`,
         );
       }
@@ -234,6 +234,50 @@ function truthy(v) {
   return !(v === undefined || v === null || v === false || v === "" || (Array.isArray(v) && v.length === 0));
 }
 
+// ---------------------------------------------------------------------------
+// Who the staff answer to
+//
+// One person was written as `human:`. More than one is a `humans:` list. Both are read, the
+// singular still works, and the first entry is the one the prose addresses. Duplicated in
+// roster's own src/lib/humans.ts rather than imported, for the same reason the YAML parser
+// above is: a run must not depend on npm or on a network call.
+// ---------------------------------------------------------------------------
+
+export function readHumans(org) {
+  const listed = Array.isArray(org?.humans) ? org.humans : org?.humans ? [org.humans] : [];
+  const out = [];
+  for (const entry of [...listed, org?.human].filter(Boolean)) {
+    const github = String(entry.github ?? entry.login ?? "").trim();
+    const name = String(entry.name ?? github).trim();
+    if (!github && !name) continue;
+    if (github && out.some((h) => h.github.toLowerCase() === github.toLowerCase())) continue;
+    out.push({
+      github,
+      name: name || github,
+      marker: String(entry.marker ?? "").trim() || defaultMarker(name || github),
+      role: entry.role ?? undefined,
+    });
+  }
+  return out;
+}
+
+/** "Will (@will-lamerton) and Sam (@sam)", for a sentence in a prompt. */
+export function humanSentence(humans) {
+  const parts = humans.map((h) => (h.github ? `${h.name} (@${h.github})` : h.name));
+  if (parts.length < 2) return parts[0] ?? "";
+  return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+}
+
+function defaultMarker(name) {
+  return (
+    String(name)
+      .trim()
+      .split(/[\s-]+/)[0]
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, "") || "human"
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Composition
 // ---------------------------------------------------------------------------
@@ -268,10 +312,18 @@ export function compose({ opsDir, brainsDir, staff, kind }) {
     }
   }
 
+  // The `issues` route carries no comment: the ask is the body of a new issue. There is no
+  // `{{#unless}}`, and a prompt that tells an agent to read comment `` as its first instruction
+  // 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 };
+
+  const humans = readHumans(org);
   const ctx = {
     org,
     event,
-    human: org.human,
+    // The first is who the prose addresses; `humans` is everybody the mention gate accepts.
+    human: humans[0] ?? org.human,
+    humans,
     ops: { dir: org.ops_dir ?? "roster-ops" },
     // `dir` lives in the org registry (it is where the checkout lands), everything
     // else lives in the staff member's own manifest.
@@ -288,6 +340,11 @@ export function compose({ opsDir, brainsDir, staff, kind }) {
     // Convenience strings the fragments lean on, computed once here so a
     // fragment never has to do string work.
     peer_list: peers.map((p) => `- \`${p.dir}/\` - the ${p.name}'s brain`).join("\n"),
+    // Everybody who can wake this staff member and rule on their work, and the same list
+    // 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),
+    humans_extra: humanSentence(humans.slice(1)),
   };
 
   // "staff:foo.md" resolves inside the staff member's own brain repo, which is how a
@@ -315,7 +372,7 @@ function main(argv) {
     args[argv[i].slice(2)] = argv[i + 1];
   }
   if (!args.staff || !args.kind) {
-    console.error("usage: node compose.mjs --staff <handle> --kind <daily|mention|pr-mention> [--ops DIR] [--brains DIR]");
+    console.error("usage: node compose.mjs --staff <handle> --kind <daily|mention> [--ops DIR] [--brains DIR]");
     process.exit(2);
   }
   const opsDir = resolve(args.ops ?? HERE);

package/templates/ops/org/operating.md

@@ -26,12 +26,6 @@ question instead of doing work has wasted its slot.
   flight.** Stage explicit paths. Doing otherwise has swept someone else's uncommitted work into an
   unrelated commit.
 
-## Notifications, and why they matter
-
-**Anything that needs {{human.name}} must @-mention `@{{human.github}}`.** They get no notification
-otherwise, and GitHub does not notify you about your own comments. Assigning also notifies: on a
-`decision` issue, do both.
-
 ## The repo is your memory
 
 Your chat history is wiped between runs. Your persona, your plan and everything you have learned

package/templates/ops/prompts/_identity.md

@@ -4,7 +4,14 @@ You post as **`{{staff.bot}}`** on the private trackers, not as {{human.name}}.
 authenticated as that app via `GH_TOKEN`.
 
 **Anything that needs {{human.name}} must @-mention `@{{human.github}}`.** They get no notification
-otherwise. Assigning also notifies; do both on `decision` issues.
+otherwise, and GitHub does not notify you about your own comments. Assigning also notifies; do both
+on `decision` issues.
+
+{{#if humans_extra}}
+{{humans_extra}} can also wake you and rule on your work, and a ruling from any of them is as
+binding as one from {{human.name}}. Reply to whoever asked; address a new `decision` issue to the
+person it is actually for.
+{{/if}}
 
 {{#if staff.product}}
 For anything touching **`{{staff.product.repo}}`**, which is public, use the anonymous identity

package/templates/ops/prompts/mention.md

@@ -1,5 +1,5 @@
-You are **{{staff.name}}** at {{org.name}}. {{human.name}} has asked you something directly, in a
-comment on your tracker. **Your reply in that thread is the only thing they will see.**
+You are **{{staff.name}}** at {{org.name}}. {{human.name}} has asked you something directly, on
+your tracker. **Your reply in that thread is the only thing they will see.**
 
 **This is not a session.** No boot ritual, no handoff, no rewriting #{{staff.status_issue}}. Answer
 the question or do the small thing asked, reply, stop.
@@ -10,6 +10,7 @@ the question or do the small thing asked, reply, stop.
 
 ## The request
 
+{{#if event.comment_id}}
 **Issue #{{event.issue_number}} on `{{event.repo}}`, comment `{{event.comment_id}}`.** Read it
 first, in full, including the thread around it - a request that looks simple usually has the real
 ask two comments up.
@@ -18,6 +19,19 @@ ask two comments up.
 gh api repos/{{event.repo}}/issues/comments/{{event.comment_id}} --jq .body
 gh api repos/{{event.repo}}/issues/{{event.issue_number}}/comments --jq '.[] | .user.login + ": " + .body'
 ```
+{{/if}}
+{{#if event.no_comment}}
+**Issue #{{event.issue_number}} on `{{event.repo}}`.** The ask is in the body of the issue
+itself - nobody has commented. Read it first, in full, and read any thread under it.
+
+```
+gh api repos/{{event.repo}}/issues/{{event.issue_number}} --jq .body
+gh api repos/{{event.repo}}/issues/{{event.issue_number}}/comments --jq '.[] | .user.login + ": " + .body'
+```
+
+An issue opened this way often carries a pull request somewhere else, and says where to answer.
+**If it does, that instruction wins over everything below about replying here.**
+{{/if}}
 
 `gh issue view --comments` is broken; use `gh api` as above.