Skip to content
Skills Library
AI & agents · Automation

fleet

/fleet

Orchestrate a fleet of coding-agent lanes in Herdr panes — open lanes in worktrees, brief and watch them, run critic rounds, reset or hand off lanes, pick remuda accounts, and clean up. Use whenever you drive other agents through Herdr (HERDR_ENV=1), or the user mentions lanes, a fleet, critic panes, or moving work to another pane.

Repository
herdr-fleet ↗
Licence
MIT
Last repository change
10.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Orchestrate a fleet of coding-agent lanes in Herdr panes — open lanes in worktrees, brief and watch them, run critic rounds, reset or hand off lanes, pick remuda accounts, and clean up. Use whenever you drive other agents through Herdr (HERDR_ENV=1), or the user mentions lanes, a fleet, critic panes, or moving work to another pane.

Original author description

Orchestrate a fleet of coding-agent lanes in Herdr panes — open lanes in worktrees, brief and watch them, run critic rounds, reset or hand off lanes, pick remuda accounts, and clean up. Use whenever you drive other agents through Herdr (HERDR_ENV=1), or the user mentions lanes, a fleet, critic panes, or moving work to another pane.

How it works

  1. Start here
  2. The helper
  3. Lane lifecycle
  4. Rules
Original SKILL.md headings · 90 lines, 4,080 words
SKILL.md preview
---
name: fleet
description: Orchestrate a fleet of coding-agent lanes in Herdr panes — open lanes in worktrees, brief and watch them, run critic rounds, reset or hand off lanes, pick remuda accounts, and clean up. Use whenever you drive other agents through Herdr (HERDR_ENV=1), or the user mentions lanes, a fleet, critic panes, or moving work to another pane.
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash(python3 "${CLAUDE_PLUGIN_ROOT}/scripts/fleet" *)
  - Bash(python3 ${CLAUDE_PLUGIN_ROOT}/scripts/fleet *)
  - Bash(herdr pane read *)
  - Bash(herdr pane get *)
  - Bash(herdr agent list*)
  - Bash(git status*)
  - Bash(git log *)
  - Bash(git diff *)
---

# Fleet

You are the orchestrator. Lanes do the work in their own Herdr panes. You decide, brief, watch, review, integrate and clean up. Stay small: when a brief needs digging, a researcher pane digs (`/fleet:research`); when a change needs a plan first, a planner pane writes it.

## Start here

1. Run `python3 "${CLAUDE_PLUGIN_ROOT}/scripts/fleet" conventions`. It prints the mode and the user's conventions: agents, models, critics, context limits and, in remuda mode, accounts. Follow them. If it prints the plugin defaults, suggest `/fleet:onboard` once.
2. Plain mode (no remuda): never pass `--account` and ignore account rules. Every lane uses the agent's own login. In remuda mode, choose each new pane's account with `accounts --pick <agent>`; the prose rules of the conventions are the fallback when it gives no account or cannot read them.
3. Your memory is the project home, `~/.fleet/projects/<name>/`, which every clone of the repository shares. A project can have several orchestrators (orchs), one per theme, each with a name and its own pane. Run `orch show`: it prints your orch, or `orch list` every orch with its pane. A project with one orch works as before: when no live pane is registered, run `orch claim`, which registers your pane as the orch `default` and creates `PROJECT.md`. When the user wants you on another theme beside a live orch, run `orch claim --name <theme>`; that switches the project to format 2 and gives each orch its own `ORCH.md`. `orch rename OLD NEW` gives an orch a theme name later (the same switch); its lanes move with it. When `orch show` exits 1 because the repository has no fleet project home yet, `orch claim` creates it too (when it says the directory is in no git repository, or not in a working tree, change to a checkout of the project first; when git could not tell the project, run it again). When another live pane holds the orch you would claim, that pane orchestrates it: tell the user, and do not claim it.
4. Run `digest`: what changed in your view since your orch last looked (lane phases, and the events of the lanes). Your view is your orch's own lanes and the unowned ones. Then `board` whenever you need the state of those lanes; it consumes nothing. `board --all` shows every lane of the project with an ORCH column. A lane that no orch owns shows `unowned: adopt it` on a board with several orchs: `adopt <target>` makes it yours.
5. Write only what nothing else knows to your memory. `PROJECT.md` is shared by every orch: the user's rules for this project, follow-ups, the project's high-risk paths under `## High-risk paths`, and decisions that concern the whole project. Once the project has several orchs, the decisions and notes of your theme go to your `ORCH.md` (`orch show` prints its path); with one orch, PROJECT.md holds them (templates and pattern rules: `${CLAUDE_PLUGIN_ROOT}/skills/fleet/references/templates.md`). A decision is a ruling and its reason, in one line: never a record of a merge, a review round, a push or a cleanup, which the event log and git keep. When the user names files or folders that must never change without their yes (a schema file, an auth folder), add them under `## High-risk paths`. The board and the event log keep the rest. At every session start of your pane (startup, resume, /clear, compaction), the SessionStart hook re-briefs it from the project home: your orch's name, PROJECT.md's rules and follow-ups, your ORCH.md's notes, your cached board, and the number of new events in your view.
6. An existing `.fleet/FLEET.md` keeps working: the hook still re-briefs the pane on its `Orchestrator:` line after /clear or compaction, and `orch claim` warns while that pane is alive. Do not start a new FLEET.md.

