jackherd 1.4.0 → 1.6.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.6.0
+
+- **Replies address you as you like.** The new setting `responseAddress` (`informal` by default, or `formal`) says whether replies use the familiar or the polite form where the language has both: in German `du` or `Sie`. Set it in `.jackherd/config.json`; `jh sync` writes it into the kit rule `rules/kit/code-style.md`, which every session loads. It follows `responseLanguage`. English has one form, so there the setting only nudges the tone (direct or businesslike). The watcher's and the plans view's own German words use no pronoun and are unchanged.
+- **`jh --version` (and `jh -v`) prints the installed version** and exits 0. The usage text lists it.
+- **Closing a lane marks its rows.** Step 5 of "Close a lane" in the `orchestrate` skill now appends the cleaned-up word (`, abgeräumt <date>` on a German board, `, cleaned up <date>` on an English one) to the name cell of every row of the lane, in the same documentation PR as the history entry. The word follows `planLanguage`. The plans view no longer lists a closed lane without a worktree as `waiting`.
+- **The worktree's dependencies are checked with one command.** When the herdr plugin `zerodice0.worktree-bootstrap` has set up the worktree, the `orchestrate` skill no longer polls for a dependencies directory (some package managers keep a workspace's out of the root, so the poll could keep waiting on an install that was long done). It runs your `commands.install` with the lock file frozen: `bun install --frozen-lockfile`, `pnpm install --frozen-lockfile`, `yarn install --immutable` or `npm ci` (which always reinstalls). Any other install command you set is run exactly as written.
+- **`jh sync` clears the empty directories a prefix change leaves.** When `skillPrefix` changes, the unedited kit files under the old names are removed, and now the directories those removals leave empty go too; an empty directory the run did not touch stays. A directory that still holds a file the kit did not write stays, and `sync` says so (`Kept .claude/skills/<name>: it holds files the kit did not write.`). A symbolic link is not followed, and `sync --check` removes nothing.
+
+## 1.5.0
+
+- **The plans view lists only the lanes that still have something to do.** Before, every lane without an agent was listed (56 of 61 on one board, nearly all of them finished). Now a lane marked cleaned up, and a lane without a worktree whose named phases are all ticked, are not shown. A lane without a worktree that still has an open phase, or no plan and a "starts after" other than "now", is listed under `· waiting` with what it waits for. A worktree without an agent stays under `· no agent`. The board needs no change. The watcher is unchanged.
+- **Documents merge without waiting for checks.** The new setting `merge.withoutChecks` (default empty) lists path patterns such as `docs/**/*.md`. When every file of a pull request matches, `/orchestrate` merges at once instead of `gh pr checks --watch`, and the merge guard does not ask for a plain `gh pr merge <number>`: it checks the file list on GitHub itself and asks as before on any doubt. Pattern rules are in the README.
+- **The heartbeat shows progress.** In a stream, a `working` lane whose phase count moved since the last heartbeat becomes `<lane> working: P12 7/12`; a lane that did not move adds nothing. The heartbeat line stays short.
+- **Source scripts are TypeScript.** The `follow` skill now writes a source's script as `scripts/sources/<name>.ts`, started with `["bun", "scripts/sources/<name>.ts"]` (Bun must be installed). The token goes from `process.env` into the request header, and a failure is an exit code, not an empty list. The README recipes for Jira with `acli`, Linear and Sentry are replaced, and a test compiles each one. The watcher reads `bun` as a source's program to mean the Bun that runs it, so Bun need not be on the `PATH`. Existing `watch.sources` entries keep working; recipes without a script stay direct commands.
+
 ## 1.4.0
 
 - **A question in running text gets a hint.** The new `Stop` hook `ask-hint` tells you when the last message of a turn ends in `?` and no `AskUserQuestion` dialog was used. It only hints; the turn ends as before. A lane session stays silent, because a lane asks its coordinator as a text block. Switch it off with `"hints": { "askUserQuestion": false }` in `.jackherd/config.json`. `jh sync` brings the hook to a project install; a global install ships none.

package/README.md

