jackherd 1.8.1 → 1.9.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 What changed for people who use jackherd, newest first.
 
+## 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

@@ -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,35 @@
 <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 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.
+
+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>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">
 </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 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/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/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/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/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/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/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/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 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/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>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>
 
 ## 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
@@ -42,22 +42,22 @@ Planning and building work without herdr; parallel lanes need it.
    ```text
    Install jackherd by following https://unpkg.com/jackherd/INSTALL.md. Ask me the setup questions it lists; herdr is optional.
    ```
-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 (optional).** In Claude Code inside herdr, hand Jack the board:
 
    ```text
    /jh-orchestrate docs/plans/board-<name>/board.md
@@ -65,9 +65,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>
@@ -87,7 +85,7 @@ You decide every open question, commit and push, once per pull request. Jack ans
 <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.
+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 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.
 
@@ -98,16 +96,14 @@ A merge passes without a question only on an answer from your own dialog: self-m
 }
 ```
 
-A global install ships no hooks, and the skills ask on their own.
+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.
 
 </details>
 
-## In detail
-
 <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.">
 
@@ -136,7 +132,7 @@ Each phase in the plan names its model: the planning model (Opus by default) whe
 <details>
 <summary><b>The watcher and tickets 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 or a lane waits for an approval; 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.
 
@@ -150,26 +146,21 @@ Jack doesn't watch the terminals himself. `jh watch`, which he starts himself, w
 ```text
 🐾 Board 01                                                                11:38
 ────────────────────────────────────────────────────────────────────────────────
-▾ ◆  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
 ────────────────────────────────────────────────────────────────────────────────
@@ -189,6 +180,8 @@ 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 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 |
 

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

@@ -45,6 +45,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",
@@ -145,6 +159,7 @@ export {
   PLAN_APPROVAL_LABELS,
   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,9 @@ 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>;
+        }, z.core.$strict>>;
         previews: z.ZodOptional<z.ZodObject<{
             deployments: z.ZodDefault<z.ZodBoolean>;
             authors: z.ZodDefault<z.ZodArray<z.ZodString>>;

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-OU2KALXP.js";
+} from "./chunk-MCP4XJQH.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -313,6 +313,15 @@ var feedbackSchema = z2.strictObject({
    */
   noFindingTemplates: z2.array(z2.string().min(1)).default([CLEAN_REVIEW_TEXT])
 });
+var DEFAULT_PARALLEL_TASKS_MAX_TOKENS = 1e5;
+var parallelTasksSchema = z2.strictObject({
+  /**
+   * The most the extra agents of a parallel proposal may cost before they do anything: the token baseline of a fresh
+   * 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)
+});
 var checksSchema = z2.strictObject({
   /**
    * Finds a failed test in a line of a red run's log (`gh run view --log-failed`) after its job, step and timestamp
@@ -397,9 +406,9 @@ var sourceSchema = z2.strictObject({
 var hasUniqueNames = (sources) => new Set(sources.map(({ name }) => name)).size === sources.length;
 var coordinatorSchema = z2.strictObject({
   /** Tokens in the coordinator's context from which the watcher reports `coordinator warn`. */
-  warnTokens: tokenCount.default(2e5),
+  warnTokens: tokenCount.default(35e4),
   /** Tokens in the coordinator's context from which the watcher reports `coordinator alert`. */
-  alertTokens: tokenCount.default(3e5)
+  alertTokens: tokenCount.default(5e5)
 }).refine(warnBelowAlert, WARN_BELOW_ALERT);
 var guardedCommand = z2.string().regex(/^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*){1,3}$/, "a program and one to three plain words, such as gh pr merge");
 var checkFreePattern = z2.string().regex(/^[A-Za-z0-9_.*/-]+$/, "path words with * and ** only, such as docs/**/*.md").refine(
@@ -517,6 +526,11 @@ var jackherdConfigSchema = z2.strictObject({
   }).prefault({}),
   models: z2.record(z2.enum(Object.values(MODEL_ROLE)), modelId),
   terminal: z2.strictObject({ adapter: z2.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) }).prefault({}),
+  /** How the coordinator shows a draft for review (`orchestrate` § 4). */
+  preview: z2.strictObject({
+    /** Publish the draft as a private Artifact when the session has the tool; `false` sends a file card or `jh preview --open` instead. */
+    publish: z2.boolean().default(true)
+  }).prefault({}),
   plans: z2.strictObject({
     /** Minutes between background fetches of the base branch while `jh herd` runs; 0 turns them off. */
     fetchIntervalMinutes: z2.number().min(0).default(5),
@@ -533,6 +547,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.
    * `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.
