jackherd 1.18.0 → 1.18.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.18.1
+
+- **Starting the watcher under Monitor works again.** The watch guard refused `jh watch --stream` under the Monitor tool, the very place its message points to, so the coordinator fell back to single background runs. The stream refusal now applies only to a Bash call with `run_in_background`, where a never-ending stream would stay silent; Monitor and a foreground call pass.
+- **No self-merge option where it cannot take effect.** A pull request that changes a guard file (`.claude/hooks/**`, `.jackherd/lock.json` and the like) is never covered by a self-merge approval, yet the coordinator still offered the option and you had to confirm the merge anyway. The question is now sent back when it offers the self-merge label for such a pull request; when the files cannot be determined, it passes and the merge guard still asks at merge time.
+- **Review feedback on the coordinator's own pull requests reaches Jack.** The watcher read reviews and comments only for pull requests of lane branches, so an inline finding on a pull request without a lane reached nobody. It now reads feedback for your open pull requests without a lane too, the same set it already read checks for; the event names them `(branch <name>)`. Previews stay lane-only.
+
 ## 1.18.0
 
 - **`jh check` measures every file your budget names.** A path in `check.skillBudgets` (no glob, no sum) is now measured even when `jh check` would not read it on its own, such as `CLAUDE.md` or a rule with `paths:`; a named file that is missing warns, it never fails. The number of measured files in the `Skill budgets` line can rise after the update.

package/README.md

@@ -1,9 +1,9 @@
 <p>
-<img alt="jackherd: a black and white Shih Tzu in a turquoise bandana, three lanes running from him to three agent nodes" src="https://unpkg.com/jackherd@1.18.0/assets/branding/jackherd-logo-outline.svg" width="340">
+<img alt="jackherd: a black and white Shih Tzu in a turquoise bandana, three lanes running from him to three agent nodes" src="https://unpkg.com/jackherd@1.18.1/assets/branding/jackherd-logo-outline.svg" width="340">
 <br>
 </p>
 