@@ -185,7 +185,7 @@ bunx jackherd sync   # later: updates the kit files
 
 `init` writes what it [detected](#user-content-detected-per-repository) into the new config, so the project sees it. It asks whether to enter the [status line](#user-content-status-line) in `.claude/settings.json`; `--yes` or `--no` answer every question without asking.
 
-**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.
+**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.
 
@@ -531,6 +531,16 @@ A merge or a release is the step nobody takes back. In a project install the `me
 - `guard.selfMerge.offer` (default `true`) lets `/orchestrate` offer "approve, and merge it yourself after green checks" in its PR question. With `false` the question has two options and the hook honours no such answer.
 - `guard.selfMerge.approvalMinutes` (default 180) is how long that answer lets `gh pr merge <number>` pass without a second dialog.
 
+**Merging without checks.** A pull request that only changes documents rarely needs its checks. List the paths in `merge.withoutChecks` (default empty, so every merge waits for the checks as before):
+
+```json
+{
+  "merge": { "withoutChecks": ["docs/**/*.md"] }
+}
+```
+
+A pattern is made of path words with `*` and `**`: no `..`, not absolute, no braces or negation, and at least one whole path segment without a wildcard, so `docs/**/*.md` is fine and `**`, `**/*.md` and `**/*.*` are refused. Keep the folder in the pattern: a `.md` file elsewhere can be an agent instruction (`CLAUDE.md`, a skill) that ships with a package and deserves its checks. With the list set, `/orchestrate` lists a pull request's files with `gh pr diff <number> --name-only` before it waits for checks and merges at once when every file matches. The merge guard checks the same itself: for a plain `gh pr merge <number>` it asks GitHub for the pull request and then for its files in that repository (`gh api …/pulls/<number>/files`, which also names the old path of a renamed file) and does not ask you when the pull request is open, from this repository, GitHub lists as many files as the pull request changes (fewer than 3000) and every one matches a pattern. This works without a self-merge answer, also when `guard.selfMerge.offer` is `false`. No file, one file outside, a count that differs, a failed `gh` call or a pattern list it cannot read means it asks as before. Limit: a push between its look and the merge is not seen.
+
 **What self-merge does.** You pick the second option of the PR question. The coordinator commits, pushes and opens the PR, waits for the checks in the background, merges with `gh pr merge <number> --squash --delete-branch` when they are green and tells you in one line; on a red check it does not merge and reports. The project supplement can block the option per approval tier.
 
 **What the hook checks.** It does not take the agent's word for your answer. It reads the session's transcript, which Claude Code writes, and looks for a dialog result where you picked that exact option for a question naming one branch. Then it asks GitHub which branch pull request `<number>` carries and lets the merge pass if the two match, the PR is open and not from a fork, and the command is exactly the plain form: `gh pr merge <number>` with `--squash`, `--merge`, `--rebase` and `--delete-branch` as the only flags, run on its own in the directory you work in (no `-R`, no `--admin`, no chain, no wrapper). `gh workflow run` and every other guarded command ask every time.
@@ -580,7 +590,7 @@ coordinator coordinator no value (no agent named coordinator)
 gh unavailable since 11:24:31
 ```
 
-As a stream (`--stream`) it keeps running, and the heartbeat is one line:
+As a stream (`--stream`) it keeps running, and the heartbeat is one line. A working lane shows its plan progress, `<lane> working: P12 7/12` (the lane's current phase and its ticked checkboxes, counted as the plans view counts them), but only when the count moved since the last heartbeat; a lane that stays on one number says nothing, and you look for yourself. The plans are read only when a lane works:
 
 ```text
 armed: search=no agent board docs/plans/board-search/board.md
@@ -710,36 +720,70 @@ Three limits stand: the watcher cannot make a command read only, so name only co
 
 ##### Recipes
 
-Each recipe is one `watch.sources` entry; put in your key, project or query, then try it with `--dry-run` (and `--raw` where the shape differs from what is shown). A token never goes into an argument: an argument shows in the process list. Where a tool keeps its own login, it is used; where a token sits in an environment variable, a small script hands it to `curl` on stdin (`-H @-`), because the watcher passes `$VARIABLE` in an argument on as it is.
-
-**Jira with the Atlassian CLI.** Login: `acli jira auth login`, kept by `acli`. `acli jira workitem search` cannot return `updated` or `comment`, so a script searches for the keys and reads each one with `view`, a few at a time to stay well under the 30 seconds a source may run. It joins the text and mention nodes of the comment's document tree into plain text. The script, for example `scripts/sources/jira.sh`, with your project in the query and `<host>` your `<site>.atlassian.net`:
+Each recipe is one `watch.sources` entry; put in your key, project or query, then try it with `--dry-run` (and `--raw` where the shape differs from what is shown). A token never goes into an argument: an argument shows in the process list. Where a tool keeps its own login, it is used; where a token sits in an environment variable, a small TypeScript script run by Bun (which runs wherever `jh` does) puts it from `process.env` straight into the request header. A script fails with an exit code, never with an empty answer the watcher would take for a source with nothing new, and it prints neither the token nor the body of a failed answer. The closing `export {}` makes the file a module, so the type check accepts top-level `await` and the names do not clash between scripts. A recipe that needs no script (`gh …`, `curl` on a public page, `curl --netrc`) stays a direct command. The watcher starts a source without a shell and reads `bun` as the first word to mean the Bun that runs the watcher itself, so the entry needs no absolute path, which would differ from machine to machine, even when Bun is not on the `PATH` (installed in `~/.bun/bin` only, say).
+
+**Jira with the Atlassian CLI.** Login: `acli jira auth login`, kept by `acli`. `acli jira workitem search` cannot return `updated` or `comment`, so a script searches for the keys and reads each one with `view`, a few at a time to stay well under the 30 seconds a source may run. `plainText` joins the text and mention nodes of the comment's document tree into plain text; it is a pure function, so you can test it on its own. The script, for example `scripts/sources/jira.ts`, with your project in the query and `<host>` your `<site>.atlassian.net`:
+
+```ts
+// scripts/sources/jira.ts
+const jql = 'project = PROJ AND assignee = currentUser() AND statusCategory != Done'
+const host = '<host>'
+const parallel = 6
+
+type DocumentNode = { type?: string; text?: string; attrs?: { text?: string }; content?: DocumentNode[] }
+type IssueComment = { author?: { displayName?: string }; body?: DocumentNode }
+type Issue = { key: string; fields: { updated: string; summary: string; comment?: { comments: IssueComment[] } } }
+
+const plainText = (node: DocumentNode): string =>
+  node.type === 'text' || node.type === 'mention'
+    ? (node.text ?? node.attrs?.text ?? '')
+    : (node.content ?? []).map(plainText).join('')
+
+const acli = async (args: string[]): Promise<unknown> => {
+  const child = Bun.spawn(['acli', ...args], { stdout: 'pipe', stderr: 'ignore', signal: AbortSignal.timeout(20_000) })
+  const output = await new Response(child.stdout).text()
+  if ((await child.exited) !== 0) process.exit(1)
+  try {
+    return JSON.parse(output)
+  } catch {
+    return process.exit(1)
+  }
+}
 
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-jql='project = PROJ AND assignee = currentUser() AND statusCategory != Done'
-acli jira workitem search --jql "$jql" --limit 100 --json |
-  jq -r '.[].key' |
-  xargs -r -P 6 -I{} acli jira workitem view {} --fields summary,updated,comment --json |
-  jq -s 'map({
+const entryOf = ({ key, fields }: Issue) => {
+  const latest = fields.comment?.comments.at(-1)
+  return {
     key,
-    url: ("https://<host>/browse/" + .key),
-    updated: .fields.updated,
-    summary: .fields.summary,
-    author: (.fields.comment.comments[-1].author.displayName // null),
-    body: (.fields.comment.comments[-1].body
-      | if . == null then null
-        else [.. | objects | select(.type == "text" or .type == "mention") | (.text // .attrs.text)] | join("")
-        end)
-  })'
+    url: `https://${host}/browse/${key}`,
+    updated: fields.updated,
+    summary: fields.summary,
+    author: latest?.author?.displayName ?? null,
+    body: latest?.body ? plainText(latest.body) : null,
+  }
+}
+
+const keys = ((await acli(['jira', 'workitem', 'search', '--jql', jql, '--limit', '100', '--json'])) as { key: string }[]).map(
+  ({ key }) => key,
+)
+const entries = []
+for (let start = 0; start < keys.length; start += parallel) {
+  const batch = keys.slice(start, start + parallel)
+  const issues = await Promise.all(
+    batch.map((key) => acli(['jira', 'workitem', 'view', key, '--fields', 'summary,updated,comment', '--json'])),
+  )
+  entries.push(...(issues as Issue[]).map(entryOf))
+}
+console.log(JSON.stringify(entries))
+
+export {}
 ```
 
-`set -euo pipefail` is what makes a failed `acli` call arrive as an error: without it the pipe ends in an empty list, and the watcher would take a lost login for a source with nothing new.
+A failed `acli` call ends the script with exit code 1, which the watcher reports as a failing source; nothing is printed that it could take for an empty list.
 
 ```json
 {
   "name": "tickets-decisions",
-  "command": ["bash", "scripts/sources/jira.sh"],
+  "command": ["bun", "scripts/sources/jira.ts"],
   "map": {
     "id": ".key",
     "updatedAt": ".updated",
@@ -768,19 +812,34 @@ acli jira workitem search --jql "$jql" --limit 100 --json |
 }
 ```
 
-**Linear over GraphQL.** Token: a personal API key in `LINEAR_API_KEY`, sent as `Authorization: <key>` without `Bearer`. The script, for example `scripts/sources/linear.sh`, with `<host>` the API host `api.linear.app`:
+**Linear over GraphQL.** Token: a personal API key in `LINEAR_API_KEY`, sent as `Authorization: <key>` without `Bearer`. The script, for example `scripts/sources/linear.ts`, with `<host>` the API host `api.linear.app`. Linear answers a bad key or query with HTTP 200 and an `errors` list, so the script checks for it as well:
 
-```sh
-#!/bin/sh
-query='{"query":"{ issues(filter: { team: { key: { eq: \"ENG\" } }, number: { eq: 123 } }) { nodes { identifier title url updatedAt comments { nodes { body user { name } } } } } }"}'
-printf 'Authorization: %s\n' "$LINEAR_API_KEY" |
-  curl -fsS --max-time 20 -H @- -H 'Content-Type: application/json' --data "$query" "https://<host>/graphql"
+```ts
+// scripts/sources/linear.ts
+const token = process.env.LINEAR_API_KEY
+if (!token) process.exit(1)
+
+const query = `{ issues(filter: { team: { key: { eq: "ENG" } }, number: { eq: 123 } }) {
+  nodes { identifier title url updatedAt comments { nodes { body user { name } } } } } }`
+
+const response = await fetch('https://<host>/graphql', {
+  method: 'POST',
+  headers: { Authorization: token, 'Content-Type': 'application/json' },
+  body: JSON.stringify({ query }),
+  signal: AbortSignal.timeout(20_000),
+})
+if (!response.ok) process.exit(1)
+const answer = (await response.json()) as { errors?: unknown }
+if (answer.errors) process.exit(1)
+console.log(JSON.stringify(answer))
+
+export {}
 ```
 
 ```json
 {
   "name": "linear-eng-123",
-  "command": ["sh", "scripts/sources/linear.sh"],
+  "command": ["bun", "scripts/sources/linear.ts"],
   "items": ".data.issues.nodes",
   "map": {
     "id": ".identifier",
@@ -813,19 +872,28 @@ Check with `--raw` which end of `comments.nodes` holds the newest comment; `[0]`
 }
 ```
 
-**Sentry.** Token: an auth token with `event:read` in `SENTRY_AUTH_TOKEN`; `<host>` is `sentry.io` or your own. The script, for example `scripts/sources/sentry.sh`:
+**Sentry.** Token: an auth token with `event:read` in `SENTRY_AUTH_TOKEN`; `<host>` is `sentry.io` or your own. The script, for example `scripts/sources/sentry.ts`:
+
+```ts
+// scripts/sources/sentry.ts
+const token = process.env.SENTRY_AUTH_TOKEN
+if (!token) process.exit(1)
+
+const response = await fetch(
+  'https://<host>/api/0/projects/<org>/<project>/issues/?query=is:unresolved&statsPeriod=24h',
+  { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(20_000) },
+)
+if (!response.ok) process.exit(1)
+console.log(JSON.stringify(await response.json()))
 
-```sh
-#!/bin/sh
-printf 'Authorization: Bearer %s\n' "$SENTRY_AUTH_TOKEN" |
-  curl -fsS --max-time 20 -H @- "https://<host>/api/0/projects/<org>/<project>/issues/?query=is:unresolved&statsPeriod=24h"
+export {}
 ```
 
 ```json
 {
   "name": "errors",
   "every": 10,
-  "command": ["sh", "scripts/sources/sentry.sh"],
+  "command": ["bun", "scripts/sources/sentry.ts"],
   "map": { "id": ".id", "updatedAt": ".lastSeen", "title": ".title", "url": ".permalink", "body": ".culprit" }
 }
 ```
@@ -865,7 +933,7 @@ Decisions never live only in a hand-over note: they are in the plan or the board
 
 In a repository that ignores `docs/`, plan and board exist only in the main checkout and the plan view reads them there; list the plan in `lanes.copy` so the lane has it to work from and to tick off its own progress.
 
-The herdr plugin `zerodice0.worktree-bootstrap`, when enabled and configured in the main checkout, can copy files and run setup commands for new worktrees; the coordinator checks its result and does the step itself when it is missing.
+The herdr plugin `zerodice0.worktree-bootstrap`, when enabled and configured in the main checkout, can copy files and run setup commands for new worktrees; the coordinator checks its result with the install command and a frozen lock file (`bun install --frozen-lockfile`, `pnpm install --frozen-lockfile`, `yarn install --immutable`, `npm ci`, derived from `commands.install`; an install command of your own runs as written) and does the step itself when it is missing.
 
 </details>
 
@@ -887,6 +955,7 @@ The herdr plugin `zerodice0.worktree-bootstrap`, when enabled and configured in
 One block per lane of the chosen board, lanes that wait on you first:
 
 - the agent's state: `❓ blocked` (waits for you), `📨 done` (the agent finished its answer, not the lane), `⏸ idle`, `⚡ working`, or `·` no agent
+- which lanes are listed at all. A lane with an agent or an open pull request is drawn in full. A lane with a worktree but no agent is listed under `· no agent`. A lane without a worktree is listed under `· waiting`, with what it starts after, when a phase it names is still open in its plan or, if it names no plan, when its "starts after" cell says something other than "now" (`sofort`); otherwise it is finished and not shown. A lane whose name cell carries the cleaned-up mark (`abgeräumt`) is finished whatever its plan says. The board needs no extra column for this
 - how full the agent's context is, and a bar with the lane's ticked tasks
 - the branch, commits ahead and uncommitted files
 - the lane's open pull request with its checks
@@ -1008,6 +1077,7 @@ At `warn` a lane offers a fresh chat at its next phase boundary, and the watcher
 
 | Command | What it does | Options |
 | ------- | ------------ | ------- |
+| `jh --version` | The installed version, e.g. `1.6.0`; `-v` is the same | none |
 | `jh init` | Creates `.jackherd/config.json` and installs the kit | `--global`: into `~/.claude` and `~/.jackherd`; `--yes`/`--no`: answer all its questions (globally the hook and the status line, in a project the prefix and the status line) and take the default [setup](#user-content-setup-questions); a status line of your own is replaced only by a yes in the dialog |
 | `jh sync` | Updates the kit files; edited files get a `.kit-new` beside them | `--global`; `--accept <path>` takes the kit's version; `--global --if-changed` syncs only after a package update and names a newer npm release once a day |
 | `jh update` | Installs the newest release with the package manager that holds the kit globally, then syncs `~/.claude` and the project with the new code | none; does nothing when the installed version is the latest |
@@ -1026,6 +1096,7 @@ Without a global install, run any of them as `bunx jackherd <command>`.
 | Key | Default | What it decides |
 | --- | --- | --- |
 | `responseLanguage` | `en` | the language the skills speak with you, and the watcher's status words |
+| `responseAddress` | `informal` | `informal` or `formal`: how replies address you where the language has both (German: `du` or `Sie`). `jh sync` writes it once into the kit rule `rules/kit/code-style.md`, which every session loads; it follows `responseLanguage`; the status words of the watcher and the plans view use no pronoun and stay as they are |
 | `planLanguage` | `en` | the language of plans and boards, including their headings |
 | `planDirectory` | `docs/plans` | where plans and boards live |
 | `board.pattern`, `board.file`, `board.term` | `board-*`, `board.md`, `board` | [Boards](#user-content-boards) |

package/dist/{chunk-UI3AZNZF.js → chunk-QJSXHHQ3.js}

@@ -4,6 +4,17 @@ var LANGUAGE_NAME = {
   [PLAN_LANGUAGE.en]: "English",
   [PLAN_LANGUAGE.de]: "German"
 };
+var RESPONSE_ADDRESS = { informal: "informal", formal: "formal" };
+var ADDRESS_FORM = {
+  [PLAN_LANGUAGE.en]: {
+    [RESPONSE_ADDRESS.informal]: "the plain, direct \u201Cyou\u201D, without titles",
+    [RESPONSE_ADDRESS.formal]: "a polite, businesslike \u201Cyou\u201D"
+  },
+  [PLAN_LANGUAGE.de]: {
+    [RESPONSE_ADDRESS.informal]: "the familiar \u201Cdu\u201D (du, dir, dein), never \u201CSie\u201D",
+    [RESPONSE_ADDRESS.formal]: "the polite \u201CSie\u201D (Sie, Ihnen, Ihr), never \u201Cdu\u201D"
+  }
+};
 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"
@@ -35,6 +46,7 @@ var PLAN_VOCABULARY = {
     phase: "Phase",
     noReviewGate: "Kein Review-Gate",
     laneClosed: "abger\xE4umt",
+    startsNow: ["sofort"],
     phaseConnectors: ["danach", "und", "dann", "sowie"],
     statusWords: {
       done: { label: "Done", leading: ["done"], anywhere: ["abgeschlossen"] },
@@ -62,6 +74,7 @@ var PLAN_VOCABULARY = {
     phase: "Phase",
     noReviewGate: "No review gate",
     laneClosed: "cleaned up",
+    startsNow: ["now", "immediately"],
     phaseConnectors: ["then", "and", "after"],
     statusWords: {
       done: { label: "Done", leading: ["done"], anywhere: ["completed"] },
@@ -88,6 +101,8 @@ var sectionHeading = (language, section) => `## ${PLAN_VOCABULARY[language].sect
 export {
   PLAN_LANGUAGE,
   LANGUAGE_NAME,
+  RESPONSE_ADDRESS,
+  ADDRESS_FORM,
   SELF_MERGE_LABEL,
   isPlanLanguage,
   PLAN_STATUS,

package/dist/config.d.ts

@@ -43,6 +43,10 @@ declare const jackherdConfigSchema: z.ZodObject<{
         de: "de";
         en: "en";
     }>>;
+    responseAddress: z.ZodDefault<z.ZodEnum<{
+        informal: "informal";
+        formal: "formal";
+    }>>;
     planLanguage: z.ZodDefault<z.ZodEnum<{
         de: "de";
         en: "en";
@@ -139,6 +143,9 @@ declare const jackherdConfigSchema: z.ZodObject<{
             approvalMinutes: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    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>;
     }, z.core.$strict>>;

package/dist/config.js

@@ -1,6 +1,7 @@
 import {
-  PLAN_LANGUAGE
-} from "./chunk-UI3AZNZF.js";
+  PLAN_LANGUAGE,
+  RESPONSE_ADDRESS
+} from "./chunk-QJSXHHQ3.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -69,6 +70,12 @@ var DERIVED_COMMANDS = {
     lintFiles: "npx @biomejs/biome check --no-errors-on-unmatched"
   }
 };
+var FROZEN_INSTALL = {
+  [DERIVED_COMMANDS.bun.install]: "bun install --frozen-lockfile",
+  [DERIVED_COMMANDS.yarn.install]: "yarn install --immutable",
+  [DERIVED_COMMANDS.pnpm.install]: "pnpm install --frozen-lockfile",
+  [DERIVED_COMMANDS.npm.install]: "npm ci"
+};
 var BUN_COMMANDS = DERIVED_COMMANDS.bun;
 
 // src/check/command-line.ts
@@ -299,6 +306,20 @@ var coordinatorSchema = z2.strictObject({
   alertAt: share.default(0.7)
 }).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(
+  (pattern) => !pattern.startsWith("/") && !pattern.split("/").includes(".."),
+  "a relative path that stays inside the repository"
+).refine(
+  (pattern) => pattern.split("/").some((segment) => /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment)),
+  "a pattern with a whole path segment that is no wildcard, such as docs/**/*.md"
+);
+var mergeSchema = z2.strictObject({
+  /**
+   * Paths of pull requests that are merged without waiting for checks: when every file of the pull request matches one
+   * of them, `/orchestrate` merges at once and the merge guard does not ask. Empty means every merge waits for checks.
+   */
+  withoutChecks: z2.array(checkFreePattern).default([])
+});
 var guardSchema = z2.strictObject({
   /**
    * The commands the merge guard hook asks the user about before they run, also behind options before the verb, a chain,
@@ -331,6 +352,8 @@ var contextSchema = z2.strictObject({
 var jackherdConfigSchema = z2.strictObject({
   $schema: z2.string().optional(),
   responseLanguage: language.default(PLAN_LANGUAGE.en),
+  /** Whether replies address the user with the familiar or the polite form where the language has both (German: du or Sie). */
+  responseAddress: z2.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
   planLanguage: language.default(PLAN_LANGUAGE.en),
   planDirectory: z2.string().min(1).default("docs/plans"),
   /** Where the boards live and what the project calls them. */
@@ -391,6 +414,8 @@ var jackherdConfigSchema = z2.strictObject({
   }).prefault({}),
   /** Read by the merge guard hook, which asks before the listed commands run, and by `/orchestrate`. */
   guard: guardSchema.prefault({}),
+  /** Read by `/orchestrate` and by the merge guard hook. */
+  merge: mergeSchema.prefault({}),
   /** Read by the `ask-hint` hook. */
   hints: hintsSchema.prefault({}),
   /** Read by `jh check`; validated here too, so a typo fails every command alike. */

package/dist/plan-format.d.ts

@@ -5,6 +5,17 @@ declare const PLAN_LANGUAGE: {
 type PlanLanguage = (typeof PLAN_LANGUAGE)[keyof typeof PLAN_LANGUAGE];
 /** The language's name as a reply or a question says it. */
 declare const LANGUAGE_NAME: Record<PlanLanguage, string>;
+declare const RESPONSE_ADDRESS: {
+    readonly informal: "informal";
+    readonly formal: "formal";
+};
+type ResponseAddress = (typeof RESPONSE_ADDRESS)[keyof typeof RESPONSE_ADDRESS];
+/**
+ * How a skill's reply addresses the user, as the words a kit rule gives the agent. German and the other languages
+ * that tell a familiar from a polite "you" name the pronoun and the possessive; English has one form and only
+ * differs in tone.
+ */
+declare const ADDRESS_FORM: Record<PlanLanguage, Record<ResponseAddress, string>>;
 /**
  * The option of the pull request question that approves the PR and a merge by the coordinator once the checks are
  * green. The merge guard hook matches the user's answer against this exact text, so it is fixed per language and not
@@ -55,6 +66,8 @@ type PlanVocabulary = {
     noReviewGate: string;
     /** Marks a lane as closed when its name cell contains it. */
     laneClosed: string;
+    /** Words a starts-after cell begins with when the lane may start at once. */
+    startsNow: readonly string[];
     /** Words that may stand between two phases of one entry (`P1 Rule und P2 Monitor`). */
     phaseConnectors: readonly string[];
     statusWords: Record<PlanStatus, StatusWord>;
@@ -328,4 +341,4 @@ declare const readSprintDocument: (markdown: string, language: PlanLanguage) =>
  */
 declare const readPhaseDependencies: (planMarkdown: string, language: PlanLanguage) => Record<string, string>;
 
-export { type ChecklistItem, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, type PhaseProgress, type PhaseTally, type PhaseWithoutGate, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithoutPhase, classifyStatus, countDecisions, currentPhase, currentPhaseOf, deferralTarget, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, keptPhaseIds, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseIdsOfCell, phaseIdsOfPlan, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };
+export { ADDRESS_FORM, type ChecklistItem, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, type PhaseProgress, type PhaseTally, type PhaseWithoutGate, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, RESPONSE_ADDRESS, type ResponseAddress, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithoutPhase, classifyStatus, countDecisions, currentPhase, currentPhaseOf, deferralTarget, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, keptPhaseIds, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseIdsOfCell, phaseIdsOfPlan, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };

package/dist/plan-format.js

@@ -1,14 +1,16 @@
 import {
+  ADDRESS_FORM,
   LANGUAGE_NAME,
   PLAN_LANGUAGE,
   PLAN_STATUS,
   PLAN_VOCABULARY,
+  RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
   classifyStatus,
   isPlanLanguage,
   phaseHeading,
   sectionHeading
-} from "./chunk-UI3AZNZF.js";
+} from "./chunk-QJSXHHQ3.js";
 
 // src/plan-format/terminal-text.ts
 var UNSAFE_RANGES = [
@@ -592,11 +594,13 @@ var readPhaseDependencies = (planMarkdown, language) => {
   return Object.fromEntries(entries);
 };
 export {
+  ADDRESS_FORM,
   LANGUAGE_NAME,
   PHASE_ID_PREFIX,
   PLAN_LANGUAGE,
   PLAN_STATUS,
   PLAN_VOCABULARY,
+  RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
   activeItem,
   boardRowsWithoutPhase,

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.4.0"
+version = "1.6.0"
 min_herdr_version = "0.8.2"
 description = "Show the plans 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.4.0}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.6.0}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/kit/hooks/hooks/merge-guard/check-free.ts

@@ -0,0 +1,70 @@
+/**
+ * Whether a pull request changes nothing but files the project merges without waiting for checks
+ * (`merge.withoutChecks`). The file list comes from GitHub, never from an agent's text. Every doubt answers
+ * "no", so the guard asks as before.
+ */
+
+import { runGh } from './gh'
+import type { RepositoryFacts } from './pull-request'
+
+/** What GitHub lists per file: the name, and the old name of a renamed file. */
+const FILE_ENTRY_QUERY = '.[] | [.filename, .previous_filename] | @json'
+
+/** GitHub lists at most this many files of a pull request and says nothing when it stops there. */
+export const MAX_LISTED_FILES = 3000
+
+const isControlCharacter = (character: string): boolean => {
+  const code = character.charCodeAt(0)
+  return code < 0x20 || code === 0x7f
+}
+
+/** A repository path as GitHub lists it: relative, no empty, `.` or `..` segment, no backslash, no control character. */
+const isPlainPath = (file: string): boolean =>
+  file !== '' &&
+  !file.startsWith('/') &&
+  !file.includes('\\') &&
+  ![...file].some(isControlCharacter) &&
+  !file.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')
+
+const isNameOrNull = (value: unknown): value is string | null => value === null || typeof value === 'string'
+
+/**
+ * The names a listing carries, the old name of a rename too, from one `[filename, previous]` JSON pair per line.
+ * The pairs must be exactly as many as the pull request changes files, and fewer than GitHub's cap: a list that
+ * was cut short would hide the files that are not in it. Anything else answers nothing.
+ */
+export const parseFileEntries = (stdout: string, changedFiles: number): string[] | undefined => {
+  if (changedFiles >= MAX_LISTED_FILES) return undefined
+  try {
+    const entries = stdout
+      .split('\n')
+      .filter((line) => line !== '')
+      .map((line): unknown => JSON.parse(line))
+    const pairs = entries.filter(
+      (entry): entry is [string, string | null] =>
+        Array.isArray(entry) && entry.length === 2 && typeof entry[0] === 'string' && isNameOrNull(entry[1]),
+    )
+    if (pairs.length !== entries.length || pairs.length !== changedFiles) return undefined
+    return pairs.flatMap(([filename, previous]) => (previous === null ? [filename] : [filename, previous]))
+  } catch {
+    return undefined
+  }
+}
+
+/** True only for at least one file, at least one pattern, and every file a plain path that matches a pattern. */
+export const allFilesMatch = (files: readonly string[], patterns: readonly string[]): boolean => {
+  if (files.length === 0 || patterns.length === 0) return false
+  const globs = patterns.map((pattern) => new Bun.Glob(pattern))
+  return files.every((file) => isPlainPath(file) && globs.some((glob) => glob.match(file)))
+}
+
+/**
+ * Asks `gh api` for the files of pull request <number> of `facts.repository`, named in full; any failure answers nothing.
+ */
+export const changedFilesOf = (pullRequest: number, directory: string, facts: RepositoryFacts): string[] | undefined => {
+  const listing = runGh(
+    ['api', `repos/${facts.repository}/pulls/${pullRequest}/files?per_page=100`, '--paginate', '--jq', FILE_ENTRY_QUERY],
+    directory,
+  )
+  return listing === undefined ? undefined : parseFileEntries(listing, facts.changedFiles)
+}

package/kit/hooks/hooks/merge-guard/decision.ts

@@ -13,7 +13,8 @@ export type GuardPolicy = {
   /** The guarded commands as words: a program and the plain words after it, such as `gh pr merge`. */
   commands: readonly string[]
   /**
-   * Whether the user approved the merge of this pull request; asked only for a plain `gh pr merge <number>`.
+   * Whether the merge of this pull request may pass without a question: the user approved it, or every file of it
+   * matches `merge.withoutChecks`. Asked only for a plain `gh pr merge <number>`.
    * A throw counts as not approved.
    */
   isMergeApproved: (pullRequest: number) => boolean

package/kit/hooks/hooks/merge-guard/gh.ts

@@ -0,0 +1,12 @@
+const LOOKUP_TIMEOUT_MS = 4000
+
+/** Runs `gh` with these arguments in `directory`, without a shell; stdout on success, nothing on any failure or timeout. */
+export const runGh = (args: readonly string[], directory: string): string | undefined => {
+  const result = Bun.spawnSync(['gh', ...args], {
+    cwd: directory,
+    timeout: LOOKUP_TIMEOUT_MS,
+    stdout: 'pipe',
+    stderr: 'ignore',
+  })
+  return result.exitCode === 0 ? result.stdout.toString() : undefined
+}

package/kit/hooks/hooks/merge-guard/pull-request.ts

@@ -4,10 +4,17 @@
  * says which branch pull request <number> carries.
  */
 
-const LOOKUP_TIMEOUT_MS = 4000
+import { runGh } from './gh'
 
 type PullRequestView = { headRefName?: unknown; isCrossRepository?: unknown; state?: unknown }
 
+/** Where a pull request lives and how many files it changes, as GitHub's `pr view` says. */
+export type RepositoryFacts = { repository: string; changedFiles: number }
+
+const VIEW_FIELDS = 'headRefName,isCrossRepository,state,url,changedFiles'
+const PULL_REQUEST_URL = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)\/pull\/[1-9]\d*$/
+
+
 /** The head branch of an open pull request from this repository; a fork's branch name proves nothing. */
 export const parseHeadBranch = (json: string): string | undefined => {
   try {
@@ -21,13 +28,23 @@ export const parseHeadBranch = (json: string): string | undefined => {
   }
 }
 
-/** Runs `gh pr view <number>` in `directory`, the directory the command itself runs in, without a shell; any failure answers nothing. */
-export const headBranchOf = (pullRequest: number, directory: string): string | undefined => {
-  const result = Bun.spawnSync(['gh', 'pr', 'view', String(pullRequest), '--json', 'headRefName,isCrossRepository,state'], {
-    cwd: directory,
-    timeout: LOOKUP_TIMEOUT_MS,
-    stdout: 'pipe',
-    stderr: 'ignore',
-  })
-  return result.exitCode === 0 ? parseHeadBranch(result.stdout.toString()) : undefined
+/**
+ * The repository from the pull request's own url (host github.com, plain owner and name) and its file count. The
+ * file list is then asked of that repository by name, so it cannot come from another one than `gh pr merge` merges in.
+ */
+export const parseRepositoryFacts = (json: string): RepositoryFacts | undefined => {
+  try {
+    const view: unknown = JSON.parse(json)
+    if (typeof view !== 'object' || view === null) return undefined
+    const { url, changedFiles } = view as { url?: unknown; changedFiles?: unknown }
+    const repository = typeof url === 'string' ? url.match(PULL_REQUEST_URL)?.[1] : undefined
+    const counted = typeof changedFiles === 'number' && Number.isInteger(changedFiles) && changedFiles >= 0
+    return repository !== undefined && counted ? { repository, changedFiles } : undefined
+  } catch {
+    return undefined
+  }
 }
+
+/** Runs `gh pr view <number>` in `directory`, the directory the command itself runs in; any failure answers nothing. */
+export const viewPullRequest = (pullRequest: number, directory: string): string | undefined =>
+  runGh(['pr', 'view', String(pullRequest), '--json', VIEW_FIELDS], directory)