## The helper

Run every command as `python3 "${CLAUDE_PLUGIN_ROOT}/scripts/fleet" <command> ...`, written out in full each time: each Bash call is a new shell. Commands print JSON unless the table says "text".

| Command | Does |
|---|---|
| `conventions` | The user's rules (text). |
| `doctor [--codex-hooks]` | Tools, mode, accounts, conventions path; in a checkout with `.codex/hooks.json`, the hooks that each Codex account has not trusted (text; `--json`). `--codex-hooks` asks the installed Codex instead (one `codex app-server` per Codex home, at most 15 s each): it also finds hooks edited since they were trusted (`modified`) and hooks in `.codex/config.toml`; a failure shows `unknown` with the reason. Run it when a Codex lane stops at the hooks review and the default doctor finds nothing. |
| `accounts [--pick claude\|codex]` | remuda accounts and cached usage (text; `--json`). A cache 24 h old or older is marked `STALE`: do not choose an account by remaining usage on those numbers. Pass `--live` only when the user asks (it starts each agent briefly). `--pick <agent>` prints the account to pass as `--account` for a new pane, and why: the conventions' `- Skip level: <n> %` (default 85; an account with any limit above it is skipped) and `- Pick order <agent>: <account>, <account>` or `most headroom` (default: codex in remuda's order, claude the most headroom). A stale or missing cache is unknown: an ordered pick takes it with a warning, the most headroom ranks it last. `account: null` (exit 0) when every account is above the level, and in plain mode: then fall back as the conventions say. It never refreshes. |
| `status [--workspace W]` | Each agent pane: status, role, account, branch, lane files (text; `--json`). |
| `worktree BRANCH --base REF --name LABEL [--orch NAME]` | A Herdr worktree in its own workspace, with a shell pane and `.fleet/` ready. `.fleet/lane.json` records your orch as the lane's owner (`--orch`: another). |
| `spawn ...` | Start an agent in a pane and confirm that it works. See below. With `--role impl`, or no `--role`, it refuses (exit 2, `changed: nothing`) while the lane has a `.fleet/PLAN.md` whose newest `PLAN READY: <n>` round has no `PLAN APPROVED: <n>` line, also when no round is ready yet, and when git fails in a directory with a PLAN.md at or above it. There is no flag around it: approve the plan, or remove PLAN.md on purpose. |
| `send PANE --text T` or `--file F` | Submit a prompt and confirm that it landed. Long or multi-line text goes to `.fleet/inbox/` and is sent as a one-line pointer. Exit code 3: the agent still works after `--timeout`; send later, or pass `--queue`. |
| `watch PANE [--marker M] [--file F]` | Wait until a line of a lane file (default `.fleet/STATUS.md`) starts with the marker, or the agent stops, blocks or exits. A mention inside a sentence does not count. Run it in the background. |
| `reset PANE [--compact [FOCUS]]` | `/clear` (or `/compact`) a Claude lane at a boundary, confirm it, and send a resume prompt. PANE comes first. |
| `retire PANE [--close]` | Exit the agent, and close the pane if asked. It refuses a working agent (exit code 3) unless you pass `--force`, which interrupts it first. |
| `approve-plan [DIR] --by orch\|user [--round N] [--base REF]` | Approve the newest round of the lane's `.fleet/PLAN.md` (DIR: the lane's worktree): it appends `PLAN APPROVED: <n> by <who> <date>` and records the approval. It refuses, changing nothing, when PLAN.md has no `PLAN READY: <n>` line for the round, the round is already approved, the worktree has changes outside `.fleet/` (untracked files and renames count, whatever the settings for untracked files, the file system monitor or the untracked cache say), an existing path outside `.fleet/` is marked assume-unchanged or skip-worktree (git status does not look at it; absent paths of a sparse checkout do not count), the lane has commits of its own (by default, HEAD commits that no tag and no branch holds, leaving out the current branch and `<remote>/<current branch>` on each remote; a detached HEAD refuses without `--base`), or the project's high-risk patterns cannot be read. With `--by orch` it also refuses when the `Risk:` line is not `none`, when `## Files` lists no path, or when a listed path matches a high-risk pattern (the refusal names the matches): such a plan is high risk whatever its `Risk:` line says. `--by user` overrides only the risk and the missing files; pass it only after the user said yes. `--base REF` counts the lane's commits as `REF..HEAD` instead, and also allows a detached HEAD: use it when no branch, remote or tag holds the lane's base, or when you plan a lane again that already has commits. |
| `risk [DIR] [--base REF]` | The lane's real changes (its own commits and `git status`, outside `.fleet/`, whatever the file system monitor or the untracked cache say) that match a high-risk pattern, each with what covers it: the newest plan round that the user approved, when it shows that category, or a line in `.fleet/RISK.md`. The rest needs the user before merge. When the changes cannot be told, the lane needs the user (text; `--json`). It only reads. |
| `approve-risk [DIR] --by user [--base REF]` | After the user's yes for a risky diff: append one `RISK APPROVED: <category> <path> by user <date>` line per uncovered path to `.fleet/RISK.md`, and record it. It refuses, changing nothing, outside a git worktree, when the changes cannot be told, when nothing needs the user, when git cannot resolve HEAD, or when a path cannot be written exactly (a control character, or bytes that are not UTF-8). |
| `sweep` | Every lane on this machine with its orch (or `unowned`) and a verdict, ready, waiting or keep, and the reason (text; `--json`). Changed and untracked files and renames count, whatever the settings for untracked files, the file system monitor or the untracked cache say; so do existing paths outside `.fleet/` marked assume-unchanged or skip-worktree (absent paths of a sparse checkout do not count). Ignored files do not, nor a mode-only change when `core.fileMode` is false. It only reads. |
| `cleanup TARGET... [--unmerged] [--dry-run] [--orch NAME] [--other-orch]` | Remove lanes: exit their agents, archive `.fleet/`, remove the worktree, delete the local branch when the merge holds every commit. It checks every target first and changes nothing when one is not ready, checks the lane again after the agents exit and before the removal (with `status.showUntrackedFiles=no`, Herdr does not refuse to remove untracked files; the helper's own `git worktree remove` passes `-c status.showUntrackedFiles=all`, so git refuses them), and never forces a removal. When `herdr worktree remove` fails, the worktree and the branch stay, and the lane's result names the command in `by_hand`: show it to the user. After a removal it closes the follow-ups that the lane's branch holds when its pull request merged, or the lane is merged and its branch moved since the lane was created (a rebase counts as a move), and releases them otherwise or when git cannot tell (reflog expiry); a failure there is reported in `follow_up_error`, changes nothing in PROJECT.md, and does not fail the cleanup. `--dry-run` lists them. A lane of another orch refuses the whole command (`lane <path> belongs to orch <name>; pass --other-orch to remove it`) until `--other-orch` is passed: pass it only for a lane that the user picked. |
| `adopt TARGET... [--orch NAME] [--other-orch]` | Make each target a lane of your orch (`--orch`: another): it writes `.fleet/lane.json`, also into a linked worktree made by hand (which gets `.fleet/`). A lane of another orch refuses without `--other-orch`, and so does a lane that a running cleanup is removing. The check and the write are one step under the project lock. A refusal exits 2 and changes nothing. |
| `prep [DIR] [--handoff]` | Create `.fleet/` and keep it out of git. `--handoff` also returns where a handoff file goes. |
| `orch [show\|list\|claim\|rename\|release] [--name N] [--orch N] [--pane P] [--replace] [--force] [--project NAME]` | The project's orchs in `orch.json`, by name (`show`, `list`: text; `--json`). `show` prints your orch (`--orch N`: another) with its files, `list` every orch with its pane, state and lane count (with `--project NAME` it needs no git; without, git finds the project from the checkout). Names are lowercase (`a-z`, `0-9`, `.`, `_`, `-`). `claim` registers the calling pane, or `--pane P`, as the orch `default` in a new project, as `--name N`, or under the name that the pane already holds; with several orchs and no name it refuses and lists them. Per name it refuses while another registered pane is alive, except `--replace` from that pane (a handoff, which keeps the name). When herdr cannot tell whether the registered pane is alive, it refuses too: check that pane, then `--force` takes over. A pane holds one orch of a project. It warns about a live FLEET.md orchestrator. `rename OLD NEW` renames an orch and moves its lanes with it; the orch keeps the old name, so no other orch can take it. `release` removes your record (`--orch N` names it; `--force`: another pane's). The first claim of a second name, or a rename, switches the project to format 2 for good. |
| `follow-up list\|add\|take\|release\|done [--project NAME]` | The project's follow-ups, the list items under `## Follow-ups` in PROJECT.md: `- [F7] <text>`, with ` (lane: <branch>)` once a lane took one. `list [--json]`: ID, text and lane of each (text). `add TEXT [--source S]` prints the new ID. `take ID --lane BRANCH` refuses while another lane holds it. `release ID` removes the lane mark. `done ID [--reason R]` removes the line; its event keeps the text and the indented lines. Every write first gives the lines without an ID their IDs, keeps every other byte of the file, and records a `follow_up_*` event (best effort, as every event). IDs come from the counter in `follow-ups.json` in the project home, so an ID is never used twice. A refusal exits 2 with `changed: "nothing"`. |
| `board [--project NAME] [--orch N] [--all]` | One row per lane of your view (your orch's lanes and the unowned ones; `--all`: every lane, with an ORCH column, saved nowhere): phase, pull request, panes, newest event, and a note, the first that applies: the plan warning, a risky diff that needs the user, the blocked line of STATUS.md, `<n> review rounds (limit <m>): ask the user first` (the hard limit of `/fleet:review`), `compacted <n>x: fleet reset <pane> at the next commit` (`/fleet:context`), the next-step line, or else the IDs of the follow-ups the lane holds (text; `--json`, where `risk` holds the high-risk matches, `follow_ups` the IDs, `compactions` and `compacted_pane` the compactions of the implementer or planner since its last reset, and `review_rounds`, `review_limit` and `review_approved` the counted review rounds, the conventions' limit and, at the limit, whether the newest round is approved). The two signals never act by themselves. Then the project's research files without a `RESEARCH DONE` line. It saves the board for your orch's re-brief and never consumes a change. |
| `digest [--peek] [--project NAME] [--orch N]` | Lane phase changes and the events of your view's lanes since your orch's last digest, at most 30, newest last (text; `--json`). It records each phase change in the log and moves the cursor. With `--peek`, or from another pane while the orch's registered pane is alive (or herdr cannot tell), it only reads; a pane that is no orch, in a project with several, names one with `--orch N`. A lane's event goes to the orch that owned the lane when the event was recorded (its `orch` field), once, even when the lane moved since; an `adopt` also goes to the orch that lost the lane (its `old` field); an event without an owner follows the lane's owner now. |
| `log [PROJECT] [--lane L] [--orch N] [--pane P] [--event E] [--since 7d] [--sessions]` | The project's event log (text; `--json`): the commands above that change something, and each Claude session in a fleet checkout. `--orch N`: the events of orch N, each by the owner of its lane at the time of the event. `--sessions`: one row per agent session, with its transcript. It only reads. |