-[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies) [![macOS](https://img.shields.io/badge/macOS-supported-brightgreen?logo=apple)](https://unpkg.com/jackherd/INSTALL.md) [![Linux](https://img.shields.io/badge/Linux-supported-brightgreen?logo=linux&logoColor=white)](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg">
+[![npm](https://img.shields.io/npm/v/jackherd)](https://www.npmjs.com/package/jackherd) [![license: MIT](https://img.shields.io/npm/l/jackherd)](https://www.npmjs.com/package/jackherd) [![2 dependencies](https://img.shields.io/badge/dependencies-2-brightgreen)](https://www.npmjs.com/package/jackherd?activeTab=dependencies) [![macOS](https://img.shields.io/badge/macOS-supported-brightgreen?logo=apple)](https://unpkg.com/jackherd/INSTALL.md) [![Linux](https://img.shields.io/badge/Linux-supported-brightgreen?logo=linux&logoColor=white)](https://unpkg.com/jackherd/INSTALL.md)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg">
 
 # Jack herds your coding agents.
 
@@ -15,27 +15,27 @@ For developers who'd rather decide than supervise.
 curl -fsSL https://unpkg.com/jackherd/install.sh | sh
 ```
 
-Then `/jh-start` in a repository, and Jack offers your first plan. → [Quickstart](#quickstart)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg">
+Then `/jh-start` in a repository, and Jack offers your first plan. → [Quickstart](#quickstart)<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg">
 
 <p>
-<img src="https://unpkg.com/jackherd@1.18.0/docs/workflow-dark.svg" width="720" alt="jackherd in herdr: a lane hits a question, Jack asks you as a choice, you pick, and the lane works on while the herd view counts its progress.">
+<img src="https://unpkg.com/jackherd@1.18.1/docs/workflow-dark.svg" width="720" alt="jackherd in herdr: a lane hits a question, Jack asks you as a choice, you pick, and the lane works on while the herd view counts its progress.">
 <br>
-<sub>Jack and his lanes in <a href="https://herdr.dev/">herdr</a>, a terminal for coding agents (recommended). Without it, one Claude Code session builds with subagents.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg">
+<sub>Jack and his lanes in <a href="https://herdr.dev/">herdr</a>, a terminal for coding agents (recommended). Without it, one Claude Code session builds with subagents.</sub><br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg">
 </p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/lanes.svg" width="24" height="34" align="middle" alt=""> <b>Parallel where it pays.</b><br>Phases that don't collide run side by side, each lane on its own branch and worktree. Jack keeps the merge order and has the others rebase.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/lanes.svg" width="24" height="34" align="middle" alt=""> <b>Parallel where it pays.</b><br>Phases that don't collide run side by side, each lane on its own branch and worktree. Jack keeps the merge order and has the others rebase.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Commits, pushes and merges wait for your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours. The guards catch mistakes, not intent; a hard boundary takes branch protection.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/decide.svg" width="24" height="34" align="middle" alt=""> <b>You make the calls.</b><br>Commits, pushes and merges wait for your approval. Jack merges on green checks only where you said so: one pull request, or a plan's for up to 24 hours. The guards catch mistakes, not intent; a hard boundary takes branch protection.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A lane gets stuck, a check goes red, a decision needs you: Jack steps in and brings you only what's yours to decide. The herd view shows where every lane stands.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/bark.svg" width="24" height="34" align="middle" alt=""> <b>Jack barks.</b><br>A lane gets stuck, a check goes red, a decision needs you: Jack steps in and brings you only what's yours to decide. The herd view shows where every lane stands.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/skills.svg" width="24" height="34" align="middle" alt=""> <b>Works with your skills.</b><br>Keep your own skills: a lane builds with whichever one you pick. Plans written elsewhere run too, once Jack fills in what they're missing.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/skills.svg" width="24" height="34" align="middle" alt=""> <b>Works with your skills.</b><br>Keep your own skills: a lane builds with whichever one you pick. Plans written elsewhere run too, once Jack fills in what they're missing.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments on a lane's pull request go back to that lane, which fixes them with a test. <code>/jh-follow</code> brings in anything a CLI or an API can read as JSON: tickets, error logs, status pages.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/ear.svg" width="24" height="34" align="middle" alt=""> <b>Jack listens.</b><br>Review comments on a lane's pull request go back to that lane, which fixes them with a test. <code>/jh-follow</code> brings in anything a CLI or an API can read as JSON: tickets, error logs, status pages.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>Picks up where you left off.</b><br>Plan and board hold the state, not the chat.</p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/bowl.svg" width="24" height="34" align="middle" alt=""> <b>Picks up where you left off.</b><br>Plan and board hold the state, not the chat.</p>
 
-<p><img src="https://unpkg.com/jackherd@1.18.0/assets/icons/plan.svg" width="24" height="34" align="middle" alt=""> <b>Lives in your repository.</b><br>Plans, board and every decision are Markdown, reviewed like code. <code>jh init</code> gives your team the same setup.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg"></p>
+<p><img src="https://unpkg.com/jackherd@1.18.1/assets/icons/plan.svg" width="24" height="34" align="middle" alt=""> <b>Lives in your repository.</b><br>Plans, board and every decision are Markdown, reviewed like code. <code>jh init</code> gives your team the same setup.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg"></p>
 
 ## Quickstart
 
@@ -66,22 +66,22 @@ Then `/jh-start` in a repository, and Jack offers your first plan. → [Quicksta
    /jh-orchestrate docs/plans/board-<name>/board.md
    ```
 
-Linux and macOS are supported (Windows through WSL); the requirements are in [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md). By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh init --global` for yourself, or `jh init` in a repository to give your team the same skills and guard hooks.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg">
+Linux and macOS are supported (Windows through WSL); the requirements are in [INSTALL.md](https://unpkg.com/jackherd/INSTALL.md). By hand (Bun 1.3+): `bun add -g jackherd` or `npm install -g jackherd`, then `jh init --global` for yourself, or `jh init` in a repository to give your team the same skills and guard hooks.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg">
 
 ## Follow anything you can query
 
 Tickets, error logs, status pages: if a command or an API call can read it as JSON with your login, Jack can watch it. Recipes cover Jira, Linear, GitHub issues and Projects, Sentry, Google Calendar and status pages; for anything else, `/jh-follow` writes the command with you. One yes, and every change shows up like this:
 
-<img src="https://unpkg.com/jackherd@1.18.0/docs/follow-dark.svg" width="720" alt="A source (ticket, error log or status page) has a new or changed entry; jh watch reports it to Jack; Jack puts a row into Your turn, prefixed with the source's label; its [ask] button makes Jack ask you, and then a lane works it.">
+<img src="https://unpkg.com/jackherd@1.18.1/docs/follow-dark.svg" width="720" alt="A source (ticket, error log or status page) has a new or changed entry; jh watch reports it to Jack; Jack puts a row into Your turn, prefixed with the source's label; its [ask] button makes Jack ask you, and then a lane works it.">
 
-The herd sums up your sources in one `Sources` line: new entries per source, or its last run, red while it fails; opened, a click opens an entry. One that needs you lands in Your turn under the source's label, [ask] has Jack look at it, and a ticket shows on the lane that works it.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.0/assets/icons/space.svg">
+The herd sums up your sources in one `Sources` line: new entries per source, or its last run, red while it fails; opened, a click opens an entry. One that needs you lands in Your turn under the source's label, [ask] has Jack look at it, and a ticket shows on the lane that works it.<br><img width="1" height="8" alt="" src="https://unpkg.com/jackherd@1.18.1/assets/icons/space.svg">
 
 ## In detail
 
 <details>
 <summary><b>What Jack does on his own, and what waits for you</b></summary>
 
-<img src="https://unpkg.com/jackherd@1.18.0/docs/lanes-dark.svg" alt="Jack prompts two lanes and asks you for decisions and approvals; the lanes send questions back as text; jh watch reads lane state, pull requests and checks and wakes Jack.">
+<img src="https://unpkg.com/jackherd@1.18.1/docs/lanes-dark.svg" alt="Jack prompts two lanes and asks you for decisions and approvals; the lanes send questions back as text; jh watch reads lane state, pull requests and checks and wakes Jack.">
 
 | On his own | After your approval | Never |
 | --- | --- | --- |
@@ -116,7 +116,7 @@ The guards catch mistakes, not intent; for that, use branch protection. The hook
 
 A **plan** is Markdown with phases, checkbox tasks, a model and a review gate per phase. A **board** lists the lanes of one or more plans: which phases each lane builds, on which model, after what. A **lane** is one agent session in its own git worktree (a second checkout of your repository), and **Jack** is the session in the main checkout that runs `/jh-orchestrate` on a board.
 
-<img src="https://unpkg.com/jackherd@1.18.0/docs/skills-dark.svg" alt="Your own plan or an issue is adopted (Jack adds what is missing, you see the diff) and goes to /jh-orchestrate; /jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement, which your own skill can replace; /jh-implement ends in /jh-pre-commit, which runs the reviewers; /jh-diagnose hands a red command to /jh-implement.">
+<img src="https://unpkg.com/jackherd@1.18.1/docs/skills-dark.svg" alt="Your own plan or an issue is adopted (Jack adds what is missing, you see the diff) and goes to /jh-orchestrate; /jh-grill hands decisions to /jh-plan; /jh-plan feeds /jh-orchestrate or a single /jh-implement, which your own skill can replace; /jh-implement ends in /jh-pre-commit, which runs the reviewers; /jh-diagnose hands a red command to /jh-implement.">
 
 | Skill | Does |
 | --- | --- |

package/herdr-plugin/herdr-plugin.toml

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

package/install.sh

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

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

@@ -29,7 +29,7 @@ const onlyOf = (values: string[]): string | undefined => {
  * The one branch a question names as ``Branch `name` ``, with the one change it names after it; a question that names
  * none or several of either approves none.
  */
-const namedChange = (question: string): ApprovedChange | undefined => {
+export const namedChange = (question: string): ApprovedChange | undefined => {
   const branch = onlyOf([...question.matchAll(BRANCH_MENTION)].map(([, name]) => name))
   const change = onlyOf([...question.matchAll(CHANGE_MENTION)].map(([, id]) => id))
   return branch !== undefined && change !== undefined && BRANCH_NAME.test(branch) ? { branch, change } : undefined

package/kit/hooks/hooks/merge-guard/lane-plan.ts

@@ -7,6 +7,7 @@ import { relative, resolve } from 'node:path'
 import { type BoardLanguage, lanePlansOf } from '../shared/board-lanes'
 import { type Board, boardsIn } from '../shared/boards'
 import { laneOf } from '../shared/lane'
+import { worktreePathOf } from '../shared/worktree-list'
 import type { BoardSettings } from './board-settings'
 
 const GIT_TIMEOUT_MS = 3000
@@ -18,9 +19,7 @@ export const laneInWorktreeList = (
   worktreeDirectory: string,
   branch: string,
 ): string | undefined => {
-  const blocks = worktreeList.split('\n\n').map((block) => block.split('\n'))
-  const block = blocks.find((lines) => lines.includes(`branch refs/heads/${branch}`))
-  const path = block?.find((line) => line.startsWith('worktree '))?.slice('worktree '.length)
+  const path = worktreePathOf(worktreeList, branch)
   if (path === undefined) return undefined
   const lane = laneOf({ cwd: path, main, worktreeDirectory })
   return lane !== null && relative(resolve(main, worktreeDirectory), resolve(path)) === lane ? lane : undefined

package/kit/hooks/hooks/plain-question/arguments.ts

@@ -0,0 +1,8 @@
+/**
+ * The positions of the values `sync` renders into the hook entry's command (`kit/hooks/hooks.json`), after the script
+ * path. `arguments.test.ts` checks the entry passes them in this order.
+ */
+export const ARGUMENT = { recommended: 2, approvalAllow: 3, approvalDeny: 4, selfMergeLabel: 5, standingApprove: 6 } as const
+
+/** The first position of a label a guard reads word for word. */
+export const FIRST_GUARDED_LABEL = ARGUMENT.approvalAllow

package/kit/hooks/hooks/plain-question/index.ts

@@ -5,7 +5,9 @@
 // pattern; a cache keyed by each file's time and size spares reading the unchanged ones. A dialog whose question
 // lacks its recommendation as the first option, marked with argv[2], is denied as well, and so is a coordinator's
 // question that breaks the form of `form.ts` (🐾 header, short question and labels); argv[3…] are the labels a
-// guard reads word for word, which carry no mark. Anything else, and any failure, answers nothing, so the dialog opens.
+// guard reads word for word, which carry no mark. A PR question that offers the self-merge label (argv[5]) for a branch
+// whose staged change carries a guard file is denied too, since the merge guard never lets that approval cover it
+// (`self-merge-files.ts`; the positions are named in `arguments.ts`). Anything else, and any failure, answers nothing, so the dialog opens.
 import { existsSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { boardLocationOf, boardsIn } from '../shared/boards'
@@ -17,13 +19,19 @@ import { isCoordinatorAgent } from '../shared/lane'
 import { ownPaneAgent } from '../shared/own-pane'
 import { planCodesOf } from '../shared/plan-codes'
 import { ensurePrivateDirectory, writePrivateFile } from '../shared/private-directory'
+import { ARGUMENT, FIRST_GUARDED_LABEL } from './arguments'
 import { type CodeCache, lookUpCodes, type PlanFileStat, parseCodeCache, serializeCodeCache } from './code-cache'
 import { formReasonOf } from './form'
 import { type RecommendationWords, recommendationReasonOf } from './recommendation'
 import { denyReasonOf, dialogTextsOf, planPathsOfBoards, planRootsOfBoards } from './run'
+import { selfMergeGuardFileReason } from './self-merge-files'
+import { stagedFilesOfBranch } from './staged-files'
 
 const HOOK_EVENT = 'PreToolUse'
 
+/** argv[5] is the self-merge label, in the order the hook entry passes its arguments; an older install passes none. */
+const selfMergeLabelOf = (argv: readonly string[]): string => argv[ARGUMENT.selfMergeLabel] ?? ''
+
 /** Where the cache lies: in the main checkout beside `.jackherd/approvals`, ignored by git. */
 const cacheDirectory = (main: string): string => join(main, '.jackherd', 'plan-codes')
 const CACHE_FILE = 'codes.json'
@@ -35,8 +43,8 @@ const statOf = (path: string): PlanFileStat | null => {
 
 /** argv[2] is the recommended mark, argv[3…] the labels a guard reads word for word; an older install passes none. */
 const recommendationWordsOf = (argv: readonly string[]): RecommendationWords => ({
-  mark: argv[2] ?? '',
-  guardedLabels: argv.slice(3),
+  mark: argv[ARGUMENT.recommended] ?? '',
+  guardedLabels: argv.slice(FIRST_GUARDED_LABEL),
 })
 
 /** Keeps the cache for the next dialog; a cache that cannot be written only costs that dialog a full read. */
@@ -96,13 +104,17 @@ const decide = async (): Promise<string | null> => {
   try {
     const input: unknown = JSON.parse(await Bun.stdin.text())
     if (!isRecord(input) || typeof input.cwd !== 'string') return null
+    const { cwd } = input
     const texts = dialogTextsOf(input.tool_input)
     if (texts.length === 0) return null
     const words = recommendationWordsOf(process.argv)
     const reasons = [
-      denyReasonOf(texts, planCodesFor(input.cwd)),
+      denyReasonOf(texts, planCodesFor(cwd)),
       recommendationReasonOf(input.tool_input, words),
-      formReasonFor(input.cwd, input.session_id, input.tool_input, words.guardedLabels),
+      formReasonFor(cwd, input.session_id, input.tool_input, words.guardedLabels),
+      selfMergeGuardFileReason(input.tool_input, selfMergeLabelOf(process.argv), (branch) =>
+        stagedFilesOfBranch(cwd, branch),
+      ),
     ].filter((reason): reason is string => reason !== null)
     return reasons.length === 0 ? null : reasons.join(' ')
   } catch {

package/kit/hooks/hooks/plain-question/self-merge-files.ts

@@ -0,0 +1,35 @@
+import { alwaysAskingFiles, STANDING_ALWAYS_ASK } from '../merge-guard/always-ask'
+import { namedChange } from '../merge-guard/approval'
+import { questionsOf, recordsOf } from './run'
+
+/** The staged files of a branch's change; undefined when they cannot be determined. */
+export type StagedFilesOf = (branch: string) => readonly string[] | undefined
+
+const offersLabel = (question: Record<string, unknown>, label: string): boolean =>
+  recordsOf(question.options).some((option) => option.label === label)
+
+const refusal = (files: readonly string[]): string =>
+  `The change carries a guard file (${files.map((file) => `\`${file}\``).join(', ')}), which a self-merge approval never covers, so the user confirms this merge in the merge dialog. Ask with the plain approval and the change option only.`
+
+const branchOffering = (question: Record<string, unknown>, label: string): string | undefined =>
+  typeof question.question === 'string' && offersLabel(question, label) ? namedChange(question.question)?.branch : undefined
+
+/**
+ * The reason to send a PR question back: it offers the self-merge label for a branch whose staged change carries a
+ * guard file, the same files (`STANDING_ALWAYS_ASK`) the merge guard refuses a self-merge for. Null for a question
+ * without the label or without a branch mark, and when the files cannot be determined: the merge guard still asks at
+ * merge time, so a doubt here only costs the user a merge dialog.
+ */
+export const selfMergeGuardFileReason = (
+  toolInput: unknown,
+  selfMergeLabel: string,
+  stagedFilesOf: StagedFilesOf,
+): string | null => {
+  if (selfMergeLabel === '') return null
+  for (const question of questionsOf(toolInput)) {
+    const branch = branchOffering(question, selfMergeLabel)
+    const guarded = branch === undefined ? [] : alwaysAskingFiles(stagedFilesOf(branch) ?? [], STANDING_ALWAYS_ASK)
+    if (guarded.length > 0) return refusal(guarded)
+  }
+  return null
+}

package/kit/hooks/hooks/plain-question/staged-files.ts

@@ -0,0 +1,24 @@
+import { baseBranchOf } from '../shared/base-branch'
+import { mainCheckoutOf } from '../shared/checkout'
+import { commandOutput } from '../shared/command'
+import { readConfig } from '../shared/config'
+import { worktreePathOf } from '../shared/worktree-list'
+
+const gitOutput = (cwd: string, ...args: string[]): string => commandOutput(['git', ...args], cwd)
+
+/**
+ * The files staged in the worktree of `branch` against the merge base with the base branch, the base the branch mark's
+ * change id is taken from; undefined when the branch has no worktree or git fails.
+ */
+export const stagedFilesOfBranch = (cwd: string, branch: string): readonly string[] | undefined => {
+  try {
+    const main = mainCheckoutOf(cwd)
+    const base = baseBranchOf(readConfig([main]))
+    const worktree = worktreePathOf(gitOutput(main, 'worktree', 'list', '--porcelain'), branch)
+    if (base === undefined || worktree === undefined) return undefined
+    const mergeBase = gitOutput(worktree, 'merge-base', `origin/${base}`, 'HEAD')
+    return gitOutput(worktree, 'diff', '--cached', '--name-only', mergeBase).split('\n').filter(Boolean)
+  } catch {
+    return undefined
+  }
+}

package/kit/hooks/hooks/shared/worktree-list.ts

@@ -0,0 +1,8 @@
+/** The path of the worktree that has `branch` checked out, from `git worktree list --porcelain`; undefined for none. */
+export const worktreePathOf = (porcelain: string, branch: string): string | undefined => {
+  const block = porcelain
+    .split('\n\n')
+    .map((entry) => entry.split('\n'))
+    .find((lines) => lines.includes(`branch refs/heads/${branch}`))
+  return block?.find((line) => line.startsWith('worktree '))?.slice('worktree '.length)
+}

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

@@ -6,7 +6,7 @@ export type BashToolInput = { command?: string; run_in_background?: boolean }
 const LINE_CONTINUATION = /\\\n\s*/g
 
 const STREAM_REFUSAL = [
-  'jh watch --stream never ends, so a Bash call never reports it, not even in the background.',
+  'A background Bash call never reports a jh watch --stream watcher: the stream never ends.',
   'Start the same command with the Monitor tool (timeout_ms 1800000), where every line it prints reaches you.',
 ].join('\n')
 
@@ -40,14 +40,16 @@ export const startsOf = (command: string, parse: typeof startsIn = startsIn): Wa
  * the package, or `bun` with the CLI's script) with the subcommand `watch`, also behind wrappers, inside
  * `bash -c`, `eval`, a substitution, or a here-document or here-string fed to a shell. Text that only
  * names the command (an argument, a quoted string, a data here-document) is no start. A `--stream` start
- * never finishes, so no Bash call reports it; a single run reports only as its own background task, in a
- * call that sends nothing off with `&`.
+ * never finishes, so a background call (`run_in_background: true`) never reports it and is refused; without
+ * that key it passes, as Monitor sends it (Monitor calls reach this hook as Bash calls without the key) or
+ * as a foreground call that visibly runs into its timeout. A single run reports only as its own background
+ * task, in a call that sends nothing off with `&`.
  */
 export const watcherStartViolation = (input: BashToolInput): string | null => {
   if (!input.command) return null
   const starts = startsOf(input.command)
   if (starts.length === 0) return null
-  if (starts.some((start) => start.stream)) return STREAM_REFUSAL
+  if (starts.some((start) => start.stream)) return input.run_in_background === true ? STREAM_REFUSAL : null
   if (input.run_in_background !== true) return BACKGROUND_REFUSAL
   return starts.some((start) => start.callHasBackgroundJob) ? BACKGROUND_JOB_REFUSAL : null
 }

package/kit/hooks/hooks/watch-guard/index.ts

@@ -4,6 +4,8 @@
 import { watcherStartViolation } from './decision'
 
 const payload = await Bun.stdin.json()
+// Claude Code passes Monitor calls to Bash-matcher hooks as tool_name "Bash" without run_in_background,
+// which is how the decision tells them apart.
 const violation = watcherStartViolation(payload.tool_input ?? {})
 if (violation) {
   console.error(violation)

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

@@ -106,7 +106,7 @@ also reports your own open PRs on a branch no lane has (`(branch <name>)`; act o
 A restart is safe, the watcher keeps what it saw; a stop during a report re-delivers that report's events, so vet
 a repeated event against `gh pr view` or the run before acting twice.
 
-- **Check the start.** A start under the Monitor tool is right (the `watch-guard` hook refuses a Bash call);
+- **Check the start.** A start under the Monitor tool is right (the `watch-guard` hook refuses a `--stream` start as a background Bash call);
   its first line, `armed: …`, comes only when lanes, states or board changed. A start as a Bash call went
   wrong: stop that task (`TaskStop`) and start it under the Monitor tool.
 - **A wake-up is done when every watched lane has a started next action or a named reason to wait**
@@ -294,7 +294,8 @@ always goes to the user, whatever the plan settles.
    The self-merge option is **{{kit.guard.selfMerge}}** (`guard.selfMerge.offer`). When it reads
    `not offered`, or the project supplement blocks self-merge for the PR's tier, ask with the other two. The
    merge guard reads the label and the branch mark back word for word and merges only that diff: never reword
-   either, and write the branch only into a question offering the label.
+   either, and write the branch only into a question offering the label. A hook sends the question back when
+   the staged change carries a guard file: ask with the plain approval and the change only.
 3. **Acceptance in the browser**, for every lane with a visible change:
    [`references/acceptance.md`](references/acceptance.md).
 4. On approval the lane commits, pushes and opens the PR per `pull-requests.md`. When the lane's

package/package.json

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

package/src/watch/command.ts

@@ -95,6 +95,8 @@ import {
   feedbackReadOf,
   feedbackSince,
   feedbackTargets,
+  isLaneTarget,
+  type LaneFeedbackTarget,
 } from './feedback'
 import { type FeedbackItem } from './feedback-item'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
@@ -937,7 +939,7 @@ const previewComments = async (
 const readPreviews = async (
   watch: Watch,
   watching: Watching,
-  targets: FeedbackTarget[],
+  targets: LaneFeedbackTarget[],
   feedbackItems: FeedbackItem[] | null,
   now: number,
 ): Promise<PreviewRead | null> => {
@@ -1037,9 +1039,11 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
   syncPlanHeads(watch, watching, pullRequests ?? [])
   const branches = { ...watching.state.laneBranches, ...laneBranches }
   const failureReadings = await readFailures(watch, watching, github, branches)
-  const targets = feedbackTargets(pullRequests, branches, watching.state.feedback)
+  const targets = feedbackTargets(pullRequests, branches, watching.state.feedback, answered(github)?.own ?? [])
   const feedback = await readFeedback(watch, watching, targets, now)
-  const previews = pullRequests ? await readPreviews(watch, watching, targets, feedback?.items ?? null, now) : null
+  const previews = pullRequests
+    ? await readPreviews(watch, watching, targets.filter(isLaneTarget), feedback?.items ?? null, now)
+    : null
   const { progress: modelProgress } = await boardReadOrNote(watch, Object.keys(fills.models), pullRequests ?? [])
   return [
     ...recordGithub(watching, github, laneBranches, now, failureReadings),

package/src/watch/feedback.ts

@@ -5,8 +5,14 @@ import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 
 export const FEEDBACK_EVENT = 'feedback'
 
-/** An open pull request of a lane whose feedback is read. */
-export type FeedbackTarget = { number: number; lane: string; headCommit: string }
+/** Whose pull request it is: a lane's, or the user's own on a `branch` no lane has. */
+export type FeedbackOwner = { lane: string } | { lane: null; branch: string }
+
+/** An open pull request whose feedback is read: a lane's or an own one without a lane. */
+export type FeedbackTarget = { number: number; headCommit: string } & FeedbackOwner
+
+/** A target of a lane, the only kind a preview is read for. */
+export type LaneFeedbackTarget = FeedbackTarget & { lane: string }
 
 /**
  * What the watcher remembers of one pull request's feedback: `seen` maps `<form>:<id>` to the `updatedAt` last seen,
@@ -46,13 +52,12 @@ export type FeedbackEntry = { place: string | null; text: string }
 
 export type FeedbackEvent = {
   kind: typeof FEEDBACK_EVENT
-  lane: string
   number: number
   author: string
   /** `review <state>`, `inline`, `comment`, or either of the last two with ` edited`. */
   label: string
   entries: FeedbackEntry[]
-}
+} & FeedbackOwner
 
 /**
  * How far a read reaches back before the last one: room for a clock that differs from GitHub's, and the round of a
@@ -77,6 +82,11 @@ const DECISIVE_REVIEW_STATES: readonly string[] = [
 const EDITED = 'edited'
 const MARKDOWN_HEADING = /^#{1,6}\s/
 
+export const isLaneTarget = (target: FeedbackTarget): target is LaneFeedbackTarget => target.lane !== null
+
+const ownerOf = (target: FeedbackTarget): FeedbackOwner =>
+  target.lane === null ? { lane: null, branch: target.branch } : { lane: target.lane }
+
 export const emptyFeedbackState = (): FeedbackState => ({ since: null, pullRequests: {} })
 
 const isNullableString = (value: unknown): boolean => value === null || value === undefined || typeof value === 'string'
@@ -217,7 +227,7 @@ const eventsOfRecord = (record: FeedbackRecord, items: readonly FeedbackItem[]):
     const key = `${item.author}\n${label}`
     const event = groups.get(key) ?? {
       kind: FEEDBACK_EVENT,
-      lane: record.lane,
+      ...ownerOf(record),
       number: record.number,
       author: item.author,
       label,
@@ -236,7 +246,7 @@ const eventsOfRecord = (record: FeedbackRecord, items: readonly FeedbackItem[]):
 export const feedbackEvents = (previous: FeedbackState, read: FeedbackRead): FeedbackEvent[] =>
   read.targets.flatMap((target) => {
     const record = previous.pullRequests[String(target.number)]
-    return record ? eventsOfRecord({ ...record, lane: target.lane }, itemsOf(read, target.number)) : []
+    return record ? eventsOfRecord({ ...record, ...ownerOf(target) }, itemsOf(read, target.number)) : []
   })
 
 const recordOf = (
@@ -277,19 +287,27 @@ export const feedbackSince = (state: Pick<FeedbackState, 'since'>, now: number):
   new Date((state.since ?? now) - SINCE_MARGIN_MS).toISOString()
 
 /**
- * The pull requests whose feedback is read: the open ones of lane branches when GitHub's list answered, else the
- * ones the state follows, so a failing list does not stop the feedback.
+ * The pull requests whose feedback is read: the open ones of lane branches and the user's own open ones without a
+ * lane (`own`, as the checks read them) when GitHub's list answered, else the ones the state follows, so a failing
+ * list does not stop the feedback.
  */
 export const feedbackTargets = (
   pullRequests: readonly WatchedPullRequest[] | null,
   laneBranches: Readonly<Record<string, string>>,
   state: FeedbackState,
+  own: readonly number[],
 ): FeedbackTarget[] => {
   if (!pullRequests)
-    return Object.values(state.pullRequests).map(({ number, lane, headCommit }) => ({ number, lane, headCommit }))
-  return pullRequests.flatMap(({ number, branch, state: lifecycle, headCommit }) => {
+    return Object.values(state.pullRequests).map((record) => ({
+      number: record.number,
+      headCommit: record.headCommit,
+      ...ownerOf(record),
+    }))
+  return pullRequests.flatMap<FeedbackTarget>(({ number, branch, state: lifecycle, headCommit }) => {
+    if (lifecycle !== PULL_REQUEST_STATE.open) return []
     const lane = Object.keys(laneBranches).find((name) => laneBranches[name] === branch)
-    return lane && lifecycle === PULL_REQUEST_STATE.open ? [{ number, lane, headCommit }] : []
+    if (lane) return [{ number, lane, headCommit }]
+    return own.includes(number) ? [{ number, lane: null, branch, headCommit }] : []
   })
 }
 
@@ -303,7 +321,7 @@ export const isReadTime = (value: unknown): boolean =>
 const isFeedbackRecord = (value: unknown): boolean =>
   isRecord(value) &&
   isPullRequestNumber(value.number) &&
-  typeof value.lane === 'string' &&
+  (typeof value.lane === 'string' || (value.lane === null && typeof value.branch === 'string')) &&
   typeof value.headCommit === 'string' &&
   typeof value.count === 'number' &&
   (value.changesRequested === undefined || typeof value.changesRequested === 'boolean') &&

package/src/watch/lane-report.ts

@@ -127,7 +127,7 @@ export const laneStopHeader = (lane: string, status: string, handoverHint: strin
 }
 
 /** The lane, or `branch <name>` for an own pull request without a lane, its name cut like other third-party text. */
-const pullRequestOwner = (event: PullRequestEvent): string =>
+const pullRequestOwner = (event: { lane: string } | { lane: null; branch: string }): string =>
   event.lane === null ? `branch ${terminalSafe(event.branch).slice(0, REPORT_TEXT_LENGTH)}` : terminalSafe(event.lane)
 
 /** The lane, `#<number>` for an own pull request without a lane, or `manual`. */
@@ -206,7 +206,7 @@ export const watchEventLine = (event: WatchEvent, target: string | null): string
   if (event.kind === WATCH_EVENT.coordinator) return `=== ${event.kind} ${event.level} ${contextLabel(event.share)}`
   if (isPullRequestEvent(event))
     return `=== ${event.kind} #${event.number} (${pullRequestOwner(event)})${failedChecksSuffix(event)}`
-  if ('number' in event) return `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)})`
+  if ('number' in event) return `=== ${event.kind} #${event.number} (${pullRequestOwner(event)})`
   return `=== ${event.kind}`
 }
 
@@ -218,11 +218,11 @@ export const appointmentEventLine = (event: AppointmentEvent): string =>
   `=== ${event.kind} ${terminalSafe(event.when)} · ${terminalSafe(event.action).slice(0, REPORT_TEXT_LENGTH)}`
 
 /**
- * The lines of a feedback event: `=== feedback #<number> (lane) <author> <label> · <k> new`, then one line per entry,
+ * The lines of a feedback event: `=== feedback #<number> (lane|branch <name>) <author> <label> · <k> new`, then one line per entry,
  * `<path>:<line> <first line>` or `<first line>`, cut to a length and to `FEEDBACK_ENTRY_LIMIT` entries.
  */
 export const feedbackEventLines = (event: FeedbackEvent): string[] => {
-  const header = `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)}) ${terminalSafe(event.author)} ${terminalSafe(event.label)} · ${event.entries.length} new`
+  const header = `=== ${event.kind} #${event.number} (${pullRequestOwner(event)}) ${terminalSafe(event.author)} ${terminalSafe(event.label)} · ${event.entries.length} new`
   const { shown: shownEntries, more } = shownWithMore(event.entries, FEEDBACK_ENTRY_LIMIT)
   const entries = shownEntries.map(({ place, text }) => {
     const line = terminalSafe(place === null ? text : `${place} ${text}`).slice(0, REPORT_TEXT_LENGTH)

package/src/watch/preview-read.ts

@@ -1,5 +1,5 @@
 import { errorText } from '../plans/error-text'
-import type { FeedbackTarget } from './feedback'
+import type { LaneFeedbackTarget } from './feedback'
 import { runGh } from './gh'
 import {
   deploymentCandidate,
@@ -25,7 +25,7 @@ const STATUS_FIELDS = '.[0] | {state: (.state // ""), url: (.environment_url //
  */
 const readHeadPreview = async (
   root: string,
-  target: FeedbackTarget,
+  target: LaneFeedbackTarget,
   deployEnvironments: readonly string[],
 ): Promise<HeadRead> => {
   const listPath = `repos/{owner}/{repo}/deployments?sha=${target.headCommit}&per_page=${DEPLOYMENT_LIMIT}`
@@ -50,7 +50,7 @@ const readHeadPreview = async (
  */
 export const readDeploymentCandidates = async (
   root: string,
-  targets: readonly FeedbackTarget[],
+  targets: readonly LaneFeedbackTarget[],
   deployEnvironments: readonly string[],
 ): Promise<PreviewCandidatesRead> => {
   const reads = await Promise.all(targets.map((target) => readHeadPreview(root, target, deployEnvironments)))

package/src/watch/previews.ts

@@ -1,5 +1,5 @@
 import { isRecord } from '../shared/is-record'
-import { type FeedbackTarget, isReadTime } from './feedback'
+import { isReadTime, type LaneFeedbackTarget } from './feedback'
 import { FEEDBACK_FORM, type FeedbackItem } from './feedback-item'
 
 export const PREVIEW_EVENT = 'preview'
@@ -33,7 +33,7 @@ export type PreviewRecord = { reportedHead: string | null; stamps: Record<string
 /** `since` is the epoch milliseconds of the last read, null before the first. */
 export type PreviewState = { since: number | null; pullRequests: Record<string, PreviewRecord> }
 
-export type PreviewRead = { readAt: number; targets: FeedbackTarget[]; candidates: PreviewCandidate[] }
+export type PreviewRead = { readAt: number; targets: LaneFeedbackTarget[]; candidates: PreviewCandidate[] }
 
 /** Which comments name a preview: their authors' logins, and optionally a pattern whose first group is the URL. */
 export type PreviewSettings = { authors: readonly string[]; urlPattern?: string }
@@ -125,7 +125,7 @@ export const previewDeployments = (deployments: readonly Deployment[], deployEnv
 
 /** A deployment of `target`'s head as a candidate once its latest status succeeded with an https URL. */
 export const deploymentCandidate = (
-  target: FeedbackTarget,
+  target: LaneFeedbackTarget,
   id: number,
   status: DeploymentStatus,
 ): PreviewCandidate | null => {
@@ -144,7 +144,7 @@ export const deploymentCandidate = (
 
 export const previewReadOf = (
   readAt: number,
-  targets: FeedbackTarget[],
+  targets: LaneFeedbackTarget[],
   candidates: readonly PreviewCandidate[],
 ): PreviewRead => {
   const numbers = new Set(targets.map(({ number }) => number))
@@ -152,18 +152,18 @@ export const previewReadOf = (
 }
 
 /** A candidate with a URL that may stand for the target's current head: a comment, or a deployment of that head. */
-const isUsable = (candidate: PreviewCandidate, target: FeedbackTarget): boolean =>
+const isUsable = (candidate: PreviewCandidate, target: LaneFeedbackTarget): boolean =>
   candidate.url !== null && (candidate.headCommit === null || candidate.headCommit === target.headCommit)
 
 /** Deployments before comments: a deployment names its commit, a comment does not. */
 const byDeploymentFirst = (a: PreviewCandidate, b: PreviewCandidate): number =>
   Number(a.source !== PREVIEW_SOURCE.deployment) - Number(b.source !== PREVIEW_SOURCE.deployment)
 
-const candidatesOf = (read: PreviewRead, target: FeedbackTarget): PreviewCandidate[] =>
+const candidatesOf = (read: PreviewRead, target: LaneFeedbackTarget): PreviewCandidate[] =>
   read.candidates.filter(({ pullRequest }) => pullRequest === target.number).sort(byDeploymentFirst)
 
 /** The usable candidate that changed since `record`, when the head has had no preview reported yet. */
-const freshPreview = (record: PreviewRecord, target: FeedbackTarget, candidates: readonly PreviewCandidate[]) =>
+const freshPreview = (record: PreviewRecord, target: LaneFeedbackTarget, candidates: readonly PreviewCandidate[]) =>
   target.headCommit === record.reportedHead
     ? undefined
     : candidates.find((candidate) => record.stamps[candidate.key] !== candidate.stamp && isUsable(candidate, target))
@@ -189,7 +189,7 @@ export const previewEvents = (previous: PreviewState, read: PreviewRead): Previe
       : []
   })
 
-const recordOf = (record: PreviewRecord | undefined, target: FeedbackTarget, candidates: PreviewCandidate[]) => {
+const recordOf = (record: PreviewRecord | undefined, target: LaneFeedbackTarget, candidates: PreviewCandidate[]) => {
   const stamps = Object.fromEntries(candidates.map(({ key, stamp }) => [key, stamp]))
   const shown = record
     ? freshPreview(record, target, candidates)
@@ -211,7 +211,7 @@ export const recordPreviews = (previous: PreviewState, read: PreviewRead): Previ
 })
 
 /** The targets whose current head has no preview reported yet; only they need their deployments read. */
-export const unreportedTargets = (state: PreviewState, targets: readonly FeedbackTarget[]): FeedbackTarget[] =>
+export const unreportedTargets = (state: PreviewState, targets: readonly LaneFeedbackTarget[]): LaneFeedbackTarget[] =>
   targets.filter(({ number, headCommit }) => state.pullRequests[String(number)]?.reportedHead !== headCommit)
 
 const isPreviewRecord = (value: unknown): boolean =>