@@ -541,6 +556,7 @@ var jackherdConfigSchema = z2.strictObject({
     deploy: deploySchema.optional(),
     feedback: z2.union([z2.literal(false), feedbackSchema]).prefault({}),
     checks: checksSchema.prefault({}),
+    parallelTasks: parallelTasksSchema.prefault({}),
     previews: previewsSchema.optional(),
     sources: z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
   }).prefault({}),

package/dist/plan-format.d.ts

@@ -59,6 +59,22 @@ declare const APPOINTMENT_VOCABULARY: Record<PlanLanguage, {
     statusAlso: readonly string[];
     open: readonly string[];
 }>;
+/**
+ * The board section of what waits on the user's answer (a sent preview, an open question, a report to accept): its
+ * heading, the header names of its columns (since, item, origin, status, found by name in any order; the status
+ * column may also carry a name of `statusAlso`) and the lower-case words a status cell of a still open item starts with.
+ */
+declare const WAITING_VOCABULARY: Record<PlanLanguage, {
+    heading: string;
+    columns: {
+        since: string;
+        item: string;
+        origin: string;
+        status: string;
+    };
+    statusAlso: readonly string[];
+    open: readonly string[];
+}>;
 declare const isPlanLanguage: (value: string) => value is PlanLanguage;
 declare const PLAN_STATUS: {
     readonly done: "done";
@@ -348,7 +364,8 @@ declare const withoutRepeats: (lane: SprintLane, step: PlanStep) => PlanStep;
 /**
  * The lanes of the sprint document's lanes table (`## Spuren` in `de`) in table order. A row whose
  * first cell names a lane in backticks belongs to that lane; a `↳` row without a name continues
- * the lane above it.
+ * the lane above it. A cleaned-up lane stays closed through its `↳` rows, but a later row that names it again
+ * without the mark starts the lane anew: the closed rows are history and drop out.
  */
 declare const parseSprintLanes: (markdown: string, language: PlanLanguage) => SprintLane[];
 declare const sprintTitleOf: (markdown: string, fallback: string) => string;
@@ -512,4 +529,4 @@ declare const readSprintDocument: (markdown: string, language: PlanLanguage) =>
  */
 declare const readPhaseDependencies: (planMarkdown: string, language: PlanLanguage) => Record<string, string>;
 
-export { ADDRESS_FORM, APPOINTMENT_VOCABULARY, APPROVAL_TEXTS, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PLAN_APPROVAL_LABELS, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithoutGate, type PhaseWithoutRow, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, RESPONSE_ADDRESS, type ResponseAddress, type RowWithProse, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithProse, boardRowsWithoutPhase, classifyStatus, columnModels, countDecisions, criticalPath, currentPhase, currentPhaseOf, deferralTarget, differsFromColumn, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isDocumentationGateItem, isOpenCheckboxLine, isPhaseFinished, isPhaseOpen, isPlanLanguage, isReviewGateLine, isTickedUnmerged, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, onlyDocumentationOpen, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phaseWaves, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };
+export { ADDRESS_FORM, APPOINTMENT_VOCABULARY, APPROVAL_TEXTS, type ChecklistItem, type ColumnModel, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_CELL_LIMIT, PHASE_ID_PREFIX, PLAN_APPROVAL_LABELS, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, PROSE_REASON, type PhaseDependency, type PhaseHeading, type PhaseProgress, type PhaseSchedule, type PhaseTally, type PhaseWithoutGate, type PhaseWithoutRow, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type ProseReason, RESPONSE_ADDRESS, type ResponseAddress, type RowWithProse, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, WAITING_VOCABULARY, activeItem, boardRowsWithProse, boardRowsWithoutPhase, classifyStatus, columnModels, countDecisions, criticalPath, currentPhase, currentPhaseOf, deferralTarget, differsFromColumn, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isDocumentationGateItem, isOpenCheckboxLine, isPhaseFinished, isPhaseOpen, isPlanLanguage, isReviewGateLine, isTickedUnmerged, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, onlyDocumentationOpen, parallelGroups, parallelGroupsOfPlan, parseDependencyTable, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseHeadings, phaseIdsOfCell, phaseIdsOfPlan, phaseLabel, phaseLabels, phaseProgress, phaseWaves, phasesText, phasesWithoutDependencyRow, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, wavesOfPlan, withoutRepeats };

package/dist/plan-format.js

@@ -9,11 +9,12 @@ import {
   PLAN_VOCABULARY,
   RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
+  WAITING_VOCABULARY,
   classifyStatus,
   isPlanLanguage,
   phaseHeading,
   sectionHeading
-} from "./chunk-OU2KALXP.js";
+} from "./chunk-MCP4XJQH.js";
 
 // src/plan-format/lanes.ts
 import { posix } from "path";
