jackherd 1.4.0 → 1.5.0

package/CHANGELOG.md

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

@@ -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" }
 }
 ```
@@ -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

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

@@ -35,6 +35,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 +63,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"] },

package/dist/config.d.ts

@@ -139,6 +139,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,6 @@
 import {
   PLAN_LANGUAGE
-} from "./chunk-UI3AZNZF.js";
+} from "./chunk-HQAONP4W.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -299,6 +299,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,
@@ -391,6 +405,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

@@ -55,6 +55,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>;

package/dist/plan-format.js

@@ -8,7 +8,7 @@ import {
   isPlanLanguage,
   phaseHeading,
   sectionHeading
-} from "./chunk-UI3AZNZF.js";
+} from "./chunk-HQAONP4W.js";
 
 // src/plan-format/terminal-text.ts
 var UNSAFE_RANGES = [

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.4.0"
+version = "1.5.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.5.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)

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

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs'
 import { isAbsolute, relative } from 'node:path'
 import { approvedBranches, parseTranscript } from './approval'
+import { allFilesMatch, changedFilesOf } from './check-free'
 import { decideBashCommand, type GuardPolicy, type MergeGuardDecision } from './decision'
-import { headBranchOf } from './pull-request'
+import { parseHeadBranch, parseRepositoryFacts, type RepositoryFacts, viewPullRequest } from './pull-request'
 import { type GuardSettings, readGuardSettings } from './settings'
 
 type HookInput = { tool_input?: { command?: unknown }; transcript_path?: unknown; cwd?: unknown }
@@ -25,13 +26,21 @@ const isInside = (directory: string, project: string): boolean => {
   return path === '' || (!path.startsWith('..') && !isAbsolute(path))
 }
 
+/** Every file of the pull request, as GitHub lists them, matches `merge.withoutChecks`. */
+const isCheckFree = (
+  pullRequest: number,
+  facts: RepositoryFacts | undefined,
+  withoutChecks: readonly string[],
+  directory: string,
+): boolean => facts !== undefined && allFilesMatch(changedFilesOf(pullRequest, directory, facts) ?? [], withoutChecks)
+
 const policyFor = (input: HookInput, label: string, projectDirectory: string): GuardPolicy => {
   const settings = readGuardSettings(projectDirectory)
   const directory = typeof input.cwd === 'string' && input.cwd !== '' ? input.cwd : projectDirectory
-  const headBranches = new Map<number, string | undefined>()
-  const headBranch = (pullRequest: number): string | undefined => {
-    if (!headBranches.has(pullRequest)) headBranches.set(pullRequest, headBranchOf(pullRequest, directory))
-    return headBranches.get(pullRequest)
+  const views = new Map<number, string | undefined>()
+  const viewOf = (pullRequest: number): string => {
+    if (!views.has(pullRequest)) views.set(pullRequest, viewPullRequest(pullRequest, directory))
+    return views.get(pullRequest) ?? ''
   }
   let approved: Set<string> | undefined
   return {
@@ -39,9 +48,14 @@ const policyFor = (input: HookInput, label: string, projectDirectory: string): G
     isMergeApproved: (pullRequest) => {
       if (!isInside(directory, projectDirectory)) return false
       const branches = (approved ??= approvedBranchesFrom(input.transcript_path, settings, label))
-      if (branches.size === 0) return false
-      const branch = headBranch(pullRequest)
-      return branch !== undefined && branches.has(branch)
+      if (branches.size === 0 && settings.withoutChecks.length === 0) return false
+      // The branch lookup also proves the pull request is open and from this repository; both paths need that.
+      const view = viewOf(pullRequest)
+      const branch = parseHeadBranch(view)
+      if (branch === undefined) return false
+      return (
+        branches.has(branch) || isCheckFree(pullRequest, parseRepositoryFacts(view), settings.withoutChecks, directory)
+      )
     },
   }
 }

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

@@ -5,17 +5,30 @@ import { join } from 'node:path'
 export type GuardSettings = {
   commands: string[]
   selfMerge: { offer: boolean; approvalMinutes: number }
+  /** Path patterns of a pull request that is merged without checks; empty means every merge waits for them. */
+  withoutChecks: string[]
 }
 
 export const DEFAULT_SETTINGS: GuardSettings = {
   commands: ['gh pr merge', 'gh workflow run'],
   selfMerge: { offer: true, approvalMinutes: 180 },
+  withoutChecks: [],
 }
 
 const CONFIG_PATH = join('.jackherd', 'config.json')
 export const GUARDED_COMMAND = /^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*){1,3}$/
 export const MAX_MINUTES = 1440
 
+/** The same rules as `checkFreePattern` in the config schema, which the hook cannot import. */
+const isCheckFreePattern = (value: unknown): value is string =>
+  typeof value === 'string' &&
+  /^[A-Za-z0-9_.*/-]+$/.test(value) &&
+  !value.startsWith('/') &&
+  !value.split('/').includes('..') &&
+  value.split('/').some((segment) => /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment))
+
+const isPatternList = (value: unknown): value is string[] => Array.isArray(value) && value.every(isCheckFreePattern)
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value)
 
@@ -25,13 +38,13 @@ const isCommandList = (value: unknown): value is string[] =>
 const isMinutes = (value: unknown): value is number =>
   typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= MAX_MINUTES
 
-/** The `guard` section of the first config that exists; the hook has no schema library, `jh` validates the file. */
-const readGuardSection = (directories: string[]): Record<string, unknown> => {
+/** The first config that exists; the hook has no schema library, `jh` validates the file. */
+const readConfig = (directories: string[]): Record<string, unknown> => {
   const path = directories.map((directory) => join(directory, CONFIG_PATH)).find((candidate) => existsSync(candidate))
   if (!path) return {}
   try {
     const config: unknown = JSON.parse(readFileSync(path, 'utf8'))
-    return isRecord(config) && isRecord(config.guard) ? config.guard : {}
+    return isRecord(config) ? config : {}
   } catch {
     return {}
   }
@@ -42,7 +55,9 @@ const readGuardSection = (directories: string[]): Record<string, unknown> => {
  * malformed keeps its default, so a broken config guards more, never less; only an empty list switches the guard off.
  */
 export const readGuardSettings = (projectDirectory: string, home: string = homedir()): GuardSettings => {
-  const section = readGuardSection([projectDirectory, home])
+  const config = readConfig([projectDirectory, home])
+  const section = isRecord(config.guard) ? config.guard : {}
+  const merge = isRecord(config.merge) ? config.merge : {}
   const selfMerge = isRecord(section.selfMerge) ? section.selfMerge : {}
   return {
     commands: isCommandList(section.commands) ? section.commands : DEFAULT_SETTINGS.commands,
@@ -52,5 +67,6 @@ export const readGuardSettings = (projectDirectory: string, home: string = homed
         ? selfMerge.approvalMinutes
         : DEFAULT_SETTINGS.selfMerge.approvalMinutes,
     },
+    withoutChecks: isPatternList(merge.withoutChecks) ? merge.withoutChecks : DEFAULT_SETTINGS.withoutChecks,
   }
 }

package/kit/workflow/skills/follow/SKILL.md

@@ -6,7 +6,7 @@ argument-hint: 'What to follow, e.g. a ticket key, an issue or a query'
 
 If `.claude/project/follow.md` exists, read it first. It extends this skill for this project and wins where the two disagree.
 
-You add one entry to `watch.sources`, so that `jh watch` reports a new or changed entry of an external service as `=== source <name> …`. You run only reading commands; the one file you write is the project's `.jackherd/config.json` in the main checkout, and only after the user approved the entry. How sources work, their fields and limits: the kit's README, section **Source reports** and **Recipes**, in the installed package (`"$(dirname "$(readlink -f "$(command -v jh)")")/../README.md"`). Read those two sections; do not copy a recipe from memory.
+You add one entry to `watch.sources`, so that `jh watch` reports a new or changed entry of an external service as `=== source <name> …`. You run only reading commands; the one file you write is the project's `.jackherd/config.json` in the main checkout, and only after the user approved the entry. How sources work, their fields and limits: the jackherd README, section **Source reports** and **Recipes**, in the installed package (`"$(dirname "$(readlink -f "$(command -v jh)")")/../README.md"`). Read those two sections; do not copy a recipe from memory.
 
 ## 1. Ask
 
@@ -20,7 +20,7 @@ One `AskUserQuestion` round in {{kit.responseLanguage}}, only for what the argum
 
 ## 2. Check, read only
 
-- The tool: `command -v <tool>` for the recipe's program (`curl`, the service's CLI).
+- The tool: `command -v <tool>` for the recipe's program (`curl`, the service's CLI, and `bun` for a recipe with a script).
 - The login: the tool's own status command where it has one. For a token in an environment variable only whether it is set: `test -n "$<VARIABLE>" && echo set || echo missing`. Never print, echo or pass on a token's value, and never read a file that holds one.
 
 Anything missing goes to the user as the command to run themselves (`! <command>`); wait until they did, then check again.
@@ -29,7 +29,14 @@ Anything missing goes to the user as the command to run themselves (`! <command>
 
 Before filling, read the help of the installed CLI version for every command the recipe calls (`acli jira workitem search --help` and `workitem view --help`, `gh issue list --help`) and confirm that the fields and options the entry needs exist there. Read the provider's web documentation only when the help leaves it open or no recipe fits. A recipe is a starting point; the installed version decides.
 