`spawn` options:
- Placement: `--pane P` (an existing shell pane), `--worktree BRANCH --base REF`, `--tab`, `--new-workspace`, or a split (`--split auto|right|down`, `--from PANE`; default: split the calling pane). A split starts in the directory of the pane it splits unless you pass `--cwd`.
- Owner: in a lane that no orch owns, `spawn` records your orch in `.fleet/lane.json` (`--orch N`: another). It never moves an owned lane; `adopt` does. It refuses (exit 2, `changed: nothing`) a lane that a running cleanup is removing, owned or not; start the agent elsewhere, or after that cleanup ends.
- Agent: `--agent claude|codex`, `--model`, `--effort` (claude `--effort`; codex `model_reasoning_effort`), `--permission-mode` (claude), `--account` (remuda only), `--name LABEL`, `--role impl|critic|orchestrator|helper|planner|researcher`, `-- <more agent arguments>`.
- Task file: `--task FILE` (needs `--role`) keeps the file's absolute path with the pane's role. After /clear or compaction, the SessionStart hook tells a researcher or helper to re-read it.
- Task: `--prompt "<one line>"` (passed as an argument, so it is never pasted). Put longer tasks in a file and point at it.
- `--resume SESSION_ID` (claude): fork that session in the new pane, for example on another account. It refuses when the target account cannot see the transcript.
- `--accept-trust`: answer the folder trust dialog. Use it only for a worktree you just created. It never answers Codex's hooks review.
- `warnings` in the result: start-up checks that did not stop the spawn. Codex project hooks without a trusted state on that account (Codex opens its hooks review and the start ends blocked), or a stale or missing usage cache of the chosen account. Tell the user. Never trust hooks for the user: the fix is theirs (open Codex on that account in the checkout and press `t` in the hooks review).
- Exit code 2: the agent did not confirm. Read its pane: `herdr pane read <pane> --source recent-unwrapped --lines 300`.