@@ -100,6 +101,8 @@ var CONTINUATION = "\u21B3";
 var PLAN_LINK = /\[([^\]]+)\]\(([^)]+)\)/;
 var PHASE_ID_PREFIX = "P";
 var phaseLabel = (id) => `${PHASE_ID_PREFIX}${id}`;
+var MAX_RANGE = 50;
+var spannedPhaseIds = (first, last) => first > last || last - first >= MAX_RANGE ? [] : Array.from({ length: last - first + 1 }, (_, offset) => String(first + offset));
 var phaseLabels = (ids, separator) => ids.map(phaseLabel).join(separator);
 var PHASES_COLUMN = 3;
 var CLAUSE_SEPARATOR = /([;,]|\.(?=\s))\s*/;
@@ -109,10 +112,18 @@ var phaseIdPatterns = (language) => {
   const id = `(?:\\*\\*)?${PHASE_ID_PREFIX}(\\d+[a-z]?)\\b`;
   return {
     leading: new RegExp(`^\\s*(?:(?:${connectors})\\s+)*${id}`),
+    rangeEnd: new RegExp(`^\\s*[\u2013-]\\s*(?:\\*\\*)?${PHASE_ID_PREFIX}(\\d+)\\b`),
     afterConnector: new RegExp(`^\\s*(?:${connectors})\\s`),
     connector: new RegExp(`\\b(?:${connectors})\\s+${id}`, "g")
   };
 };