-Fill the recipe with the item or query and the answers from step 1: a `name` of letters, digits, `.`, `_` and `-` that says what is followed, `lane` and `ignoreAuthors` where chosen. A recipe that needs a script (a token handed on stdin, or one call per item): write it to the scratchpad first, never into the repository before step 4.
+Fill the recipe with the item or query and the answers from step 1: a `name` of letters, digits, `.`, `_` and `-` that says what is followed, `lane` and `ignoreAuthors` where chosen. A recipe that needs a script (a token from the environment, or one call per item) gets TypeScript run by Bun: write it to the scratchpad first as `<name>.ts`, never into the repository before step 4, and let the entry's `command` be `["bun", "scripts/sources/<name>.ts"]`. The script:
+
+- bounds every request and every call of a tool with `AbortSignal.timeout(20_000)`, where a shell recipe would use `--max-time`;
+- reads a token only from `process.env`, and never prints it, passes it as an argument or writes it into an output;
+- ends with `process.exit(1)` when the token is missing, the answer is not 2xx (or carries an `errors` list, as GraphQL does with a 200) or a tool it calls fails, without printing the answer's body, so a failure is an exit code and never an empty list the watcher would take for a source with nothing new;
+- prints one JSON value on stdout and nothing else.
+
+A recipe that needs no script (`gh …`, `curl` on a public page, `curl --netrc`) stays a direct command. Write `bun` as the program, never an absolute path to it: the watcher starts a source without a shell and resolves `bun` to the Bun that runs the watcher, and a path in the config would differ from machine to machine.
 
 Write the entry as one JSON object to a draft file in the scratchpad and run, from the main checkout:
 