`watch` exit codes: 0 marker found, 4 blocked on a dialog, 5 agent exited or pane gone, 6 stopped without the marker, 7 timeout. It prints the end of the screen for 4, 6, and for 5 when the agent exited.

## Lane lifecycle

Follow-ups are the open work that no lane holds yet: a finding below the stop rule, a gap that a lane leaves, work that the user parks. **Add** each with `follow-up add "<text>" --source "<where>"`. **Take** one with `/fleet:lane --from <ID>`: the lane's task is its text, and the lane skill marks it with the lane's branch. It is **closed** when `cleanup` removes the lane and its pull request merged, or the lane is merged and its branch moved since the lane was created (a lane that was only rebased onto main counts as moved). Otherwise cleanup releases it: a lane whose branch never moved, a lane removed unmerged, or when git cannot tell because reflog expiry removed the branch's creation entry. Close one by hand with `follow-up done <ID> --reason "<why>"`.

0. **Research** (on demand): `/fleet:research <question>`. A researcher pane answers into `<home>/research/<slug>.md`; briefs and plans link to the answer.
1. **Open**: `/fleet:lane`. Worktree, BRIEF.md, then the triage below. Then an implementer pane with `--role impl`, and a background `watch` for `READY FOR REVIEW: round 1`.
   - **Plan first** (when the triage says so): a planner pane writes `.fleet/PLAN.md` and ends it with `PLAN READY: <n>`; you approve it with `approve-plan` (the user approves a high-risk plan), retire the planner, and start the implementer in the same pane on BRIEF.md and PLAN.md. `spawn` refuses the implementer until the newest round is approved. The board shows `planning`, `plan ready <n>`, `plan approved <n>`.