+var leadingIds = (clause, leading, patterns) => {
+  const first = leading[1];
+  const end = clause.slice(leading[0].length).match(patterns.rangeEnd);
+  if (!end || !/^\d+$/.test(first)) return [first];
+  const spanned = spannedPhaseIds(Number(first), Number(end[1]));
+  return spanned.length > 0 ? spanned : [first];
+};
 var phaseIdsOf = (cell, patterns) => {
   const parts = cell.split(CLAUSE_SEPARATOR);
   const ids = [];
@@ -125,7 +136,7 @@ var phaseIdsOf = (cell, patterns) => {
     const leading = clause.match(patterns.leading);
     const startsEntry = entryStart || listRunning || patterns.afterConnector.test(clause);
     const counts = leading !== null && startsEntry;
-    if (leading && counts) ids.push(leading[1]);
+    if (leading && counts) ids.push(...leadingIds(clause, leading, patterns));
     ids.push(...[...clause.matchAll(patterns.connector)].map((match) => match[1]));
     listRunning ||= counts;
   }
@@ -162,7 +173,12 @@ var parseSprintLanes = (markdown, language) => {
     if (!name) continue;
     const port = Number.parseInt(cells[1] ?? "", 10);
     const lane = lanes.get(name) ?? { name, port: Number.isNaN(port) ? null : port, steps: [], closed: false };
-    lane.closed ||= (cells[0] ?? "").includes(laneClosed);
+    const marked = (cells[0] ?? "").includes(laneClosed);
+    if (lane.closed && !marked && !(cells[0] ?? "").startsWith(CONTINUATION)) {
+      lane.closed = false;
+      lane.steps = [];
+    }
+    lane.closed ||= marked;
     lane.steps.push(withoutRepeats(lane, toStep(cells, phaseId)));
     lanes.set(name, lane);
     previous = name;
@@ -451,7 +467,6 @@ var GLOB_CHARACTER = /[*?{[]/;
 var VERSION = /^v?\d+(?:[.\-+][\w.-]*)?$/i;
 var PACKAGE_SCOPE = /^@[^/]+\//;
 var RELEASE_FILE = /(?:^|\/)(?:CHANGELOG\.md|package\.json)$/;
-var MAX_RANGE = 50;
 var phaseIdOf = (cell) => PHASE_ID.exec(cell)?.[1]?.toLowerCase() ?? null;
 var splitOutsideParentheses = (cell, separator) => {
   const entries = [];
@@ -470,9 +485,7 @@ var splitOutsideParentheses = (cell, separator) => {
 var rangeOf = (entry) => {
   const match = PHASE_RANGE.exec(entry);
   if (!match) return null;
-  const [first, last] = [Number(match[1]), Number(match[2])];
-  if (first > last || last - first >= MAX_RANGE) return [];
-  return Array.from({ length: last - first + 1 }, (_, offset) => String(first + offset));
+  return spannedPhaseIds(Number(match[1]), Number(match[2]));
 };
 var dependsOf = (cell, language) => {
   const noDependency = PLAN_VOCABULARY[language].noDependency;
@@ -863,6 +876,7 @@ export {
   PROSE_REASON,
   RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
+  WAITING_VOCABULARY,
   activeItem,
   boardRowsWithProse,
   boardRowsWithoutPhase,

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.8.1"
+version = "1.9.0"
 min_herdr_version = "0.8.2"
 description = "Show the herd, the state of a board's lanes, in a herdr pane"
 platforms = ["linux", "macos"]

package/install.sh

@@ -9,7 +9,7 @@ set -eu
 
 # The default is the version this file ships with. The release bump changes it together with
 # package.json; install.test.ts fails while the two differ. Overridable, but only by a plain release.
-JACKHERD_VERSION="${JACKHERD_VERSION:-1.8.1}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.9.0}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/kit/hooks/hooks/approval-gate/index.ts

@@ -1,14 +1,17 @@
 // PermissionRequest hook of Claude Code, shipped by jackherd: the client adapter of the approval gate. In a lane, known
 // by the herdr agent of the pane and not by the directory of the call, it holds a call that would open a permission
-// dialog, records it for the coordinator and answers with the user's decision from the coordinator's dialog; elsewhere,
-// and on any failure, it answers nothing and the dialog stays. argv[2..5]: the allow label, the deny label, the text for
+// dialog, records it for the coordinator and answers with the user's decision from the coordinator's dialog; the same for
+// a subagent of the coordinator, under its own name; elsewhere, and on any failure, it answers nothing and the dialog stays. argv[2..5]: the allow label, the deny label, the text for
 // a call still pending after the wait, the text for a denied call, rendered into the hook entry by `sync`.
+import { existsSync } from 'node:fs'
 import { homedir } from 'node:os'
+import { join } from 'node:path'
 import { mainCheckoutOf } from '../shared/checkout'
 import { commandOutput } from '../shared/command'
 import { readConfig } from '../shared/config'
 import { isRecord } from '../shared/json'
 import { ownPaneAgent } from '../shared/own-pane'
+import { gateSettingsOf } from './settings'
 import { coordinatorSessions } from './herdr-panes'
 import { type ClientCall, type GateDependencies, type GateOutcome, runGate } from './run'
 import { approvalsDirectory, claimRequest, pruneRequests, readRequests, writeRequest } from './store'
@@ -23,17 +26,32 @@ const herdrPanes = (): unknown => {
   return answer.result
 }
 
-/** Claude Code's hook input: `cwd`, `session_id`, `tool_name`, `tool_input`. */
+/** The subagent a call comes from: Claude Code adds `agent_id` and `agent_type` only to the hooks of a subagent. */
+const subagentOf = (input: Record<string, unknown>): ClientCall['subagent'] =>
+  typeof input.agent_id === 'string'
+    ? { id: input.agent_id, type: typeof input.agent_type === 'string' ? input.agent_type : null }
+    : undefined
+
+/** Claude Code's hook input: `cwd`, `session_id`, `tool_name`, `tool_input`, and `agent_id` inside a subagent. */
 const clientCallOf = (text: string): ClientCall | null => {
   const input: unknown = JSON.parse(text)
   if (!isRecord(input) || typeof input.cwd !== 'string' || typeof input.tool_name !== 'string') return null
   if (typeof input.session_id !== 'string') return null
-  return { cwd: input.cwd, session: input.session_id, tool: input.tool_name, input: input.tool_input ?? null }
+  const subagent = subagentOf(input)
+  return {
+    cwd: input.cwd,
+    session: input.session_id,
+    tool: input.tool_name,
+    input: input.tool_input ?? null,
+    ...(subagent ? { subagent } : {}),
+  }
 }
 
 const dependencies: GateDependencies = {
   paneAgent: () => ownPaneAgent(),
   mainCheckoutOf,
+  isLaneName: (main, name) =>
+    existsSync(join(main, gateSettingsOf(readConfig([main, homedir()])).worktreeDirectory, name)),
   config: (main) => readConfig([main, homedir()]),
   readRequests: (main) => readRequests(approvalsDirectory(main)),
   writeRequest: (main, request) => writeRequest(approvalsDirectory(main), request),