jackherd 1.9.0 → 1.11.0

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.11.0
+
+- **The herd lists your sources.** A `watch.sources` entry that is no ticket gets a row in a `Sources` block: when it last ran, since when it fails (red mark), its newest report (amber mark while it is under a day old); a click opens the report's URL. `/jh-follow` and `recipes/sources.md` say how.
+- **The colours of the herd are configurable.** `plans.tones` names the tone of each role (`waiting`, `new`, `running`, `resting`) from amber, teal, grey, red, green, blue and magenta; a source may carry its own `tone` for its new reports. The defaults are the colours it had.
+- **A row from a source says which one.** `watch.sources[].label` (at most 40 characters, one line; without it the source's name) is put before a "Waiting for you" row whose `Origin` cell names the source, as `<label>: <row>`.
+- **"Waiting for you" rows have `[done]`, the appointments have `[done]`, `[run]` and `[move]`.** `[done]` closes the row (the board's status cell, a sent file's record), `[run]` asks the coordinator to run the appointment now, `[move]` to ask you for a new time.
+- **New blocks and cells in the herd.** `Next` shows the board's next section; a resting lane says `waits on: …` or `after: …`; `groomed 3d ago` beside the clock (amber from eight days) from the board-grooming appointment; `planned` shows the next phase per plan, with `stale?` once its plan file has not changed on the base branch for 14 days.
+- **`jh mermaid <file>` checks the diagrams of a pull request text.** An edge label between dashes (`-- text -->`) or a pipe label without quotes makes GitHub show `Lexical error` instead of the diagram; the command exits 1 with the line. The pull request rule now says to write `-->|"label"|` and to run it before `gh pr create` or `gh pr edit`.
+- **A report that says "Keine offenen." asks nothing.** The watcher no longer counts it as a question, and a bold or listed "None." does not either.
+- **A note in the write set no longer widens it to the whole repository.** A backticked config key such as `watch.sources[].label` in the `Writes` cell of a plan's dependency table is no path, so `jh lane prompt` lists only the real folders.
+- **One colour rule for the buttons.** The buttons no longer wear the colour of the row's mark: amber and bold in "Waiting for you", the normal foreground colour in the other blocks, dim only where nothing is left to do (an entry that says `↑ asked`).
+- **A source with several entries opens on a click.** The `Sources` block shows one folded row per source (amber only for a new entry that no row of "Waiting for you" asks about); opened, it lists up to five entries with title, count (`map.count`, new) and time, then `+<n> more`. A click on an entry opens its `url`, `[ask]` asks the coordinator to look at exactly that entry, and an entry that "Waiting for you" already asks about is dim and says `↑ asked`. The watcher keeps the last 20 entries of such a source.
+- **A question put off twice stays one open question.** The `open-question` hook writes no second record while one with the same text is still open, so asking it again with `[ask]` and answering "later" again leaves a single row.
+- **A click folds the ticked tasks again.** The listed ticked tasks of a phase get a line `▾ <n> ticked · click or a folds them` above them; before, only `a` closed the list that a click had opened. The key hint and the legend name both.
+- **`jh lane prompt` keeps your additions and names no contested phase.** What you write below the marker line at the end of the prompt file stays through every new writing, `--handover` included. A phase that two open rows of the board name comes into neither prompt; the command prints it and a lane left with nothing is refused.
+- **The row under the mouse or the arrows is marked, everywhere.** Any clickable row of the herd (lane, phase, ticked line, `waiting`, `planned`, and the rows of `Waiting for you`, `Next`, `Appointments` and `Sources`) gets a light background and a `❯` in front, and its buttons turn bold; the background joins the text and its buttons across the full width. The herd now asks the terminal for mouse movement and redraws only when the row under the mouse changes. `↑↓` also walks the rows of the blocks on top; enter on one asks, opens or expands it, and never presses `[done]` or `[run]`. The legend names it.
+- **Links are bracket buttons, and the mouse bolds only the one it is on.** The links under a lane (`[↗ #<n>]  [📄 Plan]  [✦ title]`) lose the grey background and read like `[ask]`: a square bracket means a click does something. `… checks` stays plain text, amber and dark red badges stay badges. An artifact link shows its title (the link text, the bold label before it, else the text of its line) instead of "Artifact". With the mouse over a row only the bracket under it turns bold; with the arrows the whole row is the unit. A line of links is marked by the mouse, not walked by the arrows.
+- **The README follows a source from the command to your answer.** A short section with a diagram: source, watcher, coordinator, "Waiting for you", you.
+
+## 1.10.0
+
+- **`jh sync` writes the ask rules the merge guard left behind.** A project sync adds `permissions.ask` rules for `gh run rerun` and the `gh api` writes that merge, write a file, dispatch or rerun a workflow, or move a ref; it records them in the lock, removes one only when the kit drops it and only if a kit shipped it, and leaves your own rules alone. Claude Code applies a matching ask rule even when a hook answers `allow`.
+- **A standing approval replaces the plan approval.** The coordinator asks once per plan with an end time, at most 24 hours ahead; until then the merge guard lets the plan's lane pull requests merge on green checks, except workflows, migrations, env files and the guards' own files (hooks, settings, the jackherd config, git hooks). It lives in that chat only: after a hand-over the new chat asks again. The plan approval, its hook and its pointers under `.jackherd/approvals/plans/` are gone.
+- **`guard.planApproval` is now `guard.alwaysAsk` and `guard.requiredChecks`.** The old key is still read until 2.0.0, so your config keeps working.
+- **A lane that works without reporting its task is noticed.** A new `PostToolUse` hook `task-hint` reminds a lane once per task to run `jh task start` (off with `hints.taskSignal: false`); the watcher reports `lane <name> no task signal (P<n>)` once per lane and phase after `watch.taskSignalMinutes` (default 10) of work. The herd takes the current phase from the lane's newest reported task, else from its branch name, and a phase with a signal never reads `next`.
+- **The herd and the watcher read ticked boxes from open pull requests.** A phase whose pull request ticks it further shows that count, not the one from the base branch; `jh lane prompt` reads the plan from the lane's worktree and leaves out a phase finished in either copy. Pull request heads are fetched into `refs/jackherd/pr/<n>`, apart from your branches.
+- **`jh lane close <lane> [--dry-run]` closes a finished lane in one run.** It first checks that nothing is lost and lists every reason it refuses: the board does not name the lane, its branch has no merged pull request whose merge commit holds the same tree, the worktree holds anything beyond `node_modules`, the `.worktreeinclude` files and known build output, the hand-over directory is not empty, an agent still works in it, or the command runs inside it. Then it exits the agent, checks again, removes the worktree (never forced) and the herdr workspace, deletes the branch at the checked head and marks the board rows with a history row. `--dry-run` only checks. `jh sync` adds ask rules, so Claude Code asks before every call, `--dry-run` included. The watcher's `plan finished` line names the dry run, and the orchestrate skill shrinks its closing steps to the command.
+- **The herd shows a lane's subagents on their task.** A lane's own review ran as a subagent the herd never listed. Now the subagents of the lane's worktree count in the heartbeat, a review sits on the gate item that names its type (or shows `▶ Subagent: <description>`), and a subagent whose description starts with an open task's short name sits on that task. `task-hint` also reminds of the task signal when a subagent starts. An opened task shows its short name once.
+- **The watcher reminds you when the main checkout is out of date.** While it lags behind `origin/<base>` or has another branch or a detached head checked out, every report and heartbeat carries a line (`main checkout behind origin/<base> by <n> (git merge --ff-only origin/<base>)`, `main checkout on <branch>, not <base>`). A watcher run from source ends with `kit updated … (source changed)` when its sources change, so the herd restarts on the new code.
+- **A question from a working lane is reported at once.** A lane waiting on background subagents ends no turn, so its question waited for them. The watcher now reports a changed questions section of a working lane as `report … questions: <n>`, once per change and not again after a restart. The `open-question` hook treats "noch nicht" and "not yet" as putting a question off.
+- **A source keeps its interval over a restart of the watcher.** Each `watch.sources` entry remembers when it last ran, so a restart no longer runs every source at once.
+
+- **No mandatory rule is lost when a skill gets shorter.** The kit's own test holds the 67 rules the coordinator and the lanes must follow and finds each in its skill or in a reference the skill links, so a cut that drops one turns red.
+- **`jh check` measures what an agent loads, in words.** Every installed kit skill, reference, agent and always-loaded kit rule, each project supplement (`.claude/project/<skill>.md`, 800 words) and each skill of your own (2000 words) is counted against a word budget: a warning above it, an error above it plus 10 %. Set your own under `check.skillBudgets` in `.jackherd/config.json`, by path or glob; a key joining two paths with ` + ` budgets what loads together. The kit's test reads the same budgets, which now sit at the measured size plus at most 10 %, and every budget names a file the kit ships.
+- **A rare watcher line names the file that handles it.** A rare event ends in `· read <skill directory>/references/<file>`, so the coordinator reads that procedure when it is needed instead of carrying it in every session; a kit update reports changed, new and deleted references like the skill. The heartbeat names the tick count of every working lane and its running subagents (`P12 7/12, 3 subagents`).
+- **The herd shows what waits for you and the board's appointments as blocks of their own.** `Waiting for you` lists the board's open questions, the files sent to you and the dialog questions you left open (a new stop hook `open-question` records them); a click sends the coordinator a fixed line with the question's id. `Appointments` lists the open rows of the board's appointments section. Both fold together. A lane row shows the task's short name, a running reviewer makes its phase active, finished phases read `done P1–P2` beside `next P4–P5`, and the clock is `HH:MM`. One herd runs per terminal: a new one stops the older on the same tty (Linux). The herd reads session logs and plans through a cache and redraws only a changed frame.
+- **`jh lane prompt <lane>` writes a lane's first prompt** from its board row and the plan's dependency table, in the plan's language (`--board`, `--out`, `--handover` for a restart). It tells the lane its phases, its write set, that it may tick its own tasks, and that code and tests go through Write and Edit, never a here-document in Bash.
+- **The orchestrate skill is about a third shorter.** The coordinator loads about 7400 words instead of 11400; rare steps (setting up and closing a lane, the rare events, a draft for review, an acceptance, a lane's hand-over) moved to references under `references/` that name their section and trigger. Sections and step numbers stay.
+- **Every file jackherd keeps outside the repository lies in a private directory it checks first.** The board page, `jh preview`'s page, the watcher's lock and state, skill diffs and the herd's lane memory go below `$XDG_RUNTIME_DIR` (when it is the user's own and closed to others) or `<tmp>/jackherd-<uid>`, written through a temporary file. The herd reads the watcher's files only from a private directory and only regular files.
+- **The implement, plan and follow skills are shorter, and every task has a short name.** A plan task starts with `- [ ] **Name**: …`, at most 40 characters; the plan templates use it, and the herd shows it. `/follow` reads the rules every recipe follows from the recipe index.
+- **`skill-review` reviews changed agent texts.** `jh check` routes a change to Markdown under `skills/`, `agents/`, `rules/`, `.claude/project/` and to `CLAUDE.md`/`AGENTS.md` to the new kit agent, which judges it against `writing-for-agents.md`: no-op, the same rule twice, the wrong rung, a late trigger, a negation, an open step. `jh check` warns about a new plan task without a short name or with one over 40 characters, and about a phase title over 50.
+- **The coordinator may start parallel tasks without asking, inside a window you set.** `watch.parallelTasks.auto: { "since": "<date>", "until": "<date>" }`, at most seven days, off by default. Inside it, a `parallel tasks` proposal ends in `· auto until <day>` when every limit holds: running work in the lane, at most two extra subagents, cost under `watch.parallelTasks.maxTokens`, no path that always asks (nor a migration or env file below a written directory), read from the plan at the base branch. Otherwise it ends in `· asks: <limit>` and the coordinator asks as before. The end of the window is reported once.
+- **The merge guard and the git guard read only the parsed script.** They count a command at a program position (past options, chains, subshells, substitutions, `env`/`sudo`/`xargs`, `sh -c`, `eval`, aliases and functions), and no longer search interpreter code, here-document data or quoted text for command words, which caused most of their false alarms. A call that only reads passes (`--help`, `gh … view`, `gh … list`), and a script the parser cannot read asks only when `gh` stands where a command starts. Deliberately accepted: `subprocess.run(['gh', 'pr', 'merge', …])` in an interpreter no longer asks.
+- **The merge guard guards only `gh pr merge` and `gh workflow run` by default.** `gh run rerun` and the `gh api` writes left `guard.commands`; `jh sync` now writes them as ask rules (first entry above).
+- **`merge.withoutChecks` no longer merges a file on a path that always asks** (workflows, migrations, lockfiles, env files, agent instructions, `guard.alwaysAsk`), besides `package.json` and changelogs.
+- **A coordinator hand-over carries your standing approvals.** The hand-over script takes `--board <board> --approval "<line> <DD.MM.> <HH:MM>"` and quotes that board row word for word into the new chat's first input, so a commit you already approved is not refused there. It refuses a row without your dated mark, an end the row does not name, and an approval that has ended.
+- **npm finds jackherd under `plan-driven` and `multi-agent` too**, beside `orchestration` and the other keywords.
+- **The README says what jackherd adds to Claude Code** after a check against the code and the Claude Code docs, recommends herdr and names who it is for. `INSTALL.md` lists all eleven project hooks, and `/orchestrate` sends migrations and writes against a shared environment to you every time.
+
 ## 1.9.0
 
 - **An open lane in the herd takes fewer lines, and a red pull request says what failed where.** A failed test hangs under its check as `└ ✗ <package> · <test>`, the package read from the log (the monorepo task header, else the test file), the test path dim with `›`; a cut name unfolds on a click and folds on the next. The pull request title stays on one line, a lane's only link chip moves onto its session line, and the finished phases are ranges (`✓ P1–P7, P10–P15`). The label column (SESSION, PR, NOW, NEXT, LATER, DONE, LINKS) is gone: the tree lines and each row's mark (`⎇`, `↗`, `▶`/`▷`, `✓`) say what it is, and every row under a lane gains the 9 columns the labels took. Each running phase is a branch of its own, and the other open phases share one line, `next P18–P25` (ranges, the other plans by name after them). A reported task in other words still finds its plan task, and a lane that reports a task shows no guessed `▷`. The progress column is calmer: no `◐`, the `🥣` cell on a folded lane only from `warn`, and a hidden cell keeps its width, so no bar moves; the checkbox count stands on every lane line. A folded lane's title line in a narrow pane starts in the column of the lane's name, where an open lane's branches start too. A click on a for-you row now also lands right while `now:` lines stand above it.

package/INSTALL.md

@@ -54,7 +54,7 @@ When `init` creates a new config, it asks:
 | Use it when | the team shares the kit through the repository | the repository must stay untouched, not even untracked files |
 | Lives in | the project's `.claude/` | `~/.claude/` |
 | Skill names | `/plan`, `/implement`, `/orchestrate`, … | `/jh-plan`, `/jh-implement`, `/jh-orchestrate`, … |
-| Hooks | `git-guard`, `watch-guard`, `merge-guard`, `approval-gate`, `ask-hint`, `format-on-edit` | none; `init --global` offers only a `SessionStart` update notice |
+| Hooks | `git-guard`, `watch-guard`, `merge-guard`, `approval-gate`, `model-gate`, `model-log`, `ask-hint`, `open-question`, `sent-file`, `format-on-edit` | none; `init --global` offers only a `SessionStart` update notice |
 | Config | `.jackherd/config.json` | `~/.jackherd/config.json`, used where a repository has none |
 | Update | `jh sync` | `jh update` |
 

package/README.md

@@ -7,27 +7,33 @@
 
 # Your agents write code. Jack keeps the work moving.
 
-**Let AI do the work. Stay in control.** jackherd is a coordination layer for your coding agents, built around a plan in your repository. Claude Code alone builds it one phase at a time; with [herdr](https://herdr.dev), a terminal for coding agents, phases run in parallel, each in its own git worktree. Jack, the coordinator, keeps these lanes moving: he answers what the plan already settles and brings you only the decisions that need you.
+**Let AI do the work. Stay in control.** jackherd orchestrates your coding agents, alone or as a team. You plan once, in your repository; Jack, the coordinator, runs it in parallel lanes.
+
+He settles the small questions himself and asks only what needs you. What's running, blocked or waiting for you sits on one screen.
+
+For developers who'd rather make the calls than babysit their agents.
+
+**We recommend [herdr](https://herdr.dev), a terminal for coding agents:** Jack, the lanes and the watcher run there; without it, one Claude Code session plans and builds, with independent phases as parallel subagents.
 
 Install with one command, run `/jh-start` in a repository, and it offers your first plan: [Quickstart](#quickstart).<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg?v=2">
 
 <p>
 <img src="https://unpkg.com/jackherd/docs/workflow-dark.svg" width="720" alt="jackherd in herdr: a lane hits a question, Jack asks you as a choice, you pick, and the lane works on while the herd view counts its progress.">
 <br>
-<sub>Parallel lanes in herdr. Without herdr, you plan and build one phase at a time.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg?v=2">
+<sub>Jack and parallel lanes in herdr (recommended).</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg?v=2">
 </p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/decide.svg?v=2" width="24" height="34" align="middle" alt=""> <b>You decide. Jack takes care of the lanes.</b><br>Jack answers what the plan already settles, records his decisions on the board, and asks you about the rest. One approval per pull request covers its commits and pushes. Jack merges automatically only when you've allowed it and checks pass.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/decide.svg?v=2" width="24" height="34" align="middle" alt=""> <b>You make the calls that matter.</b><br>Jack answers what the plan or a rule already settles and records each answer on the board, where you can check it. The rest reaches you as a short choice. Approve a plan once, and its pull requests merge on green checks, except on paths you marked to always ask.</p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/lanes.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Lanes stay apart.</b><br>One phase per lane, on its own branch and worktree. Jack keeps the board's merge order and has the other lanes rebase after each merge.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/bark.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Jack barks when something moves.</b><br>One view of the whole herd: each lane's progress, pull request and checks, and on top whatever waits for your answer. In herdr it also shows what each agent is doing and every new review comment. You stop hopping between terminals and holding the state in your head.</p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/bark.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Jack barks when something moves.</b><br>One live view of the herd, all your lanes: state, plan progress, pull request, checks, feedback, context fill.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/ear.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Jack listens, on GitHub and beyond.</b><br>A review comment, from a teammate or a bot, goes to its lane, which fixes it with a test and answers in the thread; a judgement call comes to you. <code>/jh-follow</code> follows any tool with a CLI or an API, with recipes for Jira, Linear, Sentry and status pages as a head start, and Jack reports changes. Runs in herdr.</p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/ear.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Jack listens beyond GitHub.</b><br><code>/jh-follow</code> Jira, Linear, Sentry or a status page, and Jack reports changes while he runs in herdr.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/lanes.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Parallel where it pays.</b><br>The plan says what each phase writes and waits for, and jackherd works out what can run side by side: independent phases as subagents in one session, bigger ones in a lane of their own in herdr, with its own branch and worktree. Where more could run in parallel at little cost, Jack suggests it. He keeps the merge order and has the others rebase after each merge.</p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/plan.svg?v=2" width="24" height="34" align="middle" alt=""> <b>One workflow for the whole team.</b><br>After <code>jh init</code>, plans, skills, rules and guard hooks are files in your repository. Commit them, and everyone who opens it in Claude Code works with the same set; changes to it go through your usual pull request review.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/plan.svg?v=2" width="24" height="34" align="middle" alt=""> <b>One workflow, solo or team.</b><br>Plans, boards and Jack's decisions live in your repository, so everyone sees what was planned, what was settled and what comes next, and workflow changes go through your usual review. <code>jh init</code> adds the skills, rules and guard hooks through Claude Code's own project settings.</p>
 
-<p><img src="https://unpkg.com/jackherd/assets/icons/bowl.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Long chats get a fresh start.</b><br>A lane whose context fills up continues in a new chat at the end of its phase, from the ticked-off plan and a hand-over note.</p>
+<p><img src="https://unpkg.com/jackherd/assets/icons/bowl.svg?v=2" width="24" height="34" align="middle" alt=""> <b>Pick up where you left off.</b><br>The ticked-off plan and the board carry the state, not the chat. A lane whose context runs high continues in a fresh chat at the end of its phase; Jack hands himself over the same way.</p>
 
 ## Quickstart
 
@@ -40,7 +46,7 @@ Install with one command, run `/jh-start` in a repository, and it offers your fi
    Already in a coding agent? Paste this instead:
 
    ```text
-   Install jackherd by following https://unpkg.com/jackherd/INSTALL.md. Ask me the setup questions it lists; herdr is optional.
+   Install jackherd by following https://unpkg.com/jackherd/INSTALL.md. Ask me the setup questions it lists; herdr is recommended, not required.
    ```
 2. **Start Claude Code in a repository.**
 
@@ -57,7 +63,7 @@ Install with one command, run `/jh-start` in a repository, and it offers your fi
    ```text
    /jh-implement docs/plans/<plan>.md phase 1
    ```
-5. **Run phases in parallel with herdr (optional).** In Claude Code inside herdr, hand Jack the board:
+5. **Run phases in parallel with herdr (recommended).** Lanes, the full herd view, review-comment fixes and ticket reports need it. In Claude Code inside herdr, hand Jack the board:
 
    ```text
    /jh-orchestrate docs/plans/board-<name>/board.md
@@ -65,6 +71,21 @@ Install with one command, run `/jh-start` in a repository, and it offers your fi
 
 By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh init --global` for yourself, or `jh init` in a repository to give your team the same skills and guard hooks. → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)
 
+## Follow anything outside GitHub
+
+`/jh-follow` turns a ticket, an error log or a status page into something Jack acts on. It writes the source to `watch.sources` after a dry run and your yes; from then on a change takes this path:
+
+```mermaid
+flowchart LR
+  source["Source<br/>ticket, error log, status page"] -->|"new or changed entry"| watcher["jh watch"]
+  watcher -->|"=== source … report"| coordinator["Jack"]
+  coordinator -->|"board row, origin = source"| waiting["Waiting for you<br/>Error log · Checkout: …"]
+  waiting -->|"[ask]"| coordinator
+  coordinator -->|"asks you, then a lane works it"| you["You"]
+```
+
+The herd lists each source that is no ticket in a `Sources` block (when it ran, since when it fails, its newest report, a click opens it), and a row that came from a source starts with its `label`. Details and every field: [recipes](https://unpkg.com/jackherd/recipes/sources.md).
+
 ## In detail
 
 <details>
@@ -76,27 +97,25 @@ By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh
 | --- | --- | --- |
 | Starting a ready phase in a lane | Commits, push and pull request, once per pull request | Writing lane code himself |
 | Answering what the plan or a rule settles, on record in the board | Every other decision a lane raises | Merging a pull request on a path that always asks, without asking you |
-| Merging a pull request of an approved plan on green checks | A plan approval, once per plan | Storing a permission on your behalf |
-| Rebasing the lanes after a merge | Migrations and writes against a shared environment | |
-| Handing a session over to a fresh chat before its context fills up | Closing a lane | |
+| Merging a plan's pull requests on green checks for a while | A standing approval, until a time you pick | Storing a permission on your behalf |
+| Having the lanes rebase after a merge | Migrations and writes against a shared environment | |
+| Handing a lane over to a fresh chat at the end of a phase, once its context runs high | Closing a lane | |
 
 </details>
 
 <details>
 <summary><b>Guarded commands and merges</b></summary>
 
-In a project install, the `merge-guard` hook asks you before `gh pr merge`, `gh workflow run`, `gh run rerun` and a `gh api` write that merges, writes a file, dispatches or reruns a workflow, or moves a ref, also behind a chain, a wrapper or `sh -c`. The `git-guard` hook refuses a git command that hides a commit, push, rebase, reset, checkout or merge from your permission rules (`git -C … push`, `sh -c "…"`), every push to the base branch, and every force push, skipped hook and hard reset.
+A project install adds two hooks to Claude Code's [permission rules](https://code.claude.com/docs/en/permissions):
 
-A merge passes without a question only on an answer from your own dialog: self-merge for that pull request, or the approval of its plan, with green checks and no file on a path that always asks (workflows, migrations, lockfiles, `package.json`, env files, agent instructions, and your own list). `merge.withoutChecks` lets a pull request that only touches such paths as docs merge without waiting for checks.
+- **`merge-guard`** asks before `gh pr merge` and `gh workflow run`, also behind options, a chain or `sh -c`. Calls that only read pass.
+- **`git-guard`** refuses hidden commits and pushes (`git -C … push`), pushes to the base branch, force pushes without lease, skipped hooks and hard resets.
 
-```json
-{
-  "guard": { "planApproval": { "exceptPaths": ["src/billing/**", "src/auth/**"] } },
-  "merge": { "withoutChecks": ["docs/**/*.md"] }
-}
-```
+`jh sync` also adds ask rules for check reruns and `gh api` writes.
 
-The guards catch an agent's mistakes, not an agent set on getting around them; for that, use branch protection. A global install ships no hooks, and the skills ask on their own.
+A merge passes without a question on green checks after self-merge, or under a standing approval: one plan's lanes until a time you pick, at most 24 hours; workflows, migrations, env files and the guards' own files still ask. A pull request whose files all match `merge.withoutChecks`, such as docs only, skips question and checks, unless a file lies on a path that always asks.
+
+The guards catch mistakes, not intent; for that, use branch protection. The hooks need Bun; a global install ships none.
 
 </details>
 
@@ -115,8 +134,8 @@ A **plan** is Markdown with phases, checkbox tasks, a model and a review gate pe
 | `/jh-implement` | builds and tests one phase and ticks it off; independent phases run as parallel subagents |
 | `/jh-orchestrate` | runs a board's lanes in herdr, as Jack |
 | `/jh-pre-commit` | runs `jh check` and the reviewers, proposes the commit message and asks before committing |
-| `/jh-follow` | follows a ticket or a status page outside GitHub |
-| `/jh-diagnose` | turns a bug into a failing command, then hands the fix on |
+| `/jh-follow` | follows something outside GitHub: a ticket, error logs, a status page |
+| `/jh-diagnose` | turns a bug into a failing command, fixes it with a regression test |
 
 The global install names the skills with a `jh-` prefix; a project install uses none, unless the project already has skills of the same names.
 
@@ -125,26 +144,33 @@ The global install names the skills with a `jh-` prefix; a project install uses
 <details>
 <summary><b>Which model runs each phase</b></summary>
 
-Each phase in the plan names its model: the planning model (Opus by default) where a mistake is expensive, such as data, security or a migration, and the cheaper implementation model (Sonnet by default) for everything else. `/jh-implement` and Jack start each phase on its model, and in a project install a hook stops a phase handed to a weaker one. Set the models per role under `models` in the config.
+Each phase in the plan names its model: the planning model (Opus by default) where a mistake is expensive, such as data, security or a migration, and the cheaper implementation model (Sonnet by default) for everything else. `/jh-implement` and Jack start each phase on its model. In a project install, a hook stops a phase's subagent started on a weaker one, and the watcher tells Jack about a lane that runs on one. Set the models per role under `models` in the config.
 
 </details>
 
 <details>
-<summary><b>The watcher and tickets outside GitHub</b></summary>
+<summary><b>The watcher and sources outside GitHub</b></summary>
 
-Jack doesn't watch the terminals himself. `jh watch`, which he starts, wakes him when a lane is blocked or done, a check turns red, a pull request gets feedback, a lane's context fills up or a lane waits for an approval; deploys and previews too, when configured.
+Jack doesn't watch the terminals himself. `jh watch`, which he starts, wakes him when a lane is blocked or done, a check turns red, a pull request gets feedback, a lane's context fills up, a lane waits for an approval or works for ten minutes without reporting its task; deploys and previews too, when configured.
 
-`/jh-follow PROJ-123` adds a ticket, an issue or a status page: it checks the tool and its login, shows you a dry run and writes the source to `watch.sources` after your yes. The [recipes](https://unpkg.com/jackherd/recipes/README.md) cover Jira, Linear, GitHub issues and Projects, Sentry and status pages. The reports need herdr; a source can be set up and dry-run without it.
+`/jh-follow PROJ-123` adds anything a command can print as JSON: a ticket, an issue, error logs, a status page. It checks the tool and its login, shows you a dry run and writes the source to `watch.sources` after your yes. A token stays in the environment, read by a small Bun script, never in an argument. Each source runs on its own interval, kept across a restart of the watcher. The [recipes](https://unpkg.com/jackherd/recipes/README.md) cover Jira, Linear, GitHub issues and Projects, Sentry and status pages. The reports need herdr; a source can be set up and dry-run without it.
 
 </details>
 
 <details>
 <summary><b>The herd view</b></summary>
 
-`jh herd` shows every lane of a board: agent state, plan progress, pull request, checks and context fill. It only reads.
+`jh herd` shows every lane of a board: plan progress, pull request and checks, and with herdr agent state and context fill. It changes nothing in your repository.
+
+On top, **Waiting for you** lists what needs your answer: a file or Artifact sent to you (`📎`) and open questions from the board or a session's dialog (`?`). **Appointments** below it shows the dated rows of the board's appointments section. A click folds either block.
 
 ```text
 🐾 Board 01                                                                11:38
+▾ Waiting for you · 2 ──────────────────────────────────────────────────────────
+▌ 📎 search-box-mockup.html
+▌ ? Ship the fee change before Friday?                                     [ask]
+▾ Appointments · 1 ─────────────────────────────────────────────────────────────
+▌ ◷ Mo 09:00 Release 1.4 to production
 ────────────────────────────────────────────────────────────────────────────────
 ▾ ◆  search-ui     blocked                                 ██████░░░░      6/9
   ├─ Search box docs                             ⎇ feat/search-ui ↑1 ±4  🥣 62 %
@@ -164,7 +190,7 @@ Jack doesn't watch the terminals himself. `jh watch`, which he starts, wakes him
 ────────────────────────────────────────────────────────────────────────────────
 · no agent (1)  docs-site 1/3
 ────────────────────────────────────────────────────────────────────────────────
-↑↓ select  →← open  a show ticked  s html  q quit  ? help
+↑↓ select  →← open  a/click ticked tasks  s html  q quit  ? help
 ```
 
 </details>
@@ -180,22 +206,29 @@ Jack doesn't watch the terminals himself. `jh watch`, which he starts, wakes him
 | `jh check` | types, lint and tests of what you touched, plus the plan and board checks (`--skip-slow`, `--parallel <plan>`) |
 | `jh herd` | the live view (`--once`, `--lane <name>`) |
 | `jh watch` | the watcher Jack runs |
+| `jh lane prompt <lane>` | writes a lane's first prompt from its board row and its plan (`--out`, `--handover`); your additions below the marker line at its end stay |
+| `jh lane close <lane>` | removes a finished lane: agent, worktree, herdr workspace and branch, and marks the board; first checks that nothing is lost, and refuses with every reason; `--dry-run` only checks. Claude Code asks before each call |
 | `jh preview <file>` | renders a Markdown file through the GitHub API into a preview in GitHub and npm style |
 | `jh waiting` | the files and Artifacts sent to you that you have not answered yet (`close <id>…` or `close --all` once you have) |
 | `jh context` | how full an agent's context is, as JSON |
 | `jh config` | the commands and the base branch the repository uses |
 
-Without a global install, run them as `bunx jackherd <command>`. The config is `.jackherd/config.json` in a project and `~/.jackherd/config.json` globally, checked against [one schema](https://unpkg.com/jackherd/schemas/jackherd.schema.json) your editor completes. What usually needs setting:
+Without a global install, run them as `bunx jackherd <command>`. The config is `.jackherd/config.json` in a project and `~/.jackherd/config.json` globally, checked against [one schema](https://unpkg.com/jackherd/schemas/jackherd.schema.json), which your editor completes in the project config. What usually needs setting:
 
 ```json
 {
   "responseLanguage": "de",
   "terminal": { "adapter": "herdr" },
   "lanes": { "copy": ["apps/web/.env"] },
-  "check": { "reviewerRoutes": [{ "reviewer": "jh-uncle-bob", "globs": ["src/**/*.ts"], "why": "Code" }] }
+  "check": {
+    "reviewerRoutes": [{ "reviewer": "jh-uncle-bob", "globs": ["src/**/*.ts"], "why": "Code" }],
+    "skillBudgets": { ".claude/skills/release/SKILL.md": 1200 }
+  }
 }
 ```
 
+`jh check` counts the words of every skill, agent and always-loaded rule an agent reads, and warns above its budget; `check.skillBudgets` sets your own, by path or glob. `watch.parallelTasks.auto` (`since`, `until`, at most seven days) lets Jack start up to two extra subagents in a running lane without asking, under the cost limit and away from paths that always ask; he switches it on only after asking you.
+
 </details>
 
 <details>

package/dist/{chunk-MCP4XJQH.js → chunk-RMMXD4G5.js}

@@ -19,9 +19,13 @@ var SELF_MERGE_LABEL = {
   [PLAN_LANGUAGE.en]: "Approve, and merge it yourself after green checks",
   [PLAN_LANGUAGE.de]: "Freigeben, und nach gr\xFCnen Checks selbst mergen"
 };
-var PLAN_APPROVAL_LABELS = {
-  [PLAN_LANGUAGE.en]: { approve: "Approve the plan", revoke: "Revoke the plan approval" },
-  [PLAN_LANGUAGE.de]: { approve: "Plan freigeben", revoke: "Plan-Freigabe widerrufen" }
+var STANDING_APPROVAL_TEXTS = {
+  [PLAN_LANGUAGE.en]: { approve: "Approve standing", until: "until" },
+  [PLAN_LANGUAGE.de]: { approve: "Stehend freigeben", until: "bis" }
+};
+var LANE_PROMPT_OPENING = {
+  [PLAN_LANGUAGE.en]: "You are the lane",
+  [PLAN_LANGUAGE.de]: "Du bist die Spur"
 };
 var APPROVAL_REASONS = {
   pending: "Approval pending with the coordinator; retry the same call once it is approved.",
@@ -36,15 +40,21 @@ var APPOINTMENT_VOCABULARY = {
     heading: "Termine",
     columns: { when: "Wann", action: "Aktion", origin: "Herkunft", status: "Stand" },
     statusAlso: ["Status"],
-    open: ["offen"]
+    open: ["offen"],
+    grooming: "board-pflege"
   },
   [PLAN_LANGUAGE.en]: {
     heading: "Appointments",
     columns: { when: "When", action: "Action", origin: "Origin", status: "Status" },
     statusAlso: [],
-    open: ["open"]
+    open: ["open"],
+    grooming: "board grooming"
   }
 };
+var NEXT_VOCABULARY = {
+  [PLAN_LANGUAGE.de]: { heading: "Als N\xE4chstes" },
+  [PLAN_LANGUAGE.en]: { heading: "Next" }
+};
 var WAITING_VOCABULARY = {
   [PLAN_LANGUAGE.de]: {
     heading: "Wartet auf dich",
@@ -156,9 +166,11 @@ export {
   RESPONSE_ADDRESS,
   ADDRESS_FORM,
   SELF_MERGE_LABEL,
-  PLAN_APPROVAL_LABELS,
+  STANDING_APPROVAL_TEXTS,
+  LANE_PROMPT_OPENING,
   APPROVAL_TEXTS,
   APPOINTMENT_VOCABULARY,
+  NEXT_VOCABULARY,
   WAITING_VOCABULARY,
   isPlanLanguage,
   PLAN_STATUS,

package/dist/config.d.ts

@@ -34,11 +34,22 @@ declare const sourceSchema: z.ZodObject<{
         body: z.ZodOptional<z.ZodString>;
         author: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodString>;
     }, z.core.$catchall<z.ZodString>>;
     ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
     reportLimit: z.ZodDefault<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
     lane: z.ZodOptional<z.ZodString>;
     ticket: z.ZodOptional<z.ZodBoolean>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        amber: "amber";
+        teal: "teal";
+        grey: "grey";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        magenta: "magenta";
+    }>>;
     reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 declare const jackherdConfigSchema: z.ZodObject<{
@@ -110,6 +121,44 @@ declare const jackherdConfigSchema: z.ZodObject<{
                 alertTokens: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        tones: z.ZodPrefault<z.ZodObject<{
+            waiting: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            new: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            running: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+            resting: z.ZodDefault<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     watch: z.ZodPrefault<z.ZodObject<{
         deploy: z.ZodOptional<z.ZodObject<{
@@ -125,7 +174,12 @@ declare const jackherdConfigSchema: z.ZodObject<{
         }, z.core.$strict>>;
         parallelTasks: z.ZodPrefault<z.ZodObject<{
             maxTokens: z.ZodDefault<z.ZodNumber>;
+            auto: z.ZodOptional<z.ZodObject<{
+                since: z.ZodISODate;
+                until: z.ZodISODate;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
+        taskSignalMinutes: z.ZodDefault<z.ZodNumber>;
         previews: z.ZodOptional<z.ZodObject<{
             deployments: z.ZodDefault<z.ZodBoolean>;
             authors: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -144,15 +198,26 @@ declare const jackherdConfigSchema: z.ZodObject<{
                 body: z.ZodOptional<z.ZodString>;
                 author: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodString>;
+                count: z.ZodOptional<z.ZodString>;
             }, z.core.$catchall<z.ZodString>>;
             ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
             reportLimit: z.ZodDefault<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
             lane: z.ZodOptional<z.ZodString>;
             ticket: z.ZodOptional<z.ZodBoolean>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                amber: "amber";
+                teal: "teal";
+                grey: "grey";
+                red: "red";
+                green: "green";
+                blue: "blue";
+                magenta: "magenta";
+            }>>;
             reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
-    guard: z.ZodPrefault<z.ZodObject<{
+    guard: z.ZodPrefault<z.ZodPipe<z.ZodObject<{
         commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
         selfMerge: z.ZodPrefault<z.ZodObject<{
             offer: z.ZodDefault<z.ZodBoolean>;
@@ -161,16 +226,45 @@ declare const jackherdConfigSchema: z.ZodObject<{
         approvals: z.ZodPrefault<z.ZodObject<{
             waitMinutes: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
-        planApproval: z.ZodPrefault<z.ZodObject<{
-            exceptPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        alwaysAsk: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planApproval: z.ZodOptional<z.ZodObject<{
+            exceptPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
             requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        requiredChecks?: string[] | undefined;
+        alwaysAsk: string[];
+        commands: string[];
+        selfMerge: {
+            offer: boolean;
+            approvalMinutes: number;
+        };
+        approvals: {
+            waitMinutes: number;
+        };
+    }, {
+        commands: string[];
+        selfMerge: {
+            offer: boolean;
+            approvalMinutes: number;
+        };
+        approvals: {
+            waitMinutes: number;
+        };
+        alwaysAsk: string[];
+        requiredChecks?: string[] | undefined;
+        planApproval?: {
+            exceptPaths?: string[] | undefined;
+            requiredChecks?: string[] | undefined;
+        } | undefined;
+    }>>>;
     merge: z.ZodPrefault<z.ZodObject<{
         withoutChecks: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     hints: z.ZodPrefault<z.ZodObject<{
         askUserQuestion: z.ZodDefault<z.ZodBoolean>;
+        taskSignal: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
     check: z.ZodOptional<z.ZodObject<{
         lintFilesCommand: z.ZodDefault<z.ZodString>;
@@ -194,6 +288,7 @@ declare const jackherdConfigSchema: z.ZodObject<{
             exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
             reviewer: z.ZodDefault<z.ZodString>;
         }, z.core.$strict>>;
+        skillBudgets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         looseTests: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
 }, z.core.$strict>;