2. **Watch**: act on each `watch` result, then watch again.
   - 4 (blocked): read the pane. Answer only dialogs that you can safely decide. Never approve a flagged command for a lane: cancel it with `herdr pane send-keys <pane> Escape` and re-instruct.
   - 6 (stopped): read STATUS.md (its `Blocked` section) and the pane. The lane may have a question, a placeholder, or a background job. Answer with `send`.
3. **Review**: `/fleet:review`. Review request, critic panes per the conventions, verdict, findings back to the implementer, stop rule.
4. **Context**: `/fleet:context`. Reset long lanes at a commit. Hand off when an account or model must change (`/fleet:handoff`).
5. **Finish**: first run `risk <worktree>`. When it says that paths need the user, or that the changes cannot be told, show the user the matches and the diff of those paths, and ask. After the yes, run `approve-risk <worktree> --by user` and check that `risk` says nothing needs the user. Never push, open the pull request or merge while the lane needs the user. Then push, open the pull request and merge as the conventions and the project's rules say. The board and the event log show the merge: write no merge record. Write a ruling that the merge made, if any, to PROJECT.md (or your ORCH.md), and add follow-ups with `follow-up add`.
6. **Clean up**: `/fleet:cleanup`, which the user runs. It sweeps every lane, asks which ones to remove, removes them and runs the project's own cleanup. After a merge, run `sweep` and tell the user which lanes are ready. Run `cleanup` yourself only on lanes that the user named for removal.

## Rules