package/kit/workflow/skills/orchestrate/SKILL.md

@@ -122,7 +122,8 @@ stay approval-bound (§ 5, § 6).
    `git add <paths>`, `git commit -m "docs(plans): add the <topic> plan"` (English, like every commit
    message), `git push -u origin docs/plan-<topic>`, open the PR per `pull-requests.md`, `cd` back,
    and `git worktree remove {{kit.worktreeDirectory}}/docs-plan-<topic>`. The copies in the main
-   checkout stay until the PR is merged (§ 6). Answered no: no lane of these plans starts; say why,
+   checkout stay until the PR is merged (§ 6). When this PR is merged by self-merge, it needs no check wait if it qualifies under
+   **Merging without checks** (§ 5, **Self-merge**, step 2). Answered no: no lane of these plans starts; say why,
    and do not ask again in this run unless the user raises it.
 1. **Collision check.** Compare the lane's `{{kit.heading.writes}}` set and serial markers with every
    running lane. Shared paths run one after the other; migrations, database pushes and bumps of the
@@ -287,7 +288,9 @@ has no value, and `--coordinator <name>` names you. Without either the watcher l
 
 In a stream each report is printed in one piece, so it arrives as one message, and the watcher
 keeps running. The heartbeat there is one line, `=== heartbeat <time> · <lane> <status> · …`, due
-after that many minutes without a report. `lane added: <name>` and `lane removed: <name>` mark a
+after that many minutes without a report. A lane that is `working` carries its plan progress after a colon (`<lane> working: P12 7/12`, the current phase and its ticks)
+only when the count moved since the last heartbeat. Pass it on as it is. A working lane without a number
+has not moved (or has no plan): read its screen yourself when that lasts. `lane added: <name>` and `lane removed: <name>` mark a
 change of the found lanes. A lane's agent is watched from the state it shows when it first appears,
 so an agent that starts out idle does not fire; a lane whose agent exits fires as `no longer listed`,
 also when it leaves the found lanes with it.
@@ -518,16 +521,24 @@ When the user picked `"{{kit.guard.selfMergeLabel}}"` for a PR:
 1. Commit, push and open the PR as in step 4. Enter in the board's `{{kit.heading.history}}` that the
    user approved this PR with self-merge (time, lane, PR number), so the approval has a record outside
    the chat.
-2. Wait for the checks in the background, never in the foreground (§ 4): a Bash call
+2. **Merging without checks.** The paths a PR may carry to be merged without waiting for checks are
+   `{{kit.merge.withoutChecks}}` (`merge.withoutChecks` in the config; `none` means every merge waits).
+   Unless `none`, list the PR's files with `gh pr diff <n> --name-only` and compare each one with the
+   patterns yourself. When **every** file matches, go straight to step 4: no checks wait, because
+   the config says these paths need none. One file outside, an empty list, or a failed `gh` call:
+   go on with step 3. The merge guard reads the file list from GitHub itself and lets that
+   merge pass without a question only when it agrees; if it asks, the dialog is the user's (step 5).
+   This is the rule for the documents of a plan commit as well (§ 2 step 0).
+3. Wait for the checks in the background, never in the foreground (§ 4): a Bash call
    `gh pr checks <n> --watch` with `run_in_background: true`, then work on until it reports.
