jackherd 1.8.1 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 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.
+- **A lane in the herd shows only the phases its board rows name.** It showed every phase of its plan, so phases another lane had just written stood under the lane's NOW while its own phase waited; the tally (`n/m`, `n/m ph`) counts the named phases too, a sub-phase (`P10c`) belonging to the phase a row names. A board row's range (`P17–P25`) names every phase it spans, where before only its first counted. A phase runs while some of its tasks are ticked and others open, while one of its boxes was ticked in the last 20 minutes, or while an agent reports it; task lines written into a phase, or a new phase without a tick, no longer make it run, and a phase with only its review gate open waits.
+- **The herd's teal is the brand colour.** The teal accents (the working lane's dot, `▶`/`▷`, `↑n`) are exactly `#03B5BD`, as true colour where `COLORTERM` is `truecolor` or `24bit`, and 256-colour 37 elsewhere.
+- **`jh watch` proposes open plan tasks that could run in parallel at a heartbeat** (`parallel tasks <lane>: …`): disjoint paths, none touched or reported by running agents (the coordinator's subagents in the lane's worktree included), extra agents costing less than `watch.parallelTasks.maxTokens` (default 100000, the baseline is the first answer of a session log). One free task beside a running agent counts; a lane with no active work gets no proposal; once per changed situation; nothing starts by itself.
+- **The merge guard no longer asks for an interpreter script whose text merely contains the command words apart** (a path segment `workflow` and a `run` elsewhere): where the program is hidden, the words count only as adjacent whole tokens, with quotes, commas, brackets and gh options between them. An option value that brackets or braces cut into several tokens (`-R "${REPO}"`, `REPOS[0]`, `os.environ["GH_REPO"]`, an f-string) no longer hides the words after it, so those calls ask again.
+- **`jh preview` is hardened.** An image is embedded only when its answer carries a plain `image/<subtype>` type, an image address is escaped before it goes into the page (also the one behind GitHub's image proxy) and read back unescaped before it is fetched, so a badge address with `&` in it fetches the right image, and a local image is read only when it is a regular file whose real path, links followed, lies inside the package. `jh watch` reads the task signals of subagent logs written within the activity window only, and the writes of at most the 20 newest subagent logs of a session.
+- **The herd's arrow follows the task an agent works on.** It stood on the first open task of a phase; now the open task whose words the lane's agent (or a subagent working in its worktree) used most in its last 40 log entries gets the arrow, when it clearly leads (at least 3 of its distinctive words and 40 %); otherwise the first open task, as before.
+- **`jh task start "<text>"` and `jh task done` report the task an agent works on.** One record per agent in `.jackherd/tasks/` (a new `start` replaces the agent's task); the kit skills `/implement` and `/orchestrate` tell every building agent to report. `jh task done` without an open task is silent and exits 0, so a second call is no error; with text that names another task than the open one it exits 1.
+- **The herd's arrow comes from what agents report, in every case.** It reads Claude Code's task list (`TaskCreate`/`TaskUpdate`, `TodoWrite`) from the logs of the sessions and subagents of every worktree and of the coordinator, and the records of `jh task`, and matches them to open plan tasks. Every active task carries its own `▶`, a phase with an active task runs, so a lane may show several active phases; the agent's name stands dim after the title only while more than one agent is active in the lane. A report that matches no open task shows as `now: <text>` under its lane, under the title when no lane fits (also without herdr). A `jh task` record counts only while it is younger than the lane's last tick; agent text is cleaned of control characters. Without any report the word guess stays, drawn as a dim `▷` with a plain title.
+- **The herd's arrow is teal, not yellow.** `▶` on a task is teal with a bold title, as the working lane's dot is; yellow stays for what is blocked or waits on you. The legend (`?`) names `▶` and `▷`.
+- **The open lane's tree names each thing once.** An open lane no longer repeats its phase on the lane line; a folded lane names it compactly, `P3 Search API +1 · 12/20` (`+n` more active phases). The running phases stand by number, never by recency, each with its age, its count and `· gate` while only the review gate is open, without an arrow on the phase row; arrows stand before tasks only, and an agent's name stands dim at the right edge of its task, only while more than one agent is active. An open lane shows per active phase only its active tasks; a click on the phase row shows the other open ones and the next click folds them. Only you change a fold; a new active task adds its own row.
+- **Files sent to you and published artifacts stay in sight.** The new kit hook `sent-file` (PostToolUse on `SendUserFile` and `Artifact`) records each send with time and caption in `.jackherd/sent/`. `jh herd` shows the files as `📎` badges among the link chips of the lane they belong to (linked by their `file:` address; an artifact by its URL), the sends nobody closed wait on you next to the board's rows (top of the herd, heartbeat, status line), and `jh waiting close <id>` (or `--all`) closes them after your answer; `jh waiting` lists them.
+- **A draft for review is published as one Artifact.** `/orchestrate` names the `Artifact` tool: with it, and unless `preview.publish` is `false` in `.jackherd/config.json`, the coordinator publishes the `jh preview` page as a private Artifact and updates the same URL each round; without it, a file card or `jh preview --open`. `jh preview` embeds external images (badges) as data addresses so the page is complete where it may load nothing from outside, and warns once for an image it could not fetch. It fetches only `https` images from public hosts (no loopback, private or link-local address, also after a redirect) and at most 5 MB each.
+- **`jh herd` stays calm.** The lanes keep the order of the board, whatever their states are (the order by urgency is gone; the state shows in the symbol and colour of each line, and what waits on you sits on top). A lane opens by itself only when it first appears; a change of status no longer opens or closes it, so a lane you folded stays folded.
+- **A click on a `📎` row opens it.** In `jh herd` a plain left click on a file or Artifact in the block of what waits on you opens it with the platform's opener (`xdg-open`, `open`); a `?` row opens nothing and a failure shows in the footer. `jh preview --open` shares the opener (`src/terminal/open.ts`).
+- **The herd's lane line names the state only for `blocked`.** The symbol at the row start carries working, idle, done, unknown and no agent (colour unchanged); a blocked lane writes `blocked` in front of its own phase title (no column, so no other row moves). The legend names every symbol; the watcher and the heartbeat keep their words.
+- **Long for-you rows expand by click.** A `📎`/`?` row wider than the pane expands on a click (wrapped over several lines); a question folds on the next click, a file or Artifact opens on it. A row that fits opens its file at once.
+- **The coordinator's hand-over thresholds default to 350 000 / 500 000 tokens** (`plans.context.coordinator`, were 200 000 / 300 000), since a fresh coordinator chat already starts near 200 000; the 60 % / 85 % cap of a smaller window stays. The `statusline.sh` template follows.
+- **`jh preview --open` works on Windows again** through the shared opener (`rundll32 url.dll,FileProtocolHandler`, which hands the target over without a shell).
+- **`jh preview` renders long documents and answers `--help`.** The Markdown went to `gh api /markdown` as an argument and failed with `E2BIG` for a long plan; it goes through standard input now. `jh preview --help` (and `-h`) prints the usage and exits 0.
+- **A question or a waiting agent no longer sinks in the coordinator's pane.** `jh herd` shows a subagent of the coordinator that builds in a worktree as `working` (and as `blocked` while the approval gate holds a request of it), also when the worktree has no row in the board; the row carries the subagent's description and the branch. The approval gate holds a permission request of such a subagent like a lane's, under the name `subagent-<type>-<id>`, so the watcher reports `approval …` instead of the dialog sitting in the coordinator's pane. The heartbeat and each status line name what a resting (`idle`, `done`) lane waits on, from the questions in its report: `a idle: waits on: <first question>, 2 open questions`.
+- **What waits on you stays in sight.** A board section `## Wartet auf dich` (German) or `## Waiting for you` (English), one row `Seit | Punkt | Herkunft | Stand`, lists a preview sent, a question put to you or a report to accept. `jh herd` shows every open row on top as one line per item (a dim `▌`, then `📎 file` or `? question` in bold, `▌ +n` after five), closed by a rule labelled `woof`, and the watcher repeats them in each heartbeat and status until the row is closed in its status cell. `/orchestrate` says when Jack enters and closes a row.
+- **The README is shorter and keeps each point once.** The section "Human on the loop" is gone; what it said sits where it belongs, in the intro (you decide, Jack asks only what the plan does not settle), in "What Jack does on his own, and what waits for you" and in "Guarded commands and merges", which now also names the refusal of a push to the base branch and the limit of the guards. Planning and building are told apart from the parts that need herdr, the quickstart is five bare steps, and the lines on lanes, boards, worktrees, the watcher and the fresh start say what they mean. `jh preview` is in the command list.
+- **The feature icons load from a marked address.** Every icon in the README is `…/assets/icons/<name>.svg?v=2`. GitHub's image proxy keeps an unmarked address for a year, so npm kept showing the 1.8.0 icons, a few pixels too high. A test holds the mark in one place (`assets/icons/version.ts`) and compares the icon files with stored digests, so a changed icon without a new mark turns red.
+- **`jh preview <markdown-file>`** renders a Markdown file through the GitHub API into a page that shows it in GitHub and npm style, light and dark, and at phone width (`--out`, `--open`).
+- **`jh herd` shows a small fix as active.** It listed a lane as "no agent" when the board held a cleaned-up row and a newer open row of the same name, or when a cleaned-up lane had uncommitted changes in its worktree. A newer row without the mark now reopens the lane, and uncommitted changes make it active.
+- **An open lane in `jh herd` keeps its tree.** Its pull requests hang on the tree as `PR`, behind the SESSION line, the chips row is labelled `LINKS`, and a pull request title no longer repeats the lane's ticket key.
+
 ## 1.8.1
 
 - **The README reads on npm in a dark browser.** npm wraps every image in a link, so a `<picture>` never switched to its dark source, and npm has no dark theme of its own; a phone in dark mode showed the light logo on black. Every image is now one version that works on white and on black: the logo is the dark one with a light outline around Jack, the letters, the lanes and the nodes (`assets/branding/jackherd-logo-outline.svg`), the terminal diagrams are always the dark ones, and the feature icons are mid-grey and teal. Each of the six points has its icon on the line of the bold title and its text below, so nothing wraps under an icon on a phone or on a desktop and the gaps are equal.

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` |
 
@@ -69,6 +69,8 @@ bunx jackherd sync   # later: updates the kit files
 
 `init` writes what it [detected](#detected-per-repository) into the new config, so the project sees it. It asks whether to enter the status line (README, *Status line*) in `.claude/settings.json`; `--yes` or `--no` answer every question without asking.
 
+**Everyone on the team needs Bun.** The project hooks run as `bun .claude/hooks/…`, and without Bun the guard hooks block the commands they check.
+
 **Name clashes.** A project that already has a skill or agent of a kit name (`implement`, `plan`, …): `init` names the clash and offers the prefix `jh-`, so the kit's copies sit beside yours and call each other, not yours. Any project can set `skillPrefix` in `.jackherd/config.json`; `sync` then renames, and removes the unprefixed kit files you never edited, with the directories they leave empty. A directory that holds a file of yours stays, and `sync` names it.
 
 **Your edits survive.** `sync` leaves files you have edited alone. When the kit changed one of them too, its version lands beside yours as `<file>.kit-new`: merge it, or take the kit version with `sync --accept <path>`. A kit file you deleted stays deleted. Project-specific additions go into `.claude/project/<skill>.md` (read first by the skill of that name) or a rule beside `.claude/rules/kit/`, so the kit files stay updatable.

package/README.md

@@ -3,35 +3,41 @@
 <br>
 </p>
 
-[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg">
+[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg?v=2">
 
-**Let AI do the work. Stay in control.** Build several features in parallel with Claude Code. Each runs in its own branch; you only answer the questions that need a human. Jack, the coordinator (the Shih Tzu in the logo, who herds anyway), handles the rest. In a project install, hooks hold merges and releases that touch risky paths until you approve, and refuse a push to your base branch.
+# Your agents write code. Jack keeps the work moving.
 
-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">
+**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 mode in herdr (optional). Planning and building work without it.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd/assets/icons/space.svg">
+<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/plan.svg" width="24" height="34" align="middle" alt=""> <b>Plans live in your repository.</b><br>Markdown phases, a model each, ticked off as they are built.</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" width="24" height="34" align="middle" alt=""> <b>Lanes stay apart.</b><br>A lane is one phase of a plan in its own git worktree and session, side by side in herdr, the terminal that holds the parallel sessions.</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/decide.svg" width="24" height="34" align="middle" alt=""> <b>You decide. Jack takes care of the lanes.</b><br>He answers what the plan settles and asks you the rest.</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/bark.svg" 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, pull request, checks, feedback.</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/ear.svg" 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. Reports need herdr.</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" width="24" height="34" align="middle" alt=""> <b>Long sessions get a fresh start.</b><br>At a phase boundary, a lane whose context is filling up moves to a new chat.</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
 
-Planning and building work without herdr; parallel lanes need it.
-
-1. **Install** (Linux and macOS; needs Claude Code and git). It asks a few setup questions and leaves your repositories alone. → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)
+1. **Install** (Linux and macOS; needs Claude Code and git). → [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md)
 
    ```bash
    curl -fsSL https://unpkg.com/jackherd/install.sh | sh
@@ -40,24 +46,24 @@ Planning and building work without herdr; parallel lanes need it.
    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.** It checks the setup and offers your first plan.
+2. **Start Claude Code in a repository.**
 
    ```text
    /jh-start
    ```
-3. **Plan.** Phases, tasks and a model for each, written to `docs/plans/`.
+3. **Create your first plan.** It lands in `docs/plans/`, and for parallel lanes `/jh-plan` offers to write a board.
 
    ```text
    /jh-plan Add product search
    ```
-4. **Build,** one phase at a time, ticked off in the plan. No herdr needed.
+4. **Build the first phase.**
 
    ```text
    /jh-implement docs/plans/<plan>.md phase 1
    ```
-5. **Or let Jack run the herd.** Inside [herdr](https://herdr.dev), one lane per phase, with the live herd view beside him (`jh herd` anywhere else).
+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,9 +71,7 @@ Planning and building work without herdr; parallel lanes need it.
 
 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)
 
-## Human on the loop
-
-You decide every open question, commit and push, once per pull request. Jack answers on his own what the plan already settles, never money, auth, secrets, a migration or a release. Once you've approved a plan and a pull request, he merges it on green checks and tells you in one line. The guards catch mistakes, not an agent set on getting around them; only branch protection stops that. A pull request that touches a workflow, a migration, a lockfile or `package.json` still asks, and so does every release. Prefer to see every merge? Approve per pull request instead.
+## In detail
 
 <details>
 <summary><b>What Jack does on his own, and what waits for you</b></summary>
@@ -78,36 +82,32 @@ You decide every open question, commit and push, once per pull request. Jack ans
 | --- | --- | --- |
 | 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 "…"`), 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 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.
 
-</details>
+The guards catch mistakes, not intent; for that, use branch protection. The hooks need Bun; a global install ships none.
 
-## In detail
+</details>
 
 <details>
 <summary><b>Plans, boards and the skills</b></summary>
 
-A **plan** is Markdown with phases, checkbox tasks, a model and a review gate per phase. A **board** lists the lanes: which phases each one works on, on which model, after what. A **lane** is one agent session in its own git worktree, and **Jack** is the session in the main checkout that runs `/jh-orchestrate`.
+A **plan** is Markdown with phases, checkbox tasks, a model and a review gate per phase. A **board** lists the lanes of one or more plans: which phases each lane builds, on which model, after what. A **lane** is one agent session in its own git worktree (a second checkout of your repository), and **Jack** is the session in the main checkout that runs `/jh-orchestrate` on a board.
 
 <img src="https://unpkg.com/jackherd/docs/skills-dark.svg" alt="/jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement; /jh-implement ends in /jh-pre-commit, which runs the reviewers; /jh-diagnose hands a red command to /jh-implement.">
 
@@ -119,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.
 
@@ -129,51 +129,53 @@ 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 himself, 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                       🥣 62 % │ ██████░░░░ ◐    6/9
-   ⎇ feat/search-ui ↑1 ±4
-│
-└─ Product search
-   ├─ 📎  📄 Plan   📡 PROJ-123 · In Progress   ✦ Mockup   ◈ Search box
-   │
-   ├─ ✓ P2 Search box                                                      4/4
-   ├─ ▸ P3 Docs                                                        docs open
-   │  └─ ▶ Docs updated (README)
-   └─ ▸ P4 Review                                                          0/2
+▾ ◆  search-ui     blocked                                 ██████░░░░      6/9
+  ├─ Search box docs                             ⎇ feat/search-ui ↑1 ±4  🥣 62 %
+  ├─  📄 Plan   📡 PROJ-123 · In Progress   ✦ Mockup   ◈ Search box
+  ├─ P3 Docs                                      · 4 min ago · gate       2/3
+  │    ▶ Review gate
+  ├─ next P4
+  └─ ✓ P2
 ────────────────────────────────────────────────────────────────────────────────
-▸ ◉  checkout-fee  done             ↗ #42 💬 2   🥣 48 % │ ██████████ ◐    6/6
+▸ ◉  checkout-fee                   ↗ #42 💬 2             ██████████      6/6
 ────────────────────────────────────────────────────────────────────────────────
-▾ ●  search-index  working                       🥣 34 % │ ████████░░ ◐    4/5
-   ⎇ feat/search-index ↑3 ±2
-   ↗ #41    … checks   🌐 preview   💬 1 new   Search index
-│
-└─ Product search
-   └─ ▸ P1 Index                                                           4/5
-      └─ ▶ /jh-uncle-bob
+▾ ●  search-index                                          ████████░░      4/5
+  ├─ Search index                             ⎇ feat/search-index ↑3 ±2  🥣 34 %
+  ├─  ↗ #41    … checks   🌐 preview   💬 1 new   Search index
+  └─ P1 Index                                             · just now       4/5
+       ▶ /jh-uncle-bob
 ────────────────────────────────────────────────────────────────────────────────
 · 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>
@@ -189,20 +191,29 @@ Jack doesn't watch the terminals himself. `jh watch`, which he starts himself, w
 | `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-OU2KALXP.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.",
@@ -45,6 +49,20 @@ var APPOINTMENT_VOCABULARY = {
     open: ["open"]
   }
 };
+var WAITING_VOCABULARY = {
+  [PLAN_LANGUAGE.de]: {
+    heading: "Wartet auf dich",
+    columns: { since: "Seit", item: "Punkt", origin: "Herkunft", status: "Stand" },
+    statusAlso: ["Status"],
+    open: ["offen"]
+  },
+  [PLAN_LANGUAGE.en]: {
+    heading: "Waiting for you",
+    columns: { since: "Since", item: "Item", origin: "Origin", status: "Status" },
+    statusAlso: [],
+    open: ["open"]
+  }
+};
 var isPlanLanguage = (value) => Object.values(PLAN_LANGUAGE).includes(value);
 var PLAN_STATUS = {
   done: "done",
@@ -142,9 +160,11 @@ export {
   RESPONSE_ADDRESS,
   ADDRESS_FORM,
   SELF_MERGE_LABEL,
-  PLAN_APPROVAL_LABELS,
+  STANDING_APPROVAL_TEXTS,
+  LANE_PROMPT_OPENING,
   APPROVAL_TEXTS,
   APPOINTMENT_VOCABULARY,
+  WAITING_VOCABULARY,
   isPlanLanguage,
   PLAN_STATUS,
   PLAN_VOCABULARY,

package/dist/config.d.ts

@@ -90,6 +90,9 @@ declare const jackherdConfigSchema: z.ZodObject<{
             herdr: "herdr";
         }>>;
     }, z.core.$strict>>;
+    preview: z.ZodPrefault<z.ZodObject<{
+        publish: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
     plans: z.ZodPrefault<z.ZodObject<{
         fetchIntervalMinutes: z.ZodDefault<z.ZodNumber>;
         linkKinds: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -120,6 +123,14 @@ declare const jackherdConfigSchema: z.ZodObject<{
         checks: z.ZodPrefault<z.ZodObject<{
             failedTestPattern: z.ZodDefault<z.ZodString>;
         }, 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>>;
@@ -146,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>;
@@ -155,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>;
@@ -188,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>;