- Triage, by the conventions' `## Planning and research` section. Research first when you cannot name the files or facts a brief needs, or several lanes need the same answer. Plan first for a high-risk change (migration, auth or payments, deletion logic, incident hotfix), a change that spans subsystems, or a brief that cannot name its files. Otherwise the implementer plans in STATUS.md.
- A planner writes only PLAN.md, and a researcher only its research file. Approve a plan only with `approve-plan`; a high-risk plan (a `Risk:` other than `none`, or a path under `## Files` that matches a high-risk pattern) needs the user's yes.
- Only `approve-plan` writes `PLAN APPROVED` lines, and only `approve-risk` writes `RISK APPROVED` lines. A line written by hand passes the gates, so read PLAN.md and RISK.md before you rely on them, and never let an agent write those lines.
- One implementer per worktree. Critics work in the lane's worktree, write only their review file, and never edit code.
- Dispatch with `send`, `spawn --prompt` or files. Use `herdr pane run` or `send-keys` only to answer a dialog.
- Watch files and git, not scrollback. Each marker carries a round number. Never reuse a number.
- To see where the lanes stand, run `digest` or `board`, not `status` and scrollback. To recall what a lane was told and which sessions worked on it, read `log --lane <branch>` or `log --sessions`.
- `done` does not mean finished. Before a review, check that STATUS.md has real verification results and no `PLACEHOLDER`.
- The helper refuses to drive your own pane. For yourself, use `/fleet:context` or `/fleet:handoff`.
- Close only panes, tabs and workspaces that you created. Never delete a branch or worktree that holds unmerged work.
- Decisions, follow-ups and the user's project rules go to PROJECT.md as soon as they happen; once the project has several orchs, the decisions and notes of your theme go to your ORCH.md instead. A decision is a ruling and its reason, one line; a merge, a review round, a push or a cleanup is no decision. Do not keep a lane table or a merge log: the board, the event log and git keep them.
- Your lanes are the ones your orch owns. `cleanup` and `adopt` refuse a lane of another orch without `--other-orch`: pass it only for a lane that the user picked, and never to take over another orch's work on your own.
- A checkout that several orchs share stays on the default branch, and is updated only by `git fetch` and a fast-forward (`git merge --ff-only`). Branch work, dev servers and tests run in lanes: each worktree has its own. An orchestrator that needs its own working copy keeps its own clone.
- Follow-ups go in through `follow-up add`, never by hand. Only the helper writes `[F<n>]` IDs and `(lane: ...)` marks. A line written by hand still works: the next `follow-up` command gives it an ID. Before you open a lane for a follow-up, `follow-up list` shows whether another lane holds it.

The reasons behind these rules, from earlier fleets: `${CLAUDE_PLUGIN_ROOT}/skills/fleet/references/lessons.md`.
Files in this package (3)
  • SKILL.md 24 KB
  • references/lessons.md 9 KB
  • references/templates.md 19 KB

Versions

RepositoryScoreLicence
This page · rubycatco/herdr-fleet100MIT
rysweet/amplihack-rs100MIT
intentic/intentic100MIT
SethGammon/Citadel100MIT
thettwe/nyann100MIT

Database snapshot: 13.11.2026 · package version 9a9ec9d5500c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100herdr-fleet
    Runs several coding agents in parallel in Herdr panes, each reporting through a file, and wakes the orchestrator when each agent marks its task done. Agents come from a per-project config, so any mix of supported CLIs (Claude, Codex, Cursor, Devin, Grok, command-code) works. Use…
  • 100herdr-fleet
    Run several coding agents in parallel in herdr panes, each under its own clausona profile (another Claude Code or Codex account, or an API model such as GLM or DeepSeek), then watch them, check their work and retire them. Use when the user works in herdr and wants work spread…
  • 100fleet-manager
    Coding-agent sessions on every machine you connected, over Herdr where it runs, tmux elsewhere, and MSP for your MSP hosts: one digest of what is waiting on you, ready for review, working or idle; open a session with a brief; read, steer, approve, stop, close; connect a machine…
  • 100tower
    Run the orchestrator's war room on visible Herdr panes so the user can watch every child agent work. Use when the user says 'tower on', 'orchestrate this in herdr', wants routed agents they can see, or when the orchestrator is on inside a Herdr-managed pane.
  • 100herdr-dispatch
    Run a task list across parallel Herdr panes - measure the pane budget, split, start one agent per task, brief them, collect results from files, handle blocked workers, clean up. Use when the user says "dispatch these", "run these in parallel", "fan this out", "spin up agents",…
  • 100herdr
    Control Herdr, the terminal multiplexer for coding agents. Use when the user mentions Herdr or another skill delegates pane control, including concise pane naming, inspection, commands, and agents. Integrates with vd:worktree, vd:codex-workflow, and vd:ultracook. Requires HERDR_ENV=1.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.