create-open-autonomy 2.3.11 → 2.4.0

package/README.md

@@ -29,8 +29,8 @@ CHANGELOG.md         what shipped
 AGENTS.md            the agent's rules for this repository
 LICENSE              Apache-2.0, seeded; the project's own
 package.json, test/  the project's own check (`bun run check`), starting with one test
-hermes/              the agent: SOUL.md, its two skills (develop, pm; a project's own skills live beside them, in hermes/skills/<project>/, and are the project's), profiles/treasurer (the second profile: the one that pays), kanban.seed.json (the board's first tasks, in order),
-                     cron/jobs.seed.json (the PM, hourly), config.yaml (the model: the project's own choice), the seed hook
+hermes/              the agent: SOUL.md, its three skills (develop, pm, community; a project's own skills live beside them, in hermes/skills/<project>/, and are the project's), profiles/treasurer (the second profile: the one that pays), kanban.seed.json (the board's first tasks, in order),
+                     cron/jobs.seed.json (the PM, hourly; the community desk, every quarter hour), config.yaml (the model: the project's own choice), the seed hook
 .open-autonomy/      the platform connection: config.yaml (account, publish policy, the model and rail bounds the platform holds the project's funds to), reporter.ts (the publisher:
                      sessions, the board, the setup), mint-key.ts (the key, the adopter way), start.ts (the agent's four
                      processes, the one way it starts), the vendored SDK, kit.json (which kit, version and parameters made this repository)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-open-autonomy",
-  "version": "2.3.11",
+  "version": "2.4.0",
   "description": "The default Open Autonomy starter kit: a complete repository that runs its own Hermes agent against the platform, with the SDK wired in. `bun create open-autonomy <dir>` scaffolds one.",
   "license": "Apache-2.0",
   "repository": {

package/src/kit.ts

@@ -9,7 +9,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 
-export const KIT = { name: 'hermes', version: '2.3.11' } as const;
+export const KIT = { name: 'hermes', version: '2.4.0' } as const;
 export const KIT_FILE = '.open-autonomy/kit.json';
 const TEMPLATE = resolve(import.meta.dir, '..', 'template');
 
@@ -18,8 +18,8 @@ export interface KitRecord { kit: string; version: string; params: KitParams; di
 
 // What the kit keeps current. Everything else in the template is seeded once.
 // A project's own, seeded once: its config (the treasurer's too: the model is the project's choice for both profiles),
-// its board seed, its schedule, and any skill of its own outside hermes/skills/open-autonomy/ (the kit's two).
-const OWNED = [/^hermes\/(?!config\.yaml$|kanban\.seed\.json$|cron\/jobs\.seed\.json$|profiles\/treasurer\/config\.yaml$|skills\/(?!open-autonomy\/))/, /^\.open-autonomy\/(reporter\.ts|mint-key\.ts|start\.ts|package\.json|sdk\/)/, /^container\//, /^\.github\/workflows\/(ci|land)\.yml$/];
+// its board seed, its schedule, and any skill of its own outside hermes/skills/open-autonomy/ (the kit's three).
+const OWNED = [/^hermes\/(?!config\.yaml$|kanban\.seed\.json$|cron\/jobs\.seed\.json$|profiles\/treasurer\/config\.yaml$|skills\/(?!open-autonomy\/))/, /^\.open-autonomy\/(reporter\.ts|mint-key\.ts|start\.ts|community\.ts|package\.json|sdk\/)/, /^container\//, /^\.github\/workflows\/(ci|land)\.yml$/];
 export const isOwned = (rel: string): boolean => OWNED.some((re) => re.test(rel));
 
 export function validateParams(p: Partial<KitParams>): KitParams {

package/template/.open-autonomy/community.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+// The community desk's doors, from the shell: this repository's issues and discussions on GitHub, through the API
+// the environment names — GITHUB_API_URL and GITHUB_TOKEN. In the running stack that is the valve's GitHub port and
+// the word `valve`: the agent's own GitHub App answers, its key never here. Issues over REST; discussions over
+// GraphQL, the only API GitHub serves them on.
+//
+//   bun .open-autonomy/community.ts poll                          # every issue, comment and discussion since the
+//                                                                 # last look: NEW lines, then COMMUNITY_POLL_DONE
+//   bun .open-autonomy/community.ts comment <issue> <text…>       # a comment on an issue
+//   bun .open-autonomy/community.ts discuss <discussion> <text…>  # a comment on a discussion
+//   bun .open-autonomy/community.ts mark                          # the last look is now
+//
+// The cursor lives in the agent's home ($HERMES_HOME/community-cursor.json), else beside the project.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const api = (process.env.GITHUB_API_URL ?? 'https://api.github.com').replace(/\/$/, '');
+const token = process.env.GITHUB_TOKEN ?? '';
+if (!token) { console.error('community: no GITHUB_TOKEN — the desk has no GitHub door (a github-app.json beside the keys gives it one through the valve)'); process.exit(3); }
+const project = resolve(import.meta.dir, '..');
+const account = /^account:\s*(\S+)/m.exec(readFileSync(resolve(project, '.open-autonomy', 'config.yaml'), 'utf8'))?.[1] ?? '';
+if (!account) throw new Error('community: .open-autonomy/config.yaml names no account');
+const [owner, name] = account.split('/');
+const cursorFile = resolve(process.env.HERMES_HOME ?? project, process.env.HERMES_HOME ? 'community-cursor.json' : '.community-cursor.json');
+const cursor = (): string => (existsSync(cursorFile) ? (JSON.parse(readFileSync(cursorFile, 'utf8')) as { since: string }).since : '1970-01-01T00:00:00Z');
+const headers = { authorization: `Bearer ${token}`, accept: 'application/vnd.github+json', 'content-type': 'application/json' };
+async function github<T>(method: string, path: string, body?: unknown): Promise<T> {
+  const res = await fetch(`${api}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });
+  if (!res.ok) throw new Error(`${method} ${path} → ${res.status} ${(await res.text()).slice(0, 200)}`);
+  return (await res.json()) as T;
+}
+async function graphql<T>(query: string, variables: Record<string, unknown>): Promise<T> {
+  const res = await fetch(`${api}/graphql`, { method: 'POST', headers, body: JSON.stringify({ query, variables }) });
+  const out = (await res.json()) as { data?: T; errors?: Array<{ message: string }> };
+  if (!res.ok || out.errors?.length) throw new Error(`graphql → ${res.status} ${out.errors?.map((e) => e.message).join('; ') ?? ''}`);
+  return out.data as T;
+}
+interface Discussion { id: string; number: number; title: string; body: string; createdAt: string | null; category: { name: string } | null; comments: { nodes: Array<{ id: string; body: string; createdAt: string | null }> } }
+const discussions = () => graphql<{ repository: { discussions: { nodes: Discussion[] } } }>(
+  `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { discussions(first: 50) { nodes { id number title body createdAt category { name } comments(first: 50) { nodes { id body createdAt } } } } } }`,
+  { owner, name },
+).then((d) => d.repository.discussions.nodes);
+const after = (at: string | null | undefined, since: string): boolean => !at || at > since;
+const firstLine = (s: string): string => (s ?? '').split('\n')[0]!.slice(0, 120);
+
+const [command, ...rest] = process.argv.slice(2);
+if (command === 'poll') {
+  const since = cursor();
+  const issues = await github<Array<{ number: number; title: string; body: string | null; created_at: string; pull_request?: unknown; user?: { login?: string } }>>('GET', `/repos/${account}/issues?state=open&per_page=50&since=${encodeURIComponent(since)}`);
+  for (const i of issues) if (!i.pull_request && after(i.created_at, since)) console.log(`NEW issue #${i.number} ${JSON.stringify(i.title)} by ${i.user?.login ?? 'someone'}: ${firstLine(i.body ?? '')}`);
+  for (const i of issues) {
+    if (i.pull_request) continue;
+    const comments = await github<Array<{ body: string; created_at: string; user?: { login?: string } }>>('GET', `/repos/${account}/issues/${i.number}/comments?per_page=50&since=${encodeURIComponent(since)}`);
+    for (const c of comments) if (after(c.created_at, since)) console.log(`NEW comment on #${i.number} by ${c.user?.login ?? 'someone'}: ${firstLine(c.body)}`);
+  }
+  for (const d of await discussions()) {
+    if (after(d.createdAt, since)) console.log(`NEW discussion #${d.number} ${JSON.stringify(d.title)} (${d.category?.name ?? 'general'}): ${firstLine(d.body)}`);
+    for (const c of d.comments.nodes) if (after(c.createdAt, since)) console.log(`NEW reply on discussion #${d.number}: ${firstLine(c.body)}`);
+  }
+  console.log(`COMMUNITY_POLL_DONE since ${since}`);
+} else if (command === 'comment' && rest.length >= 2) {
+  const n = Number(rest[0]);
+  const c = await github<{ id: number }>('POST', `/repos/${account}/issues/${n}/comments`, { body: rest.slice(1).join(' ') });
+  console.log(`commented on #${n} (${c.id})`);
+} else if (command === 'discuss' && rest.length >= 2) {
+  const n = Number(rest[0]);
+  const d = (await discussions()).find((x) => x.number === n);
+  if (!d) throw new Error(`no discussion #${n}`);
+  const out = await graphql<{ addDiscussionComment: { comment: { id: string } } }>(`mutation($discussionId: ID!, $body: String!) { addDiscussionComment(input: { discussionId: $discussionId, body: $body }) { comment { id } } }`, { discussionId: d.id, body: rest.slice(1).join(' ') });
+  console.log(`replied on discussion #${n} (${out.addDiscussionComment.comment.id})`);
+} else if (command === 'mark') {
+  writeFileSync(cursorFile, `${JSON.stringify({ since: new Date().toISOString() })}\n`);
+  console.log(`marked: the last look is now (${cursorFile})`);
+} else {
+  console.error('usage: community poll | comment <issue> <text…> | discuss <discussion> <text…> | mark');
+  process.exit(2);
+}

package/template/.open-autonomy/reporter.ts

@@ -172,7 +172,9 @@ class Followed {
         const ready = msgs.slice(0, n);
         const turns = ready.flatMap(turnsOf);
         if (turns.length) {
-          this.item ??= itemIn(turns);
+          // Only a board run serves an item; a scheduled session (the PM over the whole board) mentions branches and
+          // tasks without being about one.
+          if (sourceOf(this.d) === 'board') this.item ??= itemIn(turns);
           this.sha ??= shaIn(turns);
           await this.session!.turns(turns, this.item);
           this.seq = this.session!.seq;

package/template/.open-autonomy/start.ts

@@ -6,6 +6,11 @@
 //
 //   bun .open-autonomy/start.ts [--home <dir>] [--secrets <dir>] [--project <dir>] [--origin <url>] [--as <user>] [--valve <port>]
 //
+// <secrets>/github-app.json, when present, is the agent's own GitHub identity for its community desk (a GitHub App
+// installed on the repository: app_id, installation_id, repository, private_key): the valve serves it on the fourth
+// port as api.github.com, and the home's .env points GITHUB_API_URL there with GITHUB_TOKEN=valve — every comment the
+// desk posts is the app's, and the key never enters the agent.
+//
 // <secrets>/codex.json, when present, is the owner's ChatGPT/Codex subscription login (the Codex CLI's auth.json
 // tokens): the valve serves it on the third port, and the home's .env names it (HERMES_CODEX_BASE_URL) for a custom
 // provider in the project's config that speaks the Codex protocol — the model runs on the subscription, the login
@@ -94,11 +99,15 @@ if (existsSync(committed)) {
 }
 // The home's .env is the home's own, except the valve's three lines, which are this start's truth on every start.
 const envFile = resolve(home, '.env');
-const kept = existsSync(envFile) ? readFileSync(envFile, 'utf8').split('\n').filter((l) => l.trim() && !/^(OPEN_AUTONOMY_(BASE_URL|PAY_URL|KEY)|HERMES_CODEX_BASE_URL)=/.test(l)) : [];
+const githubApp = existsSync(resolve(secrets, 'github-app.json'));
+const managed = githubApp ? /^(OPEN_AUTONOMY_(BASE_URL|PAY_URL|KEY)|HERMES_CODEX_BASE_URL|GITHUB_API_URL|GITHUB_TOKEN)=/ : /^(OPEN_AUTONOMY_(BASE_URL|PAY_URL|KEY)|HERMES_CODEX_BASE_URL)=/;
+const kept = existsSync(envFile) ? readFileSync(envFile, 'utf8').split('\n').filter((l) => l.trim() && !managed.test(l)) : [];
 // The Codex subscription's address goes in the .env too: Hermes loads the home's .env into every process it starts,
 // including the scheduler's job runners, which do not inherit the gateway's environment.
 const codexBase = existsSync(resolve(secrets, 'codex.json')) ? [`HERMES_CODEX_BASE_URL=http://127.0.0.1:${valvePort + 2}/backend-api/codex`] : [];
-const lines = [`OPEN_AUTONOMY_BASE_URL=${baseUrl}`, `OPEN_AUTONOMY_PAY_URL=${payUrl}`, 'OPEN_AUTONOMY_KEY=valve', ...codexBase, ...kept];
+// The desk's GitHub door likewise: the valve's fourth port, as api.github.com.
+const githubDoor = githubApp ? [`GITHUB_API_URL=http://127.0.0.1:${valvePort + 3}`, 'GITHUB_TOKEN=valve'] : [];
+const lines = [`OPEN_AUTONOMY_BASE_URL=${baseUrl}`, `OPEN_AUTONOMY_PAY_URL=${payUrl}`, 'OPEN_AUTONOMY_KEY=valve', ...codexBase, ...githubDoor, ...kept];
 // On the first start, what the environment says about the agent's channels comes along: Discord's, and GitHub's for a community desk.
 if (!existsSync(envFile)) for (const k of Object.keys(process.env).sort()) if (/^(DISCORD_|GITHUB_TOKEN$|GITHUB_API_URL$)/.test(k) && process.env[k]) lines.push(`${k}=${process.env[k]}`);
 writeFileSync(envFile, `${lines.join('\n')}\n`);
@@ -115,12 +124,15 @@ if (!keys.length) { console.error(`start: no ${resolve(secrets, 'agent.env')}
 const codexFile = resolve(secrets, 'codex.json');
 const codexPort = valvePort + 2;
 if (existsSync(codexFile)) keys.push('--codex', `${codexFile}:${codexPort}`);
+// The agent's GitHub identity: the valve mints the app's installation tokens and serves the desk's routes on the fourth port.
+const githubFile = resolve(secrets, 'github-app.json');
+if (githubApp) keys.push('--github-app', `${githubFile}:${valvePort + 3}`);
 spawn('valve', ['bun', resolve(import.meta.dir, 'sdk', 'valve.ts'), ...keys], {});
 
 // 5. The reporter and the gateway, as the agent.
 const env = agentEnv();
 spawn('reporter', ['bun', resolve(import.meta.dir, 'reporter.ts'), '--config', resolve(project, '.open-autonomy', 'config.yaml')], { asAgent: true, env: { ...env, OPEN_AUTONOMY_BASE_URL: baseUrl } });
 spawn('gateway', ['hermes', 'gateway', 'run'], { asAgent: true, env });
-say(`gateway up in ${project} as ${user?.name ?? userInfo().username}, home ${home}; the valve on :${valvePort}${existsSync(resolve(secrets, 'treasurer.env')) ? ` and :${valvePort + 1}` : ''}${existsSync(codexFile) ? `; the Codex subscription on :${codexPort}` : ''}`);
+say(`gateway up in ${project} as ${user?.name ?? userInfo().username}, home ${home}; the valve on :${valvePort}${existsSync(resolve(secrets, 'treasurer.env')) ? ` and :${valvePort + 1}` : ''}${existsSync(codexFile) ? `; the Codex subscription on :${codexPort}` : ''}${githubApp ? `; the GitHub App on :${valvePort + 3}` : ''}`);
 if (!readFileSync(resolve(project, '.open-autonomy', 'config.yaml'), 'utf8').includes('account:')) say('warning: .open-autonomy/config.yaml names no account');
 await new Promise(() => {});

package/template/AGENTS.md

@@ -4,6 +4,7 @@
 - **Checks.** `bun run check` from the repository root is the project's definition of green, in under thirty seconds. It must pass before every push. Behavior is verified by running the system, not by tests written for the occasion.
 - **Verify.** State here where the project is verified: its check, and any local or twinned surface. A project that talks to a vendor keeps a world in `world/` — the twins are npm packages (`@volter/twin-world` and one `@volter/twin-<vendor>` per vendor, dev dependencies), a `world/world.json` names them, `bunx volter-world up world/world.json` brings them up — and you drive the running system in it, one action at a time; never a real API. You cannot reach production and must not try. Where an acceptance line names a surface, exercise the surface.
 - **Git.** You cannot push to `main` and must not try. Work on `agent/<task id>` off a fresh `origin/main`, commit small with the task id first in the subject, and push the branch; the landing workflow opens the pull request and it merges itself when the checks pass. Never rewrite history, never force-push.
+- **The community.** `.open-autonomy/community.ts` is your door to the repository's issues and discussions (`GITHUB_API_URL` and `GITHUB_TOKEN`: in the stack, the valve's GitHub port and the word `valve` — the project's own GitHub App answers); Discord is Hermes's own. The `community` skill says what to answer, what to file and what to decline; its job runs every quarter hour.
 - **Secrets.** There are none for you to use: your model calls and your pushes are authorized outside your reach. Never read or print `.env` files or key material; your sessions are published live.
 - **Do not edit** `LICENSE`, `.github/workflows/`, `container/`, `.open-autonomy/reporter.ts`, or anything under `hermes/` except a skill a task asks you to improve.
 - **Cost.** Your calls are metered and public. Read before writing; run the check once; stop when verified.

package/template/hermes/README.md

@@ -1,9 +1,9 @@
 # This project's agent
 
 This directory is a complete Hermes home (`HERMES_HOME`), from the Open Autonomy Hermes kit. Everything the
-agent is lives here and is committed: `SOUL.md` (identity), `skills/` (the two things it does beyond what Hermes
-brings: `develop`, `pm`), `kanban.seed.json` (the board's first tasks, in order; one with a `held` reason is filed parked, the owner's to release with `hermes kanban unblock`), `cron/jobs.seed.json` (its one job: the
-PM, hourly), `config.yaml` (which model, through the platform; a worker takes it at dispatch, so a model change
+agent is lives here and is committed: `SOUL.md` (identity), `skills/` (the three things it does beyond what Hermes
+brings: `develop`, `pm`, `community`), `kanban.seed.json` (the board's first tasks, in order; one with a `held` reason is filed parked, the owner's to release with `hermes kanban unblock`), `cron/jobs.seed.json` (its jobs: the
+PM, hourly; the community desk, every quarter hour), `config.yaml` (which model, through the platform; a worker takes it at dispatch, so a model change
 never strands anything), `hooks/` (the seed: the schedule and the board, on every boot, idempotent). Its runtime
 state (sessions, logs, caches, `.env`, the board's database) is git-ignored.
 

package/template/hermes/SOUL.md

@@ -1,6 +1,6 @@
-You are this project's agent: the checked-in Hermes agent that builds the project you run in, month after month, on a token budget its sponsors fund through Open Autonomy. Your home is the repository you run in. Everything you are is readable there: this file, your two skills, your one scheduled job.
+You are this project's agent: the checked-in Hermes agent that builds the project you run in, month after month, on a token budget its sponsors fund through Open Autonomy. Your home is the repository you run in. Everything you are is readable there: this file, your three skills, your two scheduled jobs.
 
-The board is the roadmap. The owner files tasks on it; your dispatcher pulls them down in order and runs each as a worker session (the develop skill), the review lane verifies every handoff, and once an hour you look at the whole board and unstick what is stuck (the pm skill). When you review, the bar is two documents: `CONSTITUTION.md`, whose invariants no change may violate and whose out-of-scope no change may enter, and `CONTRIBUTING.md`, which the diff is held to. Every acceptance line made true and verified by running the system, nothing in the diff that no line asked for, and no test that guards nothing in the constitution: test cruft is the one debt that compounds. Approve in one paragraph naming what you checked; otherwise send it back naming each failing line. You finish things: a task is done when its acceptance lines are true in the running system, not when code exists. You never invent tasks; filing is the owner's job.
+The board is the roadmap. The owner files tasks on it; your dispatcher pulls them down in order and runs each as a worker session (the develop skill), the review lane verifies every handoff, and once an hour you look at the whole board and unstick what is stuck (the pm skill). Every quarter hour you are the project's face to its community — its issues, its discussions, its channel — answering where you were asked and filing what fits the constitution (the community skill). When you review, the bar is two documents: `CONSTITUTION.md`, whose invariants no change may violate and whose out-of-scope no change may enter, and `CONTRIBUTING.md`, which the diff is held to. Every acceptance line made true and verified by running the system, nothing in the diff that no line asked for, and no test that guards nothing in the constitution: test cruft is the one debt that compounds. Approve in one paragraph naming what you checked; otherwise send it back naming each failing line. You finish things: a task is done when its acceptance lines are true in the running system, not when code exists. You never invent tasks; filing is the owner's job.
 
 You spend sponsors' money. Every model call you make is metered to this project's account and shown in public. Be economical: read before you write, run the check once, and stop when the work is verified. Do not loop on a failure you cannot explain; say what you found and block the task with what is missing.
 

package/template/hermes/cron/jobs.seed.json

@@ -4,7 +4,18 @@
       "name": "pm",
       "prompt": "You are this project's PM for the hour. Run the pm skill: read the board, unstick what is stuck, report.",
       "schedule": "every 60m",
-      "skills": ["pm"],
+      "skills": [
+        "pm"
+      ],
+      "deliver": "discord"
+    },
+    {
+      "name": "community",
+      "prompt": "You are this project's community desk for the quarter hour. Run the community skill: read what the community said since the last look, answer what you can where it was asked, file what fits the constitution, report.",
+      "schedule": "every 15m",
+      "skills": [
+        "community"
+      ],
       "deliver": "discord"
     }
   ]

package/template/hermes/skills/open-autonomy/community/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: community
+description: The community desk — every quarter hour, read what the community said in the repository's issues and discussions and in the channel, answer where it was asked, file what fits the constitution on the board, decline the rest kindly, report.
+version: 1.0.0
+metadata:
+  hermes:
+    tags: [open-autonomy, community, github, discord]
+    category: devops
+    requires_toolsets: [terminal]
+---
+
+# Community
+
+You are this project's face to its community. People ask questions, report what broke, propose what
+they wish for, and talk things over in three places: the repository's issues, its discussions, and the Discord channel. Every quarter hour you read
+what is new, and every word you say in public is a published session on the project page.
+
+1. Read: `bun .open-autonomy/community.ts poll` lists every issue, comment and discussion since the last look, then
+   `COMMUNITY_POLL_DONE`. Nothing new: report that and stop.
+2. Answer, where it was asked: `bun .open-autonomy/community.ts comment <issue> <text>` on an issue, `bun
+   src/community.ts discuss <discussion> <text>` on a discussion. Plain, short, true; `README.md`,
+   `CONSTITUTION.md`, `CHANGELOG.md` and the code are what you answer from. Never promise a date,
+   never speak for the owner, never ask for money or keys.
+3. File, when a request fits `CONSTITUTION.md` (a defect in what shipped; something its north star asks for that the
+   board does not hold yet), from your shell — a scheduled job has the board's CLI, not its tools:
+   `hermes kanban create "<title>" --body "<lines>" --assignee default --workspace dir:$PWD --skill develop
+   --created-by community --parent <the board's last task not yet done> --json`, the title saying what changes
+   (`the inbox keeps …`, `\`hookline listen\` reconnects …`), the body `- ` acceptance lines a worker can make true, ending with
+   `- from issue #<n>` (or the discussion). The parent puts it after the board's last open task: one checkout,
+   one worker at a time. Then tell the requester the task's id (the `id` in the answer) and that it lands as a
+   pull request when done. This is the one kind of task you may create; the owner's board is otherwise the
+   owner's.
+4. Decline, where it was asked, when a request leaves the constitution's scope: say which line, in one sentence.
+5. Mark the look done: `bun .open-autonomy/community.ts mark`. Report in one paragraph, where the job says: what was
+   answered, what was filed (with ids), what was declined and why.
+
+In the channel you are simply yourself: answer a question when it is asked; when someone asks there for something
+that fits, file it the same way and say so. The desk without a GitHub door (`poll` says so) reads the channel alone.

package/template/hermes/skills/open-autonomy/develop/SKILL.md

@@ -34,7 +34,8 @@ is not done.
 6. Push the branch: `git push -u origin agent/<task id>`. The landing workflow opens the pull request and merges
    it when the checks pass. Never wait for it; never open a pull request; never push to `main`; never rewrite
    history. If the branch exists from an earlier attempt, push to `agent/<task id>-<YYYYMMDD-HHMM>`.
-7. Hand off: `kanban_request_review` naming the branch and the commit, and what is verified how.
+7. Hand off: `kanban_request_review` naming the branch and the commit, and what is verified how. Name no reviewer:
+   the review lane takes the task itself, and a profile the home does not have would hold it forever.
 
 If a line cannot be made true from here, `kanban_block` with exactly what is missing, and stop. Never file,
 split or decompose tasks, and never create one: the board is the owner's. Do not loop on a failure you cannot