-3. Green: `gh pr merge <n> --squash --delete-branch`, with the plain PR number and without `-R`,
+4. Green (or a PR that qualified in step 2): `gh pr merge <n> --squash --delete-branch`, with the plain PR number and without `-R`,
    `--repo` or `--admin`. The merge guard lets exactly this command through for the approved branch,
    for `guard.selfMerge.approvalMinutes` after the answer. Red, or checks that never finish: do not
    merge, report to the user with the failing check and the lane's next step.
-4. When the guard asks anyway (the approval lapsed, the branch differs, the command carries an
+5. When the guard asks anyway (the approval lapsed, the branch differs, the command carries an
    option it does not cover), the dialog is the user's. Do not confirm it for them and do not look
    for a way around it: tell them what the PR waits for.
-5. After the merge, one line to the user (PR, merge commit, checks), then § 6 as for any merge.
+6. After the merge, one line to the user (PR, merge commit, checks or "no checks: all files match merge.withoutChecks"), then § 6 as for any merge.
 
 Self-merge never covers `gh workflow run` (a release, a deploy) or another PR: each of those asks
 the user every time.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "keywords": [
     "claude-code",
     "coding-agents",

package/schemas/jackherd.schema.json

@@ -486,6 +486,21 @@
       },
       "additionalProperties": false
     },
