jackherd 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 What changed for people who use jackherd, newest first.
 
+## 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
@@ -76,27 +82,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.
+
+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 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.
+The guards catch mistakes, not intent; for that, use branch protection. The hooks need Bun; a global install ships none.
 
 </details>
 
@@ -115,8 +119,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 +129,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 +175,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 ticked tasks  s html  q quit  ? help
 ```
 
 </details>
@@ -180,22 +191,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`) |
+| `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-5MQBCUQ5.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.",
@@ -156,7 +160,8 @@ export {
   RESPONSE_ADDRESS,
   ADDRESS_FORM,
   SELF_MERGE_LABEL,
-  PLAN_APPROVAL_LABELS,
+  STANDING_APPROVAL_TEXTS,
+  LANE_PROMPT_OPENING,
   APPROVAL_TEXTS,
   APPOINTMENT_VOCABULARY,
   WAITING_VOCABULARY,

package/dist/config.d.ts

@@ -125,7 +125,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>>;
@@ -152,7 +157,7 @@ declare const jackherdConfigSchema: z.ZodObject<{
             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 +166,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 +228,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>;

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-MCP4XJQH.js";
+} from "./chunk-5MQBCUQ5.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -129,6 +129,7 @@ var publicContent = z.strictObject({
   /** The agent that judges such a change; a global install names it with its prefix. */
   reviewer: nonEmpty.default("public-content")
 });
+var skillBudgets = z.record(glob, z.number().int().positive());
 var checkConfigSchema = z.strictObject({
   /**
    * Run once over the changed files, which are appended as arguments. Separate from `commands.lint`,
@@ -141,6 +142,11 @@ var checkConfigSchema = z.strictObject({
   buildArtifacts: z.array(glob).default([...DEFAULT_BUILD_ARTIFACT_GLOBS]),
   reviewerRoutes: z.array(reviewerRoute).default([]),
   publicContent: publicContent.optional(),
+  /**
+   * Word budgets for the files an agent loads again and again. An entry replaces the kit's budget for the same
+   * path and sets one for the project's own skills; a file with none is measured against the kit's default.
+   */
+  skillBudgets: skillBudgets.optional(),
   /** Also run tests in directories that hold test files but belong to no package. */
   looseTests: z.boolean().default(false)
 });
@@ -182,11 +188,23 @@ var isSourcePath = (path) => pathSteps(path) !== null;
 var CLEAN_REVIEW_TEXT = "## Code review\n\nNo issues found. Checked for bugs and CLAUDE.md compliance.";
 var BUN_FAILED_TEST_PATTERN = "^\\(fail\\) (.+?)(?: \\[[\\d.]+m?s\\])?$";
 
+// src/plan-format/clock.ts
+var DAY_MS = 864e5;
+
+// src/config/auto-window.ts
+var MAX_AUTO_WINDOW_DAYS = 7;
+var windowDays = (since, until) => Math.round((Date.parse(`${until}T00:00:00Z`) - Date.parse(`${since}T00:00:00Z`)) / DAY_MS);
+
 // src/config/link-kinds.ts
+var ARTIFACT_LINK_KIND = {
+  pattern: "^https://claude\\.ai/(code/)?artifact/",
+  label: "Artifact",
+  icon: "\u2726"
+};
 var DEFAULT_LINK_KINDS = [
   { pattern: "^https://github\\.com/[^/]+/[^/]+/(pull|issues)/\\d+", label: "GitHub", icon: "\u2442" },
   { pattern: "^https://(www\\.)?figma\\.com/", label: "Figma", icon: "\u25C8" },
-  { pattern: "^https://claude\\.ai/(code/)?artifact/", label: "Artifact", icon: "\u2726" }
+  ARTIFACT_LINK_KIND
 ];
 var isRegularExpression = (source) => {
   try {
@@ -320,7 +338,17 @@ var parallelTasksSchema = z2.strictObject({
    * agent times the agents to add. Above it the watcher does not propose parallel tasks. The baseline is the context
    * the first answer of a lane's session carried.
    */
-  maxTokens: z2.number().int().positive().default(DEFAULT_PARALLEL_TASKS_MAX_TOKENS)
+  maxTokens: z2.number().int().positive().default(DEFAULT_PARALLEL_TASKS_MAX_TOKENS),
+  /**
+   * The days, both included, on which a proposal that keeps every limit is marked `auto` and the coordinator starts it
+   * without asking: subagents beside running work in a lane, at most two extra agents, no path that always asks.
+   * `since` is the day it was switched on, `until` at most seven days later; outside the window it is off. Unset by
+   * default, so every proposal asks.
+   */
+  auto: z2.strictObject({ since: z2.iso.date(), until: z2.iso.date() }).refine(({ since, until }) => until >= since, "until must not be before since").refine(
+    ({ since, until }) => windowDays(since, until) <= MAX_AUTO_WINDOW_DAYS,
+    `until must be at most ${MAX_AUTO_WINDOW_DAYS} days after since`
+  ).optional()
 });
 var checksSchema = z2.strictObject({
   /**
@@ -434,13 +462,13 @@ var mergeSchema = z2.strictObject({
    */
   withoutChecks: z2.array(checkFreePattern).default([])
 });
-var guardSchema = z2.strictObject({
+var guardFields = z2.strictObject({
   /**
-   * The commands the merge guard hook asks the user about before they run, also behind options before the verb, a chain,
-   * a wrapper or `sh -c`. `gh api` asks only for a write to a merge, a file, a dispatch, a rerun or a ref. An empty list switches the
-   * guard off.
+   * The commands the merge guard hook asks the user about before they run, where they stand at a program position, also
+   * behind options before the verb, a chain, a wrapper or `sh -c`. `gh api`, when listed, asks only for a write to a
+   * merge, a file, a dispatch, a rerun or a ref. An empty list switches the guard off.
    */
-  commands: z2.array(guardedCommand).default(["gh pr merge", "gh workflow run", "gh run rerun", "gh api"]),
+  commands: z2.array(guardedCommand).default(["gh pr merge", "gh workflow run"]),
   selfMerge: z2.strictObject({
     /** Whether `/orchestrate` offers "merge it yourself after green checks" in the pull request question; off also stops the hook honouring such an answer. */
     offer: z2.boolean().default(true),
@@ -451,28 +479,39 @@ var guardSchema = z2.strictObject({
     /** How long the approval gate hook holds a lane's call for the coordinator's dialog before it denies it; below the hook's 10 minutes. */
     waitMinutes: z2.number().int().min(1).max(9).default(8)
   }).prefault({}),
-  planApproval: z2.strictObject({
-    /**
-     * Paths that always ask, on top of the ones jackherd brings (`.github/**`, `**\/migrations/**`, `**\/.env*`,
-     * `.claude/**`, `.jackherd/**`, `bunfig.toml`, `**\/CLAUDE.md`, `**\/AGENTS.md`, `.agents/**`, `.mcp.json`,
-     * `.husky/**`, `lefthook.yml`, the lockfiles of bun, npm, pnpm and yarn, `**\/.npmrc`, `**\/CODEOWNERS`, every
-     * package.json, and the CHANGELOG.md of every package without `"private": true`):
-     * a pull request that changes one is never merged on a plan approval alone. They add to that list, never replace
-     * it; an invalid entry turns plan approval off, so every merge asks.
-     */
-    exceptPaths: z2.array(alwaysAskPattern).default([]),
-    /**
-     * Checks that must be among the head commit's and green before a plan approval lets a merge pass, by their names
-     * on GitHub. Unset, the merge needs at least one check and every one green; set, also each of these. Either way
-     * GitHub must be able to merge it and the head must contain the base branch.
-     */
-    requiredChecks: z2.array(checkName).optional()
-  }).prefault({})
+  /**
+   * Paths that always ask, on top of the ones jackherd brings (`.github/**`, `**\/migrations/**`, `**\/.env*`,
+   * `.claude/**`, `.jackherd/**`, `bunfig.toml`, `**\/CLAUDE.md`, `**\/AGENTS.md`, `.agents/**`, `.mcp.json`,
+   * `.husky/**`, `lefthook.yml`, the lockfiles of bun, npm, pnpm and yarn, `**\/.npmrc`, `**\/CODEOWNERS`): a
+   * `merge.withoutChecks` pattern never opens them, and the watcher never starts parallel work on them by itself. They
+   * add to that list, never replace it. A standing approval covers them; only workflows, migrations and env files ask.
+   */
+  alwaysAsk: z2.array(alwaysAskPattern).default([]),
+  /**
+   * Checks that must be among the head commit's and green before a standing approval lets a merge pass, by their names
+   * on GitHub. Unset, the merge needs at least one check and every one green; set, also each of these. Either way
+   * GitHub must be able to merge it.
+   */
+  requiredChecks: z2.array(checkName).optional(),
+  /** Read until 2.0.0 as `alwaysAsk` (`exceptPaths`) and `requiredChecks`; the plan approval it was for is gone. */
+  planApproval: z2.strictObject({ exceptPaths: z2.array(alwaysAskPattern).optional(), requiredChecks: z2.array(checkName).optional() }).optional().meta({ deprecated: true })
 });
