Skip to content
Back to search

numbrone

A chief of staff for your coding agents: route requests to per-project manager agents that run parallel workers in git worktrees, on herdr.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/stevenmichaelthomas/numbrone with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/stevenmichaelthomas/numbrone'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/stevenmichaelthomas--numbrone/badge.svg)](/listings/stevenmichaelthomas--numbrone)

HTML

<a href="/listings/stevenmichaelthomas--numbrone"><img src="/api/listings/stevenmichaelthomas--numbrone/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Install the skill

With the [skills CLI](https://github.com/vercel-labs/skills):

npx skills add stevenmichaelthomas/numbrone -g

Or by hand:

git clone https://github.com/stevenmichaelthomas/numbrone.git
cp -r numbrone/skills/numbrone ~/.claude/skills/

2. Start herdr and your agent

herdr                                # launch or attach to herdr
herdr integration install claude     # once: lets herdr track Claude sessions
claude                               # start Claude Code in a herdr pane

3. Run the setup skill

In Claude Code, type:

/numbrone

The skill walks you through:

1. **Checks**: that herdr, git and jq are present. 2. **The numbrone home**: the folder where the chief lives (default `~/.numbrone`). 3. **Your projects**: give it paths, or a parent folder to pick git repositories from. 4. **Context**: it reads each project (README, manifests, layout, recent history) and writes `projects/<name>/context.md` so the chief can route requests accurately. 5. **Inputs** (optional): sources the chief or a manager should watch, such as Linear tickets or Sentry errors (see [Inputs](#inputs-you-or-anything-else)). 6. **Knowledge** (optional): a few questions about your goals and standards, to give the chief a head start. 7. **Agent settings**: which agent to use, and how many permission prompts you want (see below). 8. **Managers**: it opens one herdr workspace per project and starts a manager in each.

4. Start your chief of staff

Open a new herdr pane and run:

cd ~/.numbrone && claude

The chief reads `~/.numbrone/CLAUDE.md` and registers itself. From then on, just ask for things:

> Fix the flaky login test in the API, and add a dark mode toggle to the web application.

It splits that into two tasks, hands each to the right manager, and tells you. Managers spawn workers, and the workers' tabs appear in each project's workspace in herdr. When something needs you (a question, or work ready for review), the chief gets a `[numbrone] …` message and passes it on. herdr also shows a notification.

Ask "what's going on?" at any time, or run `numbrone status` yourself. To use the `numbrone` command from your own shell, add it to your PATH:

export PATH="$HOME/.numbrone/bin:$PATH"   # in ~/.zshrc or ~/.bashrc

The status looks like this:

TASK                     PROJECT          STATUS   WORKER   LAST UPDATE
fix-flaky-login          api              review   done     2026-11-08 16:01 [manager-api] review: Branch numbrone/fix-flaky-login …
dark-mode-toggle         web              working  working  2026-11-08 16:00 [worker-dark-mode-toggle] working: Add toggle to …

managers: manager-api=done manager-web=idle

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 452 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # numbrone
  2. > numbrone is an independent community project built on top of [herdr](https://herdr.dev).
  3. > It is not made by or affiliated with the herdr team.
  4. **A chief of staff for your agents.** You give one agent requests in plain language: code
  5. changes, research, documents, emails, whatever your projects need.
  6. It works out which of your projects each request belongs to and hands it to that project's
  7. manager. The manager runs workers in parallel, each in its own git worktree, and everyone
  8. reports back up. All of it runs in [herdr](https://herdr.dev), so you can watch any agent at any time.
  9. We all need a numbrone at work. This is yours.
  10. ```
  11. you, or sources the chief watches (Linear, GitHub issues, ...)
  12. │ "add rate limiting to the api"
  13. ▼
  14. ┌─────────────┐
  15. │ chief │ routes, delegates, keeps track ~/.numbrone
  16. └──────┬──────┘
  17. ┌────────────┴─────────────┐
  18. ▼ ▼
  19. ┌───────────────┐ ┌───────────────┐ ◀── sources each manager watches
  20. │ manager-api │ │ manager-web │ (Sentry, Datadog, ...)
  21. └───────┬───────┘ └───────┬───────┘ one per project: herdr workspace numbrone/<project>
  22. ┌────┴─────────┐ │
  23. ▼ ▼ ▼
  24. worker-rate- worker-fix- worker-new- one per task: herdr tab and git worktree
  25. limit login navbar on branch numbrone/<task>
  26. reports flow back up: worker ──▶ manager ──▶ chief ──▶ you
  27. ```
  28. - **Chief**: the agent you talk to. Beyond quick answers, it doesn't do the work itself. It
  29. routes and delegates requests, and it tells you what's happening.
  30. - **Managers**: one per project, living in that project's herdr workspace. A manager answers
  31. small things itself and spawns a worker for everything else: code, research, writing, emails.
  32. It reviews their work before reporting it as ready.
  33. - **Workers**: one per task, each in its own tab and git worktree, so many tasks run at once
  34. without stepping on each other or on your own checkout. Work that isn't a change to the
  35. project (findings, drafts) goes in `notes/<task>.md`.
  36. Small things (a quick question, a status check) get answered in the agent's own thread. Everything
  37. else gets its own tab by default, so you can watch any piece of work.
  38. It's one skill, one bash script, and four Markdown role files. State is plain text files you
  39. can read and edit.
  40. ## Requirements
  41. - [herdr](https://herdr.dev) (`curl -fsSL https://herdr.dev/install.sh | sh`)
  42. - `git` and `jq`
  43. - A coding agent herdr supports. The default is [Claude Code](https://claude.com/claude-code);
  44. Codex, Gemini, OpenCode and others work too (see [Using another agent](#using-another-agent)).
  45. - macOS or Linux
  46. ## Setup
  47. ### 1. Install the skill
  48. With the [skills CLI](https://github.com/vercel-labs/skills):
  49. ```bash
  50. npx skills add stevenmichaelthomas/numbrone -g
  51. ```
  52. Or by hand:
  53. ```bash
  54. git clone https://github.com/stevenmichaelthomas/numbrone.git
  55. cp -r numbrone/skills/numbrone ~/.claude/skills/
  56. ```
  57. ### 2. Start herdr and your agent
  58. ```bash
  59. herdr # launch or attach to herdr
  60. herdr integration install claude # once: lets herdr track Claude sessions
  61. claude # start Claude Code in a herdr pane
  62. ```
  63. ### 3. Run the setup skill
  64. In Claude Code, type:
  65. ```
  66. /numbrone
  67. ```
  68. The skill walks you through:
  69. 1. **Checks**: that herdr, git and jq are present.
  70. 2. **The numbrone home**: the folder where the chief lives (default `~/.numbrone`).
  71. 3. **Your projects**: give it paths, or a parent folder to pick git repositories from.
  72. 4. **Context**: it reads each project (README, manifests, layout, recent history) and writes
  73. `projects/<name>/context.md` so the chief can route requests accurately.
  74. 5. **Inputs** (optional): sources the chief or a manager should watch, such as Linear tickets
  75. or Sentry errors (see [Inputs](#inputs-you-or-anything-else)).
  76. 6. **Knowledge** (optional): a few questions about your goals and standards, to give the chief a head start.
  77. 7. **Agent settings**: which agent to use, and how many permission prompts you want (see below).
  78. 8. **Managers**: it opens one herdr workspace per project and starts a manager in each.
  79. ### 4. Start your chief of staff
  80. Open a new herdr pane and run:
  81. ```bash
  82. cd ~/.numbrone && claude
  83. ```
  84. The chief reads `~/.numbrone/CLAUDE.md` and registers itself. From then on, just ask for things:
  85. > Fix the flaky login test in the API, and add a dark mode toggle to the web application.
  86. It splits that into two tasks, hands each to the right manager, and tells you. Managers spawn
  87. workers, and the workers' tabs appear in each project's workspace in herdr. When something
  88. needs you (a question, or work ready for review), the chief gets a `[numbrone] …` message and
  89. passes it on. herdr also shows a notification.
  90. Ask "what's going on?" at any time, or run `numbrone status` yourself. To use the
  91. `numbrone` command from your own shell, add it to your PATH:
  92. ```bash
  93. export PATH="$HOME/.numbrone/bin:$PATH" # in ~/.zshrc or ~/.bashrc
  94. ```
  95. The status looks like this:
  96. ```
  97. TASK PROJECT STATUS WORKER LAST UPDATE
  98. fix-flaky-login api review done 2026-11-08 16:01 [manager-api] review: Branch numbrone/fix-flaky-login …
  99. dark-mode-toggle web working working 2026-11-08 16:00 [worker-dark-mode-toggle] working: Add toggle to …
  100. managers: manager-api=done manager-web=idle
  101. ```
  102. ## Inputs: you, or anything else
  103. Work doesn't have to come from you. At each level, an agent can run a loop that watches a
  104. source and turns new items into tasks:
  105. - **The chief** watches sources that span projects, such as a Linear team, GitHub issues across
  106. an org, or a shared inbox. It routes each new item to the right project, just like a request from you.
  107. - **A manager** watches sources its project owns, such as that service's Sentry errors, its
  108. Datadog monitors, or its CI failures. It triages each item and either handles it, spawns a
  109. worker, or asks the chief (and so you) when it needs a decision.
  110. Sources are listed under a **Watch** heading: in `~/.numbrone/CLAUDE.md` for the chief, and in
  111. `projects/<name>/context.md` for a manager. One line per source:
  112. ```markdown
  113. ## Watch
  114. - Linear: new issues in team ENG labelled "agent", every 15 minutes
  115. - Sentry: new unresolved issues in project "api", every 30 minutes
  116. ```
  117. Agents start these loops when they launch (in Claude Code, with `/loop`), so watches come back
  118. after a restart. You can also add one just by asking, for example "have the api manager keep an eye on
  119. Sentry". The manager adds it to its `context.md` itself.
  120. Agents read sources with whatever tools they have: MCP connectors (Linear, Sentry, Datadog, ...)
  121. or CLIs such as `gh`. Connect those in your agent first. The item's ID goes in the task brief,
  122. so the same ticket or error is never picked up twice.
  123. ## Teaching the chief
  124. Not every conversation with the chief needs to be a task. You can also just give it context:
  125. > For context: we're prioritizing enterprise customers this quarter, so anything touching SSO
  126. > or audit logs comes first. And we decided last month to stop supporting IE.
  127. The chief files it rather than delegating it, and confirms in one line where it went:
  128. - **Context about your world** (goals, customers, people, past decisions, your standards) goes in
  129. `~/.numbrone/knowledge/`, one Markdown file per topic, with an `index.md` it reads at the start
  130. of every session.
  131. - **Context about one project** goes in that project's `context.md`, and the chief passes it to
  132. that project's manager.
  133. - **How you want the chief itself to work** goes under **Learned** (see below).
  134. The more it knows, the better its work gets. It routes ambiguous requests correctly, writes briefs
  135. that carry the "why" (managers only see the brief), and judges finished work against your goals
  136. and standards before it reaches you. Paste documents, explain history, or correct a wrong assumption.
  137. It keeps the files organized and up to date, and asks when it's missing something it needs.
  138. ## A chief that learns from you
  139. The chief is meant to act like an extension of you: opinionated and quick to decide. It
  140. recommends one option instead of listing five, makes routine calls itself, and only brings you
  141. real decisions, with its recommendation attached. It also gives feedback, for example when a
  142. request is vague or the same problem keeps happening.
  143. It gets better by taking your feedback. Whenever you correct it or tell it how you like things
  144. done, it adds one line to the **Learned** section of `~/.numbrone/CLAUDE.md`, which every future
  145. session reads first. Early on (until it has about ten lessons), it asks you a short question
  146. after each finished task to calibrate faster. You can edit **Learned** yourself at any time.
  147. **Learned** is kept short on purpose: the chief merges overlapping lessons, replaces ones that
  148. no longer hold, and moves project-specific detail into that project's `context.md`. The work log
  149. keeps the full history of your feedback.
  150. ## Work log
  151. `~/.numbrone/log/<date>.md` is the record of what the chief and its teams got done each day,
  152. one Markdown file per day. It holds outcomes and decisions, not progress chatter:
  153. - **Milestones**, written by the script as managers report them: queued, blocked, review, done, closed.
  154. - **Outcomes**, written by the chief when a task finishes: what was delivered, how it went
  155. (rework, blocks, time taken), and a one-line lesson.
  156. - **Decisions**: your answers to blocked questions, priority calls, work sent back. Managers
  157. log the decisions they make on your behalf, too.
  158. - **Feedback and context** you gave the chief.
  159. Workers' step-by-step progress stays in each task file (`numbrone status <task>`), so a day's log
  160. stays short enough to read in a minute.
  161. ```markdown
  162. # Work log 2026-11-08
  163. - 15:59 [chief] add-name: queued for demo
  164. - 16:01 [manager-demo] add-name: review: Branch numbrone/add-name (c880b98): greet.sh takes an
  165. optional name and falls back to "world". Tests pass.
  166. - 16:02 [chief] outcome: add-name (demo): optional name argument, one pass, no rework. Lesson: none
  167. - 16:20 [chief] decision: fix-login goes before new-navbar (launch Friday)
  168. - 16:21 [chief] add-name: closed: accepted (branch numbrone/add-name kept)
  169. - 17:05 [chief] q4-update-email: closed: changed: user cut the second paragraph; wanted it under 100 words
  170. ```
  171. Ask the chief "what got done today?" and it answers by project from this file. To skim
  172. outcomes across days yourself: `grep -h "outcome:" ~/.numbrone/log/*.md`.
  173. Entries are only ever appended, so the log is an audit trail you can trust. It's also how the
  174. setup gets better over time: see [Dreams](#dreams). You can also ask the chief for a retro any time
  175. ("how did this week go?"). It reads the log, tells you where work stalled or was redone and how
  176. often, and proposes changes. It only makes them once you agree.
  177. ## Dreams
  178. Once a day, the team looks back at its own work and gets better at it. The chief checks every
  179. hour (`numbrone dream`, on its loop), and the first check after 3am on a day with new activity starts a
  180. short-lived **dreamer** agent in a tab next to the chief. A chief that runs for weeks still dreams
  181. daily, and a restart never dreams twice in one day.
  182. The dreamer reads:
  183. - **The numbers**, from `numbrone stats`: for each task, its kind of work, how long it took to
  184. deliver, how often it was sent back, how many questions workers asked, how often it reached you
  185. as a decision, and your verdict when it closed. Work on a branch also shows commits made after
  186. hand-off and whether it was merged.
  187. - **The work log and task files**: your feedback, decisions, and every `sent back:` with what was wrong.
  188. - **What you changed or rejected** after work was handed to you: the note on each `changed` or
  189. `dropped` verdict, and for code, the commits you added. That's the gap between what the team
  190. delivered and what you wanted.
  191. - **The previous dream**, to check whether yesterday's changes moved the numbers.
  192. Every role learns, each from its own file:
  193. | Who | What gets better | How |
  194. | --- | --- | --- |
  195. | Workers | Conventions, checking their work, setup problems that keep coming back | `lessons.md` files, read before every task |
  196. | Managers | What to catch in review, and their own drafts, answers and emails | The same `lessons.md` files, read at startup and checked in every review |
  197. | Chief | Routing, briefs, what it lets through, what it asks you | Proposals for `CLAUDE.md` and `knowledge/` |
  198. | Dreamer | Which lessons actually helped | Proposals for `roles/dream.md` |
  199. Lessons live in two places, grouped by kind of work (`## Code`, `## Research`, `## Email`, ...):
  200. `projects/<name>/lessons.md` for one project, and `lessons.md` in the numbrone home for what holds
  201. everywhere, such as how you like research written up or the tone of your emails.
  202. The dreamer **applies** lessons about how work gets done (the `lessons.md` files, fixes to a project's
  203. `context.md`, merging duplicates in **Learned**). It **proposes** everything else, as exact
  204. edits: changes to the chief's instructions, the role files, settings, or knowledge. The chief
  205. brings you the headline and the proposals with its recommendation, and applies the ones you accept.
  206. Each dream is saved to `log/dreams/<date>.md`. Read one, or run `numbrone stats` yourself:
  207. ```
  208. TASK PROJECT KIND STATUS DELIVERED CLOSED BACK ASKED ESC VERDICT EDITED MERGED
  209. fix-flaky-login api code closed 1h11m 3h40m 1 1 0 accepted 0 yes
  210. churn-research growth research closed 2h05m 1d2h 0 0 1 changed - -
  211. q4-update-email growth email review 12m - 0 0 0 - - -
  212. since 2026-11-09: 3 tasks, 3 delivered, 2 first time (66%), median time to deliver 1h11m
  213. send-backs: 1, worker questions: 1, escalations to the user: 1
  214. verdicts: 1 accepted, 1 changed, 0 dropped, 1 without one
  215. by kind (first time / delivered): code 0/1, research 1/1, email 1/1
  216. branches: 0 changed after hand-off, 1 merged
  217. ```
  218. For this to work, two things go on the record:
  219. - **Rework.** Managers and the chief send work back with `numbrone send-back <task> "<what to fix>"`,
  220. never a bare prompt, so it lands in the task file and the log.
  221. - **Your verdict.** The chief closes every task once you've responded to it, whatever the kind of
  222. work: `accepted`, `changed` (with what you changed), or `dropped` (with why). It reads the verdict
  223. from what you say, and asks in a few words if it can't tell.
  224. ## Day to day
  225. | You want to… | Do this |
  226. | --- | --- |
  227. | Give work | Tell the chief in plain language |
  228. | See progress | Ask the chief, or `numbrone status` |
  229. | See one task in full | `numbrone status <task>` (brief, status, full log) |
  230. | Watch an agent work | Click its workspace and tab in herdr |
  231. | Accept finished work | Tell the chief, and say what you changed if anything. For code, review the `numbrone/<task>` branch and merge it your usual way first |
  232. | Add a project | Run `/numbrone` again, or `numbrone add` + write its `context.md` + `numbrone up <name>` |
  233. | Restart managers | `numbrone up` (after a reboot, for example) |
  234. | Review how things went | Ask the chief for a retro ("how did this week go?"), or read `log/dreams/` |
  235. | See the numbers | `numbrone stats [days]` |
  236. | Send work back | Tell the chief what's wrong (it runs `numbrone send-back`) |
  237. | Dream now | `numbrone dream --force` |
  238. Nobody merges, pushes, deploys, or sends, posts or publishes anything to other people (emails,
  239. messages, shared documents) unless you say so. Asking for exactly that, such as "send the update
  240. to the team", counts. `numbrone close` refuses to remove a worktree that has uncommitted changes,
  241. and it always keeps the branch.
  242. ## How it works
  243. Everything is plain files in the numbrone home folder:
  244. ```
  245. ~/.numbrone/
  246. ├── CLAUDE.md the chief's instructions (AGENTS.md links to it)
  247. ├── settings.sh which agent to run, with which arguments
  248. ├── projects.json project index: name → path + one-line summary
  249. ├── projects/<name>/
  250. │ ├── context.md what the project is, its commands, which requests belong to it
  251. │ └── lessons.md what the dreams learned about working here (managers and workers read it)
  252. ├── lessons.md what the dreams learned that holds across projects, by kind of work
  253. ├── tasks/<task>.md one file per task: brief, status, append-only log
  254. ├── notes/<task>.md what workers deliver that isn't a change to a project: findings, drafts
  255. ├── log/<date>.md the daily work log (see above)
  256. ├── log/dreams/<date>.md each day's dream: numbers, patterns, what changed, proposals
  257. ├── knowledge/ what the chief knows about your world, by topic (index.md lists them)
  258. ├── roles/
  259. │ ├── manager.md instructions every manager reads at startup
  260. │ ├── worker.md instructions every worker reads at startup
  261. │ └── dream.md instructions for the daily dreamer
  262. └── bin/numbrone the script everyone uses
  263. ```
  264. A task file looks like this:
  265. ```markdown
  266. # fix-flaky-login
  267. project: api
  268. kind: code
  269. status: review
  270. branch: numbrone/fix-flaky-login
  271. start: 4f1c2e9
  272. worktree: /code/api/.numbrone/worktrees/fix-flaky-login
  273. created: 2026-11-08 15:58
  274. ## Brief
  275. The login test fails about 1 in 5 runs on CI. Find out why and fix it ...
  276. ## Log
  277. - 2026-11-08 15:58 [chief] queued
  278. - 2026-11-08 15:59 [manager-api] spawned worker-fix-flaky-login on numbrone/fix-flaky-login
  279. - 2026-11-08 16:04 [worker-fix-flaky-login] review: Race between session write and redirect ...
  280. - 2026-11-08 16:05 [manager-api] review: Branch numbrone/fix-flaky-login: awaits the session write ...
  281. ```
  282. The `numbrone` script is a thin wrapper around the herdr CLI:
  283. | Command | What it does in herdr / git |
  284. | --- | --- |
  285. | `numbrone up [project]` | `herdr workspace create --label numbrone/<project>`, then `herdr agent start manager-<project>` |
  286. | `numbrone delegate <project> <task> "<brief>" [kind]` | Writes `tasks/<task>.md` (kind is one word: `code`, `research`, `email`, ...), then `herdr agent prompt manager-<project>` |
  287. | `numbrone spawn <task>` | `git worktree add <project>/.numbrone/worktrees/<task> -b numbrone/<task>`, `herdr tab create`, `herdr agent start worker-<task>` |
  288. | `numbrone report <task> <status> "<note>"` | Updates the task file; on `blocked`/`review`/`done` it messages one level up (worker → manager → chief) and shows a herdr notification |
  289. | `numbrone status [task]` | Reads task files plus live agent states (`herdr agent get`) |
  290. | `numbrone send-back <task> "<what to fix>"` | Records the rework in the task file and log, then `herdr agent prompt` one level down (manager → worker, chief → manager) |
  291. | `numbrone close <task> <accepted\|changed\|dropped> ["<note>"]` | Records your verdict; for work with a worker, `herdr tab close` it and `git worktree remove` (keeps the branch) |
  292. | `numbrone stats [days]` | Per-task numbers and verdicts from the task files, plus `git log` / `git merge-base` for branches |
  293. | `numbrone dream [--force]` | Once a day: `herdr tab create` next to the chief, then `herdr agent start dreamer` |
  294. | `numbrone chief` | `herdr agent rename <this pane> chief`, so reports can reach it |
  295. | `numbrone log ["<note>" \| <date>]` | Appends a note to today's work log, or prints a day's log |
  296. Worktrees go in `<project>/.numbrone/worktrees/`, listed in the repository's local `.git/info/exclude`. They
  297. never appear in `git status` or get committed, and agents started there inherit the folder
  298. trust you already gave the project.
  299. Run `numbrone` with no arguments for the full command list.
  300. ## Configuration
  301. `~/.numbrone/settings.sh`:
  302. ```bash
  303. AGENT_KIND=claude # any `herdr agent start --kind` value
  304. AGENT_ARGUMENTS="" # extra arguments for the agent
  305. BASE_BRANCH="" # branch new worktrees start from ("" = project's current HEAD)
  306. PING_CHIEF=1 # 0 = don't type reports into the chief; just log and notify
  307. DREAM_HOUR=3 # the daily dream runs at the first hourly check after this hour
  308. ```
  309. **Permission prompts.** Workers stop at every permission prompt and show as `blocked` in herdr
  310. until you answer. That's the safe default. To cut down on prompts with Claude Code, for example:
  311. ```bash
  312. AGENT_ARGUMENTS="--permission-mode acceptEdits"
  313. ```
  314. Pick what you're comfortable with. Agents run on your machine with your access.
  315. **Folder trust.** The first time Claude Code opens a project, it asks whether you trust the
  316. folder. If a manager hits this, `numbrone` shows a notification and waits up to 5 minutes for you to
  317. answer in herdr. Workers inherit their project's trust, so they won't ask again.
  318. ## Using another agent
  319. Set `AGENT_KIND` in `settings.sh` (for example `codex`, `gemini`, `opencode`) and install its herdr
  320. integration (`herdr integration install codex`). The role files are plain Markdown and the numbrone
  321. home folder has an `AGENTS.md` symlink, so any agent that reads `AGENTS.md` can be the chief. You
  322. can install the skill for that agent with `npx skills add … -a <agent>`, or run
  323. `bash skills/numbrone/scripts/numbrone init ~/.numbrone` yourself and follow `skills/numbrone/SKILL.md` by hand.
  324. ## Customizing
  325. - **Change how roles behave**: edit `~/.numbrone/roles/manager.md` or `worker.md`.
  326. - **Upgrade**: pull the repository and run `numbrone init ~/.numbrone` again. It updates `bin/numbrone`
  327. and never overwrites files you may have edited (`CLAUDE.md`, `roles/`, `settings.sh`,
  328. `projects.json`). To take a newer template, delete that file and run `init` again. If your
  329. `CLAUDE.md` or `roles/manager.md` predates dreams, `init` tells you the line to add.
  330. - **Change how the chief behaves**: edit `~/.numbrone/CLAUDE.md` directly.
  331. - **Better routing**: improve the "Route here" and "Not here" sections in each project's `context.md`.
  332. ## Troubleshooting
  333. | Symptom | Fix |
  334. | --- | --- |
  335. | `numbrone: no numbrone home found` | Run `~/.numbrone/bin/numbrone …` (not a copy elsewhere), or set `NUMBRONE_HOME=~/.numbrone` |
  336. | A manager or worker shows `blocked` | It's waiting for an answer. Click its tab in herdr, or `herdr agent read <name> --source recent-unwrapped --lines 80` |
  337. | Reports don't reach the chief | Run `numbrone chief` in the chief's session (it registers the name `chief`) |
  338. | `manager-x already running` but it seems stuck | `herdr agent read manager-x …` to see its screen; close its tab in herdr and run `numbrone up x` |
  339. | Managers gone after a reboot | `numbrone up` |
  340. | Agent states look wrong | `herdr integration status`; `herdr agent explain <name>` |
  341. ## Uninstall
  342. ```bash
  343. rm -rf ~/.claude/skills/numbrone ~/.numbrone
  344. ```
  345. Then close the `numbrone/*` workspaces in herdr. Task branches (`numbrone/*`) stay in your repositories until you
  346. delete them; any leftover worktrees can be removed with `git worktree remove <path>`.
  347. ## License
  348. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.