+    "merge": {
+      "default": {},
+      "type": "object",
+      "properties": {
+        "withoutChecks": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^[A-Za-z0-9_.*/-]+$"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
     "hints": {
       "default": {},
       "type": "object",

package/src/config/schema.ts

@@ -192,6 +192,32 @@ const guardedCommand = z
   .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')
 
+/**
+ * A path pattern for a pull request that needs no checks: plain path words with wildcards, at least one whole path
+ * segment without a wildcard that starts with a letter or digit (a docs folder, then wildcards, then a file ending, but
+ * not wildcards alone nor any pattern whose only literal is a dot), no `..`, not absolute. Braces, classes and
+ * negation stay out, so the hook, which has no schema library, reads exactly what this accepts.
+ */
+const checkFreePattern = z
+  .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',
+  )
+
+const mergeSchema = z.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: z.array(checkFreePattern).default([]),
+})
+
 const guardSchema = z.strictObject({
   /**
    * The commands the merge guard hook asks the user about before they run, also behind options before the verb, a chain,
@@ -307,6 +333,8 @@ export const jackherdConfigSchema = z.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/src/plans/lane-standing.ts

@@ -0,0 +1,59 @@
+import type { LaneProgress, SprintLane } from '../plan-format'
+import { PLAN_VOCABULARY } from '../vocabulary'
+
+/**
+ * `active` lanes are drawn in full; `noAgent` is a worktree nobody works in, still listed; `waiting` has no
+ * worktree and still something to do; `closed` has nothing left and is not drawn.
+ */
+export const LANE_STANDING = { active: 'active', noAgent: 'no-agent', waiting: 'waiting', closed: 'closed' } as const
+export type LaneStanding = (typeof LANE_STANDING)[keyof typeof LANE_STANDING]
+
+type StandingInput = {
+  progress: Pick<LaneProgress, 'lane' | 'done' | 'total'>
+  status: { agent: string | null; branch: string | null }
+  pullRequests: readonly unknown[]
+}
+
+const NO_STARTS_AFTER = new Set(['', '-', '–', '—'])
+
+/** The starts-after cell of the lane's newest row that has one, trimmed. */
+const startsAfterOf = ({ steps }: SprintLane): string =>
+  steps
+    .map((step) => step.startsAfter.trim())
+    .reverse()
+    .find((cell) => !NO_STARTS_AFTER.has(cell)) ?? ''
+
+const STARTS_NOW = Object.values(PLAN_VOCABULARY).flatMap(({ startsNow }) => startsNow)
+
+/** Every language's word counts: the language a view answers in is not the language the board is written in. */
+const startsNow = (cell: string): boolean => {
+  const lowered = cell.toLowerCase()
+  return STARTS_NOW.some(
+    (word) => lowered === word || (lowered.startsWith(word) && /^\W/.test(lowered.slice(word.length))),
+  )
+}
+
+/** What a waiting lane waits for: its starts-after text as the board writes it; null when it may start at once. */
+export const waitingNote = (lane: SprintLane): string | null => {
+  const cell = startsAfterOf(lane)
+  return cell === '' || startsNow(cell) ? null : cell
+}
+
+const hasOpenWork = (progress: StandingInput['progress']): boolean => {
+  if (progress.total > 0) return progress.done < progress.total
+  return waitingNote(progress.lane) !== null
+}
+
+/**
+ * Where a lane stands on the board. The cleaned-up mark goes first: it closes a lane, unless an agent, a worktree
+ * or a pull request is still there, which keeps it listed. Then an agent or an open pull request makes a lane
+ * active and a worktree alone lists it. Without a worktree a lane waits while it has open work, else it is closed.
+ */
+export const laneStanding = (input: StandingInput): LaneStanding => {
+  const { progress, status, pullRequests } = input
+  const working = status.agent !== null || pullRequests.length > 0
+  if (progress.lane.closed) return working || status.branch !== null ? LANE_STANDING.noAgent : LANE_STANDING.closed
+  if (working) return LANE_STANDING.active
+  if (status.branch !== null) return LANE_STANDING.noAgent
+  return hasOpenWork(progress) ? LANE_STANDING.waiting : LANE_STANDING.closed
+}

package/src/plans/layout.ts

@@ -28,6 +28,7 @@ import {
   type WatchBadges,
   type WatchHealth,
 } from '../watch/plan-badges'
+import { LANE_STANDING, type LaneStanding, laneStanding, waitingNote } from './lane-standing'
 import { chipKey, type LinkChip } from './link-chips'
 import { type PlannedPlan, phaseList, plannedPhaseCount } from './planned'
 import { CHECKS, type ChecksState, type PullRequest, pullRequestKey } from './pull-requests'
@@ -753,18 +754,27 @@ const laneBlock = (
   return joinFrames([row, ...view.pullRequests.map((pullRequest) => pullRequestFrame(pullRequest, context)), content])
 }
 
-/** A closed lane, or one with no agent and no open pull request, has nothing to act on; it is listed in the closing block. */
-const isParked = ({ progress, status, pullRequests }: LaneView): boolean =>
-  progress.lane.closed || (status.agent === null && pullRequests.length === 0)
+const laneTally = ({ progress }: Pick<LaneView, 'progress'>): string =>
+  progress.total > 0 ? `${progress.lane.name} ${progress.done}/${progress.total}` : progress.lane.name
 
-const parkedItem = ({ progress }: LaneView): string => {
-  const { name, steps } = progress.lane
-  const hasPlan = steps.some((step) => step.planHref)
-  const label =
-    progress.total > 0 ? `${name} ${progress.done}/${progress.total}` : hasPlan ? name : `${name} (${TEXTS.noPlan})`
+const parkedItem = (view: Pick<LaneView, 'progress'>): string => {
+  const hasPlan = view.progress.lane.steps.some((step) => step.planHref)
+  const label = view.progress.total > 0 || hasPlan ? laneTally(view) : `${laneTally(view)} (${TEXTS.noPlan})`
   return label.replaceAll(' ', NON_BREAKING_SPACE)
 }
 
+/** `  name 2/5  after P1 gemergt`: one dimmed row per lane that waits, its wait cut at the pane's edge. */
+const waitingBlock = (lanes: LaneView[], width: number): string[] => {
+  if (lanes.length === 0) return []
+  const head = paint.dim(`${NO_AGENT_SYMBOL} ${TEXTS.waiting(lanes.length)}`)
+  const rows = lanes.map((lane) => {
+    const note = waitingNote(lane.progress.lane)
+    const item = laneTally(lane)
+    return paint.dim(fit(note === null ? `  ${item}` : `  ${item}  ${TEXTS.startsAfter(plain(note))}`, width))
+  })
+  return [head, ...rows]
+}
+
 /** `· no agent (6)  name 3/9 · other 1/4`: one wrapping block for every parked lane, each with its progress. */
 const parkedBlock = (lanes: LaneView[], width: number): string[] => {
   if (lanes.length === 0) return []
@@ -837,19 +847,29 @@ const laneColumnsOf = (lanes: LaneView[]): LaneColumns => ({
   right: Math.max(0, ...lanes.map((lane) => visibleLength(laneRight(lane)))),
 })
 
+/** The lanes by what the view does with them; closed lanes are in none of the three groups. */
+const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAgent', LaneView[]> => {
+  const standing = (wanted: LaneStanding) => lanes.filter((lane) => laneStanding(lane) === wanted)
+  return {
+    active: standing(LANE_STANDING.active),
+    waiting: standing(LANE_STANDING.waiting),
+    noAgent: standing(LANE_STANDING.noAgent),
+  }
+}
+
 /**
  * Title and clock on top, the key hint at the bottom (with the legend after `?`), and in between one
  * block per lane: the lane line with its total bar, and for an open lane the phase rows. Folded lanes are
- * one line each, every lane block after the first is preceded by a dimmed rule, and lanes without an
- * agent share the closing block.
+ * one line each and every lane block after the first is preceded by a dimmed rule. Lanes that wait and
+ * lanes with a worktree but no agent each share a closing block; finished lanes are not drawn.
  */
 export const renderScreen = (
   { title, time, lanes, planned, watch, language = PLAN_LANGUAGE.en }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
-  const active = lanes.filter((lane) => !isParked(lane))
-  const parked = parkedBlock(lanes.filter(isParked), width)
+  const { active, waiting, noAgent } = partitionLanes(lanes)
+  const parked = [...waitingBlock(waiting, width), ...parkedBlock(noAgent, width)]
   const columns = laneColumnsOf(active)
   const badgeTexts = BADGE_TEXTS[language]
   const blocks = active.map((lane) => laneBlock(lane, state, width, columns, badgeTexts))

package/src/plans/texts.ts

@@ -8,6 +8,8 @@ import { NO_AGENT_WORD, PHASE_COUNT } from './symbols'
  */
 export type PlanTexts = {
   noAgent: string
+  waiting: (lanes: number) => string
+  startsAfter: (wait: string) => string
   noPlan: string
   noWorktree: string
   noRow: string
@@ -70,6 +72,8 @@ export const boardTexts = (term: string) => ({
 
 export const TEXTS: PlanTexts = {
   noAgent: NO_AGENT_WORD,
+  waiting: (lanes) => `waiting (${lanes})`,
+  startsAfter: (wait) => `after ${wait}`,
   noPlan: 'no plan',
   noWorktree: 'no worktree',
   noRow: 'no row in lanes',
@@ -94,7 +98,7 @@ export const TEXTS: PlanTexts = {
   hint: '↑↓ select  →← open  a all  n notes  s html  q quit  ? help',
   legend: [
     'enter/space or click toggles a lane or a phase, click or enter on a task opens its whole text, and opens a ↗ pull request · wheel PgUp PgDn scroll · j k h l like the arrows · click or ctrl+click on a 📎 chip opens its link · ✦ artifact · ⑂ pull request or issue · ◈ Figma · private = the plan says so',
-    '⚡ working · ❓ blocked, waits for you · 📨 done = the agent finished its answer, not the lane · ⏸ idle · · no agent · working and blocked lanes open by themselves, → ← overrule until the status changes',
+    '⚡ working · ❓ blocked, waits for you · 📨 done = the agent finished its answer, not the lane · ⏸ idle · · no agent = a worktree nobody works in · waiting = not started: no worktree yet, something left to do, and what it starts after; finished lanes (cleaned up, or every named phase ticked) are not shown · working and blocked lanes open by themselves, → ← overrule until the status changes',
     `n/m = m checkboxes of the phase, n ticked (the phase being worked on is yellow; ticked, not merged = all ticked in the worktree, not on the base branch yet) · ${PHASE_COUNT.allTicked} n/n all ticked · ${PHASE_COUNT.empty} no checkboxes · ${PHASE_COUNT.missing} not in the plan · n shows or hides the notes of a lane · s opens every lane and plan as one HTML page · ⎇ branch · ↑ commits ahead · ± uncommitted · no worktree: plan read from main`,
   ],
 }

package/src/sync/render.ts

@@ -12,6 +12,10 @@ const laneCopyCommand = (copy: readonly string[]): string =>
     ? WORKTREE_INCLUDE_COPY
     : `cd <main-checkout> && cp -p --parents -- ${copy.map((path) => `'${path}'`).join(' ')} <worktree>/`
 
+/** The patterns a pull request may match to be merged without checks, as prose for a skill; `none` for an empty list. */
+const checkFreeList = (patterns: readonly string[]): string =>
+  patterns.length === 0 ? 'none' : patterns.map((pattern) => `\`${pattern}\``).join(', ')
+
 const prefixed = (prefix: string, values: Record<string, string>): [string, string][] =>
   Object.entries(values).map(([key, value]) => [`kit.${prefix}.${key}`, value])
 
@@ -31,6 +35,7 @@ const placeholderValues = (config: JackherdConfig): Map<string, string> => {
     ...prefixed('board', config.board),
     ['kit.guard.selfMergeLabel', SELF_MERGE_LABEL[config.responseLanguage]],
     ['kit.guard.selfMerge', config.guard.selfMerge.offer ? 'offered' : 'not offered'],
+    ['kit.merge.withoutChecks', checkFreeList(config.merge.withoutChecks)],
     ...prefixed('heading', { ...header, ...sections, ...columns, phase }),
   ])
 }
@@ -42,7 +47,7 @@ export const listPlaceholders = (template: string): string[] =>
 /**
  * Fills the kit placeholders from the project config: `{{kit.model.<role>}}`,
  * `{{kit.command.<test|typecheck|lint|format|install|dev>}}`, `{{kit.lanes.<copyCommand|lockFile>}}`,
- * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.heading.<key>}}` from the plan
+ * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.merge.withoutChecks}}`, `{{kit.heading.<key>}}` from the plan
  * vocabulary, the two languages, the plan and worktree directory and the base branch. Other
  * `{{…}}` text is left alone; an unknown `kit.` placeholder throws rather than reaching a project
  * file unrendered. `overrides` win over the config: a global kit renders what each repository decides as

package/src/vocabulary/index.ts

@@ -59,6 +59,8 @@ export 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>
@@ -82,6 +84,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     phase: 'Phase',
     noReviewGate: 'Kein Review-Gate',
     laneClosed: 'abgeräumt',
+    startsNow: ['sofort'],
     phaseConnectors: ['danach', 'und', 'dann', 'sowie'],
     statusWords: {
       done: { label: 'Done', leading: ['done'], anywhere: ['abgeschlossen'] },
@@ -109,6 +112,7 @@ export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
     phase: 'Phase',
     noReviewGate: 'No review gate',
     laneClosed: 'cleaned up',
+    startsNow: ['now', 'immediately'],
     phaseConnectors: ['then', 'and', 'after'],
     statusWords: {
       done: { label: 'Done', leading: ['done'], anywhere: ['completed'] },

package/src/watch/command.ts

@@ -46,6 +46,7 @@ import { clockLocaleOf, type PlansSettings, plansSettingsOf, worktreeOf } from '
 import { boardTexts } from '../plans/texts'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { herdrLaneStatusSource } from '../terminal/herdr'
+import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
 import {
   type CoordinatorRead,
@@ -68,6 +69,7 @@ import {
 } from './feedback'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
+import { currentPhaseCountsOf, type PhaseCount, progressNotes } from './heartbeat-progress'
 import { agentScreen, listAgents } from './herdr'
 import { endedByKitUpdate } from './kit-update'
 import { type LaneReadings, laneFillEvents, recordLaneLevels } from './lane-fill'
@@ -216,6 +218,8 @@ type Watching = {
   state: WatchState
   baseline: LaneSnapshot
   current: LaneSnapshot
+  /** The phase count of each lane at the last heartbeat, so a heartbeat names only a count that moved. */
+  heartbeatCounts: Record<string, PhaseCount>
   /** The last `herdr agent list` answer, kept for finding the coordinator by its pane. */
   agents: HerdrAgent[]
   github: GithubRead | null
@@ -762,6 +766,20 @@ const report = async (
   return shown
 }
 
+/**
+ * The heartbeat of a stream: one line, a working lane with its phase count when that moved since the last heartbeat.
+ * The plans are read only when a lane works; a board that cannot be read leaves the lines without a count, and the
+ * next report names the failure.
+ */
+const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: number): Promise<void> => {
+  const working = watching.lanes.filter((lane) => watching.current[lane]?.status === AGENT_STATUS.working)
+  const { progress } = working.length > 0 ? await boardReadOrNote(watch, working) : { progress: {} }
+  const counts = currentPhaseCountsOf(progress)
+  const notes = progressNotes(watching.lanes, watching.current, counts, watching.heartbeatCounts)
+  watching.heartbeatCounts = { ...watching.heartbeatCounts, ...counts }
+  console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current, notes))
+}
+
 /**
  * One poll: reports what is due and tells whether to keep watching. Without `--stream` the first
  * report ends the watch; in a stream every reported lane counts as seen and the heartbeat is one line.
@@ -784,7 +802,7 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
   } else if (heartbeat && !stream) {
     next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }], { ...next, statusLines: null })
   } else {
-    if (heartbeat) console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current))
+    if (heartbeat) await printStreamHeartbeat(watch, watching, now)
     if (due) writePrivate(watch.files.state, JSON.stringify(next))
     watching.baseline = advanceBaseline(watching.baseline, watching.current)
   }
@@ -809,6 +827,7 @@ const initialWatching = (
   agents: start.agents,
   github: null,
   laneBranches: {},
+  heartbeatCounts: {},
   githubReadAt: 0,
   coordinator: { name: watch.options.coordinator, read: null },
   herdrDown: false,

package/src/watch/heartbeat-progress.ts

@@ -0,0 +1,47 @@
+import { currentPhase, type LaneProgress, PHASE_ID_PREFIX, type PhaseProgress } from '../plan-format'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneSnapshot } from './lane-watch'
+
+/** The current phase of a lane and how many of its checkboxes are ticked, as the plans view counts them. */
+export type PhaseCount = Pick<PhaseProgress, 'id' | 'done' | 'total'>
+
+/** What a heartbeat adds to a working lane, by lane name: `P12 7/12`, without the middle dot of `shortTitle`, which the heartbeat's separator rewrite would turn into a slash. */
+export type LaneNotes = Readonly<Record<string, string>>
+
+/** The count of the lane's current phase; null without a plan, without a current phase or with nothing to tick. */
+export const currentPhaseCountOf = (progress: LaneProgress | null): PhaseCount | null => {
+  const phase = progress ? currentPhase(progress) : null
+  return phase && phase.total > 0 ? { id: phase.id, done: phase.done, total: phase.total } : null
+}
+
+/** The counts of the lanes that have one. */
+export const currentPhaseCountsOf = (progress: Readonly<Record<string, LaneProgress>>): Record<string, PhaseCount> =>
+  Object.fromEntries(
+    Object.entries(progress).flatMap(([lane, laneProgress]) => {
+      const count = currentPhaseCountOf(laneProgress)
+      return count ? [[lane, count]] : []
+    }),
+  )
+
+const sameCount = (left: PhaseCount | undefined, right: PhaseCount): boolean =>
+  left?.id === right.id && left.done === right.done && left.total === right.total
+
+/**
+ * The note of each working lane whose count differs from the one at the last heartbeat (or has none before): a lane
+ * that has not moved says nothing, so a stretch on one number tells the coordinator to look for itself.
+ */
+export const progressNotes = (
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  counts: Readonly<Record<string, PhaseCount>>,
+  previous: Readonly<Record<string, PhaseCount>>,
+): LaneNotes =>
+  Object.fromEntries(
+    lanes.flatMap((lane) => {
+      const count = counts[lane]
+      const moved = count !== undefined && !sameCount(previous[lane], count)
+      return moved && current[lane]?.status === AGENT_STATUS.working
+        ? [[lane, `${PHASE_ID_PREFIX}${count.id} ${count.done}/${count.total}`]]
+        : []
+    }),
+  )

package/src/watch/source-command.ts

@@ -0,0 +1,16 @@
+import { basename } from 'node:path'
+
+const BUN_NAMES = new Set(['bun', 'bun.exe'])
+
+/**
+ * The command a source starts. The watcher starts it without a shell, so `bun` would be looked up on the PATH, where
+ * Bun may be missing although the watcher itself runs under it (installed in `~/.bun/bin` only). `bun` as the program
+ * therefore means the Bun that runs the watcher (`execPath`); a path written out, another program, or a watcher that
+ * runs under something else is left as written.
+ */
+export const resolveSourceCommand = (command: readonly string[], execPath: string): string[] => {
+  const [program, ...rest] = command
+  return program === 'bun' && BUN_NAMES.has(basename(execPath.replaceAll('\\', '/')))
+    ? [execPath, ...rest]
+    : [...command]
+}

package/src/watch/source-run.ts

@@ -1,3 +1,4 @@
+import { resolveSourceCommand } from './source-command'
 import { exitFailure, parseSourceOutput, SOURCE_FAILURE, type SourceRun, type SourceSettings } from './sources'
 
 /** How long a source's command may run and how much it may print before it is stopped. */
@@ -39,7 +40,13 @@ const readCapped = async (child: Child, maxBytes: number): Promise<string | null
 /** Started in a process group of its own, so a timeout reaches what the command started too (`curl` behind `sh`). */
 const spawned = (command: readonly string[], cwd: string): Child | null => {
   try {
-    return Bun.spawn([...command], { cwd, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore', detached: true })
+    return Bun.spawn(resolveSourceCommand(command, process.execPath), {
+      cwd,
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'ignore',
+      detached: true,
+    })
   } catch {
     return null
   }

package/src/watch/stream-output.ts

@@ -1,14 +1,31 @@
 import { terminalSafe } from '../plan-format/terminal-text'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneNotes } from './heartbeat-progress'
 import { type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { WATCH_EVENT } from './watch-events'
 
+const SEPARATOR = ' · '
+
+/** `lane status`, a working lane with its note: `lane working: P12 7/12`. */
+const laneState = (lane: string, current: LaneSnapshot, notes: LaneNotes): string => {
+  const status = current[lane]?.status ?? NO_AGENT
+  const note = status === AGENT_STATUS.working ? notes[lane] : undefined
+  const head = `${terminalSafe(lane)} ${terminalSafe(status)}`
+  return note === undefined ? head : `${head}: ${terminalSafe(note).replaceAll(SEPARATOR, ' / ')}`
+}
+
 /**
  * The heartbeat of a stream, as one line, since every line of a stream reaches the coordinator as a
  * message of its own: `=== heartbeat <time> · <lane> <status> · …`.
  */
-export const streamHeartbeatLine = (time: string, lanes: readonly string[], current: LaneSnapshot): string => {
-  const states = lanes.map((lane) => `${terminalSafe(lane)} ${terminalSafe(current[lane]?.status ?? NO_AGENT)}`)
+export const streamHeartbeatLine = (
+  time: string,
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  notes: LaneNotes,
+): string => {
+  const states = lanes.map((lane) => laneState(lane, current, notes))
   return [`=== ${WATCH_EVENT.heartbeat} ${terminalSafe(time)}`, ...(states.length > 0 ? states : ['no lanes'])].join(
-    ' · ',
+    SEPARATOR,
   )
 }