+var guardWithoutPlanApproval = ({ planApproval, ...guard }) => {
+  const requiredChecks = guard.requiredChecks ?? planApproval?.requiredChecks;
+  return {
+    ...guard,
+    alwaysAsk: [...guard.alwaysAsk, ...planApproval?.exceptPaths ?? []],
+    ...requiredChecks === void 0 ? {} : { requiredChecks }
+  };
+};
+var guardSchema = guardFields.transform(guardWithoutPlanApproval);
 var hintsSchema = z2.strictObject({
   /** Whether the `ask-hint` hook points out a last message that ends in a question while the turn used no `AskUserQuestion`; a lane session is never hinted. */
-  askUserQuestion: z2.boolean().default(true)
+  askUserQuestion: z2.boolean().default(true),
+  /** Whether the `task-hint` hook points a lane that edits a file without an open task signal to `jh task start`, once per task. */
+  taskSignal: z2.boolean().default(true)
 });
+var DEFAULT_TASK_SIGNAL_MINUTES = 10;
 var contextSchema = z2.strictObject({
   /** Tokens in a lane's context from which its fill shows yellow and `/implement` offers a new chat. */
   warnTokens: tokenCount.default(25e4),
@@ -548,6 +587,7 @@ var jackherdConfigSchema = z2.strictObject({
    * Read by `jh watch`; without `deploy` it reports no deploy runs. `feedback` is on unless set to `false`:
    * it reports new feedback on the lanes' pull requests except from the account the watcher runs as and `ignore`.
    * `parallelTasks.maxTokens` caps the cost of the extra agents in a proposal of parallel tasks at the heartbeat.
+   * `taskSignalMinutes` is how long a lane works without a task signal before it reports `no task signal`, once per phase.
    * `checks` reads the failed tests of a red lane pull request (`failedTestPattern`), also with `feedback` off.
    * Without `previews` it reads no deploy preview; with it, one `preview` per new head commit. Each of `sources` is a
    * command whose JSON output reports `source` for a new or changed entry.
@@ -557,6 +597,7 @@ var jackherdConfigSchema = z2.strictObject({
     feedback: z2.union([z2.literal(false), feedbackSchema]).prefault({}),
     checks: checksSchema.prefault({}),
     parallelTasks: parallelTasksSchema.prefault({}),
+    taskSignalMinutes: z2.number().int().positive().default(DEFAULT_TASK_SIGNAL_MINUTES),
     previews: previewsSchema.optional(),
     sources: z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
   }).prefault({}),